Initial boiler plate project

node_modules/next/dist/esm/build/webpack/alias/react-dom-server-browser-experimental.js

@@ -0,0 +1,19 @@
+var l, s;
+if (process.env.NODE_ENV === "production") {
+    l = require("next/dist/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.production.min.js");
+    s = require("next/dist/compiled/react-dom-experimental/cjs/react-dom-server.browser.production.min.js");
+} else {
+    l = require("next/dist/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.development.js");
+    s = require("next/dist/compiled/react-dom-experimental/cjs/react-dom-server.browser.development.js");
+}
+exports.version = l.version;
+exports.renderToString = l.renderToString;
+exports.renderToStaticMarkup = l.renderToStaticMarkup;
+exports.renderToNodeStream = l.renderToNodeStream;
+exports.renderToStaticNodeStream = l.renderToStaticNodeStream;
+exports.renderToReadableStream = s.renderToReadableStream;
+if (s.resume) {
+    exports.resume = s.resume;
+}
+
+//# sourceMappingURL=react-dom-server-browser-experimental.js.map

node_modules/next/dist/esm/build/webpack/alias/react-dom-server-browser-experimental.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/alias/react-dom-server-browser-experimental.js"],"names":["l","s","process","env","NODE_ENV","require","exports","version","renderToString","renderToStaticMarkup","renderToNodeStream","renderToStaticNodeStream","renderToReadableStream","resume"],"mappings":"AAAA,IAAIA,GAAGC;AACP,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;IACzCJ,IAAIK,QAAQ;IACZJ,IAAII,QAAQ;AACd,OAAO;IACLL,IAAIK,QAAQ;IACZJ,IAAII,QAAQ;AACd;AAEAC,QAAQC,OAAO,GAAGP,EAAEO,OAAO;AAC3BD,QAAQE,cAAc,GAAGR,EAAEQ,cAAc;AACzCF,QAAQG,oBAAoB,GAAGT,EAAES,oBAAoB;AACrDH,QAAQI,kBAAkB,GAAGV,EAAEU,kBAAkB;AACjDJ,QAAQK,wBAAwB,GAAGX,EAAEW,wBAAwB;AAC7DL,QAAQM,sBAAsB,GAAGX,EAAEW,sBAAsB;AACzD,IAAIX,EAAEY,MAAM,EAAE;IACZP,QAAQO,MAAM,GAAGZ,EAAEY,MAAM;AAC3B"}

node_modules/next/dist/esm/build/webpack/alias/react-dom-server-browser.js

@@ -0,0 +1,19 @@
+var l, s;
+if (process.env.NODE_ENV === "production") {
+    l = require("next/dist/compiled/react-dom/cjs/react-dom-server-legacy.browser.production.min.js");
+    s = require("next/dist/compiled/react-dom/cjs/react-dom-server.browser.production.min.js");
+} else {
+    l = require("next/dist/compiled/react-dom/cjs/react-dom-server-legacy.browser.development.js");
+    s = require("next/dist/compiled/react-dom/cjs/react-dom-server.browser.development.js");
+}
+exports.version = l.version;
+exports.renderToString = l.renderToString;
+exports.renderToStaticMarkup = l.renderToStaticMarkup;
+exports.renderToNodeStream = l.renderToNodeStream;
+exports.renderToStaticNodeStream = l.renderToStaticNodeStream;
+exports.renderToReadableStream = s.renderToReadableStream;
+if (s.resume) {
+    exports.resume = s.resume;
+}
+
+//# sourceMappingURL=react-dom-server-browser.js.map

node_modules/next/dist/esm/build/webpack/alias/react-dom-server-browser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/alias/react-dom-server-browser.js"],"names":["l","s","process","env","NODE_ENV","require","exports","version","renderToString","renderToStaticMarkup","renderToNodeStream","renderToStaticNodeStream","renderToReadableStream","resume"],"mappings":"AAAA,IAAIA,GAAGC;AACP,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;IACzCJ,IAAIK,QAAQ;IACZJ,IAAII,QAAQ;AACd,OAAO;IACLL,IAAIK,QAAQ;IACZJ,IAAII,QAAQ;AACd;AAEAC,QAAQC,OAAO,GAAGP,EAAEO,OAAO;AAC3BD,QAAQE,cAAc,GAAGR,EAAEQ,cAAc;AACzCF,QAAQG,oBAAoB,GAAGT,EAAES,oBAAoB;AACrDH,QAAQI,kBAAkB,GAAGV,EAAEU,kBAAkB;AACjDJ,QAAQK,wBAAwB,GAAGX,EAAEW,wBAAwB;AAC7DL,QAAQM,sBAAsB,GAAGX,EAAEW,sBAAsB;AACzD,IAAIX,EAAEY,MAAM,EAAE;IACZP,QAAQO,MAAM,GAAGZ,EAAEY,MAAM;AAC3B"}

node_modules/next/dist/esm/build/webpack/alias/react-dom-server-edge-experimental.js

@@ -0,0 +1,21 @@
+const ERROR_MESSAGE = "Internal Error: do not use legacy react-dom/server APIs. If you encountered this error, please open an issue on the Next.js repo.";
+function error() {
+    throw new Error(ERROR_MESSAGE);
+}
+var b;
+if (process.env.NODE_ENV === "production") {
+    b = require("next/dist/compiled/react-dom-experimental/cjs/react-dom-server.edge.production.min.js");
+} else {
+    b = require("next/dist/compiled/react-dom-experimental/cjs/react-dom-server.edge.development.js");
+}
+exports.version = b.version;
+exports.renderToReadableStream = b.renderToReadableStream;
+exports.renderToNodeStream = b.renderToNodeStream;
+exports.renderToStaticNodeStream = b.renderToStaticNodeStream;
+exports.renderToString = error;
+exports.renderToStaticMarkup = error;
+if (b.resume) {
+    exports.resume = b.resume;
+}
+
+//# sourceMappingURL=react-dom-server-edge-experimental.js.map

node_modules/next/dist/esm/build/webpack/alias/react-dom-server-edge-experimental.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/alias/react-dom-server-edge-experimental.js"],"names":["ERROR_MESSAGE","error","Error","b","process","env","NODE_ENV","require","exports","version","renderToReadableStream","renderToNodeStream","renderToStaticNodeStream","renderToString","renderToStaticMarkup","resume"],"mappings":"AAAA,MAAMA,gBACJ;AAEF,SAASC;IACP,MAAM,IAAIC,MAAMF;AAClB;AAEA,IAAIG;AACJ,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;IACzCH,IAAII,QAAQ;AACd,OAAO;IACLJ,IAAII,QAAQ;AACd;AAEAC,QAAQC,OAAO,GAAGN,EAAEM,OAAO;AAC3BD,QAAQE,sBAAsB,GAAGP,EAAEO,sBAAsB;AACzDF,QAAQG,kBAAkB,GAAGR,EAAEQ,kBAAkB;AACjDH,QAAQI,wBAAwB,GAAGT,EAAES,wBAAwB;AAC7DJ,QAAQK,cAAc,GAAGZ;AACzBO,QAAQM,oBAAoB,GAAGb;AAC/B,IAAIE,EAAEY,MAAM,EAAE;IACZP,QAAQO,MAAM,GAAGZ,EAAEY,MAAM;AAC3B"}

node_modules/next/dist/esm/build/webpack/alias/react-dom-server-edge.js

@@ -0,0 +1,21 @@
+const ERROR_MESSAGE = "Internal Error: do not use legacy react-dom/server APIs. If you encountered this error, please open an issue on the Next.js repo.";
+function error() {
+    throw new Error(ERROR_MESSAGE);
+}
+var b;
+if (process.env.NODE_ENV === "production") {
+    b = require("next/dist/compiled/react-dom/cjs/react-dom-server.edge.production.min.js");
+} else {
+    b = require("next/dist/compiled/react-dom/cjs/react-dom-server.edge.development.js");
+}
+exports.version = b.version;
+exports.renderToReadableStream = b.renderToReadableStream;
+exports.renderToNodeStream = b.renderToNodeStream;
+exports.renderToStaticNodeStream = b.renderToStaticNodeStream;
+exports.renderToString = error;
+exports.renderToStaticMarkup = error;
+if (b.resume) {
+    exports.resume = b.resume;
+}
+
+//# sourceMappingURL=react-dom-server-edge.js.map

node_modules/next/dist/esm/build/webpack/alias/react-dom-server-edge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/alias/react-dom-server-edge.js"],"names":["ERROR_MESSAGE","error","Error","b","process","env","NODE_ENV","require","exports","version","renderToReadableStream","renderToNodeStream","renderToStaticNodeStream","renderToString","renderToStaticMarkup","resume"],"mappings":"AAAA,MAAMA,gBACJ;AAEF,SAASC;IACP,MAAM,IAAIC,MAAMF;AAClB;AAEA,IAAIG;AACJ,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;IACzCH,IAAII,QAAQ;AACd,OAAO;IACLJ,IAAII,QAAQ;AACd;AAEAC,QAAQC,OAAO,GAAGN,EAAEM,OAAO;AAC3BD,QAAQE,sBAAsB,GAAGP,EAAEO,sBAAsB;AACzDF,QAAQG,kBAAkB,GAAGR,EAAEQ,kBAAkB;AACjDH,QAAQI,wBAAwB,GAAGT,EAAES,wBAAwB;AAC7DJ,QAAQK,cAAc,GAAGZ;AACzBO,QAAQM,oBAAoB,GAAGb;AAC/B,IAAIE,EAAEY,MAAM,EAAE;IACZP,QAAQO,MAAM,GAAGZ,EAAEY,MAAM;AAC3B"}

node_modules/next/dist/esm/build/webpack/config/blocks/base.js

@@ -0,0 +1,43 @@
+import curry from "next/dist/compiled/lodash.curry";
+import { COMPILER_NAMES } from "../../../../shared/lib/constants";
+export const base = curry(function base(ctx, config) {
+    config.mode = ctx.isDevelopment ? "development" : "production";
+    config.name = ctx.isServer ? ctx.isEdgeRuntime ? COMPILER_NAMES.edgeServer : COMPILER_NAMES.server : COMPILER_NAMES.client;
+    config.target = !ctx.targetWeb ? "node18.17" // Same version defined in packages/next/package.json#engines
+     : ctx.isEdgeRuntime ? [
+        "web",
+        "es6"
+    ] : [
+        "web",
+        "es5"
+    ];
+    // https://webpack.js.org/configuration/devtool/#development
+    if (ctx.isDevelopment) {
+        if (process.env.__NEXT_TEST_MODE && !process.env.__NEXT_TEST_WITH_DEVTOOL) {
+            config.devtool = false;
+        } else {
+            // `eval-source-map` provides full-fidelity source maps for the
+            // original source, including columns and original variable names.
+            // This is desirable so the in-browser debugger can correctly pause
+            // and show scoped variables with their original names.
+            config.devtool = "eval-source-map";
+        }
+    } else {
+        if (ctx.isEdgeRuntime || ctx.isServer && ctx.serverSourceMaps || // Enable browser sourcemaps:
+        ctx.productionBrowserSourceMaps && ctx.isClient) {
+            config.devtool = "source-map";
+        } else {
+            config.devtool = false;
+        }
+    }
+    if (!config.module) {
+        config.module = {
+            rules: []
+        };
+    }
+    // TODO: add codemod for "Should not import the named export" with JSON files
+    // config.module.strictExportPresence = !isWebpack5
+    return config;
+});
+
+//# sourceMappingURL=base.js.map

node_modules/next/dist/esm/build/webpack/config/blocks/base.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/config/blocks/base.ts"],"names":["curry","COMPILER_NAMES","base","ctx","config","mode","isDevelopment","name","isServer","isEdgeRuntime","edgeServer","server","client","target","targetWeb","process","env","__NEXT_TEST_MODE","__NEXT_TEST_WITH_DEVTOOL","devtool","serverSourceMaps","productionBrowserSourceMaps","isClient","module","rules"],"mappings":"AAAA,OAAOA,WAAW,kCAAiC;AAEnD,SAASC,cAAc,QAAQ,mCAAkC;AAGjE,OAAO,MAAMC,OAAOF,MAAM,SAASE,KACjCC,GAAyB,EACzBC,MAA6B;IAE7BA,OAAOC,IAAI,GAAGF,IAAIG,aAAa,GAAG,gBAAgB;IAClDF,OAAOG,IAAI,GAAGJ,IAAIK,QAAQ,GACtBL,IAAIM,aAAa,GACfR,eAAeS,UAAU,GACzBT,eAAeU,MAAM,GACvBV,eAAeW,MAAM;IAEzBR,OAAOS,MAAM,GAAG,CAACV,IAAIW,SAAS,GAC1B,YAAY,6DAA6D;OACzEX,IAAIM,aAAa,GACjB;QAAC;QAAO;KAAM,GACd;QAAC;QAAO;KAAM;IAElB,4DAA4D;IAC5D,IAAIN,IAAIG,aAAa,EAAE;QACrB,IAAIS,QAAQC,GAAG,CAACC,gBAAgB,IAAI,CAACF,QAAQC,GAAG,CAACE,wBAAwB,EAAE;YACzEd,OAAOe,OAAO,GAAG;QACnB,OAAO;YACL,+DAA+D;YAC/D,kEAAkE;YAClE,mEAAmE;YACnE,uDAAuD;YACvDf,OAAOe,OAAO,GAAG;QACnB;IACF,OAAO;QACL,IACEhB,IAAIM,aAAa,IAChBN,IAAIK,QAAQ,IAAIL,IAAIiB,gBAAgB,IACrC,6BAA6B;QAC5BjB,IAAIkB,2BAA2B,IAAIlB,IAAImB,QAAQ,EAChD;YACAlB,OAAOe,OAAO,GAAG;QACnB,OAAO;YACLf,OAAOe,OAAO,GAAG;QACnB;IACF;IAEA,IAAI,CAACf,OAAOmB,MAAM,EAAE;QAClBnB,OAAOmB,MAAM,GAAG;YAAEC,OAAO,EAAE;QAAC;IAC9B;IAEA,6EAA6E;IAC7E,mDAAmD;IAEnD,OAAOpB;AACT,GAAE"}

node_modules/next/dist/esm/build/webpack/config/blocks/css/index.js

@@ -0,0 +1,538 @@
+import curry from "next/dist/compiled/lodash.curry";
+import { loader, plugin } from "../../helpers";
+import { pipe } from "../../utils";
+import { getCssModuleLoader, getGlobalCssLoader } from "./loaders";
+import { getNextFontLoader } from "./loaders/next-font";
+import { getCustomDocumentError, getGlobalImportError, getGlobalModuleImportError, getLocalModuleImportError } from "./messages";
+import { getPostCssPlugins } from "./plugins";
+import { nonNullable } from "../../../../../lib/non-nullable";
+import { WEBPACK_LAYERS } from "../../../../../lib/constants";
+// RegExps for all Style Sheet variants
+export const regexLikeCss = /\.(css|scss|sass)$/;
+// RegExps for Style Sheets
+const regexCssGlobal = /(?<!\.module)\.css$/;
+const regexCssModules = /\.module\.css$/;
+// RegExps for Syntactically Awesome Style Sheets
+const regexSassGlobal = /(?<!\.module)\.(scss|sass)$/;
+const regexSassModules = /\.module\.(scss|sass)$/;
+const APP_LAYER_RULE = {
+    or: [
+        WEBPACK_LAYERS.reactServerComponents,
+        WEBPACK_LAYERS.serverSideRendering,
+        WEBPACK_LAYERS.appPagesBrowser
+    ]
+};
+const PAGES_LAYER_RULE = {
+    not: [
+        WEBPACK_LAYERS.reactServerComponents,
+        WEBPACK_LAYERS.serverSideRendering,
+        WEBPACK_LAYERS.appPagesBrowser
+    ]
+};
+/**
+ * Mark a rule as removable if built-in CSS support is disabled
+ */ function markRemovable(r) {
+    Object.defineProperty(r, Symbol.for("__next_css_remove"), {
+        enumerable: false,
+        value: true
+    });
+    return r;
+}
+let postcssInstancePromise;
+export async function lazyPostCSS(rootDirectory, supportedBrowsers, disablePostcssPresetEnv) {
+    if (!postcssInstancePromise) {
+        postcssInstancePromise = (async ()=>{
+            const postcss = require("postcss");
+            // @ts-ignore backwards compat
+            postcss.plugin = function postcssPlugin(name, initializer) {
+                function creator(...args) {
+                    let transformer = initializer(...args);
+                    transformer.postcssPlugin = name;
+                    // transformer.postcssVersion = new Processor().version
+                    return transformer;
+                }
+                let cache;
+                Object.defineProperty(creator, "postcss", {
+                    get () {
+                        if (!cache) cache = creator();
+                        return cache;
+                    }
+                });
+                creator.process = function(css, processOpts, pluginOpts) {
+                    return postcss([
+                        creator(pluginOpts)
+                    ]).process(css, processOpts);
+                };
+                return creator;
+            };
+            // @ts-ignore backwards compat
+            postcss.vendor = {
+                /**
+         * Returns the vendor prefix extracted from an input string.
+         *
+         * @example
+         * postcss.vendor.prefix('-moz-tab-size') //=> '-moz-'
+         * postcss.vendor.prefix('tab-size')      //=> ''
+         */ prefix: function prefix(prop) {
+                    const match = prop.match(/^(-\w+-)/);
+                    if (match) {
+                        return match[0];
+                    }
+                    return "";
+                },
+                /**
+         * Returns the input string stripped of its vendor prefix.
+         *
+         * @example
+         * postcss.vendor.unprefixed('-moz-tab-size') //=> 'tab-size'
+         */ unprefixed: function unprefixed(/**
+           * String with or without vendor prefix.
+           */ prop) {
+                    return prop.replace(/^-\w+-/, "");
+                }
+            };
+            const postCssPlugins = await getPostCssPlugins(rootDirectory, supportedBrowsers, disablePostcssPresetEnv);
+            return {
+                postcss,
+                postcssWithPlugins: postcss(postCssPlugins)
+            };
+        })();
+    }
+    return postcssInstancePromise;
+}
+export const css = curry(async function css(ctx, config) {
+    const { prependData: sassPrependData, additionalData: sassAdditionalData, ...sassOptions } = ctx.sassOptions;
+    const lazyPostCSSInitializer = ()=>lazyPostCSS(ctx.rootDirectory, ctx.supportedBrowsers, ctx.experimental.disablePostcssPresetEnv);
+    const sassPreprocessors = [
+        // First, process files with `sass-loader`: this inlines content, and
+        // compiles away the proprietary syntax.
+        {
+            loader: require.resolve("next/dist/compiled/sass-loader"),
+            options: {
+                // Source maps are required so that `resolve-url-loader` can locate
+                // files original to their source directory.
+                sourceMap: true,
+                sassOptions: {
+                    // The "fibers" option is not needed for Node.js 16+, but it's causing
+                    // problems for Node.js <= 14 users as you'll have to manually install
+                    // the `fibers` package:
+                    // https://github.com/webpack-contrib/sass-loader#:~:text=We%20automatically%20inject%20the%20fibers%20package
+                    // https://github.com/vercel/next.js/issues/45052
+                    // Since it's optional and not required, we'll disable it by default
+                    // to avoid the confusion.
+                    fibers: false,
+                    ...sassOptions
+                },
+                additionalData: sassPrependData || sassAdditionalData
+            }
+        },
+        // Then, `sass-loader` will have passed-through CSS imports as-is instead
+        // of inlining them. Because they were inlined, the paths are no longer
+        // correct.
+        // To fix this, we use `resolve-url-loader` to rewrite the CSS
+        // imports to real file paths.
+        {
+            loader: require.resolve("../../../loaders/resolve-url-loader/index"),
+            options: {
+                postcss: lazyPostCSSInitializer,
+                // Source maps are not required here, but we may as well emit
+                // them.
+                sourceMap: true
+            }
+        }
+    ];
+    const fns = [];
+    const googleLoader = require.resolve("next/dist/compiled/@next/font/google/loader");
+    const localLoader = require.resolve("next/dist/compiled/@next/font/local/loader");
+    const nextFontLoaders = [
+        [
+            require.resolve("next/font/google/target.css"),
+            googleLoader
+        ],
+        [
+            require.resolve("next/font/local/target.css"),
+            localLoader
+        ],
+        // TODO: remove this in the next major version
+        [
+            /node_modules[\\/]@next[\\/]font[\\/]google[\\/]target.css/,
+            googleLoader
+        ],
+        [
+            /node_modules[\\/]@next[\\/]font[\\/]local[\\/]target.css/,
+            localLoader
+        ]
+    ];
+    nextFontLoaders.forEach(([fontLoaderTarget, fontLoaderPath])=>{
+        // Matches the resolved font loaders noop files to run next-font-loader
+        fns.push(loader({
+            oneOf: [
+                markRemovable({
+                    sideEffects: false,
+                    test: fontLoaderTarget,
+                    use: getNextFontLoader(ctx, lazyPostCSSInitializer, fontLoaderPath)
+                })
+            ]
+        }));
+    });
+    // CSS cannot be imported in _document. This comes before everything because
+    // global CSS nor CSS modules work in said file.
+    fns.push(loader({
+        oneOf: [
+            markRemovable({
+                test: regexLikeCss,
+                // Use a loose regex so we don't have to crawl the file system to
+                // find the real file name (if present).
+                issuer: /pages[\\/]_document\./,
+                use: {
+                    loader: "error-loader",
+                    options: {
+                        reason: getCustomDocumentError()
+                    }
+                }
+            })
+        ]
+    }));
+    const shouldIncludeExternalCSSImports = !!ctx.experimental.craCompat || !!ctx.transpilePackages;
+    // CSS modules & SASS modules support. They are allowed to be imported in anywhere.
+    fns.push(// CSS Modules should never have side effects. This setting will
+    // allow unused CSS to be removed from the production build.
+    // We ensure this by disallowing `:global()` CSS at the top-level
+    // via the `pure` mode in `css-loader`.
+    loader({
+        oneOf: [
+            // For app dir, we need to match the specific app layer.
+            ctx.hasAppDir ? markRemovable({
+                sideEffects: true,
+                test: regexCssModules,
+                issuerLayer: APP_LAYER_RULE,
+                use: [
+                    {
+                        loader: require.resolve("../../../loaders/next-flight-css-loader"),
+                        options: {
+                            cssModules: true
+                        }
+                    },
+                    ...getCssModuleLoader({
+                        ...ctx,
+                        isAppDir: true
+                    }, lazyPostCSSInitializer)
+                ]
+            }) : null,
+            markRemovable({
+                sideEffects: true,
+                test: regexCssModules,
+                issuerLayer: PAGES_LAYER_RULE,
+                use: getCssModuleLoader({
+                    ...ctx,
+                    isAppDir: false
+                }, lazyPostCSSInitializer)
+            })
+        ].filter(nonNullable)
+    }), // Opt-in support for Sass (using .scss or .sass extensions).
+    // Sass Modules should never have side effects. This setting will
+    // allow unused Sass to be removed from the production build.
+    // We ensure this by disallowing `:global()` Sass at the top-level
+    // via the `pure` mode in `css-loader`.
+    loader({
+        oneOf: [
+            // For app dir, we need to match the specific app layer.
+            ctx.hasAppDir ? markRemovable({
+                sideEffects: true,
+                test: regexSassModules,
+                issuerLayer: APP_LAYER_RULE,
+                use: [
+                    {
+                        loader: require.resolve("../../../loaders/next-flight-css-loader"),
+                        options: {
+                            cssModules: true
+                        }
+                    },
+                    ...getCssModuleLoader({
+                        ...ctx,
+                        isAppDir: true
+                    }, lazyPostCSSInitializer, sassPreprocessors)
+                ]
+            }) : null,
+            markRemovable({
+                sideEffects: true,
+                test: regexSassModules,
+                issuerLayer: PAGES_LAYER_RULE,
+                use: getCssModuleLoader({
+                    ...ctx,
+                    isAppDir: false
+                }, lazyPostCSSInitializer, sassPreprocessors)
+            })
+        ].filter(nonNullable)
+    }), // Throw an error for CSS Modules used outside their supported scope
+    loader({
+        oneOf: [
+            markRemovable({
+                test: [
+                    regexCssModules,
+                    regexSassModules
+                ],
+                use: {
+                    loader: "error-loader",
+                    options: {
+                        reason: getLocalModuleImportError()
+                    }
+                }
+            })
+        ]
+    }));
+    // Global CSS and SASS support.
+    if (ctx.isServer) {
+        fns.push(loader({
+            oneOf: [
+                ctx.hasAppDir && !ctx.isProduction ? markRemovable({
+                    sideEffects: true,
+                    test: [
+                        regexCssGlobal,
+                        regexSassGlobal
+                    ],
+                    issuerLayer: APP_LAYER_RULE,
+                    use: {
+                        loader: require.resolve("../../../loaders/next-flight-css-loader"),
+                        options: {
+                            cssModules: false
+                        }
+                    }
+                }) : null,
+                markRemovable({
+                    // CSS imports have side effects, even on the server side.
+                    sideEffects: true,
+                    test: [
+                        regexCssGlobal,
+                        regexSassGlobal
+                    ],
+                    use: require.resolve("next/dist/compiled/ignore-loader")
+                })
+            ].filter(nonNullable)
+        }));
+    } else {
+        // External CSS files are allowed to be loaded when any of the following is true:
+        // - hasAppDir: all CSS files are allowed
+        // - If the CSS file is located in `node_modules`
+        // - If the CSS file is located in another package in a monorepo (outside of the current rootDir)
+        // - If the issuer is pages/_app (matched later)
+        const allowedPagesGlobalCSSPath = ctx.hasAppDir ? undefined : {
+            and: [
+                {
+                    or: [
+                        /node_modules/,
+                        {
+                            not: [
+                                ctx.rootDirectory
+                            ]
+                        }
+                    ]
+                }
+            ]
+        };
+        const allowedPagesGlobalCSSIssuer = ctx.hasAppDir ? undefined : shouldIncludeExternalCSSImports ? undefined : {
+            and: [
+                ctx.rootDirectory
+            ],
+            not: [
+                /node_modules/
+            ]
+        };
+        fns.push(loader({
+            oneOf: [
+                ...ctx.hasAppDir ? [
+                    markRemovable({
+                        sideEffects: true,
+                        test: regexCssGlobal,
+                        issuerLayer: APP_LAYER_RULE,
+                        use: [
+                            {
+                                loader: require.resolve("../../../loaders/next-flight-css-loader"),
+                                options: {
+                                    cssModules: false
+                                }
+                            },
+                            ...getGlobalCssLoader({
+                                ...ctx,
+                                isAppDir: true
+                            }, lazyPostCSSInitializer)
+                        ]
+                    }),
+                    markRemovable({
+                        sideEffects: true,
+                        test: regexSassGlobal,
+                        issuerLayer: APP_LAYER_RULE,
+                        use: [
+                            {
+                                loader: require.resolve("../../../loaders/next-flight-css-loader"),
+                                options: {
+                                    cssModules: false
+                                }
+                            },
+                            ...getGlobalCssLoader({
+                                ...ctx,
+                                isAppDir: true
+                            }, lazyPostCSSInitializer, sassPreprocessors)
+                        ]
+                    })
+                ] : [],
+                markRemovable({
+                    sideEffects: true,
+                    test: regexCssGlobal,
+                    include: allowedPagesGlobalCSSPath,
+                    issuer: allowedPagesGlobalCSSIssuer,
+                    issuerLayer: PAGES_LAYER_RULE,
+                    use: getGlobalCssLoader({
+                        ...ctx,
+                        isAppDir: false
+                    }, lazyPostCSSInitializer)
+                }),
+                markRemovable({
+                    sideEffects: true,
+                    test: regexSassGlobal,
+                    include: allowedPagesGlobalCSSPath,
+                    issuer: allowedPagesGlobalCSSIssuer,
+                    issuerLayer: PAGES_LAYER_RULE,
+                    use: getGlobalCssLoader({
+                        ...ctx,
+                        isAppDir: false
+                    }, lazyPostCSSInitializer, sassPreprocessors)
+                })
+            ].filter(nonNullable)
+        }));
+        if (ctx.customAppFile) {
+            fns.push(loader({
+                oneOf: [
+                    markRemovable({
+                        sideEffects: true,
+                        test: regexCssGlobal,
+                        issuer: {
+                            and: [
+                                ctx.customAppFile
+                            ]
+                        },
+                        use: getGlobalCssLoader({
+                            ...ctx,
+                            isAppDir: false
+                        }, lazyPostCSSInitializer)
+                    })
+                ]
+            }), loader({
+                oneOf: [
+                    markRemovable({
+                        sideEffects: true,
+                        test: regexSassGlobal,
+                        issuer: {
+                            and: [
+                                ctx.customAppFile
+                            ]
+                        },
+                        use: getGlobalCssLoader({
+                            ...ctx,
+                            isAppDir: false
+                        }, lazyPostCSSInitializer, sassPreprocessors)
+                    })
+                ]
+            }));
+        }
+    }
+    // Throw an error for Global CSS used inside of `node_modules`
+    if (!shouldIncludeExternalCSSImports) {
+        fns.push(loader({
+            oneOf: [
+                markRemovable({
+                    test: [
+                        regexCssGlobal,
+                        regexSassGlobal
+                    ],
+                    issuer: {
+                        and: [
+                            /node_modules/
+                        ]
+                    },
+                    use: {
+                        loader: "error-loader",
+                        options: {
+                            reason: getGlobalModuleImportError()
+                        }
+                    }
+                })
+            ]
+        }));
+    }
+    // Throw an error for Global CSS used outside of our custom <App> file
+    fns.push(loader({
+        oneOf: [
+            markRemovable({
+                test: [
+                    regexCssGlobal,
+                    regexSassGlobal
+                ],
+                issuer: ctx.hasAppDir ? {
+                    // If it's inside the app dir, but not importing from a layout file,
+                    // throw an error.
+                    and: [
+                        ctx.rootDirectory
+                    ],
+                    not: [
+                        /layout\.(js|mjs|jsx|ts|tsx)$/
+                    ]
+                } : undefined,
+                use: {
+                    loader: "error-loader",
+                    options: {
+                        reason: getGlobalImportError()
+                    }
+                }
+            })
+        ]
+    }));
+    if (ctx.isClient) {
+        // Automatically transform references to files (i.e. url()) into URLs
+        // e.g. url(./logo.svg)
+        fns.push(loader({
+            oneOf: [
+                markRemovable({
+                    // This should only be applied to CSS files
+                    issuer: regexLikeCss,
+                    // Exclude extensions that webpack handles by default
+                    exclude: [
+                        /\.(js|mjs|jsx|ts|tsx)$/,
+                        /\.html$/,
+                        /\.json$/,
+                        /\.webpack\[[^\]]+\]$/
+                    ],
+                    // `asset/resource` always emits a URL reference, where `asset`
+                    // might inline the asset as a data URI
+                    type: "asset/resource"
+                })
+            ]
+        }));
+    }
+    // Enable full mini-css-extract-plugin hmr for prod mode pages or app dir
+    if (ctx.isClient && (ctx.isProduction || ctx.hasAppDir)) {
+        // Extract CSS as CSS file(s) in the client-side production bundle.
+        const MiniCssExtractPlugin = require("../../../plugins/mini-css-extract-plugin").default;
+        fns.push(plugin(// @ts-ignore webpack 5 compat
+        new MiniCssExtractPlugin({
+            filename: ctx.isProduction ? "static/css/[contenthash].css" : "static/css/[name].css",
+            chunkFilename: ctx.isProduction ? "static/css/[contenthash].css" : "static/css/[name].css",
+            // Next.js guarantees that CSS order "doesn't matter", due to imposed
+            // restrictions:
+            // 1. Global CSS can only be defined in a single entrypoint (_app)
+            // 2. CSS Modules generate scoped class names by default and cannot
+            //    include Global CSS (:global() selector).
+            //
+            // While not a perfect guarantee (e.g. liberal use of `:global()`
+            // selector), this assumption is required to code-split CSS.
+            //
+            // If this warning were to trigger, it'd be unactionable by the user,
+            // but likely not valid -- so we disable it.
+            ignoreOrder: true
+        })));
+    }
+    const fn = pipe(...fns);
+    return fn(config);
+});
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/esm/build/webpack/config/blocks/css/loaders/client.js

@@ -0,0 +1,37 @@
+export function getClientStyleLoader({ hasAppDir, isAppDir, isDevelopment, assetPrefix }) {
+    const shouldEnableApp = typeof isAppDir === "boolean" ? isAppDir : hasAppDir;
+    // Keep next-style-loader for development mode in `pages/`
+    if (isDevelopment && !shouldEnableApp) {
+        return {
+            loader: "next-style-loader",
+            options: {
+                insert: function(element) {
+                    // By default, style-loader injects CSS into the bottom
+                    // of <head>. This causes ordering problems between dev
+                    // and prod. To fix this, we render a <noscript> tag as
+                    // an anchor for the styles to be placed before. These
+                    // styles will be applied _before_ <style jsx global>.
+                    // These elements should always exist. If they do not,
+                    // this code should fail.
+                    var anchorElement = document.querySelector("#__next_css__DO_NOT_USE__");
+                    var parentNode = anchorElement.parentNode// Normally <head>
+                    ;
+                    // Each style tag should be placed right before our
+                    // anchor. By inserting before and not after, we do not
+                    // need to track the last inserted element.
+                    parentNode.insertBefore(element, anchorElement);
+                }
+            }
+        };
+    }
+    const MiniCssExtractPlugin = require("../../../../plugins/mini-css-extract-plugin").default;
+    return {
+        loader: MiniCssExtractPlugin.loader,
+        options: {
+            publicPath: `${assetPrefix}/_next/`,
+            esModule: false
+        }
+    };
+}
+
+//# sourceMappingURL=client.js.map

node_modules/next/dist/esm/build/webpack/config/blocks/css/loaders/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/build/webpack/config/blocks/css/loaders/client.ts"],"names":["getClientStyleLoader","hasAppDir","isAppDir","isDevelopment","assetPrefix","shouldEnableApp","loader","options","insert","element","anchorElement","document","querySelector","parentNode","insertBefore","MiniCssExtractPlugin","require","default","publicPath","esModule"],"mappings":"AAEA,OAAO,SAASA,qBAAqB,EACnCC,SAAS,EACTC,QAAQ,EACRC,aAAa,EACbC,WAAW,EAMZ;IACC,MAAMC,kBAAkB,OAAOH,aAAa,YAAYA,WAAWD;IAEnE,0DAA0D;IAC1D,IAAIE,iBAAiB,CAACE,iBAAiB;QACrC,OAAO;YACLC,QAAQ;YACRC,SAAS;gBACPC,QAAQ,SAAUC,OAAa;oBAC7B,uDAAuD;oBACvD,uDAAuD;oBACvD,uDAAuD;oBACvD,sDAAsD;oBACtD,sDAAsD;oBAEtD,sDAAsD;oBACtD,yBAAyB;oBACzB,IAAIC,gBAAgBC,SAASC,aAAa,CACxC;oBAEF,IAAIC,aAAaH,cAAcG,UAAU,AAAE,kBAAkB;;oBAE7D,mDAAmD;oBACnD,uDAAuD;oBACvD,2CAA2C;oBAC3CA,WAAWC,YAAY,CAACL,SAASC;gBACnC;YACF;QACF;IACF;IAEA,MAAMK,uBACJC,QAAQ,+CAA+CC,OAAO;IAChE,OAAO;QACLX,QAAQS,qBAAqBT,MAAM;QACnCC,SAAS;YACPW,YAAY,CAAC,EAAEd,YAAY,OAAO,CAAC;YACnCe,UAAU;QACZ;IACF;AACF"}

node_modules/next/dist/esm/build/webpack/config/blocks/css/loaders/file-resolve.js

@@ -0,0 +1,11 @@
+export function cssFileResolve(url, _resourcePath, urlImports) {
+    if (url.startsWith("/")) {
+        return false;
+    }
+    if (!urlImports && /^[a-z][a-z0-9+.-]*:/i.test(url)) {
+        return false;
+    }
+    return true;
+}
+
+//# sourceMappingURL=file-resolve.js.map

node_modules/next/dist/esm/build/webpack/config/blocks/css/loaders/file-resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/build/webpack/config/blocks/css/loaders/file-resolve.ts"],"names":["cssFileResolve","url","_resourcePath","urlImports","startsWith","test"],"mappings":"AAAA,OAAO,SAASA,eACdC,GAAW,EACXC,aAAqB,EACrBC,UAAe;IAEf,IAAIF,IAAIG,UAAU,CAAC,MAAM;QACvB,OAAO;IACT;IACA,IAAI,CAACD,cAAc,uBAAuBE,IAAI,CAACJ,MAAM;QACnD,OAAO;IACT;IACA,OAAO;AACT"}

node_modules/next/dist/esm/build/webpack/config/blocks/css/loaders/getCssModuleLocalIdent.js

@@ -0,0 +1,22 @@
+import loaderUtils from "next/dist/compiled/loader-utils3";
+import path from "path";
+const regexLikeIndexModule = /(?<!pages[\\/])index\.module\.(scss|sass|css)$/;
+export function getCssModuleLocalIdent(context, _, exportName, options) {
+    const relativePath = path.relative(context.rootContext, context.resourcePath).replace(/\\+/g, "/");
+    // Generate a more meaningful name (parent folder) when the user names the
+    // file `index.module.css`.
+    const fileNameOrFolder = regexLikeIndexModule.test(relativePath) ? "[folder]" : "[name]";
+    // Generate a hash to make the class name unique.
+    const hash = loaderUtils.getHashDigest(Buffer.from(`filePath:${relativePath}#className:${exportName}`), "sha1", "base64", 5);
+    // Have webpack interpolate the `[folder]` or `[name]` to its real value.
+    return loaderUtils.interpolateName(context, fileNameOrFolder + "_" + exportName + "__" + hash, options).replace(// Webpack name interpolation returns `about.module_root__2oFM9` for
+    // `.root {}` inside a file named `about.module.css`. Let's simplify
+    // this.
+    /\.module_/, "_")// Replace invalid symbols with underscores instead of escaping
+    // https://mathiasbynens.be/notes/css-escapes#identifiers-strings
+    .replace(/[^a-zA-Z0-9-_]/g, "_")// "they cannot start with a digit, two hyphens, or a hyphen followed by a digit [sic]"
+    // https://www.w3.org/TR/CSS21/syndata.html#characters
+    .replace(/^(\d|--|-\d)/, "__$1");
+}
+
+//# sourceMappingURL=getCssModuleLocalIdent.js.map

node_modules/next/dist/esm/build/webpack/config/blocks/css/loaders/getCssModuleLocalIdent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/build/webpack/config/blocks/css/loaders/getCssModuleLocalIdent.ts"],"names":["loaderUtils","path","regexLikeIndexModule","getCssModuleLocalIdent","context","_","exportName","options","relativePath","relative","rootContext","resourcePath","replace","fileNameOrFolder","test","hash","getHashDigest","Buffer","from","interpolateName"],"mappings":"AAAA,OAAOA,iBAAiB,mCAAkC;AAC1D,OAAOC,UAAU,OAAM;AAGvB,MAAMC,uBAAuB;AAE7B,OAAO,SAASC,uBACdC,OAAkC,EAClCC,CAAM,EACNC,UAAkB,EAClBC,OAAe;IAEf,MAAMC,eAAeP,KAClBQ,QAAQ,CAACL,QAAQM,WAAW,EAAEN,QAAQO,YAAY,EAClDC,OAAO,CAAC,QAAQ;IAEnB,0EAA0E;IAC1E,2BAA2B;IAC3B,MAAMC,mBAAmBX,qBAAqBY,IAAI,CAACN,gBAC/C,aACA;IAEJ,iDAAiD;IACjD,MAAMO,OAAOf,YAAYgB,aAAa,CACpCC,OAAOC,IAAI,CAAC,CAAC,SAAS,EAAEV,aAAa,WAAW,EAAEF,WAAW,CAAC,GAC9D,QACA,UACA;IAGF,yEAAyE;IACzE,OACEN,YACGmB,eAAe,CACdf,SACAS,mBAAmB,MAAMP,aAAa,OAAOS,MAC7CR,SAEDK,OAAO,CACN,oEAAoE;IACpE,oEAAoE;IACpE,QAAQ;IACR,aACA,IAEF,+DAA+D;IAC/D,iEAAiE;KAChEA,OAAO,CAAC,mBAAmB,IAC5B,uFAAuF;IACvF,sDAAsD;KACrDA,OAAO,CAAC,gBAAgB;AAE/B"}

node_modules/next/dist/esm/build/webpack/config/blocks/css/loaders/global.js

@@ -0,0 +1,52 @@
+import { getClientStyleLoader } from "./client";
+import { cssFileResolve } from "./file-resolve";
+export function getGlobalCssLoader(ctx, postcss, preProcessors = []) {
+    const loaders = [];
+    if (ctx.isClient) {
+        // Add appropriate development more or production mode style
+        // loader
+        loaders.push(getClientStyleLoader({
+            hasAppDir: ctx.hasAppDir,
+            isAppDir: ctx.isAppDir,
+            isDevelopment: ctx.isDevelopment,
+            assetPrefix: ctx.assetPrefix
+        }));
+    }
+    if (ctx.experimental.useLightningcss) {
+        loaders.push({
+            loader: require.resolve("../../../../loaders/lightningcss-loader/src"),
+            options: {
+                importLoaders: 1 + preProcessors.length,
+                url: (url, resourcePath)=>cssFileResolve(url, resourcePath, ctx.experimental.urlImports),
+                import: (url, _, resourcePath)=>cssFileResolve(url, resourcePath, ctx.experimental.urlImports),
+                targets: ctx.supportedBrowsers
+            }
+        });
+    } else {
+        // Resolve CSS `@import`s and `url()`s
+        loaders.push({
+            loader: require.resolve("../../../../loaders/css-loader/src"),
+            options: {
+                postcss,
+                importLoaders: 1 + preProcessors.length,
+                // Next.js controls CSS Modules eligibility:
+                modules: false,
+                url: (url, resourcePath)=>cssFileResolve(url, resourcePath, ctx.experimental.urlImports),
+                import: (url, _, resourcePath)=>cssFileResolve(url, resourcePath, ctx.experimental.urlImports)
+            }
+        });
+        // Compile CSS
+        loaders.push({
+            loader: require.resolve("../../../../loaders/postcss-loader/src"),
+            options: {
+                postcss
+            }
+        });
+    }
+    loaders.push(// Webpack loaders run like a stack, so we need to reverse the natural
+    // order of preprocessors.
+    ...preProcessors.slice().reverse());
+    return loaders;
+}
+
+//# sourceMappingURL=global.js.map

node_modules/next/dist/esm/build/webpack/config/blocks/css/loaders/global.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/build/webpack/config/blocks/css/loaders/global.ts"],"names":["getClientStyleLoader","cssFileResolve","getGlobalCssLoader","ctx","postcss","preProcessors","loaders","isClient","push","hasAppDir","isAppDir","isDevelopment","assetPrefix","experimental","useLightningcss","loader","require","resolve","options","importLoaders","length","url","resourcePath","urlImports","import","_","targets","supportedBrowsers","modules","slice","reverse"],"mappings":"AAGA,SAASA,oBAAoB,QAAQ,WAAU;AAC/C,SAASC,cAAc,QAAQ,iBAAgB;AAE/C,OAAO,SAASC,mBACdC,GAAyB,EACzBC,OAAY,EACZC,gBAAmD,EAAE;IAErD,MAAMC,UAAoC,EAAE;IAE5C,IAAIH,IAAII,QAAQ,EAAE;QAChB,4DAA4D;QAC5D,SAAS;QACTD,QAAQE,IAAI,CACVR,qBAAqB;YACnBS,WAAWN,IAAIM,SAAS;YACxBC,UAAUP,IAAIO,QAAQ;YACtBC,eAAeR,IAAIQ,aAAa;YAChCC,aAAaT,IAAIS,WAAW;QAC9B;IAEJ;IAEA,IAAIT,IAAIU,YAAY,CAACC,eAAe,EAAE;QACpCR,QAAQE,IAAI,CAAC;YACXO,QAAQC,QAAQC,OAAO,CAAC;YACxBC,SAAS;gBACPC,eAAe,IAAId,cAAce,MAAM;gBACvCC,KAAK,CAACA,KAAaC,eACjBrB,eAAeoB,KAAKC,cAAcnB,IAAIU,YAAY,CAACU,UAAU;gBAC/DC,QAAQ,CAACH,KAAaI,GAAQH,eAC5BrB,eAAeoB,KAAKC,cAAcnB,IAAIU,YAAY,CAACU,UAAU;gBAC/DG,SAASvB,IAAIwB,iBAAiB;YAChC;QACF;IACF,OAAO;QACL,sCAAsC;QACtCrB,QAAQE,IAAI,CAAC;YACXO,QAAQC,QAAQC,OAAO,CAAC;YACxBC,SAAS;gBACPd;gBACAe,eAAe,IAAId,cAAce,MAAM;gBACvC,4CAA4C;gBAC5CQ,SAAS;gBACTP,KAAK,CAACA,KAAaC,eACjBrB,eAAeoB,KAAKC,cAAcnB,IAAIU,YAAY,CAACU,UAAU;gBAC/DC,QAAQ,CAACH,KAAaI,GAAQH,eAC5BrB,eAAeoB,KAAKC,cAAcnB,IAAIU,YAAY,CAACU,UAAU;YACjE;QACF;QAEA,cAAc;QACdjB,QAAQE,IAAI,CAAC;YACXO,QAAQC,QAAQC,OAAO,CAAC;YACxBC,SAAS;gBACPd;YACF;QACF;IACF;IAEAE,QAAQE,IAAI,CACV,sEAAsE;IACtE,0BAA0B;OACvBH,cAAcwB,KAAK,GAAGC,OAAO;IAGlC,OAAOxB;AACT"}

node_modules/next/dist/esm/build/webpack/config/blocks/css/loaders/index.js

@@ -0,0 +1,4 @@
+export * from "./global";
+export * from "./modules";
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/esm/build/webpack/config/blocks/css/loaders/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/build/webpack/config/blocks/css/loaders/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAU;AACxB,cAAc,YAAW"}

node_modules/next/dist/esm/build/webpack/config/blocks/css/loaders/modules.js

@@ -0,0 +1,74 @@
+import { getClientStyleLoader } from "./client";
+import { cssFileResolve } from "./file-resolve";
+import { getCssModuleLocalIdent } from "./getCssModuleLocalIdent";
+export function getCssModuleLoader(ctx, postcss, preProcessors = []) {
+    const loaders = [];
+    if (ctx.isClient) {
+        // Add appropriate development more or production mode style
+        // loader
+        loaders.push(getClientStyleLoader({
+            hasAppDir: ctx.hasAppDir,
+            isAppDir: ctx.isAppDir,
+            isDevelopment: ctx.isDevelopment,
+            assetPrefix: ctx.assetPrefix
+        }));
+    }
+    if (ctx.experimental.useLightningcss) {
+        loaders.push({
+            loader: require.resolve("../../../../loaders/lightningcss-loader/src"),
+            options: {
+                importLoaders: 1 + preProcessors.length,
+                url: (url, resourcePath)=>cssFileResolve(url, resourcePath, ctx.experimental.urlImports),
+                import: (url, _, resourcePath)=>cssFileResolve(url, resourcePath, ctx.experimental.urlImports),
+                modules: {
+                    // Do not transform class names (CJS mode backwards compatibility):
+                    exportLocalsConvention: "asIs",
+                    // Server-side (Node.js) rendering support:
+                    exportOnlyLocals: ctx.isServer
+                },
+                targets: ctx.supportedBrowsers
+            }
+        });
+    } else {
+        // Resolve CSS `@import`s and `url()`s
+        loaders.push({
+            loader: require.resolve("../../../../loaders/css-loader/src"),
+            options: {
+                postcss,
+                importLoaders: 1 + preProcessors.length,
+                // Use CJS mode for backwards compatibility:
+                esModule: false,
+                url: (url, resourcePath)=>cssFileResolve(url, resourcePath, ctx.experimental.urlImports),
+                import: (url, _, resourcePath)=>cssFileResolve(url, resourcePath, ctx.experimental.urlImports),
+                modules: {
+                    // Do not transform class names (CJS mode backwards compatibility):
+                    exportLocalsConvention: "asIs",
+                    // Server-side (Node.js) rendering support:
+                    exportOnlyLocals: ctx.isServer,
+                    // Disallow global style exports so we can code-split CSS and
+                    // not worry about loading order.
+                    mode: "pure",
+                    // Generate a friendly production-ready name so it's
+                    // reasonably understandable. The same name is used for
+                    // development.
+                    // TODO: Consider making production reduce this to a single
+                    // character?
+                    getLocalIdent: getCssModuleLocalIdent
+                }
+            }
+        });
+        // Compile CSS
+        loaders.push({
+            loader: require.resolve("../../../../loaders/postcss-loader/src"),
+            options: {
+                postcss
+            }
+        });
+    }
+    loaders.push(// Webpack loaders run like a stack, so we need to reverse the natural
+    // order of preprocessors.
+    ...preProcessors.slice().reverse());
+    return loaders;
+}
+
+//# sourceMappingURL=modules.js.map

node_modules/next/dist/esm/build/webpack/config/blocks/css/loaders/modules.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/build/webpack/config/blocks/css/loaders/modules.ts"],"names":["getClientStyleLoader","cssFileResolve","getCssModuleLocalIdent","getCssModuleLoader","ctx","postcss","preProcessors","loaders","isClient","push","hasAppDir","isAppDir","isDevelopment","assetPrefix","experimental","useLightningcss","loader","require","resolve","options","importLoaders","length","url","resourcePath","urlImports","import","_","modules","exportLocalsConvention","exportOnlyLocals","isServer","targets","supportedBrowsers","esModule","mode","getLocalIdent","slice","reverse"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ,WAAU;AAC/C,SAASC,cAAc,QAAQ,iBAAgB;AAC/C,SAASC,sBAAsB,QAAQ,2BAA0B;AAEjE,OAAO,SAASC,mBACdC,GAAyB,EACzBC,OAAY,EACZC,gBAAmD,EAAE;IAErD,MAAMC,UAAoC,EAAE;IAE5C,IAAIH,IAAII,QAAQ,EAAE;QAChB,4DAA4D;QAC5D,SAAS;QACTD,QAAQE,IAAI,CACVT,qBAAqB;YACnBU,WAAWN,IAAIM,SAAS;YACxBC,UAAUP,IAAIO,QAAQ;YACtBC,eAAeR,IAAIQ,aAAa;YAChCC,aAAaT,IAAIS,WAAW;QAC9B;IAEJ;IAEA,IAAIT,IAAIU,YAAY,CAACC,eAAe,EAAE;QACpCR,QAAQE,IAAI,CAAC;YACXO,QAAQC,QAAQC,OAAO,CAAC;YACxBC,SAAS;gBACPC,eAAe,IAAId,cAAce,MAAM;gBACvCC,KAAK,CAACA,KAAaC,eACjBtB,eAAeqB,KAAKC,cAAcnB,IAAIU,YAAY,CAACU,UAAU;gBAC/DC,QAAQ,CAACH,KAAaI,GAAQH,eAC5BtB,eAAeqB,KAAKC,cAAcnB,IAAIU,YAAY,CAACU,UAAU;gBAC/DG,SAAS;oBACP,mEAAmE;oBACnEC,wBAAwB;oBACxB,2CAA2C;oBAC3CC,kBAAkBzB,IAAI0B,QAAQ;gBAChC;gBACAC,SAAS3B,IAAI4B,iBAAiB;YAChC;QACF;IACF,OAAO;QACL,sCAAsC;QACtCzB,QAAQE,IAAI,CAAC;YACXO,QAAQC,QAAQC,OAAO,CAAC;YACxBC,SAAS;gBACPd;gBACAe,eAAe,IAAId,cAAce,MAAM;gBACvC,4CAA4C;gBAC5CY,UAAU;gBACVX,KAAK,CAACA,KAAaC,eACjBtB,eAAeqB,KAAKC,cAAcnB,IAAIU,YAAY,CAACU,UAAU;gBAC/DC,QAAQ,CAACH,KAAaI,GAAQH,eAC5BtB,eAAeqB,KAAKC,cAAcnB,IAAIU,YAAY,CAACU,UAAU;gBAC/DG,SAAS;oBACP,mEAAmE;oBACnEC,wBAAwB;oBACxB,2CAA2C;oBAC3CC,kBAAkBzB,IAAI0B,QAAQ;oBAC9B,6DAA6D;oBAC7D,iCAAiC;oBACjCI,MAAM;oBACN,oDAAoD;oBACpD,uDAAuD;oBACvD,eAAe;oBACf,2DAA2D;oBAC3D,aAAa;oBACbC,eAAejC;gBACjB;YACF;QACF;QAEA,cAAc;QACdK,QAAQE,IAAI,CAAC;YACXO,QAAQC,QAAQC,OAAO,CAAC;YACxBC,SAAS;gBACPd;YACF;QACF;IACF;IAEAE,QAAQE,IAAI,CACV,sEAAsE;IACtE,0BAA0B;OACvBH,cAAc8B,KAAK,GAAGC,OAAO;IAGlC,OAAO9B;AACT"}

node_modules/next/dist/esm/build/webpack/config/blocks/css/loaders/next-font.js

@@ -0,0 +1,52 @@
+import { getClientStyleLoader } from "./client";
+import { cssFileResolve } from "./file-resolve";
+export function getNextFontLoader(ctx, postcss, fontLoaderPath) {
+    const loaders = [];
+    if (ctx.isClient) {
+        // Add appropriate development mode or production mode style
+        // loader
+        loaders.push(getClientStyleLoader({
+            hasAppDir: ctx.hasAppDir,
+            isDevelopment: ctx.isDevelopment,
+            assetPrefix: ctx.assetPrefix
+        }));
+    }
+    loaders.push({
+        loader: require.resolve("../../../../loaders/css-loader/src"),
+        options: {
+            postcss,
+            importLoaders: 1,
+            // Use CJS mode for backwards compatibility:
+            esModule: false,
+            url: (url, resourcePath)=>cssFileResolve(url, resourcePath, ctx.experimental.urlImports),
+            import: (url, _, resourcePath)=>cssFileResolve(url, resourcePath, ctx.experimental.urlImports),
+            modules: {
+                // Do not transform class names (CJS mode backwards compatibility):
+                exportLocalsConvention: "asIs",
+                // Server-side (Node.js) rendering support:
+                exportOnlyLocals: ctx.isServer,
+                // Disallow global style exports so we can code-split CSS and
+                // not worry about loading order.
+                mode: "pure",
+                getLocalIdent: (_context, _localIdentName, exportName, _options, meta)=>{
+                    // hash from next-font-loader
+                    return `__${exportName}_${meta.fontFamilyHash}`;
+                }
+            },
+            fontLoader: true
+        }
+    });
+    loaders.push({
+        loader: "next-font-loader",
+        options: {
+            isDev: ctx.isDevelopment,
+            isServer: ctx.isServer,
+            assetPrefix: ctx.assetPrefix,
+            fontLoaderPath,
+            postcss
+        }
+    });
+    return loaders;
+}
+
+//# sourceMappingURL=next-font.js.map

node_modules/next/dist/esm/build/webpack/config/blocks/css/loaders/next-font.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/build/webpack/config/blocks/css/loaders/next-font.ts"],"names":["getClientStyleLoader","cssFileResolve","getNextFontLoader","ctx","postcss","fontLoaderPath","loaders","isClient","push","hasAppDir","isDevelopment","assetPrefix","loader","require","resolve","options","importLoaders","esModule","url","resourcePath","experimental","urlImports","import","_","modules","exportLocalsConvention","exportOnlyLocals","isServer","mode","getLocalIdent","_context","_localIdentName","exportName","_options","meta","fontFamilyHash","fontLoader","isDev"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ,WAAU;AAC/C,SAASC,cAAc,QAAQ,iBAAgB;AAE/C,OAAO,SAASC,kBACdC,GAAyB,EACzBC,OAAY,EACZC,cAAsB;IAEtB,MAAMC,UAAoC,EAAE;IAE5C,IAAIH,IAAII,QAAQ,EAAE;QAChB,4DAA4D;QAC5D,SAAS;QACTD,QAAQE,IAAI,CACVR,qBAAqB;YACnBS,WAAWN,IAAIM,SAAS;YACxBC,eAAeP,IAAIO,aAAa;YAChCC,aAAaR,IAAIQ,WAAW;QAC9B;IAEJ;IAEAL,QAAQE,IAAI,CAAC;QACXI,QAAQC,QAAQC,OAAO,CAAC;QACxBC,SAAS;YACPX;YACAY,eAAe;YACf,4CAA4C;YAC5CC,UAAU;YACVC,KAAK,CAACA,KAAaC,eACjBlB,eAAeiB,KAAKC,cAAchB,IAAIiB,YAAY,CAACC,UAAU;YAC/DC,QAAQ,CAACJ,KAAaK,GAAQJ,eAC5BlB,eAAeiB,KAAKC,cAAchB,IAAIiB,YAAY,CAACC,UAAU;YAC/DG,SAAS;gBACP,mEAAmE;gBACnEC,wBAAwB;gBACxB,2CAA2C;gBAC3CC,kBAAkBvB,IAAIwB,QAAQ;gBAC9B,6DAA6D;gBAC7D,iCAAiC;gBACjCC,MAAM;gBACNC,eAAe,CACbC,UACAC,iBACAC,YACAC,UACAC;oBAEA,6BAA6B;oBAC7B,OAAO,CAAC,EAAE,EAAEF,WAAW,CAAC,EAAEE,KAAKC,cAAc,CAAC,CAAC;gBACjD;YACF;YACAC,YAAY;QACd;IACF;IAEA9B,QAAQE,IAAI,CAAC;QACXI,QAAQ;QACRG,SAAS;YACPsB,OAAOlC,IAAIO,aAAa;YACxBiB,UAAUxB,IAAIwB,QAAQ;YACtBhB,aAAaR,IAAIQ,WAAW;YAC5BN;YACAD;QACF;IACF;IAEA,OAAOE;AACT"}

node_modules/next/dist/esm/build/webpack/config/blocks/css/messages.js

@@ -0,0 +1,15 @@
+import { bold, cyan } from "../../../../../lib/picocolors";
+export function getGlobalImportError() {
+    return `Global CSS ${bold("cannot")} be imported from files other than your ${bold("Custom <App>")}. Due to the Global nature of stylesheets, and to avoid conflicts, Please move all first-party global CSS imports to ${cyan("pages/_app.js")}. Or convert the import to Component-Level CSS (CSS Modules).\nRead more: https://nextjs.org/docs/messages/css-global`;
+}
+export function getGlobalModuleImportError() {
+    return `Global CSS ${bold("cannot")} be imported from within ${bold("node_modules")}.\nRead more: https://nextjs.org/docs/messages/css-npm`;
+}
+export function getLocalModuleImportError() {
+    return `CSS Modules ${bold("cannot")} be imported from within ${bold("node_modules")}.\nRead more: https://nextjs.org/docs/messages/css-modules-npm`;
+}
+export function getCustomDocumentError() {
+    return `CSS ${bold("cannot")} be imported within ${cyan("pages/_document.js")}. Please move global styles to ${cyan("pages/_app.js")}.`;
+}
+
+//# sourceMappingURL=messages.js.map

node_modules/next/dist/esm/build/webpack/config/blocks/css/messages.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/config/blocks/css/messages.ts"],"names":["bold","cyan","getGlobalImportError","getGlobalModuleImportError","getLocalModuleImportError","getCustomDocumentError"],"mappings":"AAAA,SAASA,IAAI,EAAEC,IAAI,QAAQ,gCAA+B;AAE1D,OAAO,SAASC;IACd,OAAO,CAAC,WAAW,EAAEF,KACnB,UACA,wCAAwC,EAAEA,KAC1C,gBACA,qHAAqH,EAAEC,KACvH,iBACA,qHAAqH,CAAC;AAC1H;AAEA,OAAO,SAASE;IACd,OAAO,CAAC,WAAW,EAAEH,KAAK,UAAU,yBAAyB,EAAEA,KAC7D,gBACA,sDAAsD,CAAC;AAC3D;AAEA,OAAO,SAASI;IACd,OAAO,CAAC,YAAY,EAAEJ,KAAK,UAAU,yBAAyB,EAAEA,KAC9D,gBACA,8DAA8D,CAAC;AACnE;AAEA,OAAO,SAASK;IACd,OAAO,CAAC,IAAI,EAAEL,KAAK,UAAU,oBAAoB,EAAEC,KACjD,sBACA,+BAA+B,EAAEA,KAAK,iBAAiB,CAAC,CAAC;AAC7D"}

node_modules/next/dist/esm/build/webpack/config/blocks/css/plugins.js

@@ -0,0 +1,152 @@
+import { bold, red, underline, yellow } from "../../../../../lib/picocolors";
+import { findConfig } from "../../../../../lib/find-config";
+const genericErrorText = "Malformed PostCSS Configuration";
+function getError_NullConfig(pluginName) {
+    return `${red(bold("Error"))}: Your PostCSS configuration for '${pluginName}' cannot have ${bold("null")} configuration.\nTo disable '${pluginName}', pass ${bold("false")}, otherwise, pass ${bold("true")} or a configuration object.`;
+}
+function isIgnoredPlugin(pluginPath) {
+    const ignoredRegex = /(?:^|[\\/])(postcss-modules-values|postcss-modules-scope|postcss-modules-extract-imports|postcss-modules-local-by-default|postcss-modules)(?:[\\/]|$)/i;
+    const match = ignoredRegex.exec(pluginPath);
+    if (match == null) {
+        return false;
+    }
+    const plugin = match.pop();
+    console.warn(`${yellow(bold("Warning"))}: Please remove the ${underline(plugin)} plugin from your PostCSS configuration. ` + `This plugin is automatically configured by Next.js.\n` + "Read more: https://nextjs.org/docs/messages/postcss-ignored-plugin");
+    return true;
+}
+const createLazyPostCssPlugin = (fn)=>{
+    let result = undefined;
+    const plugin = (...args)=>{
+        if (result === undefined) result = fn();
+        if (result.postcss === true) {
+            return result(...args);
+        } else if (result.postcss) {
+            return result.postcss;
+        }
+        return result;
+    };
+    plugin.postcss = true;
+    return plugin;
+};
+async function loadPlugin(dir, pluginName, options) {
+    if (options === false || isIgnoredPlugin(pluginName)) {
+        return false;
+    }
+    if (options == null) {
+        console.error(getError_NullConfig(pluginName));
+        throw new Error(genericErrorText);
+    }
+    const pluginPath = require.resolve(pluginName, {
+        paths: [
+            dir
+        ]
+    });
+    if (isIgnoredPlugin(pluginPath)) {
+        return false;
+    } else if (options === true) {
+        return createLazyPostCssPlugin(()=>require(pluginPath));
+    } else {
+        if (typeof options === "object" && Object.keys(options).length === 0) {
+            return createLazyPostCssPlugin(()=>require(pluginPath));
+        }
+        return createLazyPostCssPlugin(()=>require(pluginPath)(options));
+    }
+}
+function getDefaultPlugins(supportedBrowsers, disablePostcssPresetEnv) {
+    return [
+        require.resolve("next/dist/compiled/postcss-flexbugs-fixes"),
+        disablePostcssPresetEnv ? false : [
+            require.resolve("next/dist/compiled/postcss-preset-env"),
+            {
+                browsers: supportedBrowsers ?? [
+                    "defaults"
+                ],
+                autoprefixer: {
+                    // Disable legacy flexbox support
+                    flexbox: "no-2009"
+                },
+                // Enable CSS features that have shipped to the
+                // web platform, i.e. in 2+ browsers unflagged.
+                stage: 3,
+                features: {
+                    "custom-properties": false
+                }
+            }
+        ]
+    ].filter(Boolean);
+}
+export async function getPostCssPlugins(dir, supportedBrowsers, disablePostcssPresetEnv = false) {
+    let config = await findConfig(dir, "postcss");
+    if (config == null) {
+        config = {
+            plugins: getDefaultPlugins(supportedBrowsers, disablePostcssPresetEnv)
+        };
+    }
+    if (typeof config === "function") {
+        throw new Error(`Your custom PostCSS configuration may not export a function. Please export a plain object instead.\n` + "Read more: https://nextjs.org/docs/messages/postcss-function");
+    }
+    // Warn user about configuration keys which are not respected
+    const invalidKey = Object.keys(config).find((key)=>key !== "plugins");
+    if (invalidKey) {
+        console.warn(`${yellow(bold("Warning"))}: Your PostCSS configuration defines a field which is not supported (\`${invalidKey}\`). ` + `Please remove this configuration value.`);
+    }
+    // Enforce the user provided plugins if the configuration file is present
+    let plugins = config.plugins;
+    if (plugins == null || typeof plugins !== "object") {
+        throw new Error(`Your custom PostCSS configuration must export a \`plugins\` key.`);
+    }
+    if (!Array.isArray(plugins)) {
+        // Capture variable so TypeScript is happy
+        const pc = plugins;
+        plugins = Object.keys(plugins).reduce((acc, curr)=>{
+            const p = pc[curr];
+            if (typeof p === "undefined") {
+                console.error(getError_NullConfig(curr));
+                throw new Error(genericErrorText);
+            }
+            acc.push([
+                curr,
+                p
+            ]);
+            return acc;
+        }, []);
+    }
+    const parsed = [];
+    plugins.forEach((plugin)=>{
+        if (plugin == null) {
+            console.warn(`${yellow(bold("Warning"))}: A ${bold("null")} PostCSS plugin was provided. This entry will be ignored.`);
+        } else if (typeof plugin === "string") {
+            parsed.push([
+                plugin,
+                true
+            ]);
+        } else if (Array.isArray(plugin)) {
+            const pluginName = plugin[0];
+            const pluginConfig = plugin[1];
+            if (typeof pluginName === "string" && (typeof pluginConfig === "boolean" || typeof pluginConfig === "object" || typeof pluginConfig === "string")) {
+                parsed.push([
+                    pluginName,
+                    pluginConfig
+                ]);
+            } else {
+                if (typeof pluginName !== "string") {
+                    console.error(`${red(bold("Error"))}: A PostCSS Plugin must be provided as a ${bold("string")}. Instead, we got: '${pluginName}'.\n` + "Read more: https://nextjs.org/docs/messages/postcss-shape");
+                } else {
+                    console.error(`${red(bold("Error"))}: A PostCSS Plugin was passed as an array but did not provide its configuration ('${pluginName}').\n` + "Read more: https://nextjs.org/docs/messages/postcss-shape");
+                }
+                throw new Error(genericErrorText);
+            }
+        } else if (typeof plugin === "function") {
+            console.error(`${red(bold("Error"))}: A PostCSS Plugin was passed as a function using require(), but it must be provided as a ${bold("string")}.\nRead more: https://nextjs.org/docs/messages/postcss-shape`);
+            throw new Error(genericErrorText);
+        } else {
+            console.error(`${red(bold("Error"))}: An unknown PostCSS plugin was provided (${plugin}).\n` + "Read more: https://nextjs.org/docs/messages/postcss-shape");
+            throw new Error(genericErrorText);
+        }
+    });
+    const resolved = await Promise.all(parsed.map((p)=>loadPlugin(dir, p[0], p[1])));
+    const filtered = resolved.filter(Boolean);
+    return filtered;
+}
+
+//# sourceMappingURL=plugins.js.map

node_modules/next/dist/esm/build/webpack/config/blocks/css/plugins.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/config/blocks/css/plugins.ts"],"names":["bold","red","underline","yellow","findConfig","genericErrorText","getError_NullConfig","pluginName","isIgnoredPlugin","pluginPath","ignoredRegex","match","exec","plugin","pop","console","warn","createLazyPostCssPlugin","fn","result","undefined","args","postcss","loadPlugin","dir","options","error","Error","require","resolve","paths","Object","keys","length","getDefaultPlugins","supportedBrowsers","disablePostcssPresetEnv","browsers","autoprefixer","flexbox","stage","features","filter","Boolean","getPostCssPlugins","config","plugins","invalidKey","find","key","Array","isArray","pc","reduce","acc","curr","p","push","parsed","forEach","pluginConfig","resolved","Promise","all","map","filtered"],"mappings":"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"}

node_modules/next/dist/esm/build/webpack/config/blocks/images/index.js

@@ -0,0 +1,27 @@
+import curry from "next/dist/compiled/lodash.curry";
+import { nextImageLoaderRegex } from "../../../../webpack-config";
+import { loader } from "../../helpers";
+import { pipe } from "../../utils";
+import { getCustomDocumentImageError } from "./messages";
+export const images = curry(async function images(_ctx, config) {
+    const fns = [
+        loader({
+            oneOf: [
+                {
+                    test: nextImageLoaderRegex,
+                    use: {
+                        loader: "error-loader",
+                        options: {
+                            reason: getCustomDocumentImageError()
+                        }
+                    },
+                    issuer: /pages[\\/]_document\./
+                }
+            ]
+        })
+    ];
+    const fn = pipe(...fns);
+    return fn(config);
+});
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/esm/build/webpack/config/blocks/images/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/config/blocks/images/index.ts"],"names":["curry","nextImageLoaderRegex","loader","pipe","getCustomDocumentImageError","images","_ctx","config","fns","oneOf","test","use","options","reason","issuer","fn"],"mappings":"AAAA,OAAOA,WAAW,kCAAiC;AAEnD,SAASC,oBAAoB,QAAQ,6BAA4B;AACjE,SAASC,MAAM,QAAQ,gBAAe;AACtC,SAASC,IAAI,QAAQ,cAAa;AAElC,SAASC,2BAA2B,QAAQ,aAAY;AAExD,OAAO,MAAMC,SAASL,MAAM,eAAeK,OACzCC,IAA0B,EAC1BC,MAA6B;IAE7B,MAAMC,MAAyB;QAC7BN,OAAO;YACLO,OAAO;gBACL;oBACEC,MAAMT;oBACNU,KAAK;wBACHT,QAAQ;wBACRU,SAAS;4BACPC,QAAQT;wBACV;oBACF;oBACAU,QAAQ;gBACV;aACD;QACH;KACD;IAED,MAAMC,KAAKZ,QAAQK;IACnB,OAAOO,GAAGR;AACZ,GAAE"}

node_modules/next/dist/esm/build/webpack/config/blocks/images/messages.js

@@ -0,0 +1,6 @@
+import { bold, cyan } from "../../../../../lib/picocolors";
+export function getCustomDocumentImageError() {
+    return `Images ${bold("cannot")} be imported within ${cyan("pages/_document.js")}. Please move image imports that need to be displayed on every page into ${cyan("pages/_app.js")}.\nRead more: https://nextjs.org/docs/messages/custom-document-image-import`;
+}
+
+//# sourceMappingURL=messages.js.map

node_modules/next/dist/esm/build/webpack/config/blocks/images/messages.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/config/blocks/images/messages.ts"],"names":["bold","cyan","getCustomDocumentImageError"],"mappings":"AAAA,SAASA,IAAI,EAAEC,IAAI,QAAQ,gCAA+B;AAE1D,OAAO,SAASC;IACd,OAAO,CAAC,OAAO,EAAEF,KAAK,UAAU,oBAAoB,EAAEC,KACpD,sBACA,yEAAyE,EAAEA,KAC3E,iBACA,2EAA2E,CAAC;AAChF"}

node_modules/next/dist/esm/build/webpack/config/helpers.js

@@ -0,0 +1,47 @@
+import curry from "next/dist/compiled/lodash.curry";
+export const loader = curry(function loader(rule, config) {
+    var _config_module_rules;
+    if (!config.module) {
+        config.module = {
+            rules: []
+        };
+    }
+    if (rule.oneOf) {
+        var _config_module_rules1;
+        const existing = (_config_module_rules1 = config.module.rules) == null ? void 0 : _config_module_rules1.find((arrayRule)=>arrayRule && typeof arrayRule === "object" && arrayRule.oneOf);
+        if (existing && typeof existing === "object") {
+            existing.oneOf.push(...rule.oneOf);
+            return config;
+        }
+    }
+    (_config_module_rules = config.module.rules) == null ? void 0 : _config_module_rules.push(rule);
+    return config;
+});
+export const unshiftLoader = curry(function unshiftLoader(rule, config) {
+    var _config_module_rules;
+    if (!config.module) {
+        config.module = {
+            rules: []
+        };
+    }
+    if (rule.oneOf) {
+        var _config_module_rules1;
+        const existing = (_config_module_rules1 = config.module.rules) == null ? void 0 : _config_module_rules1.find((arrayRule)=>arrayRule && typeof arrayRule === "object" && arrayRule.oneOf);
+        if (existing && typeof existing === "object") {
+            var _existing_oneOf;
+            (_existing_oneOf = existing.oneOf) == null ? void 0 : _existing_oneOf.unshift(...rule.oneOf);
+            return config;
+        }
+    }
+    (_config_module_rules = config.module.rules) == null ? void 0 : _config_module_rules.unshift(rule);
+    return config;
+});
+export const plugin = curry(function plugin(p, config) {
+    if (!config.plugins) {
+        config.plugins = [];
+    }
+    config.plugins.push(p);
+    return config;
+});
+
+//# sourceMappingURL=helpers.js.map

node_modules/next/dist/esm/build/webpack/config/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/config/helpers.ts"],"names":["curry","loader","rule","config","module","rules","oneOf","existing","find","arrayRule","push","unshiftLoader","unshift","plugin","p","plugins"],"mappings":"AAAA,OAAOA,WAAW,kCAAiC;AAGnD,OAAO,MAAMC,SAASD,MAAM,SAASC,OACnCC,IAAyB,EACzBC,MAA6B;QAiB7BA;IAfA,IAAI,CAACA,OAAOC,MAAM,EAAE;QAClBD,OAAOC,MAAM,GAAG;YAAEC,OAAO,EAAE;QAAC;IAC9B;IAEA,IAAIH,KAAKI,KAAK,EAAE;YACGH;QAAjB,MAAMI,YAAWJ,wBAAAA,OAAOC,MAAM,CAACC,KAAK,qBAAnBF,sBAAqBK,IAAI,CACxC,CAACC,YACCA,aAAa,OAAOA,cAAc,YAAYA,UAAUH,KAAK;QAEjE,IAAIC,YAAY,OAAOA,aAAa,UAAU;YAC5CA,SAASD,KAAK,CAAEI,IAAI,IAAIR,KAAKI,KAAK;YAClC,OAAOH;QACT;IACF;KAEAA,uBAAAA,OAAOC,MAAM,CAACC,KAAK,qBAAnBF,qBAAqBO,IAAI,CAACR;IAC1B,OAAOC;AACT,GAAE;AAEF,OAAO,MAAMQ,gBAAgBX,MAAM,SAASW,cAC1CT,IAAyB,EACzBC,MAA6B;QAiB7BA;IAfA,IAAI,CAACA,OAAOC,MAAM,EAAE;QAClBD,OAAOC,MAAM,GAAG;YAAEC,OAAO,EAAE;QAAC;IAC9B;IAEA,IAAIH,KAAKI,KAAK,EAAE;YACGH;QAAjB,MAAMI,YAAWJ,wBAAAA,OAAOC,MAAM,CAACC,KAAK,qBAAnBF,sBAAqBK,IAAI,CACxC,CAACC,YACCA,aAAa,OAAOA,cAAc,YAAYA,UAAUH,KAAK;QAEjE,IAAIC,YAAY,OAAOA,aAAa,UAAU;gBAC5CA;aAAAA,kBAAAA,SAASD,KAAK,qBAAdC,gBAAgBK,OAAO,IAAIV,KAAKI,KAAK;YACrC,OAAOH;QACT;IACF;KAEAA,uBAAAA,OAAOC,MAAM,CAACC,KAAK,qBAAnBF,qBAAqBS,OAAO,CAACV;IAC7B,OAAOC;AACT,GAAE;AAEF,OAAO,MAAMU,SAASb,MAAM,SAASa,OACnCC,CAAgC,EAChCX,MAA6B;IAE7B,IAAI,CAACA,OAAOY,OAAO,EAAE;QACnBZ,OAAOY,OAAO,GAAG,EAAE;IACrB;IACAZ,OAAOY,OAAO,CAACL,IAAI,CAACI;IACpB,OAAOX;AACT,GAAE"}

node_modules/next/dist/esm/build/webpack/config/index.js

@@ -0,0 +1,36 @@
+import { base } from "./blocks/base";
+import { css } from "./blocks/css";
+import { images } from "./blocks/images";
+import { pipe } from "./utils";
+export async function buildConfiguration(config, { hasAppDir, supportedBrowsers, rootDirectory, customAppFile, isDevelopment, isServer, isEdgeRuntime, targetWeb, assetPrefix, sassOptions, productionBrowserSourceMaps, future, transpilePackages, experimental, disableStaticImages, serverSourceMaps }) {
+    const ctx = {
+        hasAppDir,
+        supportedBrowsers,
+        rootDirectory,
+        customAppFile,
+        isDevelopment,
+        isProduction: !isDevelopment,
+        isServer,
+        isEdgeRuntime,
+        isClient: !isServer,
+        targetWeb,
+        assetPrefix: assetPrefix ? assetPrefix.endsWith("/") ? assetPrefix.slice(0, -1) : assetPrefix : "",
+        sassOptions,
+        productionBrowserSourceMaps,
+        transpilePackages,
+        future,
+        experimental,
+        serverSourceMaps: serverSourceMaps ?? false
+    };
+    let fns = [
+        base(ctx),
+        css(ctx)
+    ];
+    if (!disableStaticImages) {
+        fns.push(images(ctx));
+    }
+    const fn = pipe(...fns);
+    return fn(config);
+}
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/esm/build/webpack/config/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/config/index.ts"],"names":["base","css","images","pipe","buildConfiguration","config","hasAppDir","supportedBrowsers","rootDirectory","customAppFile","isDevelopment","isServer","isEdgeRuntime","targetWeb","assetPrefix","sassOptions","productionBrowserSourceMaps","future","transpilePackages","experimental","disableStaticImages","serverSourceMaps","ctx","isProduction","isClient","endsWith","slice","fns","push","fn"],"mappings":"AAIA,SAASA,IAAI,QAAQ,gBAAe;AACpC,SAASC,GAAG,QAAQ,eAAc;AAClC,SAASC,MAAM,QAAQ,kBAAiB;AACxC,SAASC,IAAI,QAAQ,UAAS;AAE9B,OAAO,eAAeC,mBACpBC,MAA6B,EAC7B,EACEC,SAAS,EACTC,iBAAiB,EACjBC,aAAa,EACbC,aAAa,EACbC,aAAa,EACbC,QAAQ,EACRC,aAAa,EACbC,SAAS,EACTC,WAAW,EACXC,WAAW,EACXC,2BAA2B,EAC3BC,MAAM,EACNC,iBAAiB,EACjBC,YAAY,EACZC,mBAAmB,EACnBC,gBAAgB,EAkBjB;IAED,MAAMC,MAA4B;QAChChB;QACAC;QACAC;QACAC;QACAC;QACAa,cAAc,CAACb;QACfC;QACAC;QACAY,UAAU,CAACb;QACXE;QACAC,aAAaA,cACTA,YAAYW,QAAQ,CAAC,OACnBX,YAAYY,KAAK,CAAC,GAAG,CAAC,KACtBZ,cACF;QACJC;QACAC;QACAE;QACAD;QACAE;QACAE,kBAAkBA,oBAAoB;IACxC;IAEA,IAAIM,MAAM;QAAC3B,KAAKsB;QAAMrB,IAAIqB;KAAK;IAC/B,IAAI,CAACF,qBAAqB;QACxBO,IAAIC,IAAI,CAAC1B,OAAOoB;IAClB;IACA,MAAMO,KAAK1B,QAAQwB;IACnB,OAAOE,GAAGxB;AACZ"}

node_modules/next/dist/esm/build/webpack/config/utils.js

@@ -0,0 +1,3 @@
+export const pipe = (...fns)=>(param)=>fns.reduce(async (result, next)=>next(await result), param);
+
+//# sourceMappingURL=utils.js.map

node_modules/next/dist/esm/build/webpack/config/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/config/utils.ts"],"names":["pipe","fns","param","reduce","result","next"],"mappings":"AAoCA,OAAO,MAAMA,OACX,CAAI,GAAGC,MACP,CAACC,QACCD,IAAIE,MAAM,CACR,OAAOC,QAAwBC,OAASA,KAAK,MAAMD,SACnDF,OACD"}

node_modules/next/dist/esm/build/webpack/loaders/css-loader/src/CssSyntaxError.js

@@ -0,0 +1,22 @@
+export default class CssSyntaxError extends Error {
+    constructor(error){
+        super(error);
+        const { reason, line, column } = error;
+        this.name = "CssSyntaxError";
+        // Based on https://github.com/postcss/postcss/blob/master/lib/css-syntax-error.es6#L132
+        // We don't need `plugin` and `file` properties.
+        this.message = `${this.name}\n\n`;
+        if (typeof line !== "undefined") {
+            this.message += `(${line}:${column}) `;
+        }
+        this.message += reason;
+        const code = error.showSourceCode();
+        if (code) {
+            this.message += `\n\n${code}\n`;
+        }
+        // We don't need stack https://github.com/postcss/postcss/blob/master/docs/guidelines/runner.md#31-dont-show-js-stack-for-csssyntaxerror
+        this.stack = false;
+    }
+}
+
+//# sourceMappingURL=CssSyntaxError.js.map

node_modules/next/dist/esm/build/webpack/loaders/css-loader/src/CssSyntaxError.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/loaders/css-loader/src/CssSyntaxError.ts"],"names":["CssSyntaxError","Error","constructor","error","reason","line","column","name","message","code","showSourceCode","stack"],"mappings":"AAAA,eAAe,MAAMA,uBAAuBC;IAE1CC,YAAYC,KAAU,CAAE;QACtB,KAAK,CAACA;QAEN,MAAM,EAAEC,MAAM,EAAEC,IAAI,EAAEC,MAAM,EAAE,GAAGH;QAEjC,IAAI,CAACI,IAAI,GAAG;QAEZ,wFAAwF;QACxF,gDAAgD;QAChD,IAAI,CAACC,OAAO,GAAG,CAAC,EAAE,IAAI,CAACD,IAAI,CAAC,IAAI,CAAC;QAEjC,IAAI,OAAOF,SAAS,aAAa;YAC/B,IAAI,CAACG,OAAO,IAAI,CAAC,CAAC,EAAEH,KAAK,CAAC,EAAEC,OAAO,EAAE,CAAC;QACxC;QAEA,IAAI,CAACE,OAAO,IAAIJ;QAEhB,MAAMK,OAAON,MAAMO,cAAc;QAEjC,IAAID,MAAM;YACR,IAAI,CAACD,OAAO,IAAI,CAAC,IAAI,EAAEC,KAAK,EAAE,CAAC;QACjC;QAEA,wIAAwI;QACxI,IAAI,CAACE,KAAK,GAAG;IACf;AACF"}

node_modules/next/dist/esm/build/webpack/loaders/css-loader/src/camelcase.js

@@ -0,0 +1,79 @@
+/*
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/ const preserveCamelCase = (string, locale)=>{
+    let isLastCharLower = false;
+    let isLastCharUpper = false;
+    let isLastLastCharUpper = false;
+    for(let i = 0; i < string.length; i++){
+        const character = string[i];
+        if (isLastCharLower && /[\p{Lu}]/u.test(character)) {
+            string = string.slice(0, i) + "-" + string.slice(i);
+            isLastCharLower = false;
+            isLastLastCharUpper = isLastCharUpper;
+            isLastCharUpper = true;
+            i++;
+        } else if (isLastCharUpper && isLastLastCharUpper && /[\p{Ll}]/u.test(character)) {
+            string = string.slice(0, i - 1) + "-" + string.slice(i - 1);
+            isLastLastCharUpper = isLastCharUpper;
+            isLastCharUpper = false;
+            isLastCharLower = true;
+        } else {
+            isLastCharLower = character.toLocaleLowerCase(locale) === character && character.toLocaleUpperCase(locale) !== character;
+            isLastLastCharUpper = isLastCharUpper;
+            isLastCharUpper = character.toLocaleUpperCase(locale) === character && character.toLocaleLowerCase(locale) !== character;
+        }
+    }
+    return string;
+};
+const preserveConsecutiveUppercase = (input)=>{
+    return input.replace(/^[\p{Lu}](?![\p{Lu}])/gu, (m1)=>m1.toLowerCase());
+};
+const postProcess = (input, options)=>{
+    return input.replace(/[_.\- ]+([\p{Alpha}\p{N}_]|$)/gu, (_, p1)=>p1.toLocaleUpperCase(options.locale)).replace(/\d+([\p{Alpha}\p{N}_]|$)/gu, (m)=>m.toLocaleUpperCase(options.locale));
+};
+const camelCase = (input, options)=>{
+    if (!(typeof input === "string" || Array.isArray(input))) {
+        throw new TypeError("Expected the input to be `string | string[]`");
+    }
+    options = {
+        pascalCase: false,
+        preserveConsecutiveUppercase: false,
+        ...options
+    };
+    if (Array.isArray(input)) {
+        input = input.map((x)=>x.trim()).filter((x)=>x.length).join("-");
+    } else {
+        input = input.trim();
+    }
+    if (input.length === 0) {
+        return "";
+    }
+    if (input.length === 1) {
+        return options.pascalCase ? input.toLocaleUpperCase(options.locale) : input.toLocaleLowerCase(options.locale);
+    }
+    const hasUpperCase = input !== input.toLocaleLowerCase(options.locale);
+    if (hasUpperCase) {
+        input = preserveCamelCase(input, options.locale);
+    }
+    input = input.replace(/^[_.\- ]+/, "");
+    if (options.preserveConsecutiveUppercase) {
+        input = preserveConsecutiveUppercase(input);
+    } else {
+        input = input.toLocaleLowerCase();
+    }
+    if (options.pascalCase) {
+        input = input.charAt(0).toLocaleUpperCase(options.locale) + input.slice(1);
+    }
+    return postProcess(input, options);
+};
+export default camelCase;
+
+//# sourceMappingURL=camelcase.js.map

node_modules/next/dist/esm/build/webpack/loaders/css-loader/src/camelcase.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/loaders/css-loader/src/camelcase.ts"],"names":["preserveCamelCase","string","locale","isLastCharLower","isLastCharUpper","isLastLastCharUpper","i","length","character","test","slice","toLocaleLowerCase","toLocaleUpperCase","preserveConsecutiveUppercase","input","replace","m1","toLowerCase","postProcess","options","_","p1","m","camelCase","Array","isArray","TypeError","pascalCase","map","x","trim","filter","join","hasUpperCase","charAt"],"mappings":"AAAA;;;;;;;;;;AAUA,GAEA,MAAMA,oBAAoB,CAACC,QAAgBC;IACzC,IAAIC,kBAAkB;IACtB,IAAIC,kBAAkB;IACtB,IAAIC,sBAAsB;IAE1B,IAAK,IAAIC,IAAI,GAAGA,IAAIL,OAAOM,MAAM,EAAED,IAAK;QACtC,MAAME,YAAYP,MAAM,CAACK,EAAE;QAE3B,IAAIH,mBAAmB,YAAYM,IAAI,CAACD,YAAY;YAClDP,SAASA,OAAOS,KAAK,CAAC,GAAGJ,KAAK,MAAML,OAAOS,KAAK,CAACJ;YACjDH,kBAAkB;YAClBE,sBAAsBD;YACtBA,kBAAkB;YAClBE;QACF,OAAO,IACLF,mBACAC,uBACA,YAAYI,IAAI,CAACD,YACjB;YACAP,SAASA,OAAOS,KAAK,CAAC,GAAGJ,IAAI,KAAK,MAAML,OAAOS,KAAK,CAACJ,IAAI;YACzDD,sBAAsBD;YACtBA,kBAAkB;YAClBD,kBAAkB;QACpB,OAAO;YACLA,kBACEK,UAAUG,iBAAiB,CAACT,YAAYM,aACxCA,UAAUI,iBAAiB,CAACV,YAAYM;YAC1CH,sBAAsBD;YACtBA,kBACEI,UAAUI,iBAAiB,CAACV,YAAYM,aACxCA,UAAUG,iBAAiB,CAACT,YAAYM;QAC5C;IACF;IAEA,OAAOP;AACT;AAEA,MAAMY,+BAA+B,CAACC;IACpC,OAAOA,MAAMC,OAAO,CAAC,2BAA2B,CAACC,KAAOA,GAAGC,WAAW;AACxE;AAEA,MAAMC,cAAc,CAACJ,OAAeK;IAClC,OAAOL,MACJC,OAAO,CAAC,mCAAmC,CAACK,GAAGC,KAC9CA,GAAGT,iBAAiB,CAACO,QAAQjB,MAAM,GAEpCa,OAAO,CAAC,8BAA8B,CAACO,IACtCA,EAAEV,iBAAiB,CAACO,QAAQjB,MAAM;AAExC;AAEA,MAAMqB,YAAY,CAACT,OAA0BK;IAC3C,IAAI,CAAE,CAAA,OAAOL,UAAU,YAAYU,MAAMC,OAAO,CAACX,MAAK,GAAI;QACxD,MAAM,IAAIY,UAAU;IACtB;IAEAP,UAAU;QACRQ,YAAY;QACZd,8BAA8B;QAC9B,GAAGM,OAAO;IACZ;IAEA,IAAIK,MAAMC,OAAO,CAACX,QAAQ;QACxBA,QAAQA,MACLc,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI,IACjBC,MAAM,CAAC,CAACF,IAAMA,EAAEtB,MAAM,EACtByB,IAAI,CAAC;IACV,OAAO;QACLlB,QAAQA,MAAMgB,IAAI;IACpB;IAEA,IAAIhB,MAAMP,MAAM,KAAK,GAAG;QACtB,OAAO;IACT;IAEA,IAAIO,MAAMP,MAAM,KAAK,GAAG;QACtB,OAAOY,QAAQQ,UAAU,GACrBb,MAAMF,iBAAiB,CAACO,QAAQjB,MAAM,IACtCY,MAAMH,iBAAiB,CAACQ,QAAQjB,MAAM;IAC5C;IAEA,MAAM+B,eAAenB,UAAUA,MAAMH,iBAAiB,CAACQ,QAAQjB,MAAM;IAErE,IAAI+B,cAAc;QAChBnB,QAAQd,kBAAkBc,OAAOK,QAAQjB,MAAM;IACjD;IAEAY,QAAQA,MAAMC,OAAO,CAAC,aAAa;IAEnC,IAAII,QAAQN,4BAA4B,EAAE;QACxCC,QAAQD,6BAA6BC;IACvC,OAAO;QACLA,QAAQA,MAAMH,iBAAiB;IACjC;IAEA,IAAIQ,QAAQQ,UAAU,EAAE;QACtBb,QAAQA,MAAMoB,MAAM,CAAC,GAAGtB,iBAAiB,CAACO,QAAQjB,MAAM,IAAIY,MAAMJ,KAAK,CAAC;IAC1E;IAEA,OAAOQ,YAAYJ,OAAOK;AAC5B;AAEA,eAAeI,UAAS"}

node_modules/next/dist/esm/build/webpack/loaders/css-loader/src/index.js

@@ -0,0 +1,254 @@
+/*
+  MIT License http://www.opensource.org/licenses/mit-license.php
+  Author Tobias Koppers @sokra
+*/ import CssSyntaxError from "./CssSyntaxError";
+import Warning from "../../postcss-loader/src/Warning";
+import { stringifyRequest } from "../../../stringify-request";
+const moduleRegExp = /\.module\.\w+$/i;
+function getModulesOptions(rawOptions, loaderContext) {
+    const { resourcePath } = loaderContext;
+    if (typeof rawOptions.modules === "undefined") {
+        const isModules = moduleRegExp.test(resourcePath);
+        if (!isModules) {
+            return false;
+        }
+    } else if (typeof rawOptions.modules === "boolean" && rawOptions.modules === false) {
+        return false;
+    }
+    let modulesOptions = {
+        compileType: rawOptions.icss ? "icss" : "module",
+        auto: true,
+        mode: "local",
+        exportGlobals: false,
+        localIdentName: "[hash:base64]",
+        localIdentContext: loaderContext.rootContext,
+        localIdentHashPrefix: "",
+        // eslint-disable-next-line no-undefined
+        localIdentRegExp: undefined,
+        namedExport: false,
+        exportLocalsConvention: "asIs",
+        exportOnlyLocals: false
+    };
+    if (typeof rawOptions.modules === "boolean" || typeof rawOptions.modules === "string") {
+        modulesOptions.mode = typeof rawOptions.modules === "string" ? rawOptions.modules : "local";
+    } else {
+        if (rawOptions.modules) {
+            if (typeof rawOptions.modules.auto === "boolean") {
+                const isModules = rawOptions.modules.auto && moduleRegExp.test(resourcePath);
+                if (!isModules) {
+                    return false;
+                }
+            } else if (rawOptions.modules.auto instanceof RegExp) {
+                const isModules = rawOptions.modules.auto.test(resourcePath);
+                if (!isModules) {
+                    return false;
+                }
+            } else if (typeof rawOptions.modules.auto === "function") {
+                const isModule = rawOptions.modules.auto(resourcePath);
+                if (!isModule) {
+                    return false;
+                }
+            }
+            if (rawOptions.modules.namedExport === true && typeof rawOptions.modules.exportLocalsConvention === "undefined") {
+                modulesOptions.exportLocalsConvention = "camelCaseOnly";
+            }
+        }
+        modulesOptions = {
+            ...modulesOptions,
+            ...rawOptions.modules || {}
+        };
+    }
+    if (typeof modulesOptions.mode === "function") {
+        modulesOptions.mode = modulesOptions.mode(loaderContext.resourcePath);
+    }
+    if (modulesOptions.namedExport === true) {
+        if (rawOptions.esModule === false) {
+            throw new Error('The "modules.namedExport" option requires the "esModules" option to be enabled');
+        }
+        if (modulesOptions.exportLocalsConvention !== "camelCaseOnly") {
+            throw new Error('The "modules.namedExport" option requires the "modules.exportLocalsConvention" option to be "camelCaseOnly"');
+        }
+    }
+    return modulesOptions;
+}
+function normalizeOptions(rawOptions, loaderContext) {
+    if (rawOptions.icss) {
+        loaderContext.emitWarning(new Error('The "icss" option is deprecated, use "modules.compileType: "icss"" instead'));
+    }
+    const modulesOptions = getModulesOptions(rawOptions, loaderContext);
+    return {
+        url: typeof rawOptions.url === "undefined" ? true : rawOptions.url,
+        import: typeof rawOptions.import === "undefined" ? true : rawOptions.import,
+        modules: modulesOptions,
+        // TODO remove in the next major release
+        icss: typeof rawOptions.icss === "undefined" ? false : rawOptions.icss,
+        sourceMap: typeof rawOptions.sourceMap === "boolean" ? rawOptions.sourceMap : loaderContext.sourceMap,
+        importLoaders: typeof rawOptions.importLoaders === "string" ? parseInt(rawOptions.importLoaders, 10) : rawOptions.importLoaders,
+        esModule: typeof rawOptions.esModule === "undefined" ? true : rawOptions.esModule,
+        fontLoader: rawOptions.fontLoader
+    };
+}
+export default async function loader(content, map, meta) {
+    const rawOptions = this.getOptions();
+    const plugins = [];
+    const callback = this.async();
+    const loaderSpan = this.currentTraceSpan.traceChild("css-loader");
+    loaderSpan.traceAsyncFn(async ()=>{
+        let options;
+        try {
+            options = normalizeOptions(rawOptions, this);
+        } catch (error) {
+            throw error;
+        }
+        const { postcss } = await rawOptions.postcss();
+        const { shouldUseModulesPlugins, shouldUseImportPlugin, shouldUseURLPlugin, shouldUseIcssPlugin, getPreRequester, getExportCode, getFilter, getImportCode, getModuleCode, getModulesPlugins, normalizeSourceMap, sort } = require("./utils");
+        const { icssParser, importParser, urlParser } = require("./plugins");
+        const replacements = [];
+        // if it's a font loader next-font-loader will have exports that should be exported as is
+        const exports = options.fontLoader ? meta.exports : [];
+        if (shouldUseModulesPlugins(options)) {
+            plugins.push(...getModulesPlugins(options, this, meta));
+        }
+        const importPluginImports = [];
+        const importPluginApi = [];
+        if (shouldUseImportPlugin(options)) {
+            const resolver = this.getResolve({
+                conditionNames: [
+                    "style"
+                ],
+                extensions: [
+                    ".css"
+                ],
+                mainFields: [
+                    "css",
+                    "style",
+                    "main",
+                    "..."
+                ],
+                mainFiles: [
+                    "index",
+                    "..."
+                ],
+                restrictions: [
+                    /\.css$/i
+                ]
+            });
+            plugins.push(importParser({
+                imports: importPluginImports,
+                api: importPluginApi,
+                context: this.context,
+                rootContext: this.rootContext,
+                filter: getFilter(options.import, this.resourcePath),
+                resolver,
+                urlHandler: (url)=>stringifyRequest(this, getPreRequester(this)(options.importLoaders) + url)
+            }));
+        }
+        const urlPluginImports = [];
+        if (shouldUseURLPlugin(options)) {
+            const urlResolver = this.getResolve({
+                conditionNames: [
+                    "asset"
+                ],
+                mainFields: [
+                    "asset"
+                ],
+                mainFiles: [],
+                extensions: []
+            });
+            plugins.push(urlParser({
+                imports: urlPluginImports,
+                replacements,
+                context: this.context,
+                rootContext: this.rootContext,
+                filter: getFilter(options.url, this.resourcePath),
+                resolver: urlResolver,
+                urlHandler: (url)=>stringifyRequest(this, url)
+            }));
+        }
+        const icssPluginImports = [];
+        const icssPluginApi = [];
+        if (shouldUseIcssPlugin(options)) {
+            const icssResolver = this.getResolve({
+                conditionNames: [
+                    "style"
+                ],
+                extensions: [],
+                mainFields: [
+                    "css",
+                    "style",
+                    "main",
+                    "..."
+                ],
+                mainFiles: [
+                    "index",
+                    "..."
+                ]
+            });
+            plugins.push(icssParser({
+                imports: icssPluginImports,
+                api: icssPluginApi,
+                replacements,
+                exports,
+                context: this.context,
+                rootContext: this.rootContext,
+                resolver: icssResolver,
+                urlHandler: (url)=>stringifyRequest(this, getPreRequester(this)(options.importLoaders) + url)
+            }));
+        }
+        // Reuse CSS AST (PostCSS AST e.g 'postcss-loader') to avoid reparsing
+        if (meta) {
+            const { ast } = meta;
+            if (ast && ast.type === "postcss") {
+                // eslint-disable-next-line no-param-reassign
+                content = ast.root;
+                loaderSpan.setAttribute("astUsed", "true");
+            }
+        }
+        const { resourcePath } = this;
+        let result;
+        try {
+            result = await postcss(plugins).process(content, {
+                from: resourcePath,
+                to: resourcePath,
+                map: options.sourceMap ? {
+                    prev: map ? normalizeSourceMap(map, resourcePath) : null,
+                    inline: false,
+                    annotation: false
+                } : false
+            });
+        } catch (error) {
+            if (error.file) {
+                this.addDependency(error.file);
+            }
+            throw error.name === "CssSyntaxError" ? new CssSyntaxError(error) : error;
+        }
+        for (const warning of result.warnings()){
+            this.emitWarning(new Warning(warning));
+        }
+        const imports = [
+            ...icssPluginImports.sort(sort),
+            ...importPluginImports.sort(sort),
+            ...urlPluginImports.sort(sort)
+        ];
+        const api = [
+            ...importPluginApi.sort(sort),
+            ...icssPluginApi.sort(sort)
+        ];
+        if (options.modules.exportOnlyLocals !== true) {
+            imports.unshift({
+                importName: "___CSS_LOADER_API_IMPORT___",
+                url: stringifyRequest(this, require.resolve("./runtime/api"))
+            });
+        }
+        const importCode = getImportCode(imports, options);
+        const moduleCode = getModuleCode(result, api, replacements, options, this);
+        const exportCode = getExportCode(exports, replacements, options);
+        return `${importCode}${moduleCode}${exportCode}`;
+    }).then((code)=>{
+        callback(null, code);
+    }, (err)=>{
+        callback(err);
+    });
+}
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/esm/build/webpack/loaders/css-loader/src/plugins/index.js

@@ -0,0 +1,6 @@
+import importParser from "./postcss-import-parser";
+import icssParser from "./postcss-icss-parser";
+import urlParser from "./postcss-url-parser";
+export { importParser, icssParser, urlParser };
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/esm/build/webpack/loaders/css-loader/src/plugins/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/build/webpack/loaders/css-loader/src/plugins/index.ts"],"names":["importParser","icssParser","urlParser"],"mappings":"AAAA,OAAOA,kBAAkB,0BAAyB;AAClD,OAAOC,gBAAgB,wBAAuB;AAC9C,OAAOC,eAAe,uBAAsB;AAE5C,SAASF,YAAY,EAAEC,UAAU,EAAEC,SAAS,GAAE"}

node_modules/next/dist/esm/build/webpack/loaders/css-loader/src/plugins/postcss-icss-parser.js

@@ -0,0 +1,97 @@
+import { extractICSS, replaceValueSymbols, replaceSymbols } from "next/dist/compiled/icss-utils";
+import { normalizeUrl, resolveRequests, requestify } from "../utils";
+const plugin = (options = {})=>{
+    return {
+        postcssPlugin: "postcss-icss-parser",
+        async OnceExit (root) {
+            const importReplacements = Object.create(null);
+            const { icssImports, icssExports } = extractICSS(root);
+            const imports = new Map();
+            const tasks = [];
+            // eslint-disable-next-line guard-for-in
+            for(const url in icssImports){
+                const tokens = icssImports[url];
+                if (Object.keys(tokens).length === 0) {
+                    continue;
+                }
+                let normalizedUrl = url;
+                let prefix = "";
+                const queryParts = normalizedUrl.split("!");
+                if (queryParts.length > 1) {
+                    normalizedUrl = queryParts.pop();
+                    prefix = queryParts.join("!");
+                }
+                const request = requestify(normalizeUrl(normalizedUrl, true), options.rootContext);
+                const doResolve = async ()=>{
+                    const { resolver, context } = options;
+                    const resolvedUrl = await resolveRequests(resolver, context, [
+                        ...new Set([
+                            normalizedUrl,
+                            request
+                        ])
+                    ]);
+                    if (!resolvedUrl) {
+                        return;
+                    }
+                    // eslint-disable-next-line consistent-return
+                    return {
+                        url: resolvedUrl,
+                        prefix,
+                        tokens
+                    };
+                };
+                tasks.push(doResolve());
+            }
+            const results = await Promise.all(tasks);
+            for(let index = 0; index <= results.length - 1; index++){
+                const item = results[index];
+                if (!item) {
+                    continue;
+                }
+                const newUrl = item.prefix ? `${item.prefix}!${item.url}` : item.url;
+                const importKey = newUrl;
+                let importName = imports.get(importKey);
+                if (!importName) {
+                    importName = `___CSS_LOADER_ICSS_IMPORT_${imports.size}___`;
+                    imports.set(importKey, importName);
+                    options.imports.push({
+                        type: "icss_import",
+                        importName,
+                        url: options.urlHandler(newUrl),
+                        icss: true,
+                        index
+                    });
+                    options.api.push({
+                        importName,
+                        dedupe: true,
+                        index
+                    });
+                }
+                for (const [replacementIndex, token] of Object.keys(item.tokens).entries()){
+                    const replacementName = `___CSS_LOADER_ICSS_IMPORT_${index}_REPLACEMENT_${replacementIndex}___`;
+                    const localName = item.tokens[token];
+                    importReplacements[token] = replacementName;
+                    options.replacements.push({
+                        replacementName,
+                        importName,
+                        localName
+                    });
+                }
+            }
+            if (Object.keys(importReplacements).length > 0) {
+                replaceSymbols(root, importReplacements);
+            }
+            for (const name of Object.keys(icssExports)){
+                const value = replaceValueSymbols(icssExports[name], importReplacements);
+                options.exports.push({
+                    name,
+                    value
+                });
+            }
+        }
+    };
+};
+plugin.postcss = true;
+export default plugin;
+
+//# sourceMappingURL=postcss-icss-parser.js.map

node_modules/next/dist/esm/build/webpack/loaders/css-loader/src/plugins/postcss-icss-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/build/webpack/loaders/css-loader/src/plugins/postcss-icss-parser.ts"],"names":["extractICSS","replaceValueSymbols","replaceSymbols","normalizeUrl","resolveRequests","requestify","plugin","options","postcssPlugin","OnceExit","root","importReplacements","Object","create","icssImports","icssExports","imports","Map","tasks","url","tokens","keys","length","normalizedUrl","prefix","queryParts","split","pop","join","request","rootContext","doResolve","resolver","context","resolvedUrl","Set","push","results","Promise","all","index","item","newUrl","importKey","importName","get","size","set","type","urlHandler","icss","api","dedupe","replacementIndex","token","entries","replacementName","localName","replacements","name","value","exports","postcss"],"mappings":"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"}

node_modules/next/dist/esm/build/webpack/loaders/css-loader/src/plugins/postcss-import-parser.js

@@ -0,0 +1,193 @@
+import valueParser from "next/dist/compiled/postcss-value-parser";
+import { normalizeUrl, resolveRequests, isUrlRequestable, requestify, // @ts-expect-error TODO: this export doesn't exist? Double check.
+WEBPACK_IGNORE_COMMENT_REGEXP } from "../utils";
+function parseNode(atRule, key) {
+    // Convert only top-level @import
+    if (atRule.parent.type !== "root") {
+        return;
+    }
+    if (atRule.raws && atRule.raws.afterName && atRule.raws.afterName.trim().length > 0) {
+        const lastCommentIndex = atRule.raws.afterName.lastIndexOf("/*");
+        const matched = atRule.raws.afterName.slice(lastCommentIndex).match(WEBPACK_IGNORE_COMMENT_REGEXP);
+        if (matched && matched[2] === "true") {
+            return;
+        }
+    }
+    const prevNode = atRule.prev();
+    if (prevNode && prevNode.type === "comment") {
+        const matched = prevNode.text.match(WEBPACK_IGNORE_COMMENT_REGEXP);
+        if (matched && matched[2] === "true") {
+            return;
+        }
+    }
+    // Nodes do not exists - `@import url('http://') :root {}`
+    if (atRule.nodes) {
+        const error = new Error("It looks like you didn't end your @import statement correctly. Child nodes are attached to it.");
+        error.node = atRule;
+        throw error;
+    }
+    const { nodes: paramsNodes } = valueParser(atRule[key]);
+    // No nodes - `@import ;`
+    // Invalid type - `@import foo-bar;`
+    if (paramsNodes.length === 0 || paramsNodes[0].type !== "string" && paramsNodes[0].type !== "function") {
+        const error = new Error(`Unable to find uri in "${atRule.toString()}"`);
+        error.node = atRule;
+        throw error;
+    }
+    let isStringValue;
+    let url;
+    if (paramsNodes[0].type === "string") {
+        isStringValue = true;
+        url = paramsNodes[0].value;
+    } else {
+        // Invalid function - `@import nourl(test.css);`
+        if (paramsNodes[0].value.toLowerCase() !== "url") {
+            const error = new Error(`Unable to find uri in "${atRule.toString()}"`);
+            error.node = atRule;
+            throw error;
+        }
+        isStringValue = paramsNodes[0].nodes.length !== 0 && paramsNodes[0].nodes[0].type === "string";
+        url = isStringValue ? paramsNodes[0].nodes[0].value : valueParser.stringify(paramsNodes[0].nodes);
+    }
+    url = normalizeUrl(url, isStringValue);
+    const isRequestable = isUrlRequestable(url);
+    let prefix;
+    if (isRequestable) {
+        const queryParts = url.split("!");
+        if (queryParts.length > 1) {
+            url = queryParts.pop();
+            prefix = queryParts.join("!");
+        }
+    }
+    // Empty url - `@import "";` or `@import url();`
+    if (url.trim().length === 0) {
+        const error = new Error(`Unable to find uri in "${atRule.toString()}"`);
+        error.node = atRule;
+        throw error;
+    }
+    const mediaNodes = paramsNodes.slice(1);
+    let media;
+    if (mediaNodes.length > 0) {
+        media = valueParser.stringify(mediaNodes).trim().toLowerCase();
+    }
+    // eslint-disable-next-line consistent-return
+    return {
+        atRule,
+        prefix,
+        url,
+        media,
+        isRequestable
+    };
+}
+const plugin = (options = {})=>{
+    return {
+        postcssPlugin: "postcss-import-parser",
+        prepare (result) {
+            const parsedAtRules = [];
+            return {
+                AtRule: {
+                    import (atRule) {
+                        let parsedAtRule;
+                        try {
+                            // @ts-expect-error TODO: there is no third argument?
+                            parsedAtRule = parseNode(atRule, "params", result);
+                        } catch (error) {
+                            result.warn(error.message, {
+                                node: error.node
+                            });
+                        }
+                        if (!parsedAtRule) {
+                            return;
+                        }
+                        parsedAtRules.push(parsedAtRule);
+                    }
+                },
+                async OnceExit () {
+                    if (parsedAtRules.length === 0) {
+                        return;
+                    }
+                    const resolvedAtRules = await Promise.all(parsedAtRules.map(async (parsedAtRule)=>{
+                        const { atRule, isRequestable, prefix, url, media } = parsedAtRule;
+                        if (options.filter) {
+                            const needKeep = await options.filter(url, media);
+                            if (!needKeep) {
+                                return;
+                            }
+                        }
+                        if (isRequestable) {
+                            const request = requestify(url, options.rootContext);
+                            const { resolver, context } = options;
+                            const resolvedUrl = await resolveRequests(resolver, context, [
+                                ...new Set([
+                                    request,
+                                    url
+                                ])
+                            ]);
+                            if (!resolvedUrl) {
+                                return;
+                            }
+                            if (resolvedUrl === options.resourcePath) {
+                                atRule.remove();
+                                return;
+                            }
+                            atRule.remove();
+                            // eslint-disable-next-line consistent-return
+                            return {
+                                url: resolvedUrl,
+                                media,
+                                prefix,
+                                isRequestable
+                            };
+                        }
+                        atRule.remove();
+                        // eslint-disable-next-line consistent-return
+                        return {
+                            url,
+                            media,
+                            prefix,
+                            isRequestable
+                        };
+                    }));
+                    const urlToNameMap = new Map();
+                    for(let index = 0; index <= resolvedAtRules.length - 1; index++){
+                        const resolvedAtRule = resolvedAtRules[index];
+                        if (!resolvedAtRule) {
+                            continue;
+                        }
+                        const { url, isRequestable, media } = resolvedAtRule;
+                        if (!isRequestable) {
+                            options.api.push({
+                                url,
+                                media,
+                                index
+                            });
+                            continue;
+                        }
+                        const { prefix } = resolvedAtRule;
+                        const newUrl = prefix ? `${prefix}!${url}` : url;
+                        let importName = urlToNameMap.get(newUrl);
+                        if (!importName) {
+                            importName = `___CSS_LOADER_AT_RULE_IMPORT_${urlToNameMap.size}___`;
+                            urlToNameMap.set(newUrl, importName);
+                            options.imports.push({
+                                type: "rule_import",
+                                importName,
+                                url: options.urlHandler(newUrl),
+                                index
+                            });
+                        }
+                        options.api.push({
+                            importName,
+                            media,
+                            index
+                        });
+                    }
+                }
+            };
+        }
+    };
+};
+plugin.postcss = true;
+export default plugin;
+
+//# sourceMappingURL=postcss-import-parser.js.map

node_modules/next/dist/esm/build/webpack/loaders/css-loader/src/plugins/postcss-url-parser.js

@@ -0,0 +1,313 @@
+import valueParser from "next/dist/compiled/postcss-value-parser";
+import { resolveRequests, normalizeUrl, requestify, isUrlRequestable, isDataUrl, // @ts-expect-error TODO: this export doesn't exist? Double check.
+WEBPACK_IGNORE_COMMENT_REGEXP } from "../utils";
+const isUrlFunc = /url/i;
+const isImageSetFunc = /^(?:-webkit-)?image-set$/i;
+const needParseDeclaration = /(?:url|(?:-webkit-)?image-set)\(/i;
+function getNodeFromUrlFunc(node) {
+    return node.nodes && node.nodes[0];
+}
+function getWebpackIgnoreCommentValue(index, nodes, inBetween) {
+    if (index === 0 && typeof inBetween !== "undefined") {
+        return inBetween;
+    }
+    let prevValueNode = nodes[index - 1];
+    if (!prevValueNode) {
+        // eslint-disable-next-line consistent-return
+        return;
+    }
+    if (prevValueNode.type === "space") {
+        if (!nodes[index - 2]) {
+            // eslint-disable-next-line consistent-return
+            return;
+        }
+        prevValueNode = nodes[index - 2];
+    }
+    if (prevValueNode.type !== "comment") {
+        // eslint-disable-next-line consistent-return
+        return;
+    }
+    const matched = prevValueNode.value.match(WEBPACK_IGNORE_COMMENT_REGEXP);
+    return matched && matched[2] === "true";
+}
+function shouldHandleURL(url, declaration, result, isSupportDataURLInNewURL) {
+    if (url.length === 0) {
+        result.warn(`Unable to find uri in '${declaration.toString()}'`, {
+            node: declaration
+        });
+        return false;
+    }
+    if (isDataUrl(url) && isSupportDataURLInNewURL) {
+        try {
+            decodeURIComponent(url);
+        } catch (ignoreError) {
+            return false;
+        }
+        return true;
+    }
+    if (!isUrlRequestable(url)) {
+        return false;
+    }
+    return true;
+}
+function parseDeclaration(declaration, key, result, isSupportDataURLInNewURL) {
+    if (!needParseDeclaration.test(declaration[key])) {
+        return;
+    }
+    const parsed = valueParser(declaration.raws && declaration.raws.value && declaration.raws.value.raw ? declaration.raws.value.raw : declaration[key]);
+    let inBetween;
+    if (declaration.raws && declaration.raws.between) {
+        const lastCommentIndex = declaration.raws.between.lastIndexOf("/*");
+        const matched = declaration.raws.between.slice(lastCommentIndex).match(WEBPACK_IGNORE_COMMENT_REGEXP);
+        if (matched) {
+            inBetween = matched[2] === "true";
+        }
+    }
+    let isIgnoreOnDeclaration = false;
+    const prevNode = declaration.prev();
+    if (prevNode && prevNode.type === "comment") {
+        const matched = prevNode.text.match(WEBPACK_IGNORE_COMMENT_REGEXP);
+        if (matched) {
+            isIgnoreOnDeclaration = matched[2] === "true";
+        }
+    }
+    let needIgnore;
+    const parsedURLs = [];
+    parsed.walk((valueNode, index, valueNodes)=>{
+        if (valueNode.type !== "function") {
+            return;
+        }
+        if (isUrlFunc.test(valueNode.value)) {
+            needIgnore = getWebpackIgnoreCommentValue(index, valueNodes, inBetween);
+            if (isIgnoreOnDeclaration && typeof needIgnore === "undefined" || needIgnore) {
+                if (needIgnore) {
+                    // eslint-disable-next-line no-undefined
+                    needIgnore = undefined;
+                }
+                return;
+            }
+            const { nodes } = valueNode;
+            const isStringValue = nodes.length !== 0 && nodes[0].type === "string";
+            let url = isStringValue ? nodes[0].value : valueParser.stringify(nodes);
+            url = normalizeUrl(url, isStringValue);
+            // Do not traverse inside `url`
+            if (!shouldHandleURL(url, declaration, result, isSupportDataURLInNewURL)) {
+                // eslint-disable-next-line consistent-return
+                return false;
+            }
+            const queryParts = url.split("!");
+            let prefix;
+            if (queryParts.length > 1) {
+                url = queryParts.pop();
+                prefix = queryParts.join("!");
+            }
+            parsedURLs.push({
+                declaration,
+                parsed,
+                node: getNodeFromUrlFunc(valueNode),
+                prefix,
+                url,
+                needQuotes: false
+            });
+            // eslint-disable-next-line consistent-return
+            return false;
+        } else if (isImageSetFunc.test(valueNode.value)) {
+            for (const [innerIndex, nNode] of valueNode.nodes.entries()){
+                const { type, value } = nNode;
+                if (type === "function" && isUrlFunc.test(value)) {
+                    needIgnore = getWebpackIgnoreCommentValue(innerIndex, valueNode.nodes);
+                    if (isIgnoreOnDeclaration && typeof needIgnore === "undefined" || needIgnore) {
+                        if (needIgnore) {
+                            // eslint-disable-next-line no-undefined
+                            needIgnore = undefined;
+                        }
+                        continue;
+                    }
+                    const { nodes } = nNode;
+                    const isStringValue = nodes.length !== 0 && nodes[0].type === "string";
+                    let url = isStringValue ? nodes[0].value : valueParser.stringify(nodes);
+                    url = normalizeUrl(url, isStringValue);
+                    // Do not traverse inside `url`
+                    if (!shouldHandleURL(url, declaration, result, isSupportDataURLInNewURL)) {
+                        // eslint-disable-next-line consistent-return
+                        return false;
+                    }
+                    const queryParts = url.split("!");
+                    let prefix;
+                    if (queryParts.length > 1) {
+                        url = queryParts.pop();
+                        prefix = queryParts.join("!");
+                    }
+                    parsedURLs.push({
+                        declaration,
+                        parsed,
+                        node: getNodeFromUrlFunc(nNode),
+                        prefix,
+                        url,
+                        needQuotes: false
+                    });
+                } else if (type === "string") {
+                    needIgnore = getWebpackIgnoreCommentValue(innerIndex, valueNode.nodes);
+                    if (isIgnoreOnDeclaration && typeof needIgnore === "undefined" || needIgnore) {
+                        if (needIgnore) {
+                            // eslint-disable-next-line no-undefined
+                            needIgnore = undefined;
+                        }
+                        continue;
+                    }
+                    let url = normalizeUrl(value, true);
+                    // Do not traverse inside `url`
+                    if (!shouldHandleURL(url, declaration, result, isSupportDataURLInNewURL)) {
+                        // eslint-disable-next-line consistent-return
+                        return false;
+                    }
+                    const queryParts = url.split("!");
+                    let prefix;
+                    if (queryParts.length > 1) {
+                        url = queryParts.pop();
+                        prefix = queryParts.join("!");
+                    }
+                    parsedURLs.push({
+                        declaration,
+                        parsed,
+                        node: nNode,
+                        prefix,
+                        url,
+                        needQuotes: true
+                    });
+                }
+            }
+            // Do not traverse inside `image-set`
+            // eslint-disable-next-line consistent-return
+            return false;
+        }
+    });
+    // eslint-disable-next-line consistent-return
+    return parsedURLs;
+}
+const plugin = (options = {})=>{
+    return {
+        postcssPlugin: "postcss-url-parser",
+        prepare (result) {
+            const parsedDeclarations = [];
+            return {
+                Declaration (declaration) {
+                    const { isSupportDataURLInNewURL } = options;
+                    const parsedURL = parseDeclaration(declaration, "value", result, isSupportDataURLInNewURL);
+                    if (!parsedURL) {
+                        return;
+                    }
+                    parsedDeclarations.push(...parsedURL);
+                },
+                async OnceExit () {
+                    if (parsedDeclarations.length === 0) {
+                        return;
+                    }
+                    const resolvedDeclarations = await Promise.all(parsedDeclarations.map(async (parsedDeclaration)=>{
+                        const { url } = parsedDeclaration;
+                        if (options.filter) {
+                            const needKeep = await options.filter(url);
+                            if (!needKeep) {
+                                // eslint-disable-next-line consistent-return
+                                return;
+                            }
+                        }
+                        if (isDataUrl(url)) {
+                            // eslint-disable-next-line consistent-return
+                            return parsedDeclaration;
+                        }
+                        const [pathname, query, hashOrQuery] = url.split(/(\?)?#/, 3);
+                        let hash = query ? "?" : "";
+                        hash += hashOrQuery ? `#${hashOrQuery}` : "";
+                        const { needToResolveURL, rootContext } = options;
+                        const request = requestify(pathname, rootContext, // @ts-expect-error TODO: only 2 arguments allowed.
+                        needToResolveURL);
+                        if (!needToResolveURL) {
+                            // eslint-disable-next-line consistent-return
+                            return {
+                                ...parsedDeclaration,
+                                url: request,
+                                hash
+                            };
+                        }
+                        const { resolver, context } = options;
+                        const resolvedUrl = await resolveRequests(resolver, context, [
+                            ...new Set([
+                                request,
+                                url
+                            ])
+                        ]);
+                        if (!resolvedUrl) {
+                            // eslint-disable-next-line consistent-return
+                            return;
+                        }
+                        // eslint-disable-next-line consistent-return
+                        return {
+                            ...parsedDeclaration,
+                            url: resolvedUrl,
+                            hash
+                        };
+                    }));
+                    const urlToNameMap = new Map();
+                    const urlToReplacementMap = new Map();
+                    let hasUrlImportHelper = false;
+                    for(let index = 0; index <= resolvedDeclarations.length - 1; index++){
+                        const item = resolvedDeclarations[index];
+                        if (!item) {
+                            continue;
+                        }
+                        if (!hasUrlImportHelper) {
+                            options.imports.push({
+                                type: "get_url_import",
+                                importName: "___CSS_LOADER_GET_URL_IMPORT___",
+                                url: options.urlHandler(require.resolve("../runtime/getUrl.js")),
+                                index: -1
+                            });
+                            hasUrlImportHelper = true;
+                        }
+                        const { url, prefix } = item;
+                        const newUrl = prefix ? `${prefix}!${url}` : url;
+                        let importName = urlToNameMap.get(newUrl);
+                        if (!importName) {
+                            importName = `___CSS_LOADER_URL_IMPORT_${urlToNameMap.size}___`;
+                            urlToNameMap.set(newUrl, importName);
+                            options.imports.push({
+                                type: "url",
+                                importName,
+                                url: options.needToResolveURL ? options.urlHandler(newUrl) : JSON.stringify(newUrl),
+                                index
+                            });
+                        }
+                        const { hash, needQuotes } = item;
+                        const replacementKey = JSON.stringify({
+                            newUrl,
+                            hash,
+                            needQuotes
+                        });
+                        let replacementName = urlToReplacementMap.get(replacementKey);
+                        if (!replacementName) {
+                            replacementName = `___CSS_LOADER_URL_REPLACEMENT_${urlToReplacementMap.size}___`;
+                            urlToReplacementMap.set(replacementKey, replacementName);
+                            options.replacements.push({
+                                replacementName,
+                                importName,
+                                hash,
+                                needQuotes
+                            });
+                        }
+                        // eslint-disable-next-line no-param-reassign
+                        item.node.type = "word";
+                        // eslint-disable-next-line no-param-reassign
+                        item.node.value = replacementName;
+                        // eslint-disable-next-line no-param-reassign
+                        item.declaration.value = item.parsed.toString();
+                    }
+                }
+            };
+        }
+    };
+};
+plugin.postcss = true;
+export default plugin;
+
+//# sourceMappingURL=postcss-url-parser.js.map

node_modules/next/dist/esm/build/webpack/loaders/css-loader/src/runtime/api.js

@@ -0,0 +1,90 @@
+/*
+  MIT License http://www.opensource.org/licenses/mit-license.php
+  Author Tobias Koppers @sokra
+*/ // css base code, injected by the css-loader
+// eslint-disable-next-line func-names
+module.exports = function(useSourceMap) {
+    var list = [] // return the list of modules as css string
+    ;
+    list.toString = function toString() {
+        return this.map(function(item) {
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            var content = cssWithMappingToString(item, useSourceMap);
+            if (item[2]) {
+                return "@media ".concat(item[2], " {").concat(content, "}");
+            }
+            return content;
+        }).join("");
+    } // import a list of modules into the list
+    ;
+    // eslint-disable-next-line func-names
+    // @ts-expect-error TODO: fix type
+    list.i = function(modules, mediaQuery, dedupe) {
+        if (typeof modules === "string") {
+            // eslint-disable-next-line no-param-reassign
+            modules = [
+                [
+                    null,
+                    modules,
+                    ""
+                ]
+            ];
+        }
+        var alreadyImportedModules = {};
+        if (dedupe) {
+            for(var i = 0; i < this.length; i++){
+                // eslint-disable-next-line prefer-destructuring
+                var id = this[i][0];
+                if (id != null) {
+                    alreadyImportedModules[id] = true;
+                }
+            }
+        }
+        for(var _i = 0; _i < modules.length; _i++){
+            var item = [].concat(modules[_i]);
+            if (dedupe && alreadyImportedModules[item[0]]) {
+                continue;
+            }
+            if (mediaQuery) {
+                if (!item[2]) {
+                    item[2] = mediaQuery;
+                } else {
+                    item[2] = "".concat(mediaQuery, " and ").concat(item[2]);
+                }
+            }
+            list.push(item);
+        }
+    };
+    return list;
+};
+function cssWithMappingToString(item, useSourceMap) {
+    var content = item[1] || "" // eslint-disable-next-line prefer-destructuring
+    ;
+    var cssMapping = item[3];
+    if (!cssMapping) {
+        return content;
+    }
+    if (useSourceMap && typeof btoa === "function") {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        var sourceMapping = toComment(cssMapping);
+        var sourceURLs = cssMapping.sources.map(function(source) {
+            return "/*# sourceURL=".concat(cssMapping.sourceRoot || "").concat(source, " */");
+        });
+        return [
+            content
+        ].concat(sourceURLs).concat([
+            sourceMapping
+        ]).join("\n");
+    }
+    return [
+        content
+    ].join("\n");
+} // Adapted from convert-source-map (MIT)
+function toComment(sourceMap) {
+    // eslint-disable-next-line no-undef
+    var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))));
+    var data = "sourceMappingURL=data:application/json;charset=utf-8;base64,".concat(base64);
+    return "/*# ".concat(data, " */");
+}
+
+//# sourceMappingURL=api.js.map

node_modules/next/dist/esm/build/webpack/loaders/css-loader/src/runtime/api.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/build/webpack/loaders/css-loader/src/runtime/api.ts"],"names":["module","exports","useSourceMap","list","toString","map","item","content","cssWithMappingToString","concat","join","i","modules","mediaQuery","dedupe","alreadyImportedModules","length","id","_i","push","cssMapping","btoa","sourceMapping","toComment","sourceURLs","sources","source","sourceRoot","sourceMap","base64","unescape","encodeURIComponent","JSON","stringify","data"],"mappings":"AAAA;;;AAGA,GACA,4CAA4C;AAC5C,sCAAsC;AACtCA,OAAOC,OAAO,GAAG,SAAUC,YAAiB;IAC1C,IAAIC,OAAc,EAAE,CAAC,2CAA2C;;IAEhEA,KAAKC,QAAQ,GAAG,SAASA;QACvB,OAAO,IAAI,CAACC,GAAG,CAAC,SAAUC,IAAI;YAC5B,mEAAmE;YACnE,IAAIC,UAAUC,uBAAuBF,MAAMJ;YAE3C,IAAII,IAAI,CAAC,EAAE,EAAE;gBACX,OAAO,UAAUG,MAAM,CAACH,IAAI,CAAC,EAAE,EAAE,MAAMG,MAAM,CAACF,SAAS;YACzD;YAEA,OAAOA;QACT,GAAGG,IAAI,CAAC;IACV,EAAE,yCAAyC;;IAC3C,sCAAsC;IAEtC,kCAAkC;IAClCP,KAAKQ,CAAC,GAAG,SAAUC,OAAY,EAAEC,UAAe,EAAEC,MAAW;QAC3D,IAAI,OAAOF,YAAY,UAAU;YAC/B,6CAA6C;YAC7CA,UAAU;gBAAC;oBAAC;oBAAMA;oBAAS;iBAAG;aAAC;QACjC;QAEA,IAAIG,yBAA8B,CAAC;QAEnC,IAAID,QAAQ;YACV,IAAK,IAAIH,IAAI,GAAGA,IAAI,IAAI,CAACK,MAAM,EAAEL,IAAK;gBACpC,gDAAgD;gBAChD,IAAIM,KAAK,IAAI,CAACN,EAAE,CAAC,EAAE;gBAEnB,IAAIM,MAAM,MAAM;oBACdF,sBAAsB,CAACE,GAAG,GAAG;gBAC/B;YACF;QACF;QAEA,IAAK,IAAIC,KAAK,GAAGA,KAAKN,QAAQI,MAAM,EAAEE,KAAM;YAC1C,IAAIZ,OAAY,EAAE,CAACG,MAAM,CAACG,OAAO,CAACM,GAAG;YAErC,IAAIJ,UAAUC,sBAAsB,CAACT,IAAI,CAAC,EAAE,CAAC,EAAE;gBAE7C;YACF;YAEA,IAAIO,YAAY;gBACd,IAAI,CAACP,IAAI,CAAC,EAAE,EAAE;oBACZA,IAAI,CAAC,EAAE,GAAGO;gBACZ,OAAO;oBACLP,IAAI,CAAC,EAAE,GAAG,GAAGG,MAAM,CAACI,YAAY,SAASJ,MAAM,CAACH,IAAI,CAAC,EAAE;gBACzD;YACF;YAEAH,KAAKgB,IAAI,CAACb;QACZ;IACF;IAEA,OAAOH;AACT;AAEA,SAASK,uBAAuBF,IAAS,EAAEJ,YAAiB;IAC1D,IAAIK,UAAUD,IAAI,CAAC,EAAE,IAAI,GAAG,gDAAgD;;IAE5E,IAAIc,aAAad,IAAI,CAAC,EAAE;IAExB,IAAI,CAACc,YAAY;QACf,OAAOb;IACT;IAEA,IAAIL,gBAAgB,OAAOmB,SAAS,YAAY;QAC9C,mEAAmE;QACnE,IAAIC,gBAAgBC,UAAUH;QAC9B,IAAII,aAAaJ,WAAWK,OAAO,CAACpB,GAAG,CAAC,SAAUqB,MAAc;YAC9D,OAAO,iBACJjB,MAAM,CAACW,WAAWO,UAAU,IAAI,IAChClB,MAAM,CAACiB,QAAQ;QACpB;QACA,OAAO;YAACnB;SAAQ,CAACE,MAAM,CAACe,YAAYf,MAAM,CAAC;YAACa;SAAc,EAAEZ,IAAI,CAAC;IACnE;IAEA,OAAO;QAACH;KAAQ,CAACG,IAAI,CAAC;AACxB,EAAE,wCAAwC;AAE1C,SAASa,UAAUK,SAAc;IAC/B,oCAAoC;IACpC,IAAIC,SAASR,KAAKS,SAASC,mBAAmBC,KAAKC,SAAS,CAACL;IAC7D,IAAIM,OACF,+DAA+DzB,MAAM,CACnEoB;IAEJ,OAAO,OAAOpB,MAAM,CAACyB,MAAM;AAC7B"}

node_modules/next/dist/esm/build/webpack/loaders/css-loader/src/runtime/getUrl.js

@@ -0,0 +1,25 @@
+module.exports = function(url, options) {
+    if (!options) {
+        // eslint-disable-next-line no-param-reassign
+        options = {};
+    } // eslint-disable-next-line no-underscore-dangle, no-param-reassign
+    url = url && url.__esModule ? url.default : url;
+    if (typeof url !== "string") {
+        return url;
+    } // If url is already wrapped in quotes, remove them
+    if (/^['"].*['"]$/.test(url)) {
+        // eslint-disable-next-line no-param-reassign
+        url = url.slice(1, -1);
+    }
+    if (options.hash) {
+        // eslint-disable-next-line no-param-reassign
+        url += options.hash;
+    } // Should url be wrapped?
+    // See https://drafts.csswg.org/css-values-3/#urls
+    if (/["'() \t\n]/.test(url) || options.needQuotes) {
+        return '"'.concat(url.replace(/"/g, '\\"').replace(/\n/g, "\\n"), '"');
+    }
+    return url;
+};
+
+//# sourceMappingURL=getUrl.js.map

node_modules/next/dist/esm/build/webpack/loaders/css-loader/src/runtime/getUrl.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/build/webpack/loaders/css-loader/src/runtime/getUrl.ts"],"names":["module","exports","url","options","__esModule","default","test","slice","hash","needQuotes","concat","replace"],"mappings":"AAAAA,OAAOC,OAAO,GAAG,SAAUC,GAAQ,EAAEC,OAAY;IAC/C,IAAI,CAACA,SAAS;QACZ,6CAA6C;QAC7CA,UAAU,CAAC;IACb,EAAE,mEAAmE;IAErED,MAAMA,OAAOA,IAAIE,UAAU,GAAGF,IAAIG,OAAO,GAAGH;IAE5C,IAAI,OAAOA,QAAQ,UAAU;QAC3B,OAAOA;IACT,EAAE,mDAAmD;IAErD,IAAI,eAAeI,IAAI,CAACJ,MAAM;QAC5B,6CAA6C;QAC7CA,MAAMA,IAAIK,KAAK,CAAC,GAAG,CAAC;IACtB;IAEA,IAAIJ,QAAQK,IAAI,EAAE;QAChB,6CAA6C;QAC7CN,OAAOC,QAAQK,IAAI;IACrB,EAAE,yBAAyB;IAC3B,kDAAkD;IAElD,IAAI,cAAcF,IAAI,CAACJ,QAAQC,QAAQM,UAAU,EAAE;QACjD,OAAO,IAAIC,MAAM,CAACR,IAAIS,OAAO,CAAC,MAAM,OAAOA,OAAO,CAAC,OAAO,QAAQ;IACpE;IAEA,OAAOT;AACT"}

node_modules/next/dist/esm/build/webpack/loaders/css-loader/src/utils.js

@@ -0,0 +1,369 @@
+/*
+  MIT License http://www.opensource.org/licenses/mit-license.php
+  Author Tobias Koppers @sokra
+*/ import { fileURLToPath } from "url";
+import path from "path";
+import { urlToRequest } from "next/dist/compiled/loader-utils3";
+import modulesValues from "next/dist/compiled/postcss-modules-values";
+import localByDefault from "next/dist/compiled/postcss-modules-local-by-default";
+import extractImports from "next/dist/compiled/postcss-modules-extract-imports";
+import modulesScope from "next/dist/compiled/postcss-modules-scope";
+import camelCase from "./camelcase";
+const whitespace = "[\\x20\\t\\r\\n\\f]";
+const unescapeRegExp = new RegExp(`\\\\([\\da-f]{1,6}${whitespace}?|(${whitespace})|.)`, "ig");
+const matchNativeWin32Path = /^[A-Z]:[/\\]|^\\\\/i;
+function unescape(str) {
+    return str.replace(unescapeRegExp, (_, escaped, escapedWhitespace)=>{
+        const high = `0x${escaped}` - 0x10000;
+        /* eslint-disable line-comment-position */ // NaN means non-codepoint
+        // Workaround erroneous numeric interpretation of +"0x"
+        // eslint-disable-next-line no-self-compare
+        return high !== high || escapedWhitespace ? escaped : high < 0 ? String.fromCharCode(high + 0x10000) : // eslint-disable-next-line no-bitwise
+        String.fromCharCode(high >> 10 | 0xd800, high & 0x3ff | 0xdc00);
+    /* eslint-enable line-comment-position */ });
+}
+function normalizePath(file) {
+    return path.sep === "\\" ? file.replace(/\\/g, "/") : file;
+}
+function fixedEncodeURIComponent(str) {
+    return str.replace(/[!'()*]/g, (c)=>`%${c.charCodeAt(0).toString(16)}`);
+}
+function normalizeUrl(url, isStringValue) {
+    let normalizedUrl = url;
+    if (isStringValue && /\\(\n|\r\n|\r|\f)/.test(normalizedUrl)) {
+        normalizedUrl = normalizedUrl.replace(/\\(\n|\r\n|\r|\f)/g, "");
+    }
+    if (matchNativeWin32Path.test(url)) {
+        try {
+            normalizedUrl = decodeURIComponent(normalizedUrl);
+        } catch (error) {
+        // Ignores invalid and broken URLs and try to resolve them as is
+        }
+        return normalizedUrl;
+    }
+    normalizedUrl = unescape(normalizedUrl);
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    if (isDataUrl(url)) {
+        return fixedEncodeURIComponent(normalizedUrl);
+    }
+    try {
+        normalizedUrl = decodeURI(normalizedUrl);
+    } catch (error) {
+    // Ignores invalid and broken URLs and try to resolve them as is
+    }
+    return normalizedUrl;
+}
+function requestify(url, rootContext) {
+    if (/^file:/i.test(url)) {
+        return fileURLToPath(url);
+    }
+    if (/^[a-z][a-z0-9+.-]*:/i.test(url)) {
+        return url;
+    }
+    return url.charAt(0) === "/" ? urlToRequest(url, rootContext) : urlToRequest(url);
+}
+function getFilter(filter, resourcePath) {
+    return (...args)=>{
+        if (typeof filter === "function") {
+            return filter(...args, resourcePath);
+        }
+        return true;
+    };
+}
+function shouldUseImportPlugin(options) {
+    if (options.modules.exportOnlyLocals) {
+        return false;
+    }
+    if (typeof options.import === "boolean") {
+        return options.import;
+    }
+    return true;
+}
+function shouldUseURLPlugin(options) {
+    if (options.modules.exportOnlyLocals) {
+        return false;
+    }
+    if (typeof options.url === "boolean") {
+        return options.url;
+    }
+    return true;
+}
+function shouldUseModulesPlugins(options) {
+    return options.modules.compileType === "module";
+}
+function shouldUseIcssPlugin(options) {
+    return options.icss === true || Boolean(options.modules);
+}
+function getModulesPlugins(options, loaderContext, meta) {
+    const { mode, getLocalIdent, localIdentName, localIdentContext, localIdentHashPrefix, localIdentRegExp } = options.modules;
+    let plugins = [];
+    try {
+        plugins = [
+            modulesValues,
+            localByDefault({
+                mode
+            }),
+            extractImports(),
+            modulesScope({
+                generateScopedName (exportName) {
+                    return getLocalIdent(loaderContext, localIdentName, exportName, {
+                        context: localIdentContext,
+                        hashPrefix: localIdentHashPrefix,
+                        regExp: localIdentRegExp
+                    }, meta);
+                },
+                exportGlobals: options.modules.exportGlobals
+            })
+        ];
+    } catch (error) {
+        loaderContext.emitError(error);
+    }
+    return plugins;
+}
+const IS_NATIVE_WIN32_PATH = /^[a-z]:[/\\]|^\\\\/i;
+const ABSOLUTE_SCHEME = /^[a-z0-9+\-.]+:/i;
+function getURLType(source) {
+    if (source[0] === "/") {
+        if (source[1] === "/") {
+            return "scheme-relative";
+        }
+        return "path-absolute";
+    }
+    if (IS_NATIVE_WIN32_PATH.test(source)) {
+        return "path-absolute";
+    }
+    return ABSOLUTE_SCHEME.test(source) ? "absolute" : "path-relative";
+}
+function normalizeSourceMap(map, resourcePath) {
+    let newMap = map;
+    // Some loader emit source map as string
+    // Strip any JSON XSSI avoidance prefix from the string (as documented in the source maps specification), and then parse the string as JSON.
+    if (typeof newMap === "string") {
+        newMap = JSON.parse(newMap);
+    }
+    delete newMap.file;
+    const { sourceRoot } = newMap;
+    delete newMap.sourceRoot;
+    if (newMap.sources) {
+        // Source maps should use forward slash because it is URLs (https://github.com/mozilla/source-map/issues/91)
+        // We should normalize path because previous loaders like `sass-loader` using backslash when generate source map
+        newMap.sources = newMap.sources.map((source)=>{
+            // Non-standard syntax from `postcss`
+            if (source.indexOf("<") === 0) {
+                return source;
+            }
+            const sourceType = getURLType(source);
+            // Do no touch `scheme-relative` and `absolute` URLs
+            if (sourceType === "path-relative" || sourceType === "path-absolute") {
+                const absoluteSource = sourceType === "path-relative" && sourceRoot ? path.resolve(sourceRoot, normalizePath(source)) : normalizePath(source);
+                return path.relative(path.dirname(resourcePath), absoluteSource);
+            }
+            return source;
+        });
+    }
+    return newMap;
+}
+function getPreRequester({ loaders, loaderIndex }) {
+    const cache = Object.create(null);
+    return (number)=>{
+        if (cache[number]) {
+            return cache[number];
+        }
+        if (number === false) {
+            cache[number] = "";
+        } else {
+            const loadersRequest = loaders.slice(loaderIndex, loaderIndex + 1 + (typeof number !== "number" ? 0 : number)).map((x)=>x.request).join("!");
+            cache[number] = `-!${loadersRequest}!`;
+        }
+        return cache[number];
+    };
+}
+function getImportCode(imports, options) {
+    let code = "";
+    for (const item of imports){
+        const { importName, url, icss } = item;
+        if (options.esModule) {
+            if (icss && options.modules.namedExport) {
+                code += `import ${options.modules.exportOnlyLocals ? "" : `${importName}, `}* as ${importName}_NAMED___ from ${url};\n`;
+            } else {
+                code += `import ${importName} from ${url};\n`;
+            }
+        } else {
+            code += `var ${importName} = require(${url});\n`;
+        }
+    }
+    return code ? `// Imports\n${code}` : "";
+}
+function normalizeSourceMapForRuntime(map, loaderContext) {
+    const resultMap = map ? map.toJSON() : null;
+    if (resultMap) {
+        delete resultMap.file;
+        resultMap.sourceRoot = "";
+        resultMap.sources = resultMap.sources.map((source)=>{
+            // Non-standard syntax from `postcss`
+            if (source.indexOf("<") === 0) {
+                return source;
+            }
+            const sourceType = getURLType(source);
+            if (sourceType !== "path-relative") {
+                return source;
+            }
+            const resourceDirname = path.dirname(loaderContext.resourcePath);
+            const absoluteSource = path.resolve(resourceDirname, source);
+            const contextifyPath = normalizePath(path.relative(loaderContext.rootContext, absoluteSource));
+            return `webpack://${contextifyPath}`;
+        });
+    }
+    return JSON.stringify(resultMap);
+}
+function getModuleCode(result, api, replacements, options, loaderContext) {
+    if (options.modules.exportOnlyLocals === true) {
+        return "";
+    }
+    const sourceMapValue = options.sourceMap ? `,${normalizeSourceMapForRuntime(result.map, loaderContext)}` : "";
+    let code = JSON.stringify(result.css);
+    let beforeCode = `var ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(${options.sourceMap});\n`;
+    for (const item of api){
+        const { url, media, dedupe } = item;
+        beforeCode += url ? `___CSS_LOADER_EXPORT___.push([module.id, ${JSON.stringify(`@import url(${url});`)}${media ? `, ${JSON.stringify(media)}` : ""}]);\n` : `___CSS_LOADER_EXPORT___.i(${item.importName}${media ? `, ${JSON.stringify(media)}` : dedupe ? ', ""' : ""}${dedupe ? ", true" : ""});\n`;
+    }
+    for (const item of replacements){
+        const { replacementName, importName, localName } = item;
+        if (localName) {
+            code = code.replace(new RegExp(replacementName, "g"), ()=>options.modules.namedExport ? `" + ${importName}_NAMED___[${JSON.stringify(camelCase(localName))}] + "` : `" + ${importName}.locals[${JSON.stringify(localName)}] + "`);
+        } else {
+            const { hash, needQuotes } = item;
+            const getUrlOptions = [
+                ...hash ? [
+                    `hash: ${JSON.stringify(hash)}`
+                ] : [],
+                ...needQuotes ? "needQuotes: true" : []
+            ];
+            const preparedOptions = getUrlOptions.length > 0 ? `, { ${getUrlOptions.join(", ")} }` : "";
+            beforeCode += `var ${replacementName} = ___CSS_LOADER_GET_URL_IMPORT___(${importName}${preparedOptions});\n`;
+            code = code.replace(new RegExp(replacementName, "g"), ()=>`" + ${replacementName} + "`);
+        }
+    }
+    return `${beforeCode}// Module\n___CSS_LOADER_EXPORT___.push([module.id, ${code}, ""${sourceMapValue}]);\n`;
+}
+function dashesCamelCase(str) {
+    return str.replace(/-+(\w)/g, (_match, firstLetter)=>firstLetter.toUpperCase());
+}
+function getExportCode(exports, replacements, options) {
+    let code = "// Exports\n";
+    let localsCode = "";
+    const addExportToLocalsCode = (name, value)=>{
+        if (options.modules.namedExport) {
+            localsCode += `export const ${camelCase(name)} = ${JSON.stringify(value)};\n`;
+        } else {
+            if (localsCode) {
+                localsCode += `,\n`;
+            }
+            localsCode += `\t${JSON.stringify(name)}: ${JSON.stringify(value)}`;
+        }
+    };
+    for (const { name, value } of exports){
+        switch(options.modules.exportLocalsConvention){
+            case "camelCase":
+                {
+                    addExportToLocalsCode(name, value);
+                    const modifiedName = camelCase(name);
+                    if (modifiedName !== name) {
+                        addExportToLocalsCode(modifiedName, value);
+                    }
+                    break;
+                }
+            case "camelCaseOnly":
+                {
+                    addExportToLocalsCode(camelCase(name), value);
+                    break;
+                }
+            case "dashes":
+                {
+                    addExportToLocalsCode(name, value);
+                    const modifiedName = dashesCamelCase(name);
+                    if (modifiedName !== name) {
+                        addExportToLocalsCode(modifiedName, value);
+                    }
+                    break;
+                }
+            case "dashesOnly":
+                {
+                    addExportToLocalsCode(dashesCamelCase(name), value);
+                    break;
+                }
+            case "asIs":
+            default:
+                addExportToLocalsCode(name, value);
+                break;
+        }
+    }
+    for (const item of replacements){
+        const { replacementName, localName } = item;
+        if (localName) {
+            const { importName } = item;
+            localsCode = localsCode.replace(new RegExp(replacementName, "g"), ()=>{
+                if (options.modules.namedExport) {
+                    return `" + ${importName}_NAMED___[${JSON.stringify(camelCase(localName))}] + "`;
+                } else if (options.modules.exportOnlyLocals) {
+                    return `" + ${importName}[${JSON.stringify(localName)}] + "`;
+                }
+                return `" + ${importName}.locals[${JSON.stringify(localName)}] + "`;
+            });
+        } else {
+            localsCode = localsCode.replace(new RegExp(replacementName, "g"), ()=>`" + ${replacementName} + "`);
+        }
+    }
+    if (options.modules.exportOnlyLocals) {
+        code += options.modules.namedExport ? localsCode : `${options.esModule ? "export default" : "module.exports ="} {\n${localsCode}\n};\n`;
+        return code;
+    }
+    if (localsCode) {
+        code += options.modules.namedExport ? localsCode : `___CSS_LOADER_EXPORT___.locals = {\n${localsCode}\n};\n`;
+    }
+    code += `${options.esModule ? "export default" : "module.exports ="} ___CSS_LOADER_EXPORT___;\n`;
+    return code;
+}
+async function resolveRequests(resolve, context, possibleRequests) {
+    return resolve(context, possibleRequests[0]).then((result)=>{
+        return result;
+    }).catch((error)=>{
+        const [, ...tailPossibleRequests] = possibleRequests;
+        if (tailPossibleRequests.length === 0) {
+            throw error;
+        }
+        return resolveRequests(resolve, context, tailPossibleRequests);
+    });
+}
+function isUrlRequestable(url) {
+    // Protocol-relative URLs
+    if (/^\/\//.test(url)) {
+        return false;
+    }
+    // `file:` protocol
+    if (/^file:/i.test(url)) {
+        return true;
+    }
+    // Absolute URLs
+    if (/^[a-z][a-z0-9+.-]*:/i.test(url)) {
+        return true;
+    }
+    // `#` URLs
+    if (/^#/.test(url)) {
+        return false;
+    }
+    return true;
+}
+function sort(a, b) {
+    return a.index - b.index;
+}
+function isDataUrl(url) {
+    if (/^data:/i.test(url)) {
+        return true;
+    }
+    return false;
+}
+export { isDataUrl, shouldUseModulesPlugins, shouldUseImportPlugin, shouldUseURLPlugin, shouldUseIcssPlugin, normalizeUrl, requestify, getFilter, getModulesPlugins, normalizeSourceMap, getPreRequester, getImportCode, getModuleCode, getExportCode, resolveRequests, isUrlRequestable, sort, // For lightningcss-loader
+normalizeSourceMapForRuntime, dashesCamelCase,  };
+
+//# sourceMappingURL=utils.js.map

node_modules/next/dist/esm/build/webpack/loaders/empty-loader.js

@@ -0,0 +1,4 @@
+const EmptyLoader = ()=>"export default {}";
+export default EmptyLoader;
+
+//# sourceMappingURL=empty-loader.js.map

node_modules/next/dist/esm/build/webpack/loaders/empty-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/empty-loader.ts"],"names":["EmptyLoader"],"mappings":"AAEA,MAAMA,cAAgD,IAAM;AAC5D,eAAeA,YAAW"}

node_modules/next/dist/esm/build/webpack/loaders/error-loader.js

@@ -0,0 +1,17 @@
+import { cyan } from "../../../lib/picocolors";
+import path from "path";
+const ErrorLoader = function() {
+    var _this__module_issuer, _this__module, _this__compiler;
+    // @ts-ignore exists
+    const options = this.getOptions() || {};
+    const { reason = "An unknown error has occurred" } = options;
+    // @ts-expect-error
+    const resource = ((_this__module = this._module) == null ? void 0 : (_this__module_issuer = _this__module.issuer) == null ? void 0 : _this__module_issuer.resource) ?? null;
+    const context = this.rootContext ?? ((_this__compiler = this._compiler) == null ? void 0 : _this__compiler.context);
+    const issuer = resource ? context ? path.relative(context, resource) : resource : null;
+    const err = new Error(reason + (issuer ? `\nLocation: ${cyan(issuer)}` : ""));
+    this.emitError(err);
+};
+export default ErrorLoader;
+
+//# sourceMappingURL=error-loader.js.map

node_modules/next/dist/esm/build/webpack/loaders/error-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/error-loader.ts"],"names":["cyan","path","ErrorLoader","options","getOptions","reason","resource","_module","issuer","context","rootContext","_compiler","relative","err","Error","emitError"],"mappings":"AAAA,SAASA,IAAI,QAAQ,0BAAyB;AAC9C,OAAOC,UAAU,OAAM;AAGvB,MAAMC,cAAgD;QAOnC,sBAAA,eACmB;IAPpC,oBAAoB;IACpB,MAAMC,UAAU,IAAI,CAACC,UAAU,MAAO,CAAC;IAEvC,MAAM,EAAEC,SAAS,+BAA+B,EAAE,GAAGF;IAErD,mBAAmB;IACnB,MAAMG,WAAW,EAAA,gBAAA,IAAI,CAACC,OAAO,sBAAZ,uBAAA,cAAcC,MAAM,qBAApB,qBAAsBF,QAAQ,KAAI;IACnD,MAAMG,UAAU,IAAI,CAACC,WAAW,MAAI,kBAAA,IAAI,CAACC,SAAS,qBAAd,gBAAgBF,OAAO;IAE3D,MAAMD,SAASF,WACXG,UACER,KAAKW,QAAQ,CAACH,SAASH,YACvBA,WACF;IAEJ,MAAMO,MAAM,IAAIC,MAAMT,SAAUG,CAAAA,SAAS,CAAC,YAAY,EAAER,KAAKQ,QAAQ,CAAC,GAAG,EAAC;IAC1E,IAAI,CAACO,SAAS,CAACF;AACjB;AAEA,eAAeX,YAAW"}

node_modules/next/dist/esm/build/webpack/loaders/get-module-build-info.js

@@ -0,0 +1,8 @@
+/**
+ * A getter for module build info that casts to the type it should have.
+ * We also expose here types to make easier to use it.
+ */ export function getModuleBuildInfo(webpackModule) {
+    return webpackModule.buildInfo;
+}
+
+//# sourceMappingURL=get-module-build-info.js.map

node_modules/next/dist/esm/build/webpack/loaders/get-module-build-info.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/get-module-build-info.ts"],"names":["getModuleBuildInfo","webpackModule","buildInfo"],"mappings":"AAoBA;;;CAGC,GACD,OAAO,SAASA,mBAAmBC,aAA6B;IAC9D,OAAOA,cAAcC,SAAS;AAChC"}

node_modules/next/dist/esm/build/webpack/loaders/lightningcss-loader/src/codegen.js

@@ -0,0 +1,125 @@
+import camelCase from "../../css-loader/src/camelcase";
+import { dashesCamelCase, normalizeSourceMapForRuntime } from "../../css-loader/src/utils";
+export function getImportCode(imports, options) {
+    let code = "";
+    for (const item of imports){
+        const { importName, url, icss } = item;
+        if (options.esModule) {
+            if (icss && options.modules.namedExport) {
+                code += `import ${options.modules.exportOnlyLocals ? "" : `${importName}, `}* as ${importName}_NAMED___ from ${url};\n`;
+            } else {
+                code += `import ${importName} from ${url};\n`;
+            }
+        } else {
+            code += `var ${importName} = require(${url});\n`;
+        }
+    }
+    return code ? `// Imports\n${code}` : "";
+}
+export function getModuleCode(result, api, replacements, options, loaderContext) {
+    if (options.modules.exportOnlyLocals === true) {
+        return "";
+    }
+    const sourceMapValue = options.sourceMap ? `,${normalizeSourceMapForRuntime(result.map, loaderContext)}` : "";
+    let code = JSON.stringify(result.css);
+    let beforeCode = `var ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(${options.sourceMap});\n`;
+    for (const item of api){
+        const { url, media, dedupe } = item;
+        beforeCode += url ? `___CSS_LOADER_EXPORT___.push([module.id, ${JSON.stringify(`@import url(${url});`)}${media ? `, ${JSON.stringify(media)}` : ""}]);\n` : `___CSS_LOADER_EXPORT___.i(${item.importName}${media ? `, ${JSON.stringify(media)}` : dedupe ? ', ""' : ""}${dedupe ? ", true" : ""});\n`;
+    }
+    for (const item of replacements){
+        const { replacementName, importName, localName } = item;
+        if (localName) {
+            code = code.replace(new RegExp(replacementName, "g"), ()=>options.modules.namedExport ? `" + ${importName}_NAMED___[${JSON.stringify(camelCase(localName))}] + "` : `" + ${importName}.locals[${JSON.stringify(localName)}] + "`);
+        } else {
+            const { hash, needQuotes } = item;
+            const getUrlOptions = [
+                ...hash ? [
+                    `hash: ${JSON.stringify(hash)}`
+                ] : [],
+                ...needQuotes ? "needQuotes: true" : []
+            ];
+            const preparedOptions = getUrlOptions.length > 0 ? `, { ${getUrlOptions.join(", ")} }` : "";
+            beforeCode += `var ${replacementName} = ___CSS_LOADER_GET_URL_IMPORT___(${importName}${preparedOptions});\n`;
+            code = code.replace(new RegExp(replacementName, "g"), ()=>`" + ${replacementName} + "`);
+        }
+    }
+    return `${beforeCode}// Module\n___CSS_LOADER_EXPORT___.push([module.id, ${code}, ""${sourceMapValue}]);\n`;
+}
+export function getExportCode(exports, replacements, options) {
+    let code = "// Exports\n";
+    let localsCode = "";
+    const addExportToLocalsCode = (name, value)=>{
+        if (options.modules.namedExport) {
+            localsCode += `export const ${camelCase(name)} = ${JSON.stringify(value)};\n`;
+        } else {
+            if (localsCode) {
+                localsCode += `,\n`;
+            }
+            localsCode += `\t${JSON.stringify(name)}: ${JSON.stringify(value)}`;
+        }
+    };
+    for (const { name, value } of exports){
+        switch(options.modules.exportLocalsConvention){
+            case "camelCase":
+                {
+                    addExportToLocalsCode(name, value);
+                    const modifiedName = camelCase(name);
+                    if (modifiedName !== name) {
+                        addExportToLocalsCode(modifiedName, value);
+                    }
+                    break;
+                }
+            case "camelCaseOnly":
+                {
+                    addExportToLocalsCode(camelCase(name), value);
+                    break;
+                }
+            case "dashes":
+                {
+                    addExportToLocalsCode(name, value);
+                    const modifiedName = dashesCamelCase(name);
+                    if (modifiedName !== name) {
+                        addExportToLocalsCode(modifiedName, value);
+                    }
+                    break;
+                }
+            case "dashesOnly":
+                {
+                    addExportToLocalsCode(dashesCamelCase(name), value);
+                    break;
+                }
+            case "asIs":
+            default:
+                addExportToLocalsCode(name, value);
+                break;
+        }
+    }
+    for (const item of replacements){
+        const { replacementName, localName } = item;
+        if (localName) {
+            const { importName } = item;
+            localsCode = localsCode.replace(new RegExp(replacementName, "g"), ()=>{
+                if (options.modules.namedExport) {
+                    return `" + ${importName}_NAMED___[${JSON.stringify(camelCase(localName))}] + "`;
+                } else if (options.modules.exportOnlyLocals) {
+                    return `" + ${importName}[${JSON.stringify(localName)}] + "`;
+                }
+                return `" + ${importName}.locals[${JSON.stringify(localName)}] + "`;
+            });
+        } else {
+            localsCode = localsCode.replace(new RegExp(replacementName, "g"), ()=>`" + ${replacementName} + "`);
+        }
+    }
+    if (options.modules.exportOnlyLocals) {
+        code += options.modules.namedExport ? localsCode : `${options.esModule ? "export default" : "module.exports ="} {\n${localsCode}\n};\n`;
+        return code;
+    }
+    if (localsCode) {
+        code += options.modules.namedExport ? localsCode : `___CSS_LOADER_EXPORT___.locals = {\n${localsCode}\n};\n`;
+    }
+    code += `${options.esModule ? "export default" : "module.exports ="} ___CSS_LOADER_EXPORT___;\n`;
+    return code;
+}
+
+//# sourceMappingURL=codegen.js.map

node_modules/next/dist/esm/build/webpack/loaders/lightningcss-loader/src/codegen.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/loaders/lightningcss-loader/src/codegen.ts"],"names":["camelCase","dashesCamelCase","normalizeSourceMapForRuntime","getImportCode","imports","options","code","item","importName","url","icss","esModule","modules","namedExport","exportOnlyLocals","getModuleCode","result","api","replacements","loaderContext","sourceMapValue","sourceMap","map","JSON","stringify","css","beforeCode","media","dedupe","replacementName","localName","replace","RegExp","hash","needQuotes","getUrlOptions","preparedOptions","length","join","getExportCode","exports","localsCode","addExportToLocalsCode","name","value","exportLocalsConvention","modifiedName"],"mappings":"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"}

node_modules/next/dist/esm/build/webpack/loaders/lightningcss-loader/src/index.js

@@ -0,0 +1,5 @@
+import { LightningCssLoader } from "./loader";
+export { LightningCssMinifyPlugin } from "./minify";
+export default LightningCssLoader;
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/esm/build/webpack/loaders/lightningcss-loader/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/loaders/lightningcss-loader/src/index.ts"],"names":["LightningCssLoader","LightningCssMinifyPlugin"],"mappings":"AAAA,SAASA,kBAAkB,QAAQ,WAAU;AAE7C,SAASC,wBAAwB,QAAQ,WAAU;AACnD,eAAeD,mBAAkB"}

node_modules/next/dist/esm/build/webpack/loaders/lightningcss-loader/src/interface.js

@@ -0,0 +1,7 @@
+export var ECacheKey;
+(function(ECacheKey) {
+    ECacheKey["loader"] = "loader";
+    ECacheKey["minify"] = "minify";
+})(ECacheKey || (ECacheKey = {}));
+
+//# sourceMappingURL=interface.js.map

node_modules/next/dist/esm/build/webpack/loaders/lightningcss-loader/src/interface.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/loaders/lightningcss-loader/src/interface.ts"],"names":["ECacheKey"],"mappings":";UAAYA;;;GAAAA,cAAAA"}

node_modules/next/dist/esm/build/webpack/loaders/lightningcss-loader/src/loader.js

@@ -0,0 +1,388 @@
+import { getTargets } from "./utils";
+import { getImportCode, getModuleCode, getExportCode } from "./codegen";
+import { getFilter, getPreRequester, isDataUrl, isUrlRequestable, requestify, resolveRequests } from "../../css-loader/src/utils";
+import { stringifyRequest } from "../../../stringify-request";
+import { ECacheKey } from "./interface";
+const encoder = new TextEncoder();
+const moduleRegExp = /\.module\.\w+$/i;
+function createUrlAndImportVisitor(visitorOptions, apis, imports, replacements, replacedUrls, replacedImportUrls) {
+    const importUrlToNameMap = new Map();
+    let hasUrlImportHelper = false;
+    const urlToNameMap = new Map();
+    const urlToReplacementMap = new Map();
+    let urlIndex = -1;
+    let importUrlIndex = -1;
+    function handleUrl(u) {
+        let url = u.url;
+        const needKeep = visitorOptions.urlFilter(url);
+        if (!needKeep) {
+            return u;
+        }
+        if (isDataUrl(url)) {
+            return u;
+        }
+        urlIndex++;
+        replacedUrls.set(urlIndex, url);
+        url = `__NEXT_LIGHTNINGCSS_LOADER_URL_REPLACE_${urlIndex}__`;
+        const [, query, hashOrQuery] = url.split(/(\?)?#/, 3);
+        const queryParts = url.split("!");
+        let prefix;
+        if (queryParts.length > 1) {
+            url = queryParts.pop();
+            prefix = queryParts.join("!");
+        }
+        let hash = query ? "?" : "";
+        hash += hashOrQuery ? `#${hashOrQuery}` : "";
+        if (!hasUrlImportHelper) {
+            imports.push({
+                type: "get_url_import",
+                importName: "___CSS_LOADER_GET_URL_IMPORT___",
+                url: JSON.stringify(require.resolve("../../css-loader/src/runtime/getUrl.js")),
+                index: -1
+            });
+            hasUrlImportHelper = true;
+        }
+        const newUrl = prefix ? `${prefix}!${url}` : url;
+        let importName = urlToNameMap.get(newUrl);
+        if (!importName) {
+            importName = `___CSS_LOADER_URL_IMPORT_${urlToNameMap.size}___`;
+            urlToNameMap.set(newUrl, importName);
+            imports.push({
+                type: "url",
+                importName,
+                url: JSON.stringify(newUrl),
+                index: urlIndex
+            });
+        }
+        // This should be true for string-urls in image-set
+        const needQuotes = false;
+        const replacementKey = JSON.stringify({
+            newUrl,
+            hash,
+            needQuotes
+        });
+        let replacementName = urlToReplacementMap.get(replacementKey);
+        if (!replacementName) {
+            replacementName = `___CSS_LOADER_URL_REPLACEMENT_${urlToReplacementMap.size}___`;
+            urlToReplacementMap.set(replacementKey, replacementName);
+            replacements.push({
+                replacementName,
+                importName,
+                hash,
+                needQuotes
+            });
+        }
+        return {
+            loc: u.loc,
+            url: replacementName
+        };
+    }
+    return {
+        Rule: {
+            import (node) {
+                if (visitorOptions.importFilter) {
+                    const needKeep = visitorOptions.importFilter(node.value.url, node.value.media);
+                    if (!needKeep) {
+                        return node;
+                    }
+                }
+                let url = node.value.url;
+                importUrlIndex++;
+                replacedImportUrls.set(importUrlIndex, url);
+                url = `__NEXT_LIGHTNINGCSS_LOADER_IMPORT_URL_REPLACE_${importUrlIndex}__`;
+                // TODO: Use identical logic as valueParser.stringify()
+                const media = node.value.media.mediaQueries.length ? JSON.stringify(node.value.media.mediaQueries) : undefined;
+                const isRequestable = isUrlRequestable(url);
+                let prefix;
+                if (isRequestable) {
+                    const queryParts = url.split("!");
+                    if (queryParts.length > 1) {
+                        url = queryParts.pop();
+                        prefix = queryParts.join("!");
+                    }
+                }
+                if (!isRequestable) {
+                    apis.push({
+                        url,
+                        media
+                    });
+                    // Bug of lightningcss
+                    return {
+                        type: "ignored",
+                        value: ""
+                    };
+                }
+                const newUrl = prefix ? `${prefix}!${url}` : url;
+                let importName = importUrlToNameMap.get(newUrl);
+                if (!importName) {
+                    importName = `___CSS_LOADER_AT_RULE_IMPORT_${importUrlToNameMap.size}___`;
+                    importUrlToNameMap.set(newUrl, importName);
+                    const importUrl = visitorOptions.urlHandler(newUrl);
+                    imports.push({
+                        type: "rule_import",
+                        importName,
+                        url: importUrl
+                    });
+                }
+                apis.push({
+                    importName,
+                    media
+                });
+                // Bug of lightningcss
+                return {
+                    type: "ignored",
+                    value: ""
+                };
+            }
+        },
+        Url (node) {
+            return handleUrl(node);
+        }
+    };
+}
+function createIcssVisitor({ apis, imports, replacements, replacedUrls, urlHandler }) {
+    let index = -1;
+    let replacementIndex = -1;
+    return {
+        Declaration: {
+            composes (node) {
+                if (node.property === "unparsed") {
+                    return;
+                }
+                const specifier = node.value.from;
+                if ((specifier == null ? void 0 : specifier.type) !== "file") {
+                    return;
+                }
+                let url = specifier.value;
+                if (!url) {
+                    return;
+                }
+                index++;
+                replacedUrls.set(index, url);
+                url = `__NEXT_LIGHTNINGCSS_LOADER_ICSS_URL_REPLACE_${index}__`;
+                const importName = `___CSS_LOADER_ICSS_IMPORT_${imports.length}___`;
+                imports.push({
+                    type: "icss_import",
+                    importName,
+                    icss: true,
+                    url: urlHandler(url),
+                    index
+                });
+                apis.push({
+                    importName,
+                    dedupe: true,
+                    index
+                });
+                const newNames = [];
+                for (const localName of node.value.names){
+                    replacementIndex++;
+                    const replacementName = `___CSS_LOADER_ICSS_IMPORT_${index}_REPLACEMENT_${replacementIndex}___`;
+                    replacements.push({
+                        replacementName,
+                        importName,
+                        localName
+                    });
+                    newNames.push(replacementName);
+                }
+                return {
+                    property: "composes",
+                    value: {
+                        loc: node.value.loc,
+                        names: newNames,
+                        from: specifier
+                    }
+                };
+            }
+        }
+    };
+}
+const LOADER_NAME = `lightningcss-loader`;
+export async function LightningCssLoader(source, prevMap) {
+    var _options_modules;
+    const done = this.async();
+    const options = this.getOptions();
+    const { implementation, targets: userTargets, ...opts } = options;
+    options.modules ??= {};
+    if (implementation && typeof implementation.transformCss !== "function") {
+        done(new TypeError(`[${LOADER_NAME}]: options.implementation.transformCss must be an 'lightningcss' transform function. Received ${typeof implementation.transformCss}`));
+        return;
+    }
+    const exports = [];
+    const imports = [];
+    const icssImports = [];
+    const apis = [];
+    const replacements = [];
+    if (((_options_modules = options.modules) == null ? void 0 : _options_modules.exportOnlyLocals) !== true) {
+        imports.unshift({
+            type: "api_import",
+            importName: "___CSS_LOADER_API_IMPORT___",
+            url: stringifyRequest(this, require.resolve("../../css-loader/src/runtime/api"))
+        });
+    }
+    const { loadBindings } = require("next/dist/build/swc");
+    const transform = (implementation == null ? void 0 : implementation.transformCss) ?? (await loadBindings()).css.lightning.transform;
+    const replacedUrls = new Map();
+    const icssReplacedUrls = new Map();
+    const replacedImportUrls = new Map();
+    const urlImportVisitor = createUrlAndImportVisitor({
+        urlHandler: (url)=>stringifyRequest(this, getPreRequester(this)(options.importLoaders ?? 0) + url),
+        urlFilter: getFilter(options.url, this.resourcePath),
+        importFilter: getFilter(options.import, this.resourcePath),
+        context: this.context
+    }, apis, imports, replacements, replacedUrls, replacedImportUrls);
+    const icssVisitor = createIcssVisitor({
+        apis,
+        imports: icssImports,
+        replacements,
+        replacedUrls: icssReplacedUrls,
+        urlHandler: (url)=>stringifyRequest(this, getPreRequester(this)(options.importLoaders) + url)
+    });
+    // This works by returned visitors are not conflicting.
+    // naive workaround for composeVisitors, as we do not directly depends on lightningcss's npm pkg
+    // but next-swc provides bindings
+    const visitor = {
+        ...urlImportVisitor,
+        ...icssVisitor
+    };
+    try {
+        const { code, map, exports: moduleExports } = transform({
+            ...opts,
+            visitor,
+            cssModules: options.modules && moduleRegExp.test(this.resourcePath) ? {
+                pattern: process.env.__NEXT_TEST_MODE ? "[name]__[local]" : "[name]__[hash]__[local]"
+            } : undefined,
+            filename: this.resourcePath,
+            code: encoder.encode(source),
+            sourceMap: this.sourceMap,
+            targets: getTargets({
+                targets: userTargets,
+                key: ECacheKey.loader
+            }),
+            inputSourceMap: this.sourceMap && prevMap ? JSON.stringify(prevMap) : undefined,
+            include: 1
+        });
+        let cssCodeAsString = code.toString();
+        if (moduleExports) {
+            for(const name in moduleExports){
+                if (Object.prototype.hasOwnProperty.call(moduleExports, name)) {
+                    const v = moduleExports[name];
+                    let value = v.name;
+                    for (const compose of v.composes){
+                        value += ` ${compose.name}`;
+                    }
+                    exports.push({
+                        name,
+                        value
+                    });
+                }
+            }
+        }
+        if (replacedUrls.size !== 0) {
+            const urlResolver = this.getResolve({
+                conditionNames: [
+                    "asset"
+                ],
+                mainFields: [
+                    "asset"
+                ],
+                mainFiles: [],
+                extensions: []
+            });
+            for (const [index, url] of replacedUrls.entries()){
+                const [pathname] = url.split(/(\?)?#/, 3);
+                const request = requestify(pathname, this.rootContext);
+                const resolvedUrl = await resolveRequests(urlResolver, this.context, [
+                    ...new Set([
+                        request,
+                        url
+                    ])
+                ]);
+                for (const importItem of imports){
+                    importItem.url = importItem.url.replace(`__NEXT_LIGHTNINGCSS_LOADER_URL_REPLACE_${index}__`, resolvedUrl ?? url);
+                }
+            }
+        }
+        if (replacedImportUrls.size !== 0) {
+            const importResolver = this.getResolve({
+                conditionNames: [
+                    "style"
+                ],
+                extensions: [
+                    ".css"
+                ],
+                mainFields: [
+                    "css",
+                    "style",
+                    "main",
+                    "..."
+                ],
+                mainFiles: [
+                    "index",
+                    "..."
+                ],
+                restrictions: [
+                    /\.css$/i
+                ]
+            });
+            for (const [index, url] of replacedImportUrls.entries()){
+                const [pathname] = url.split(/(\?)?#/, 3);
+                const request = requestify(pathname, this.rootContext);
+                const resolvedUrl = await resolveRequests(importResolver, this.context, [
+                    ...new Set([
+                        request,
+                        url
+                    ])
+                ]);
+                for (const importItem of imports){
+                    importItem.url = importItem.url.replace(`__NEXT_LIGHTNINGCSS_LOADER_IMPORT_URL_REPLACE_${index}__`, resolvedUrl ?? url);
+                }
+            }
+        }
+        if (icssReplacedUrls.size !== 0) {
+            const icssResolver = this.getResolve({
+                conditionNames: [
+                    "style"
+                ],
+                extensions: [],
+                mainFields: [
+                    "css",
+                    "style",
+                    "main",
+                    "..."
+                ],
+                mainFiles: [
+                    "index",
+                    "..."
+                ]
+            });
+            for (const [index, url] of icssReplacedUrls.entries()){
+                const [pathname] = url.split(/(\?)?#/, 3);
+                const request = requestify(pathname, this.rootContext);
+                const resolvedUrl = await resolveRequests(icssResolver, this.context, [
+                    ...new Set([
+                        url,
+                        request
+                    ])
+                ]);
+                for (const importItem of icssImports){
+                    importItem.url = importItem.url.replace(`__NEXT_LIGHTNINGCSS_LOADER_ICSS_URL_REPLACE_${index}__`, resolvedUrl ?? url);
+                }
+            }
+        }
+        imports.push(...icssImports);
+        const importCode = getImportCode(imports, options);
+        const moduleCode = getModuleCode({
+            css: cssCodeAsString,
+            map
+        }, apis, replacements, options, this);
+        const exportCode = getExportCode(exports, replacements, options);
+        const esCode = `${importCode}${moduleCode}${exportCode}`;
+        done(null, esCode, map && JSON.parse(map.toString()));
+    } catch (error) {
+        console.error("lightningcss-loader error", error);
+        done(error);
+    }
+}
+export const raw = true;
+
+//# sourceMappingURL=loader.js.map

node_modules/next/dist/esm/build/webpack/loaders/lightningcss-loader/src/minify.js

@@ -0,0 +1,82 @@
+// @ts-ignore
+import { ModuleFilenameHelpers } from "next/dist/compiled/webpack/webpack";
+import { webpack } from "next/dist/compiled/webpack/webpack";
+// @ts-ignore
+import { RawSource, SourceMapSource } from "next/dist/compiled/webpack-sources3";
+import { ECacheKey } from "./interface";
+import { getTargets } from "./utils";
+import { Buffer } from "buffer";
+const PLUGIN_NAME = "lightning-css-minify";
+const CSS_FILE_REG = /\.css(?:\?.*)?$/i;
+export class LightningCssMinifyPlugin {
+    constructor(opts = {}){
+        const { implementation, ...otherOpts } = opts;
+        if (implementation && typeof implementation.transformCss !== "function") {
+            throw new TypeError(`[LightningCssMinifyPlugin]: implementation.transformCss must be an 'lightningcss' transform function. Received ${typeof implementation.transformCss}`);
+        }
+        this.transform = implementation == null ? void 0 : implementation.transformCss;
+        this.options = otherOpts;
+    }
+    apply(compiler) {
+        const meta = JSON.stringify({
+            name: "@next/lightningcss-loader",
+            version: "0.0.0",
+            options: this.options
+        });
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation)=>{
+            compilation.hooks.chunkHash.tap(PLUGIN_NAME, (_, hash)=>hash.update(meta));
+            compilation.hooks.processAssets.tapPromise({
+                name: PLUGIN_NAME,
+                stage: webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE,
+                additionalAssets: true
+            }, async ()=>await this.transformAssets(compilation));
+            compilation.hooks.statsPrinter.tap(PLUGIN_NAME, (statsPrinter)=>{
+                statsPrinter.hooks.print.for("asset.info.minimized")// @ts-ignore
+                .tap(PLUGIN_NAME, (minimized, { green, formatFlag })=>{
+                    // @ts-ignore
+                    return minimized ? green(formatFlag("minimized")) : undefined;
+                });
+            });
+        });
+    }
+    async transformAssets(compilation) {
+        const { options: { devtool } } = compilation.compiler;
+        if (!this.transform) {
+            const { loadBindings } = require("next/dist/build/swc");
+            this.transform = (await loadBindings()).css.lightning.transform;
+        }
+        const sourcemap = this.options.sourceMap === undefined ? devtool && devtool.includes("source-map") : this.options.sourceMap;
+        const { include, exclude, test: testRegExp, targets: userTargets, ...transformOptions } = this.options;
+        const assets = compilation.getAssets().filter((asset)=>// Filter out already minimized
+            !asset.info.minimized && // Filter out by file type
+            (testRegExp || CSS_FILE_REG).test(asset.name) && ModuleFilenameHelpers.matchObject({
+                include,
+                exclude
+            }, asset.name));
+        await Promise.all(assets.map(async (asset)=>{
+            const { source, map } = asset.source.sourceAndMap();
+            const sourceAsString = source.toString();
+            const code = typeof source === "string" ? Buffer.from(source) : source;
+            const targets = getTargets({
+                targets: userTargets,
+                key: ECacheKey.minify
+            });
+            const result = await this.transform({
+                filename: asset.name,
+                code,
+                minify: true,
+                sourceMap: sourcemap,
+                targets,
+                ...transformOptions
+            });
+            const codeString = result.code.toString();
+            compilation.updateAsset(asset.name, // @ts-ignore
+            sourcemap ? new SourceMapSource(codeString, asset.name, JSON.parse(result.map.toString()), sourceAsString, map, true) : new RawSource(codeString), {
+                ...asset.info,
+                minimized: true
+            });
+        }));
+    }
+}
+
+//# sourceMappingURL=minify.js.map

node_modules/next/dist/esm/build/webpack/loaders/lightningcss-loader/src/minify.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/loaders/lightningcss-loader/src/minify.ts"],"names":["ModuleFilenameHelpers","webpack","RawSource","SourceMapSource","ECacheKey","getTargets","Buffer","PLUGIN_NAME","CSS_FILE_REG","LightningCssMinifyPlugin","constructor","opts","implementation","otherOpts","transformCss","TypeError","transform","options","apply","compiler","meta","JSON","stringify","name","version","hooks","compilation","tap","chunkHash","_","hash","update","processAssets","tapPromise","stage","Compilation","PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE","additionalAssets","transformAssets","statsPrinter","print","for","minimized","green","formatFlag","undefined","devtool","loadBindings","require","css","lightning","sourcemap","sourceMap","includes","include","exclude","test","testRegExp","targets","userTargets","transformOptions","assets","getAssets","filter","asset","info","matchObject","Promise","all","map","source","sourceAndMap","sourceAsString","toString","code","from","key","minify","result","filename","codeString","updateAsset","parse"],"mappings":"AAAA,aAAa;AACb,SAASA,qBAAqB,QAAQ,qCAAoC;AAC1E,SAASC,OAAO,QAAQ,qCAAoC;AAC5D,aAAa;AACb,SAASC,SAAS,EAAEC,eAAe,QAAQ,sCAAqC;AAChF,SAASC,SAAS,QAAQ,cAAa;AAEvC,SAASC,UAAU,QAAQ,UAAS;AACpC,SAASC,MAAM,QAAQ,SAAQ;AAE/B,MAAMC,cAAc;AACpB,MAAMC,eAAe;AAErB,OAAO,MAAMC;IAIXC,YAAYC,OAAY,CAAC,CAAC,CAAE;QAC1B,MAAM,EAAEC,cAAc,EAAE,GAAGC,WAAW,GAAGF;QACzC,IAAIC,kBAAkB,OAAOA,eAAeE,YAAY,KAAK,YAAY;YACvE,MAAM,IAAIC,UACR,CAAC,+GAA+G,EAAE,OAAOH,eAAeE,YAAY,CAAC,CAAC;QAE1J;QAEA,IAAI,CAACE,SAAS,GAAGJ,kCAAAA,eAAgBE,YAAY;QAC7C,IAAI,CAACG,OAAO,GAAGJ;IACjB;IAEAK,MAAMC,QAAkB,EAAE;QACxB,MAAMC,OAAOC,KAAKC,SAAS,CAAC;YAC1BC,MAAM;YACNC,SAAS;YACTP,SAAS,IAAI,CAACA,OAAO;QACvB;QAEAE,SAASM,KAAK,CAACC,WAAW,CAACC,GAAG,CAACpB,aAAa,CAACmB;YAC3CA,YAAYD,KAAK,CAACG,SAAS,CAACD,GAAG,CAACpB,aAAa,CAACsB,GAAGC,OAC/CA,KAAKC,MAAM,CAACX;YAGdM,YAAYD,KAAK,CAACO,aAAa,CAACC,UAAU,CACxC;gBACEV,MAAMhB;gBACN2B,OAAOjC,QAAQkC,WAAW,CAACC,kCAAkC;gBAC7DC,kBAAkB;YACpB,GACA,UAAY,MAAM,IAAI,CAACC,eAAe,CAACZ;YAGzCA,YAAYD,KAAK,CAACc,YAAY,CAACZ,GAAG,CAACpB,aAAa,CAACgC;gBAC/CA,aAAad,KAAK,CAACe,KAAK,CACrBC,GAAG,CAAC,uBACL,aAAa;iBACZd,GAAG,CAACpB,aAAa,CAACmC,WAAW,EAAEC,KAAK,EAAEC,UAAU,EAAE;oBACjD,aAAa;oBACb,OAAOF,YAAYC,MAAMC,WAAW,gBAAgBC;gBACtD;YACJ;QACF;IACF;IAEA,MAAcP,gBAAgBZ,WAAwB,EAAiB;QACrE,MAAM,EACJT,SAAS,EAAE6B,OAAO,EAAE,EACrB,GAAGpB,YAAYP,QAAQ;QAExB,IAAI,CAAC,IAAI,CAACH,SAAS,EAAE;YACnB,MAAM,EAAE+B,YAAY,EAAE,GAAGC,QAAQ;YACjC,IAAI,CAAChC,SAAS,GAAG,AAAC,CAAA,MAAM+B,cAAa,EAAGE,GAAG,CAACC,SAAS,CAAClC,SAAS;QACjE;QAEA,MAAMmC,YACJ,IAAI,CAAClC,OAAO,CAACmC,SAAS,KAAKP,YACrBC,WAAW,AAACA,QAAmBO,QAAQ,CAAC,gBAC1C,IAAI,CAACpC,OAAO,CAACmC,SAAS;QAE5B,MAAM,EACJE,OAAO,EACPC,OAAO,EACPC,MAAMC,UAAU,EAChBC,SAASC,WAAW,EACpB,GAAGC,kBACJ,GAAG,IAAI,CAAC3C,OAAO;QAEhB,MAAM4C,SAASnC,YAAYoC,SAAS,GAAGC,MAAM,CAC3C,CAACC,QACC,+BAA+B;YAC/B,CAACA,MAAMC,IAAI,CAACvB,SAAS,IAErB,AADA,0BAA0B;YACzBe,CAAAA,cAAcjD,YAAW,EAAGgD,IAAI,CAACQ,MAAMzC,IAAI,KAC5CvB,sBAAsBkE,WAAW,CAAC;gBAAEZ;gBAASC;YAAQ,GAAGS,MAAMzC,IAAI;QAGtE,MAAM4C,QAAQC,GAAG,CACfP,OAAOQ,GAAG,CAAC,OAAOL;YAChB,MAAM,EAAEM,MAAM,EAAED,GAAG,EAAE,GAAGL,MAAMM,MAAM,CAACC,YAAY;YACjD,MAAMC,iBAAiBF,OAAOG,QAAQ;YACtC,MAAMC,OAAO,OAAOJ,WAAW,WAAWhE,OAAOqE,IAAI,CAACL,UAAUA;YAChE,MAAMZ,UAAUrD,WAAW;gBACzBqD,SAASC;gBACTiB,KAAKxE,UAAUyE,MAAM;YACvB;YAEA,MAAMC,SAAS,MAAM,IAAI,CAAC9D,SAAS,CAAE;gBACnC+D,UAAUf,MAAMzC,IAAI;gBACpBmD;gBACAG,QAAQ;gBACRzB,WAAWD;gBACXO;gBACA,GAAGE,gBAAgB;YACrB;YACA,MAAMoB,aAAaF,OAAOJ,IAAI,CAACD,QAAQ;YAEvC/C,YAAYuD,WAAW,CACrBjB,MAAMzC,IAAI,EACV,aAAa;YACb4B,YACI,IAAIhD,gBACF6E,YACAhB,MAAMzC,IAAI,EACVF,KAAK6D,KAAK,CAACJ,OAAOT,GAAG,CAAEI,QAAQ,KAC/BD,gBACAH,KACA,QAEF,IAAInE,UAAU8E,aAClB;gBACE,GAAGhB,MAAMC,IAAI;gBACbvB,WAAW;YACb;QAEJ;IAEJ;AACF"}

node_modules/next/dist/esm/build/webpack/loaders/lightningcss-loader/src/utils.js

@@ -0,0 +1,48 @@
+let targetsCache = {};
+/**
+ * Convert a version number to a single 24-bit number
+ *
+ * https://github.com/lumeland/lume/blob/4cc75599006df423a14befc06d3ed8493c645b09/plugins/lightningcss.ts#L160
+ */ function version(major, minor = 0, patch = 0) {
+    return major << 16 | minor << 8 | patch;
+}
+function parseVersion(v) {
+    return v.split(".").reduce((acc, val)=>{
+        if (!acc) {
+            return null;
+        }
+        const parsed = parseInt(val, 10);
+        if (isNaN(parsed)) {
+            return null;
+        }
+        acc.push(parsed);
+        return acc;
+    }, []);
+}
+function browserslistToTargets(targets) {
+    return targets.reduce((acc, value)=>{
+        const [name, v] = value.split(" ");
+        const parsedVersion = parseVersion(v);
+        if (!parsedVersion) {
+            return acc;
+        }
+        const versionDigit = version(parsedVersion[0], parsedVersion[1], parsedVersion[2]);
+        if (name === "and_qq" || name === "and_uc" || name === "baidu" || name === "bb" || name === "kaios" || name === "op_mini") {
+            return acc;
+        }
+        if (acc[name] == null || versionDigit < acc[name]) {
+            acc[name] = versionDigit;
+        }
+        return acc;
+    }, {});
+}
+export const getTargets = (opts)=>{
+    const cache = targetsCache[opts.key];
+    if (cache) {
+        return cache;
+    }
+    const result = browserslistToTargets(opts.targets ?? []);
+    return targetsCache[opts.key] = result;
+};
+
+//# sourceMappingURL=utils.js.map

node_modules/next/dist/esm/build/webpack/loaders/lightningcss-loader/src/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/loaders/lightningcss-loader/src/utils.ts"],"names":["targetsCache","version","major","minor","patch","parseVersion","v","split","reduce","acc","val","parsed","parseInt","isNaN","push","browserslistToTargets","targets","value","name","parsedVersion","versionDigit","getTargets","opts","cache","key","result"],"mappings":"AAAA,IAAIA,eAAoC,CAAC;AAEzC;;;;CAIC,GACD,SAASC,QAAQC,KAAa,EAAEC,QAAQ,CAAC,EAAEC,QAAQ,CAAC;IAClD,OAAO,AAACF,SAAS,KAAOC,SAAS,IAAKC;AACxC;AAEA,SAASC,aAAaC,CAAS;IAC7B,OAAOA,EAAEC,KAAK,CAAC,KAAKC,MAAM,CAAC,CAACC,KAAKC;QAC/B,IAAI,CAACD,KAAK;YACR,OAAO;QACT;QAEA,MAAME,SAASC,SAASF,KAAK;QAC7B,IAAIG,MAAMF,SAAS;YACjB,OAAO;QACT;QACAF,IAAIK,IAAI,CAACH;QACT,OAAOF;IACT,GAAG,EAAE;AACP;AAEA,SAASM,sBAAsBC,OAAsB;IACnD,OAAOA,QAAQR,MAAM,CAAC,CAACC,KAAKQ;QAC1B,MAAM,CAACC,MAAMZ,EAAE,GAAGW,MAAMV,KAAK,CAAC;QAC9B,MAAMY,gBAAgBd,aAAaC;QAEnC,IAAI,CAACa,eAAe;YAClB,OAAOV;QACT;QACA,MAAMW,eAAenB,QACnBkB,aAAa,CAAC,EAAE,EAChBA,aAAa,CAAC,EAAE,EAChBA,aAAa,CAAC,EAAE;QAGlB,IACED,SAAS,YACTA,SAAS,YACTA,SAAS,WACTA,SAAS,QACTA,SAAS,WACTA,SAAS,WACT;YACA,OAAOT;QACT;QAEA,IAAIA,GAAG,CAACS,KAAK,IAAI,QAAQE,eAAeX,GAAG,CAACS,KAAK,EAAE;YACjDT,GAAG,CAACS,KAAK,GAAGE;QACd;QAEA,OAAOX;IACT,GAAG,CAAC;AACN;AAEA,OAAO,MAAMY,aAAa,CAACC;IACzB,MAAMC,QAAQvB,YAAY,CAACsB,KAAKE,GAAG,CAAC;IACpC,IAAID,OAAO;QACT,OAAOA;IACT;IAEA,MAAME,SAASV,sBAAsBO,KAAKN,OAAO,IAAI,EAAE;IACvD,OAAQhB,YAAY,CAACsB,KAAKE,GAAG,CAAC,GAAGC;AACnC,EAAC"}

node_modules/next/dist/esm/build/webpack/loaders/metadata/discover.js

@@ -0,0 +1,92 @@
+import path from "path";
+import { stringify } from "querystring";
+import { STATIC_METADATA_IMAGES } from "../../../../lib/metadata/is-metadata-route";
+import { WEBPACK_RESOURCE_QUERIES } from "../../../../lib/constants";
+const METADATA_TYPE = "metadata";
+// Produce all compositions with filename (icon, apple-icon, etc.) with extensions (png, jpg, etc.)
+async function enumMetadataFiles(dir, filename, extensions, { metadataResolver, // When set to true, possible filename without extension could: icon, icon0, ..., icon9
+numericSuffix }) {
+    const collectedFiles = [];
+    const possibleFileNames = [
+        filename
+    ].concat(numericSuffix ? Array(10).fill(0).map((_, index)=>filename + index) : []);
+    for (const name of possibleFileNames){
+        const resolved = await metadataResolver(dir, name, extensions);
+        if (resolved) {
+            collectedFiles.push(resolved);
+        }
+    }
+    return collectedFiles;
+}
+export async function createStaticMetadataFromRoute(resolvedDir, { segment, metadataResolver, isRootLayoutOrRootPage, pageExtensions, basePath }) {
+    let hasStaticMetadataFiles = false;
+    const staticImagesMetadata = {
+        icon: [],
+        apple: [],
+        twitter: [],
+        openGraph: [],
+        manifest: undefined
+    };
+    async function collectIconModuleIfExists(type) {
+        if (type === "manifest") {
+            const staticManifestExtension = [
+                "webmanifest",
+                "json"
+            ];
+            const manifestFile = await enumMetadataFiles(resolvedDir, "manifest", staticManifestExtension.concat(pageExtensions), {
+                metadataResolver,
+                numericSuffix: false
+            });
+            if (manifestFile.length > 0) {
+                hasStaticMetadataFiles = true;
+                const { name, ext } = path.parse(manifestFile[0]);
+                const extension = staticManifestExtension.includes(ext.slice(1)) ? ext.slice(1) : "webmanifest";
+                staticImagesMetadata.manifest = JSON.stringify(`/${name}.${extension}`);
+            }
+            return;
+        }
+        const resolvedMetadataFiles = await enumMetadataFiles(resolvedDir, STATIC_METADATA_IMAGES[type].filename, [
+            ...STATIC_METADATA_IMAGES[type].extensions,
+            ...type === "favicon" ? [] : pageExtensions
+        ], {
+            metadataResolver,
+            numericSuffix: true
+        });
+        resolvedMetadataFiles.sort((a, b)=>a.localeCompare(b)).forEach((filepath)=>{
+            const imageModuleImportSource = `next-metadata-image-loader?${stringify({
+                type,
+                segment,
+                basePath,
+                pageExtensions
+            })}!${filepath}?${WEBPACK_RESOURCE_QUERIES.metadata}`;
+            const imageModule = `(async (props) => (await import(/* webpackMode: "eager" */ ${JSON.stringify(imageModuleImportSource)})).default(props))`;
+            hasStaticMetadataFiles = true;
+            if (type === "favicon") {
+                staticImagesMetadata.icon.unshift(imageModule);
+            } else {
+                staticImagesMetadata[type].push(imageModule);
+            }
+        });
+    }
+    // Intentionally make these serial to reuse directory access cache.
+    await collectIconModuleIfExists("icon");
+    await collectIconModuleIfExists("apple");
+    await collectIconModuleIfExists("openGraph");
+    await collectIconModuleIfExists("twitter");
+    if (isRootLayoutOrRootPage) {
+        await collectIconModuleIfExists("favicon");
+        await collectIconModuleIfExists("manifest");
+    }
+    return hasStaticMetadataFiles ? staticImagesMetadata : null;
+}
+export function createMetadataExportsCode(metadata) {
+    return metadata ? `${METADATA_TYPE}: {
+    icon: [${metadata.icon.join(",")}],
+    apple: [${metadata.apple.join(",")}],
+    openGraph: [${metadata.openGraph.join(",")}],
+    twitter: [${metadata.twitter.join(",")}],
+    manifest: ${metadata.manifest ? metadata.manifest : "undefined"}
+  }` : "";
+}
+
+//# sourceMappingURL=discover.js.map

node_modules/next/dist/esm/build/webpack/loaders/metadata/discover.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/metadata/discover.ts"],"names":["path","stringify","STATIC_METADATA_IMAGES","WEBPACK_RESOURCE_QUERIES","METADATA_TYPE","enumMetadataFiles","dir","filename","extensions","metadataResolver","numericSuffix","collectedFiles","possibleFileNames","concat","Array","fill","map","_","index","name","resolved","push","createStaticMetadataFromRoute","resolvedDir","segment","isRootLayoutOrRootPage","pageExtensions","basePath","hasStaticMetadataFiles","staticImagesMetadata","icon","apple","twitter","openGraph","manifest","undefined","collectIconModuleIfExists","type","staticManifestExtension","manifestFile","length","ext","parse","extension","includes","slice","JSON","resolvedMetadataFiles","sort","a","b","localeCompare","forEach","filepath","imageModuleImportSource","metadata","imageModule","unshift","createMetadataExportsCode","join"],"mappings":"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"}

node_modules/next/dist/esm/build/webpack/loaders/metadata/resolve-route-data.js

@@ -0,0 +1,99 @@
+import { resolveArray } from "../../../../lib/metadata/generate/utils";
+// convert robots data to txt string
+export function resolveRobots(data) {
+    let content = "";
+    const rules = Array.isArray(data.rules) ? data.rules : [
+        data.rules
+    ];
+    for (const rule of rules){
+        const userAgent = resolveArray(rule.userAgent || [
+            "*"
+        ]);
+        for (const agent of userAgent){
+            content += `User-Agent: ${agent}\n`;
+        }
+        if (rule.allow) {
+            const allow = resolveArray(rule.allow);
+            for (const item of allow){
+                content += `Allow: ${item}\n`;
+            }
+        }
+        if (rule.disallow) {
+            const disallow = resolveArray(rule.disallow);
+            for (const item of disallow){
+                content += `Disallow: ${item}\n`;
+            }
+        }
+        if (rule.crawlDelay) {
+            content += `Crawl-delay: ${rule.crawlDelay}\n`;
+        }
+        content += "\n";
+    }
+    if (data.host) {
+        content += `Host: ${data.host}\n`;
+    }
+    if (data.sitemap) {
+        const sitemap = resolveArray(data.sitemap);
+        // TODO-METADATA: support injecting sitemap url into robots.txt
+        sitemap.forEach((item)=>{
+            content += `Sitemap: ${item}\n`;
+        });
+    }
+    return content;
+}
+// TODO-METADATA: support multi sitemap files
+// convert sitemap data to xml string
+export function resolveSitemap(data) {
+    const hasAlternates = data.some((item)=>Object.keys(item.alternates ?? {}).length > 0);
+    let content = "";
+    content += '<?xml version="1.0" encoding="UTF-8"?>\n';
+    content += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"';
+    if (hasAlternates) {
+        content += ' xmlns:xhtml="http://www.w3.org/1999/xhtml">\n';
+    } else {
+        content += ">\n";
+    }
+    for (const item of data){
+        var _item_alternates;
+        content += "<url>\n";
+        content += `<loc>${item.url}</loc>\n`;
+        const languages = (_item_alternates = item.alternates) == null ? void 0 : _item_alternates.languages;
+        if (languages && Object.keys(languages).length) {
+            // Since sitemap is separated from the page rendering, there's not metadataBase accessible yet.
+            // we give the default setting that won't effect the languages resolving.
+            for(const language in languages){
+                content += `<xhtml:link rel="alternate" hreflang="${language}" href="${languages[language]}" />\n`;
+            }
+        }
+        if (item.lastModified) {
+            const serializedDate = item.lastModified instanceof Date ? item.lastModified.toISOString() : item.lastModified;
+            content += `<lastmod>${serializedDate}</lastmod>\n`;
+        }
+        if (item.changeFrequency) {
+            content += `<changefreq>${item.changeFrequency}</changefreq>\n`;
+        }
+        if (typeof item.priority === "number") {
+            content += `<priority>${item.priority}</priority>\n`;
+        }
+        content += "</url>\n";
+    }
+    content += "</urlset>\n";
+    return content;
+}
+export function resolveManifest(data) {
+    return JSON.stringify(data);
+}
+export function resolveRouteData(data, fileType) {
+    if (fileType === "robots") {
+        return resolveRobots(data);
+    }
+    if (fileType === "sitemap") {
+        return resolveSitemap(data);
+    }
+    if (fileType === "manifest") {
+        return resolveManifest(data);
+    }
+    return "";
+}
+
+//# sourceMappingURL=resolve-route-data.js.map

node_modules/next/dist/esm/build/webpack/loaders/metadata/resolve-route-data.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/metadata/resolve-route-data.ts"],"names":["resolveArray","resolveRobots","data","content","rules","Array","isArray","rule","userAgent","agent","allow","item","disallow","crawlDelay","host","sitemap","forEach","resolveSitemap","hasAlternates","some","Object","keys","alternates","length","url","languages","language","lastModified","serializedDate","Date","toISOString","changeFrequency","priority","resolveManifest","JSON","stringify","resolveRouteData","fileType"],"mappings":"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"}

node_modules/next/dist/esm/build/webpack/loaders/metadata/types.js

@@ -0,0 +1,4 @@
+// TODO-APP: check if this can be narrowed.
+export { };
+
+//# sourceMappingURL=types.js.map

node_modules/next/dist/esm/build/webpack/loaders/metadata/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/metadata/types.ts"],"names":[],"mappings":"AAAA,2CAA2C;AA4C3C,WAEc"}

node_modules/next/dist/esm/build/webpack/loaders/modularize-import-loader.js

@@ -0,0 +1,24 @@
+import path from "path";
+/**
+ * This loader is to create special re-exports from a specific file.
+ * For example, the following loader:
+ *
+ * modularize-import-loader?name=Arrow&from=Arrow&as=default&join=./icons/Arrow!lucide-react
+ *
+ * will be used to create a re-export of:
+ *
+ * export { Arrow as default } from "join(resolve_path('lucide-react'), '/icons/Arrow')"
+ *
+ * This works even if there's no export field in the package.json of the package.
+ */ export default function transformSource() {
+    const { name, from, as, join } = this.getOptions();
+    const { resourcePath } = this;
+    const fullPath = join ? path.join(path.dirname(resourcePath), join) : resourcePath;
+    return `
+export {
+  ${from === "default" ? "default" : name} as ${as === "default" ? "default" : name}
+} from ${JSON.stringify(fullPath)}
+`;
+}
+
+//# sourceMappingURL=modularize-import-loader.js.map

node_modules/next/dist/esm/build/webpack/loaders/modularize-import-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/modularize-import-loader.ts"],"names":["path","transformSource","name","from","as","join","getOptions","resourcePath","fullPath","dirname","JSON","stringify"],"mappings":"AAAA,OAAOA,UAAU,OAAM;AASvB;;;;;;;;;;;CAWC,GACD,eAAe,SAASC;IACtB,MAAM,EAAEC,IAAI,EAAEC,IAAI,EAAEC,EAAE,EAAEC,IAAI,EAAE,GAC5B,IAAI,CAACC,UAAU;IACjB,MAAM,EAAEC,YAAY,EAAE,GAAG,IAAI;IAC7B,MAAMC,WAAWH,OACbL,KAAKK,IAAI,CAACL,KAAKS,OAAO,CAACF,eAAeF,QACtCE;IAEJ,OAAO,CAAC;;EAER,EAAEJ,SAAS,YAAY,YAAYD,KAAK,IAAI,EAC1CE,OAAO,YAAY,YAAYF,KAChC;OACI,EAAEQ,KAAKC,SAAS,CAACH,UAAU;AAClC,CAAC;AACD"}

node_modules/next/dist/esm/build/webpack/loaders/next-app-loader.js

@@ -0,0 +1,496 @@
+import { UNDERSCORE_NOT_FOUND_ROUTE, UNDERSCORE_NOT_FOUND_ROUTE_ENTRY } from "../../../shared/lib/constants";
+import path from "path";
+import { stringify } from "querystring";
+import { bold } from "../../../lib/picocolors";
+import { getModuleBuildInfo } from "./get-module-build-info";
+import { verifyRootLayout } from "../../../lib/verify-root-layout";
+import * as Log from "../../output/log";
+import { APP_DIR_ALIAS, WEBPACK_RESOURCE_QUERIES } from "../../../lib/constants";
+import { createMetadataExportsCode, createStaticMetadataFromRoute } from "./metadata/discover";
+import { promises as fs } from "fs";
+import { isAppRouteRoute } from "../../../lib/is-app-route-route";
+import { isMetadataRoute } from "../../../lib/metadata/is-metadata-route";
+import { AppPathnameNormalizer } from "../../../server/future/normalizers/built/app/app-pathname-normalizer";
+import { AppBundlePathNormalizer } from "../../../server/future/normalizers/built/app/app-bundle-path-normalizer";
+import { getFilenameAndExtension } from "./next-metadata-route-loader";
+import { isAppBuiltinNotFoundPage } from "../../utils";
+import { loadEntrypoint } from "../../load-entrypoint";
+import { isGroupSegment, DEFAULT_SEGMENT_KEY, PAGE_SEGMENT_KEY } from "../../../shared/lib/segment";
+import { getFilesInDir } from "../../../lib/get-files-in-dir";
+import { PARALLEL_ROUTE_DEFAULT_PATH } from "../../../client/components/parallel-route-default";
+const FILE_TYPES = {
+    layout: "layout",
+    template: "template",
+    error: "error",
+    loading: "loading",
+    "not-found": "not-found"
+};
+const GLOBAL_ERROR_FILE_TYPE = "global-error";
+const PAGE_SEGMENT = "page$";
+const PARALLEL_CHILDREN_SEGMENT = "children$";
+const defaultNotFoundPath = "next/dist/client/components/not-found-error";
+const defaultGlobalErrorPath = "next/dist/client/components/error-boundary";
+const defaultLayoutPath = "next/dist/client/components/default-layout";
+async function createAppRouteCode({ name, page, pagePath, resolveAppRoute, pageExtensions, nextConfigOutput }) {
+    // routePath is the path to the route handler file,
+    // but could be aliased e.g. private-next-app-dir/favicon.ico
+    const routePath = pagePath.replace(/[\\/]/, "/");
+    // This, when used with the resolver will give us the pathname to the built
+    // route handler file.
+    let resolvedPagePath = await resolveAppRoute(routePath);
+    if (!resolvedPagePath) {
+        throw new Error(`Invariant: could not resolve page path for ${name} at ${routePath}`);
+    }
+    // If this is a metadata route, then we need to use the metadata loader for
+    // the route to ensure that the route is generated.
+    const filename = path.parse(resolvedPagePath).name;
+    if (isMetadataRoute(name) && filename !== "route") {
+        const { ext } = getFilenameAndExtension(resolvedPagePath);
+        const isDynamic = pageExtensions.includes(ext);
+        resolvedPagePath = `next-metadata-route-loader?${stringify({
+            page,
+            filePath: resolvedPagePath,
+            isDynamic: isDynamic ? "1" : "0"
+        })}!?${WEBPACK_RESOURCE_QUERIES.metadataRoute}`;
+    }
+    const pathname = new AppPathnameNormalizer().normalize(page);
+    const bundlePath = new AppBundlePathNormalizer().normalize(page);
+    return await loadEntrypoint("app-route", {
+        VAR_USERLAND: resolvedPagePath,
+        VAR_DEFINITION_PAGE: page,
+        VAR_DEFINITION_PATHNAME: pathname,
+        VAR_DEFINITION_FILENAME: filename,
+        VAR_DEFINITION_BUNDLE_PATH: bundlePath,
+        VAR_RESOLVED_PAGE_PATH: resolvedPagePath,
+        VAR_ORIGINAL_PATHNAME: page
+    }, {
+        nextConfigOutput: JSON.stringify(nextConfigOutput)
+    });
+}
+const normalizeParallelKey = (key)=>key.startsWith("@") ? key.slice(1) : key;
+const isDirectory = async (pathname)=>{
+    try {
+        const stat = await fs.stat(pathname);
+        return stat.isDirectory();
+    } catch (err) {
+        return false;
+    }
+};
+async function createTreeCodeFromPath(pagePath, { page, resolveDir, resolver, resolveParallelSegments, metadataResolver, pageExtensions, basePath, collectedAsyncImports }) {
+    const splittedPath = pagePath.split(/[\\/]/, 1);
+    const isNotFoundRoute = page === UNDERSCORE_NOT_FOUND_ROUTE_ENTRY;
+    const isDefaultNotFound = isAppBuiltinNotFoundPage(pagePath);
+    const appDirPrefix = isDefaultNotFound ? APP_DIR_ALIAS : splittedPath[0];
+    const hasRootNotFound = await resolver(`${appDirPrefix}/${FILE_TYPES["not-found"]}`);
+    const pages = [];
+    let rootLayout;
+    let globalError;
+    async function resolveAdjacentParallelSegments(segmentPath) {
+        const absoluteSegmentPath = await resolveDir(`${appDirPrefix}${segmentPath}`);
+        if (!absoluteSegmentPath) {
+            return [];
+        }
+        const segmentIsDirectory = await isDirectory(absoluteSegmentPath);
+        if (!segmentIsDirectory) {
+            return [];
+        }
+        // We need to resolve all parallel routes in this level.
+        const files = await fs.opendir(absoluteSegmentPath);
+        const parallelSegments = [
+            "children"
+        ];
+        for await (const dirent of files){
+            // Make sure name starts with "@" and is a directory.
+            if (dirent.isDirectory() && dirent.name.charCodeAt(0) === 64) {
+                parallelSegments.push(dirent.name);
+            }
+        }
+        return parallelSegments;
+    }
+    async function createSubtreePropsFromSegmentPath(segments, nestedCollectedAsyncImports) {
+        const segmentPath = segments.join("/");
+        // Existing tree are the children of the current segment
+        const props = {};
+        // Root layer could be 1st layer of normal routes
+        const isRootLayer = segments.length === 0;
+        const isRootLayoutOrRootPage = segments.length <= 1;
+        // We need to resolve all parallel routes in this level.
+        const parallelSegments = [];
+        if (isRootLayer) {
+            parallelSegments.push([
+                "children",
+                ""
+            ]);
+        } else {
+            parallelSegments.push(...resolveParallelSegments(segmentPath));
+        }
+        let metadata = null;
+        const routerDirPath = `${appDirPrefix}${segmentPath}`;
+        // For default not-found, don't traverse the directory to find metadata.
+        const resolvedRouteDir = isDefaultNotFound ? "" : await resolveDir(routerDirPath);
+        if (resolvedRouteDir) {
+            metadata = await createStaticMetadataFromRoute(resolvedRouteDir, {
+                basePath,
+                segment: segmentPath,
+                metadataResolver,
+                isRootLayoutOrRootPage,
+                pageExtensions
+            });
+        }
+        for (const [parallelKey, parallelSegment] of parallelSegments){
+            // if parallelSegment is the page segment (ie, `page$` and not ['page$']), it gets loaded into the __PAGE__ slot
+            // as it's the page for the current route.
+            if (parallelSegment === PAGE_SEGMENT) {
+                const matchedPagePath = `${appDirPrefix}${segmentPath}${parallelKey === "children" ? "" : `/${parallelKey}`}/page`;
+                const resolvedPagePath = await resolver(matchedPagePath);
+                if (resolvedPagePath) {
+                    pages.push(resolvedPagePath);
+                    nestedCollectedAsyncImports.push(resolvedPagePath);
+                }
+                // Use '' for segment as it's the page. There can't be a segment called '' so this is the safest way to add it.
+                props[normalizeParallelKey(parallelKey)] = `['${PAGE_SEGMENT_KEY}', {}, {
+          page: [() => import(/* webpackMode: "eager" */ ${JSON.stringify(resolvedPagePath)}), ${JSON.stringify(resolvedPagePath)}],
+          ${createMetadataExportsCode(metadata)}
+        }]`;
+                if (resolvedPagePath) continue;
+            }
+            // if the parallelSegment was not matched to the __PAGE__ slot, then it's a parallel route at this level.
+            // the code below recursively traverses the parallel slots directory to match the corresponding __PAGE__ for each parallel slot
+            // while also filling in layout/default/etc files into the loader tree at each segment level.
+            const subSegmentPath = [
+                ...segments
+            ];
+            if (parallelKey !== "children") {
+                // A `children` parallel key should have already been processed in the above segment
+                // So we exclude it when constructing the subsegment path for the remaining segment levels
+                subSegmentPath.push(parallelKey);
+            }
+            const normalizedParallelSegment = Array.isArray(parallelSegment) ? parallelSegment[0] : parallelSegment;
+            if (normalizedParallelSegment !== PAGE_SEGMENT && normalizedParallelSegment !== PARALLEL_CHILDREN_SEGMENT) {
+                // If we don't have a page segment, nor a special $children marker, it means we need to traverse the next directory
+                // (ie, `normalizedParallelSegment` would correspond with the folder that contains the next level of pages/layout/etc)
+                // we push it to the subSegmentPath so that we can fill in the loader tree for that segment.
+                subSegmentPath.push(normalizedParallelSegment);
+            }
+            const { treeCode: pageSubtreeCode } = await createSubtreePropsFromSegmentPath(subSegmentPath, nestedCollectedAsyncImports);
+            const parallelSegmentPath = subSegmentPath.join("/");
+            // Fill in the loader tree for all of the special files types (layout, default, etc) at this level
+            // `page` is not included here as it's added above.
+            const filePaths = await Promise.all(Object.values(FILE_TYPES).map(async (file)=>{
+                return [
+                    file,
+                    await resolver(`${appDirPrefix}${// TODO-APP: parallelSegmentPath sometimes ends in `/` but sometimes it doesn't. This should be consistent.
+                    parallelSegmentPath.endsWith("/") ? parallelSegmentPath : parallelSegmentPath + "/"}${file}`)
+                ];
+            }));
+            const definedFilePaths = filePaths.filter(([, filePath])=>filePath !== undefined);
+            // Add default not found error as root not found if not present
+            const hasNotFoundFile = definedFilePaths.some(([type])=>type === "not-found");
+            // If the first layer is a group route, we treat it as root layer
+            const isFirstLayerGroupRoute = segments.length === 1 && subSegmentPath.filter((seg)=>isGroupSegment(seg)).length === 1;
+            if ((isRootLayer || isFirstLayerGroupRoute) && !hasNotFoundFile) {
+                // If you already have a root not found, don't insert default not-found to group routes root
+                if (!(hasRootNotFound && isFirstLayerGroupRoute)) {
+                    definedFilePaths.push([
+                        "not-found",
+                        defaultNotFoundPath
+                    ]);
+                }
+            }
+            if (!rootLayout) {
+                var _definedFilePaths_find;
+                const layoutPath = (_definedFilePaths_find = definedFilePaths.find(([type])=>type === "layout")) == null ? void 0 : _definedFilePaths_find[1];
+                rootLayout = layoutPath;
+                if (isDefaultNotFound && !layoutPath && !rootLayout) {
+                    rootLayout = defaultLayoutPath;
+                    definedFilePaths.push([
+                        "layout",
+                        rootLayout
+                    ]);
+                }
+            }
+            if (!globalError) {
+                const resolvedGlobalErrorPath = await resolver(`${appDirPrefix}/${GLOBAL_ERROR_FILE_TYPE}`);
+                if (resolvedGlobalErrorPath) {
+                    globalError = resolvedGlobalErrorPath;
+                }
+            }
+            let parallelSegmentKey = Array.isArray(parallelSegment) ? parallelSegment[0] : parallelSegment;
+            // normalize the parallel segment key to remove any special markers that we inserted in the
+            // earlier logic (such as children$ and page$). These should never appear in the loader tree, and
+            // should instead be the corresponding segment keys (ie `__PAGE__`) or the `children` parallel route.
+            parallelSegmentKey = parallelSegmentKey === PARALLEL_CHILDREN_SEGMENT ? "children" : parallelSegmentKey === PAGE_SEGMENT ? PAGE_SEGMENT_KEY : parallelSegmentKey;
+            const normalizedParallelKey = normalizeParallelKey(parallelKey);
+            let subtreeCode = pageSubtreeCode;
+            // If it's root not found page, set not-found boundary as children page
+            if (isNotFoundRoute && normalizedParallelKey === "children") {
+                var _definedFilePaths_find1;
+                const notFoundPath = ((_definedFilePaths_find1 = definedFilePaths.find(([type])=>type === "not-found")) == null ? void 0 : _definedFilePaths_find1[1]) ?? defaultNotFoundPath;
+                nestedCollectedAsyncImports.push(notFoundPath);
+                subtreeCode = `{
+          children: [${JSON.stringify(UNDERSCORE_NOT_FOUND_ROUTE)}, {
+            children: ['${PAGE_SEGMENT_KEY}', {}, {
+              page: [
+                () => import(/* webpackMode: "eager" */ ${JSON.stringify(notFoundPath)}),
+                ${JSON.stringify(notFoundPath)}
+              ]
+            }]
+          }, {}]
+        }`;
+            }
+            const componentsCode = `{
+        ${definedFilePaths.map(([file, filePath])=>{
+                if (filePath) nestedCollectedAsyncImports.push(filePath);
+                return `'${file}': [() => import(/* webpackMode: "eager" */ ${JSON.stringify(filePath)}), ${JSON.stringify(filePath)}],`;
+            }).join("\n")}
+        ${createMetadataExportsCode(metadata)}
+      }`;
+            props[normalizedParallelKey] = `[
+        '${parallelSegmentKey}',
+        ${subtreeCode},
+        ${componentsCode}
+      ]`;
+        }
+        const adjacentParallelSegments = await resolveAdjacentParallelSegments(segmentPath);
+        for (const adjacentParallelSegment of adjacentParallelSegments){
+            if (!props[normalizeParallelKey(adjacentParallelSegment)]) {
+                const actualSegment = adjacentParallelSegment === "children" ? "" : `/${adjacentParallelSegment}`;
+                // if a default is found, use that. Otherwise use the fallback, which will trigger a `notFound()`
+                const defaultPath = await resolver(`${appDirPrefix}${segmentPath}${actualSegment}/default`) ?? PARALLEL_ROUTE_DEFAULT_PATH;
+                nestedCollectedAsyncImports.push(defaultPath);
+                props[normalizeParallelKey(adjacentParallelSegment)] = `[
+          '${DEFAULT_SEGMENT_KEY}',
+          {},
+          {
+            defaultPage: [() => import(/* webpackMode: "eager" */ ${JSON.stringify(defaultPath)}), ${JSON.stringify(defaultPath)}],
+          }
+        ]`;
+            }
+        }
+        return {
+            treeCode: `{
+        ${Object.entries(props).map(([key, value])=>`${key}: ${value}`).join(",\n")}
+      }`
+        };
+    }
+    const { treeCode } = await createSubtreePropsFromSegmentPath([], collectedAsyncImports);
+    return {
+        treeCode: `${treeCode}.children;`,
+        pages: `${JSON.stringify(pages)};`,
+        rootLayout,
+        globalError: globalError ?? defaultGlobalErrorPath
+    };
+}
+function createAbsolutePath(appDir, pathToTurnAbsolute) {
+    return pathToTurnAbsolute// Replace all POSIX path separators with the current OS path separator
+    .replace(/\//g, path.sep).replace(/^private-next-app-dir/, appDir);
+}
+const nextAppLoader = async function nextAppLoader() {
+    const loaderOptions = this.getOptions();
+    const { name, appDir, appPaths, pagePath, pageExtensions, rootDir, tsconfigPath, isDev, nextConfigOutput, preferredRegion, basePath, middlewareConfig: middlewareConfigBase64, nextConfigExperimentalUseEarlyImport } = loaderOptions;
+    const buildInfo = getModuleBuildInfo(this._module);
+    const collectedAsyncImports = [];
+    const page = name.replace(/^app/, "");
+    const middlewareConfig = JSON.parse(Buffer.from(middlewareConfigBase64, "base64").toString());
+    buildInfo.route = {
+        page,
+        absolutePagePath: createAbsolutePath(appDir, pagePath),
+        preferredRegion,
+        middlewareConfig
+    };
+    const extensions = pageExtensions.map((extension)=>`.${extension}`);
+    const normalizedAppPaths = typeof appPaths === "string" ? [
+        appPaths
+    ] : appPaths || [];
+    const resolveParallelSegments = (pathname)=>{
+        const matched = {};
+        let existingChildrenPath;
+        for (const appPath of normalizedAppPaths){
+            if (appPath.startsWith(pathname + "/")) {
+                const rest = appPath.slice(pathname.length + 1).split("/");
+                // It is the actual page, mark it specially.
+                if (rest.length === 1 && rest[0] === "page") {
+                    existingChildrenPath = appPath;
+                    matched.children = PAGE_SEGMENT;
+                    continue;
+                }
+                const isParallelRoute = rest[0].startsWith("@");
+                if (isParallelRoute) {
+                    if (rest.length === 2 && rest[1] === "page") {
+                        // We found a parallel route at this level. We don't want to mark it explicitly as the page segment,
+                        // as that should be matched to the `children` slot. Instead, we use an array, to signal to `createSubtreePropsFromSegmentPath`
+                        // that it needs to recursively fill in the loader tree code for the parallel route at the appropriate levels.
+                        matched[rest[0]] = [
+                            PAGE_SEGMENT
+                        ];
+                        continue;
+                    }
+                    // If it was a parallel route but we weren't able to find the page segment (ie, maybe the page is nested further)
+                    // we first insert a special marker to ensure that we still process layout/default/etc at the slot level prior to continuing
+                    // on to the page segment.
+                    matched[rest[0]] = [
+                        PARALLEL_CHILDREN_SEGMENT,
+                        ...rest.slice(1)
+                    ];
+                    continue;
+                }
+                if (existingChildrenPath && matched.children !== rest[0]) {
+                    // If we get here, it means we already set a `page` segment earlier in the loop,
+                    // meaning we already matched a page to the `children` parallel segment.
+                    const isIncomingParallelPage = appPath.includes("@");
+                    const hasCurrentParallelPage = existingChildrenPath.includes("@");
+                    if (isIncomingParallelPage) {
+                        continue;
+                    } else if (!hasCurrentParallelPage && !isIncomingParallelPage) {
+                        // Both the current `children` and the incoming `children` are regular pages.
+                        throw new Error(`You cannot have two parallel pages that resolve to the same path. Please check ${existingChildrenPath} and ${appPath}. Refer to the route group docs for more information: https://nextjs.org/docs/app/building-your-application/routing/route-groups`);
+                    }
+                }
+                existingChildrenPath = appPath;
+                matched.children = rest[0];
+            }
+        }
+        return Object.entries(matched);
+    };
+    const resolveDir = (pathToResolve)=>{
+        return createAbsolutePath(appDir, pathToResolve);
+    };
+    const resolveAppRoute = (pathToResolve)=>{
+        return createAbsolutePath(appDir, pathToResolve);
+    };
+    // Cached checker to see if a file exists in a given directory.
+    // This can be more efficient than checking them with `fs.stat` one by one
+    // because all the thousands of files are likely in a few possible directories.
+    // Note that it should only be cached for this compilation, not globally.
+    const filesInDir = new Map();
+    const fileExistsInDirectory = async (dirname, fileName)=>{
+        const existingFiles = filesInDir.get(dirname);
+        if (existingFiles) {
+            return existingFiles.has(fileName);
+        }
+        try {
+            const files = await getFilesInDir(dirname);
+            const fileNames = new Set(files);
+            filesInDir.set(dirname, fileNames);
+            return fileNames.has(fileName);
+        } catch (err) {
+            return false;
+        }
+    };
+    const resolver = async (pathname)=>{
+        const absolutePath = createAbsolutePath(appDir, pathname);
+        const filenameIndex = absolutePath.lastIndexOf(path.sep);
+        const dirname = absolutePath.slice(0, filenameIndex);
+        const filename = absolutePath.slice(filenameIndex + 1);
+        let result;
+        for (const ext of extensions){
+            const absolutePathWithExtension = `${absolutePath}${ext}`;
+            if (!result && await fileExistsInDirectory(dirname, `${filename}${ext}`)) {
+                result = absolutePathWithExtension;
+            }
+            // Call `addMissingDependency` for all files even if they didn't match,
+            // because they might be added or removed during development.
+            this.addMissingDependency(absolutePathWithExtension);
+        }
+        return result;
+    };
+    const metadataResolver = async (dirname, filename, exts)=>{
+        const absoluteDir = createAbsolutePath(appDir, dirname);
+        let result;
+        for (const ext of exts){
+            // Compared to `resolver` above the exts do not have the `.` included already, so it's added here.
+            const filenameWithExt = `${filename}.${ext}`;
+            const absolutePathWithExtension = `${absoluteDir}${path.sep}${filenameWithExt}`;
+            if (!result && await fileExistsInDirectory(dirname, filenameWithExt)) {
+                result = absolutePathWithExtension;
+            }
+            // Call `addMissingDependency` for all files even if they didn't match,
+            // because they might be added or removed during development.
+            this.addMissingDependency(absolutePathWithExtension);
+        }
+        return result;
+    };
+    if (isAppRouteRoute(name)) {
+        return createAppRouteCode({
+            // TODO: investigate if the local `page` is the same as the loaderOptions.page
+            page: loaderOptions.page,
+            name,
+            pagePath,
+            resolveAppRoute,
+            pageExtensions,
+            nextConfigOutput
+        });
+    }
+    let treeCodeResult = await createTreeCodeFromPath(pagePath, {
+        page,
+        resolveDir,
+        resolver,
+        metadataResolver,
+        resolveParallelSegments,
+        loaderContext: this,
+        pageExtensions,
+        basePath,
+        collectedAsyncImports
+    });
+    if (!treeCodeResult.rootLayout) {
+        if (!isDev) {
+            // If we're building and missing a root layout, exit the build
+            Log.error(`${bold(pagePath.replace(`${APP_DIR_ALIAS}/`, ""))} doesn't have a root layout. To fix this error, make sure every page has a root layout.`);
+            process.exit(1);
+        } else {
+            // In dev we'll try to create a root layout
+            const [createdRootLayout, rootLayoutPath] = await verifyRootLayout({
+                appDir: appDir,
+                dir: rootDir,
+                tsconfigPath: tsconfigPath,
+                pagePath,
+                pageExtensions
+            });
+            if (!createdRootLayout) {
+                let message = `${bold(pagePath.replace(`${APP_DIR_ALIAS}/`, ""))} doesn't have a root layout. `;
+                if (rootLayoutPath) {
+                    var _this__compiler;
+                    message += `We tried to create ${bold(path.relative(((_this__compiler = this._compiler) == null ? void 0 : _this__compiler.context) ?? "", rootLayoutPath))} for you but something went wrong.`;
+                } else {
+                    message += "To fix this error, make sure every page has a root layout.";
+                }
+                throw new Error(message);
+            }
+            // Clear fs cache, get the new result with the created root layout.
+            filesInDir.clear();
+            treeCodeResult = await createTreeCodeFromPath(pagePath, {
+                page,
+                resolveDir,
+                resolver,
+                metadataResolver,
+                resolveParallelSegments,
+                loaderContext: this,
+                pageExtensions,
+                basePath,
+                collectedAsyncImports
+            });
+        }
+    }
+    const pathname = new AppPathnameNormalizer().normalize(page);
+    // Prefer to modify next/src/server/app-render/entry-base.ts since this is shared with Turbopack.
+    // Any changes to this code should be reflected in Turbopack's app_source.rs and/or app-renderer.tsx as well.
+    const code = await loadEntrypoint("app-page", {
+        VAR_DEFINITION_PAGE: page,
+        VAR_DEFINITION_PATHNAME: pathname,
+        VAR_MODULE_GLOBAL_ERROR: treeCodeResult.globalError,
+        VAR_ORIGINAL_PATHNAME: page
+    }, {
+        tree: treeCodeResult.treeCode,
+        pages: treeCodeResult.pages,
+        __next_app_require__: "__webpack_require__",
+        __next_app_load_chunk__: "() => Promise.resolve()"
+    });
+    // Evaluated the imported modules early in the generated code
+    const earlyEvaluateCode = nextConfigExperimentalUseEarlyImport && process.env.NODE_ENV === "production" ? collectedAsyncImports.map((modulePath)=>{
+        return `import ${JSON.stringify(modulePath)};`;
+    }).join("\n") : "";
+    return earlyEvaluateCode + code;
+};
+export default nextAppLoader;
+
+//# sourceMappingURL=next-app-loader.js.map

node_modules/next/dist/esm/build/webpack/loaders/next-barrel-loader.js

@@ -0,0 +1,248 @@
+/**
+ * ## Barrel Optimizations
+ *
+ * This loader is used to optimize the imports of "barrel" files that have many
+ * re-exports. Currently, both Node.js and Webpack have to enter all of these
+ * submodules even if we only need a few of them.
+ *
+ * For example, say a file `foo.js` with the following contents:
+ *
+ *   export { a } from './a'
+ *   export { b } from './b'
+ *   export { c } from './c'
+ *   ...
+ *
+ * If the user imports `a` only, this loader will accept the `names` option to
+ * be `['a']`. Then, it request the "__barrel_transform__" SWC transform to load
+ * `foo.js` and receive the following output:
+ *
+ *   export const __next_private_export_map__ = '[["a","./a","a"],["b","./b","b"],["c","./c","c"],...]'
+ *
+ *   format: '["<imported identifier>", "<import path>", "<exported name>"]'
+ *   e.g.: import { a as b } from './module-a' => '["b", "./module-a", "a"]'
+ *
+ * The export map, generated by SWC, is a JSON that represents the exports of
+ * that module, their original file, and their original name (since you can do
+ * `export { a as b }`).
+ *
+ * Then, this loader can safely remove all the exports that are not needed and
+ * re-export the ones from `names`:
+ *
+ *   export { a } from './a'
+ *
+ * That's the basic situation and also the happy path.
+ *
+ *
+ *
+ * ## Wildcard Exports
+ *
+ * For wildcard exports (e.g. `export * from './a'`), it becomes a bit more complicated.
+ * Say `foo.js` with the following contents:
+ *
+ *   export * from './a'
+ *   export * from './b'
+ *   export * from './c'
+ *   ...
+ *
+ * If the user imports `bar` from it, SWC can never know which files are going to be
+ * exporting `bar`. So, we have to keep all the wildcard exports and do the same
+ * process recursively. This loader will return the following output:
+ *
+ *   export * from '__barrel_optimize__?names=bar&wildcard!=!./a'
+ *   export * from '__barrel_optimize__?names=bar&wildcard!=!./b'
+ *   export * from '__barrel_optimize__?names=bar&wildcard!=!./c'
+ *   ...
+ *
+ * The "!=!" tells Webpack to use the same loader to process './a', './b', and './c'.
+ * After the recursive process, the "inner loaders" will either return an empty string
+ * or:
+ *
+ *   export * from './target'
+ *
+ * Where `target` is the file that exports `bar`.
+ *
+ *
+ *
+ * ## Non-Barrel Files
+ *
+ * If the file is not a barrel, we can't apply any optimizations. That's because
+ * we can't easily remove things from the file. For example, say `foo.js` with:
+ *
+ *   const v = 1
+ *   export function b () {
+ *     return v
+ *   }
+ *
+ * If the user imports `b` only, we can't remove the `const v = 1` even though
+ * the file is side-effect free. In these caes, this loader will simply re-export
+ * `foo.js`:
+ *
+ *   export * from './foo'
+ *
+ * Besides these cases, this loader also carefully handles the module cache so
+ * SWC won't analyze the same file twice, and no instance of the same file will
+ * be accidentally created as different instances.
+ */ import path from "path";
+import { transform } from "../../swc";
+// This is a in-memory cache for the mapping of barrel exports. This only applies
+// to the packages that we optimize. It will never change (e.g. upgrading packages)
+// during the lifetime of the server so we can safely cache it.
+// There is also no need to collect the cache for the same reason.
+const barrelTransformMappingCache = new Map();
+async function getBarrelMapping(resourcePath, swcCacheDir, resolve, fs) {
+    if (barrelTransformMappingCache.has(resourcePath)) {
+        return barrelTransformMappingCache.get(resourcePath);
+    }
+    // This is a SWC transform specifically for `optimizeBarrelExports`. We don't
+    // care about other things but the export map only.
+    async function transpileSource(filename, source, isWildcard) {
+        const isTypeScript = filename.endsWith(".ts") || filename.endsWith(".tsx");
+        return new Promise((res)=>transform(source, {
+                filename,
+                inputSourceMap: undefined,
+                sourceFileName: filename,
+                optimizeBarrelExports: {
+                    wildcard: isWildcard
+                },
+                jsc: {
+                    parser: {
+                        syntax: isTypeScript ? "typescript" : "ecmascript",
+                        [isTypeScript ? "tsx" : "jsx"]: true
+                    },
+                    experimental: {
+                        cacheRoot: swcCacheDir
+                    }
+                }
+            }).then((output)=>{
+                res(output.code);
+            }));
+    }
+    // Avoid circular `export *` dependencies
+    const visited = new Set();
+    async function getMatches(file, isWildcard, isClientEntry) {
+        if (visited.has(file)) {
+            return null;
+        }
+        visited.add(file);
+        const source = await new Promise((res, rej)=>{
+            fs.readFile(file, (err, data)=>{
+                if (err || data === undefined) {
+                    rej(err);
+                } else {
+                    res(data.toString());
+                }
+            });
+        });
+        const output = await transpileSource(file, source, isWildcard);
+        const matches = output.match(/^([^]*)export (const|var) __next_private_export_map__ = ('[^']+'|"[^"]+")/);
+        if (!matches) {
+            return null;
+        }
+        const matchedDirectives = output.match(/^([^]*)export (const|var) __next_private_directive_list__ = '([^']+)'/);
+        const directiveList = matchedDirectives ? JSON.parse(matchedDirectives[3]) : [];
+        // "use client" in barrel files has to be transferred to the target file.
+        isClientEntry = directiveList.includes("use client");
+        let exportList = JSON.parse(matches[3].slice(1, -1));
+        const wildcardExports = [
+            ...output.matchAll(/export \* from "([^"]+)"/g)
+        ].map((match)=>match[1]);
+        // In the wildcard case, if the value is exported from another file, we
+        // redirect to that file (decl[0]). Otherwise, export from the current
+        // file itself.
+        if (isWildcard) {
+            for (const decl of exportList){
+                decl[1] = file;
+                decl[2] = decl[0];
+            }
+        }
+        // This recursively handles the wildcard exports (e.g. `export * from './a'`)
+        if (wildcardExports.length) {
+            await Promise.all(wildcardExports.map(async (req)=>{
+                const targetPath = await resolve(path.dirname(file), req.replace("__barrel_optimize__?names=__PLACEHOLDER__!=!", ""));
+                const targetMatches = await getMatches(targetPath, true, isClientEntry);
+                if (targetMatches) {
+                    // Merge the export list
+                    exportList = exportList.concat(targetMatches.exportList);
+                }
+            }));
+        }
+        return {
+            exportList,
+            wildcardExports,
+            isClientEntry
+        };
+    }
+    const res = await getMatches(resourcePath, false, false);
+    barrelTransformMappingCache.set(resourcePath, res);
+    return res;
+}
+const NextBarrelLoader = async function() {
+    this.async();
+    this.cacheable(true);
+    const { names, swcCacheDir } = this.getOptions();
+    // For barrel optimizations, we always prefer the "module" field over the
+    // "main" field because ESM handling is more robust with better tree-shaking.
+    const resolve = this.getResolve({
+        mainFields: [
+            "module",
+            "main"
+        ]
+    });
+    const mapping = await getBarrelMapping(this.resourcePath, swcCacheDir, resolve, this.fs);
+    // `resolve` adds all sub-paths to the dependency graph. However, we already
+    // cached the mapping and we assume them to not change. So, we can safely
+    // clear the dependencies here to avoid unnecessary watchers which turned out
+    // to be very expensive.
+    this.clearDependencies();
+    if (!mapping) {
+        // This file isn't a barrel and we can't apply any optimizations. Let's re-export everything.
+        // Since this loader accepts `names` and the request is keyed with `names`, we can't simply
+        // return the original source here. That will create these imports with different names as
+        // different modules instances.
+        this.callback(null, `export * from ${JSON.stringify(this.resourcePath)}`);
+        return;
+    }
+    const exportList = mapping.exportList;
+    const isClientEntry = mapping.isClientEntry;
+    const exportMap = new Map();
+    for (const [name, filePath, orig] of exportList){
+        exportMap.set(name, [
+            filePath,
+            orig
+        ]);
+    }
+    let output = "";
+    let missedNames = [];
+    for (const name of names){
+        // If the name matches
+        if (exportMap.has(name)) {
+            const decl = exportMap.get(name);
+            if (decl[1] === "*") {
+                output += `\nexport * as ${name} from ${JSON.stringify(decl[0])}`;
+            } else if (decl[1] === "default") {
+                output += `\nexport { default as ${name} } from ${JSON.stringify(decl[0])}`;
+            } else if (decl[1] === name) {
+                output += `\nexport { ${name} } from ${JSON.stringify(decl[0])}`;
+            } else {
+                output += `\nexport { ${decl[1]} as ${name} } from ${JSON.stringify(decl[0])}`;
+            }
+        } else {
+            missedNames.push(name);
+        }
+    }
+    // These are from wildcard exports.
+    if (missedNames.length > 0) {
+        for (const req of mapping.wildcardExports){
+            output += `\nexport * from ${JSON.stringify(req.replace("__PLACEHOLDER__", missedNames.join(",") + "&wildcard"))}`;
+        }
+    }
+    // When it has `"use client"` inherited from its barrel files, we need to
+    // prefix it to this target file as well.
+    if (isClientEntry) {
+        output = `"use client";\n${output}`;
+    }
+    this.callback(null, output);
+};
+export default NextBarrelLoader;
+
+//# sourceMappingURL=next-barrel-loader.js.map

node_modules/next/dist/esm/build/webpack/loaders/next-client-pages-loader.js

@@ -0,0 +1,27 @@
+import { stringifyRequest } from "../stringify-request";
+// this parameter: https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters
+function nextClientPagesLoader() {
+    const pagesLoaderSpan = this.currentTraceSpan.traceChild("next-client-pages-loader");
+    return pagesLoaderSpan.traceFn(()=>{
+        const { absolutePagePath, page } = this.getOptions();
+        pagesLoaderSpan.setAttribute("absolutePagePath", absolutePagePath);
+        const stringifiedPageRequest = stringifyRequest(this, absolutePagePath);
+        const stringifiedPage = JSON.stringify(page);
+        return `
+    (window.__NEXT_P = window.__NEXT_P || []).push([
+      ${stringifiedPage},
+      function () {
+        return require(${stringifiedPageRequest});
+      }
+    ]);
+    if(module.hot) {
+      module.hot.dispose(function () {
+        window.__NEXT_P.push([${stringifiedPage}])
+      });
+    }
+  `;
+    });
+}
+export default nextClientPagesLoader;
+
+//# sourceMappingURL=next-client-pages-loader.js.map

node_modules/next/dist/esm/build/webpack/loaders/next-client-pages-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-client-pages-loader.ts"],"names":["stringifyRequest","nextClientPagesLoader","pagesLoaderSpan","currentTraceSpan","traceChild","traceFn","absolutePagePath","page","getOptions","setAttribute","stringifiedPageRequest","stringifiedPage","JSON","stringify"],"mappings":"AAAA,SAASA,gBAAgB,QAAQ,uBAAsB;AAOvD,8FAA8F;AAC9F,SAASC;IACP,MAAMC,kBAAkB,IAAI,CAACC,gBAAgB,CAACC,UAAU,CACtD;IAGF,OAAOF,gBAAgBG,OAAO,CAAC;QAC7B,MAAM,EAAEC,gBAAgB,EAAEC,IAAI,EAAE,GAC9B,IAAI,CAACC,UAAU;QAEjBN,gBAAgBO,YAAY,CAAC,oBAAoBH;QAEjD,MAAMI,yBAAyBV,iBAAiB,IAAI,EAAEM;QACtD,MAAMK,kBAAkBC,KAAKC,SAAS,CAACN;QAEvC,OAAO,CAAC;;MAEN,EAAEI,gBAAgB;;uBAED,EAAED,uBAAuB;;;;;8BAKlB,EAAEC,gBAAgB;;;EAG9C,CAAC;IACD;AACF;AAEA,eAAeV,sBAAqB"}

node_modules/next/dist/esm/build/webpack/loaders/next-edge-app-route-loader/index.js

@@ -0,0 +1,31 @@
+import { getModuleBuildInfo } from "../get-module-build-info";
+import { stringifyRequest } from "../../stringify-request";
+import { WEBPACK_RESOURCE_QUERIES } from "../../../../lib/constants";
+import { loadEntrypoint } from "../../../load-entrypoint";
+const EdgeAppRouteLoader = async function() {
+    const { page, absolutePagePath, preferredRegion, appDirLoader: appDirLoaderBase64 = "", middlewareConfig: middlewareConfigBase64 = "" } = this.getOptions();
+    const appDirLoader = Buffer.from(appDirLoaderBase64, "base64").toString();
+    const middlewareConfig = JSON.parse(Buffer.from(middlewareConfigBase64, "base64").toString());
+    // Ensure we only run this loader for as a module.
+    if (!this._module) throw new Error("This loader is only usable as a module");
+    const buildInfo = getModuleBuildInfo(this._module);
+    buildInfo.nextEdgeSSR = {
+        isServerComponent: false,
+        page: page,
+        isAppDir: true
+    };
+    buildInfo.route = {
+        page,
+        absolutePagePath,
+        preferredRegion,
+        middlewareConfig
+    };
+    const stringifiedPagePath = stringifyRequest(this, absolutePagePath);
+    const modulePath = `${appDirLoader}${stringifiedPagePath.substring(1, stringifiedPagePath.length - 1)}?${WEBPACK_RESOURCE_QUERIES.edgeSSREntry}`;
+    return await loadEntrypoint("edge-app-route", {
+        VAR_USERLAND: modulePath
+    });
+};
+export default EdgeAppRouteLoader;
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/esm/build/webpack/loaders/next-edge-app-route-loader/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-edge-app-route-loader/index.ts"],"names":["getModuleBuildInfo","stringifyRequest","WEBPACK_RESOURCE_QUERIES","loadEntrypoint","EdgeAppRouteLoader","page","absolutePagePath","preferredRegion","appDirLoader","appDirLoaderBase64","middlewareConfig","middlewareConfigBase64","getOptions","Buffer","from","toString","JSON","parse","_module","Error","buildInfo","nextEdgeSSR","isServerComponent","isAppDir","route","stringifiedPagePath","modulePath","substring","length","edgeSSREntry","VAR_USERLAND"],"mappings":"AAAA,SAASA,kBAAkB,QAAQ,2BAA0B;AAC7D,SAASC,gBAAgB,QAAQ,0BAAyB;AAG1D,SAASC,wBAAwB,QAAQ,4BAA2B;AAEpE,SAASC,cAAc,QAAQ,2BAA0B;AAWzD,MAAMC,qBACJ;IACE,MAAM,EACJC,IAAI,EACJC,gBAAgB,EAChBC,eAAe,EACfC,cAAcC,qBAAqB,EAAE,EACrCC,kBAAkBC,yBAAyB,EAAE,EAC9C,GAAG,IAAI,CAACC,UAAU;IAEnB,MAAMJ,eAAeK,OAAOC,IAAI,CAACL,oBAAoB,UAAUM,QAAQ;IACvE,MAAML,mBAAqCM,KAAKC,KAAK,CACnDJ,OAAOC,IAAI,CAACH,wBAAwB,UAAUI,QAAQ;IAGxD,kDAAkD;IAClD,IAAI,CAAC,IAAI,CAACG,OAAO,EAAE,MAAM,IAAIC,MAAM;IAEnC,MAAMC,YAAYpB,mBAAmB,IAAI,CAACkB,OAAO;IAEjDE,UAAUC,WAAW,GAAG;QACtBC,mBAAmB;QACnBjB,MAAMA;QACNkB,UAAU;IACZ;IACAH,UAAUI,KAAK,GAAG;QAChBnB;QACAC;QACAC;QACAG;IACF;IAEA,MAAMe,sBAAsBxB,iBAAiB,IAAI,EAAEK;IACnD,MAAMoB,aAAa,CAAC,EAAElB,aAAa,EAAEiB,oBAAoBE,SAAS,CAChE,GACAF,oBAAoBG,MAAM,GAAG,GAC7B,CAAC,EAAE1B,yBAAyB2B,YAAY,CAAC,CAAC;IAE5C,OAAO,MAAM1B,eAAe,kBAAkB;QAC5C2B,cAAcJ;IAChB;AACF;AAEF,eAAetB,mBAAkB"}

node_modules/next/dist/esm/build/webpack/loaders/next-edge-function-loader.js

@@ -0,0 +1,42 @@
+import { getModuleBuildInfo } from "./get-module-build-info";
+import { stringifyRequest } from "../stringify-request";
+const nextEdgeFunctionLoader = function nextEdgeFunctionLoader() {
+    const { absolutePagePath, page, rootDir, preferredRegion, middlewareConfig: middlewareConfigBase64 } = this.getOptions();
+    const stringifiedPagePath = stringifyRequest(this, absolutePagePath);
+    const buildInfo = getModuleBuildInfo(this._module);
+    const middlewareConfig = JSON.parse(Buffer.from(middlewareConfigBase64, "base64").toString());
+    buildInfo.route = {
+        page: page || "/",
+        absolutePagePath,
+        preferredRegion,
+        middlewareConfig
+    };
+    buildInfo.nextEdgeApiFunction = {
+        page: page || "/"
+    };
+    buildInfo.rootDir = rootDir;
+    return `
+        import 'next/dist/esm/server/web/globals'
+        import { adapter } from 'next/dist/esm/server/web/adapter'
+        import { IncrementalCache } from 'next/dist/esm/server/lib/incremental-cache'
+        import { wrapApiHandler } from 'next/dist/esm/server/api-utils'
+
+        import handler from ${stringifiedPagePath}
+
+        if (typeof handler !== 'function') {
+          throw new Error('The Edge Function "pages${page}" must export a \`default\` function');
+        }
+
+        export default function nHandler (opts) {
+          return adapter({
+              ...opts,
+              IncrementalCache,
+              page: ${JSON.stringify(page)},
+              handler: wrapApiHandler(${JSON.stringify(page)}, handler),
+          })
+        }
+    `;
+};
+export default nextEdgeFunctionLoader;
+
+//# sourceMappingURL=next-edge-function-loader.js.map

node_modules/next/dist/esm/build/webpack/loaders/next-edge-function-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-edge-function-loader.ts"],"names":["getModuleBuildInfo","stringifyRequest","nextEdgeFunctionLoader","absolutePagePath","page","rootDir","preferredRegion","middlewareConfig","middlewareConfigBase64","getOptions","stringifiedPagePath","buildInfo","_module","JSON","parse","Buffer","from","toString","route","nextEdgeApiFunction","stringify"],"mappings":"AACA,SAASA,kBAAkB,QAAQ,0BAAyB;AAC5D,SAASC,gBAAgB,QAAQ,uBAAsB;AAWvD,MAAMC,yBACJ,SAASA;IACP,MAAM,EACJC,gBAAgB,EAChBC,IAAI,EACJC,OAAO,EACPC,eAAe,EACfC,kBAAkBC,sBAAsB,EACzC,GAA8B,IAAI,CAACC,UAAU;IAC9C,MAAMC,sBAAsBT,iBAAiB,IAAI,EAAEE;IACnD,MAAMQ,YAAYX,mBAAmB,IAAI,CAACY,OAAO;IACjD,MAAML,mBAAqCM,KAAKC,KAAK,CACnDC,OAAOC,IAAI,CAACR,wBAAwB,UAAUS,QAAQ;IAExDN,UAAUO,KAAK,GAAG;QAChBd,MAAMA,QAAQ;QACdD;QACAG;QACAC;IACF;IACAI,UAAUQ,mBAAmB,GAAG;QAC9Bf,MAAMA,QAAQ;IAChB;IACAO,UAAUN,OAAO,GAAGA;IAEpB,OAAO,CAAC;;;;;;4BAMgB,EAAEK,oBAAoB;;;mDAGC,EAAEN,KAAK;;;;;;;oBAOtC,EAAES,KAAKO,SAAS,CAAChB,MAAM;sCACL,EAAES,KAAKO,SAAS,CAAChB,MAAM;;;IAGzD,CAAC;AACH;AAEF,eAAeF,uBAAsB"}

node_modules/next/dist/esm/build/webpack/loaders/next-edge-ssr-loader/index.js

@@ -0,0 +1,90 @@
+import { getModuleBuildInfo } from "../get-module-build-info";
+import { WEBPACK_RESOURCE_QUERIES } from "../../../../lib/constants";
+import { RouteKind } from "../../../../server/future/route-kind";
+import { normalizePagePath } from "../../../../shared/lib/page-path/normalize-page-path";
+import { loadEntrypoint } from "../../../load-entrypoint";
+/*
+For pages SSR'd at the edge, we bundle them with the ESM version of Next in order to
+benefit from the better tree-shaking and thus, smaller bundle sizes.
+
+The absolute paths for _app, _error and _document, used in this loader, link to the regular CJS modules.
+They are generated in `createPagesMapping` where we don't have access to `isEdgeRuntime`,
+so we have to do it here. It's not that bad because it keeps all references to ESM modules magic in this place.
+*/ function swapDistFolderWithEsmDistFolder(path) {
+    return path.replace("next/dist/pages", "next/dist/esm/pages");
+}
+function getRouteModuleOptions(page) {
+    const options = {
+        definition: {
+            kind: RouteKind.PAGES,
+            page: normalizePagePath(page),
+            pathname: page,
+            // The following aren't used in production.
+            bundlePath: "",
+            filename: ""
+        }
+    };
+    return options;
+}
+const edgeSSRLoader = async function edgeSSRLoader() {
+    const { dev, page, absolutePagePath, absoluteAppPath, absoluteDocumentPath, absolute500Path, absoluteErrorPath, isServerComponent, stringifiedConfig: stringifiedConfigBase64, appDirLoader: appDirLoaderBase64, pagesType, sriEnabled, cacheHandler, preferredRegion, middlewareConfig: middlewareConfigBase64, serverActions } = this.getOptions();
+    const middlewareConfig = JSON.parse(Buffer.from(middlewareConfigBase64, "base64").toString());
+    const stringifiedConfig = Buffer.from(stringifiedConfigBase64 || "", "base64").toString();
+    const appDirLoader = Buffer.from(appDirLoaderBase64 || "", "base64").toString();
+    const isAppDir = pagesType === "app";
+    const buildInfo = getModuleBuildInfo(this._module);
+    buildInfo.nextEdgeSSR = {
+        isServerComponent,
+        page: page,
+        isAppDir
+    };
+    buildInfo.route = {
+        page,
+        absolutePagePath,
+        preferredRegion,
+        middlewareConfig
+    };
+    const pagePath = this.utils.contextify(this.context || this.rootContext, absolutePagePath);
+    const appPath = this.utils.contextify(this.context || this.rootContext, swapDistFolderWithEsmDistFolder(absoluteAppPath));
+    const errorPath = this.utils.contextify(this.context || this.rootContext, swapDistFolderWithEsmDistFolder(absoluteErrorPath));
+    const documentPath = this.utils.contextify(this.context || this.rootContext, swapDistFolderWithEsmDistFolder(absoluteDocumentPath));
+    const userland500Path = absolute500Path ? this.utils.contextify(this.context || this.rootContext, swapDistFolderWithEsmDistFolder(absolute500Path)) : null;
+    const stringifiedPagePath = JSON.stringify(pagePath);
+    const pageModPath = `${appDirLoader}${stringifiedPagePath.substring(1, stringifiedPagePath.length - 1)}${isAppDir ? `?${WEBPACK_RESOURCE_QUERIES.edgeSSREntry}` : ""}`;
+    if (isAppDir) {
+        return await loadEntrypoint("edge-ssr-app", {
+            VAR_USERLAND: pageModPath,
+            VAR_PAGE: page
+        }, {
+            sriEnabled: JSON.stringify(sriEnabled),
+            nextConfig: stringifiedConfig,
+            isServerComponent: JSON.stringify(isServerComponent),
+            dev: JSON.stringify(dev),
+            serverActions: typeof serverActions === "undefined" ? "undefined" : JSON.stringify(serverActions)
+        }, {
+            incrementalCacheHandler: cacheHandler ?? null
+        });
+    } else {
+        return await loadEntrypoint("edge-ssr", {
+            VAR_USERLAND: pageModPath,
+            VAR_PAGE: page,
+            VAR_MODULE_DOCUMENT: documentPath,
+            VAR_MODULE_APP: appPath,
+            VAR_MODULE_GLOBAL_ERROR: errorPath
+        }, {
+            pagesType: JSON.stringify(pagesType),
+            sriEnabled: JSON.stringify(sriEnabled),
+            nextConfig: stringifiedConfig,
+            dev: JSON.stringify(dev),
+            pageRouteModuleOptions: JSON.stringify(getRouteModuleOptions(page)),
+            errorRouteModuleOptions: JSON.stringify(getRouteModuleOptions("/_error")),
+            user500RouteModuleOptions: JSON.stringify(getRouteModuleOptions("/500"))
+        }, {
+            userland500Page: userland500Path,
+            incrementalCacheHandler: cacheHandler ?? null
+        });
+    }
+};
+export default edgeSSRLoader;
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/esm/build/webpack/loaders/next-edge-ssr-loader/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-edge-ssr-loader/index.ts"],"names":["getModuleBuildInfo","WEBPACK_RESOURCE_QUERIES","RouteKind","normalizePagePath","loadEntrypoint","swapDistFolderWithEsmDistFolder","path","replace","getRouteModuleOptions","page","options","definition","kind","PAGES","pathname","bundlePath","filename","edgeSSRLoader","dev","absolutePagePath","absoluteAppPath","absoluteDocumentPath","absolute500Path","absoluteErrorPath","isServerComponent","stringifiedConfig","stringifiedConfigBase64","appDirLoader","appDirLoaderBase64","pagesType","sriEnabled","cacheHandler","preferredRegion","middlewareConfig","middlewareConfigBase64","serverActions","getOptions","JSON","parse","Buffer","from","toString","isAppDir","buildInfo","_module","nextEdgeSSR","route","pagePath","utils","contextify","context","rootContext","appPath","errorPath","documentPath","userland500Path","stringifiedPagePath","stringify","pageModPath","substring","length","edgeSSREntry","VAR_USERLAND","VAR_PAGE","nextConfig","incrementalCacheHandler","VAR_MODULE_DOCUMENT","VAR_MODULE_APP","VAR_MODULE_GLOBAL_ERROR","pageRouteModuleOptions","errorRouteModuleOptions","user500RouteModuleOptions","userland500Page"],"mappings":"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"}

node_modules/next/dist/esm/build/webpack/loaders/next-edge-ssr-loader/render.js

@@ -0,0 +1,99 @@
+import WebServer from "../../../../server/web-server";
+import { WebNextRequest, WebNextResponse } from "../../../../server/base-http/web";
+import { SERVER_RUNTIME } from "../../../../lib/constants";
+import { normalizeAppPath } from "../../../../shared/lib/router/utils/app-paths";
+import { internal_getCurrentFunctionWaitUntil } from "../../../../server/web/internal-edge-wait-until";
+export function getRender({ dev, page, appMod, pageMod, errorMod, error500Mod, pagesType, Document, buildManifest, reactLoadableManifest, interceptionRouteRewrites, renderToHTML, clientReferenceManifest, subresourceIntegrityManifest, serverActionsManifest, serverActions, config, buildId, nextFontManifest, incrementalCacheHandler }) {
+    const isAppPath = pagesType === "app";
+    const baseLoadComponentResult = {
+        dev,
+        buildManifest,
+        reactLoadableManifest,
+        subresourceIntegrityManifest,
+        Document,
+        App: appMod == null ? void 0 : appMod.default,
+        clientReferenceManifest
+    };
+    const server = new WebServer({
+        dev,
+        conf: config,
+        minimalMode: true,
+        webServerConfig: {
+            page,
+            pathname: isAppPath ? normalizeAppPath(page) : page,
+            pagesType,
+            interceptionRouteRewrites,
+            extendRenderOpts: {
+                buildId,
+                runtime: SERVER_RUNTIME.experimentalEdge,
+                supportsDynamicResponse: true,
+                disableOptimizedLoading: true,
+                serverActionsManifest,
+                serverActions,
+                nextFontManifest
+            },
+            renderToHTML,
+            incrementalCacheHandler,
+            loadComponent: async (inputPage)=>{
+                if (inputPage === page) {
+                    return {
+                        ...baseLoadComponentResult,
+                        Component: pageMod.default,
+                        pageConfig: pageMod.config || {},
+                        getStaticProps: pageMod.getStaticProps,
+                        getServerSideProps: pageMod.getServerSideProps,
+                        getStaticPaths: pageMod.getStaticPaths,
+                        ComponentMod: pageMod,
+                        isAppPath: !!pageMod.__next_app__,
+                        page: inputPage,
+                        routeModule: pageMod.routeModule
+                    };
+                }
+                // If there is a custom 500 page, we need to handle it separately.
+                if (inputPage === "/500" && error500Mod) {
+                    return {
+                        ...baseLoadComponentResult,
+                        Component: error500Mod.default,
+                        pageConfig: error500Mod.config || {},
+                        getStaticProps: error500Mod.getStaticProps,
+                        getServerSideProps: error500Mod.getServerSideProps,
+                        getStaticPaths: error500Mod.getStaticPaths,
+                        ComponentMod: error500Mod,
+                        page: inputPage,
+                        routeModule: error500Mod.routeModule
+                    };
+                }
+                if (inputPage === "/_error") {
+                    return {
+                        ...baseLoadComponentResult,
+                        Component: errorMod.default,
+                        pageConfig: errorMod.config || {},
+                        getStaticProps: errorMod.getStaticProps,
+                        getServerSideProps: errorMod.getServerSideProps,
+                        getStaticPaths: errorMod.getStaticPaths,
+                        ComponentMod: errorMod,
+                        page: inputPage,
+                        routeModule: errorMod.routeModule
+                    };
+                }
+                return null;
+            }
+        }
+    });
+    const handler = server.getRequestHandler();
+    return async function render(request, event) {
+        const extendedReq = new WebNextRequest(request);
+        const extendedRes = new WebNextResponse();
+        handler(extendedReq, extendedRes);
+        const result = await extendedRes.toResponse();
+        if (event == null ? void 0 : event.waitUntil) {
+            const waitUntilPromise = internal_getCurrentFunctionWaitUntil();
+            if (waitUntilPromise) {
+                event.waitUntil(waitUntilPromise);
+            }
+        }
+        return result;
+    };
+}
+
+//# sourceMappingURL=render.js.map

node_modules/next/dist/esm/build/webpack/loaders/next-edge-ssr-loader/render.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-edge-ssr-loader/render.ts"],"names":["WebServer","WebNextRequest","WebNextResponse","SERVER_RUNTIME","normalizeAppPath","internal_getCurrentFunctionWaitUntil","getRender","dev","page","appMod","pageMod","errorMod","error500Mod","pagesType","Document","buildManifest","reactLoadableManifest","interceptionRouteRewrites","renderToHTML","clientReferenceManifest","subresourceIntegrityManifest","serverActionsManifest","serverActions","config","buildId","nextFontManifest","incrementalCacheHandler","isAppPath","baseLoadComponentResult","App","default","server","conf","minimalMode","webServerConfig","pathname","extendRenderOpts","runtime","experimentalEdge","supportsDynamicResponse","disableOptimizedLoading","loadComponent","inputPage","Component","pageConfig","getStaticProps","getServerSideProps","getStaticPaths","ComponentMod","__next_app__","routeModule","handler","getRequestHandler","render","request","event","extendedReq","extendedRes","result","toResponse","waitUntil","waitUntilPromise"],"mappings":"AASA,OAAOA,eAAe,gCAA+B;AACrD,SACEC,cAAc,EACdC,eAAe,QACV,mCAAkC;AACzC,SAASC,cAAc,QAAQ,4BAA2B;AAE1D,SAASC,gBAAgB,QAAQ,gDAA+C;AAEhF,SAASC,oCAAoC,QAAQ,kDAAiD;AAItG,OAAO,SAASC,UAAU,EACxBC,GAAG,EACHC,IAAI,EACJC,MAAM,EACNC,OAAO,EACPC,QAAQ,EACRC,WAAW,EACXC,SAAS,EACTC,QAAQ,EACRC,aAAa,EACbC,qBAAqB,EACrBC,yBAAyB,EACzBC,YAAY,EACZC,uBAAuB,EACvBC,4BAA4B,EAC5BC,qBAAqB,EACrBC,aAAa,EACbC,MAAM,EACNC,OAAO,EACPC,gBAAgB,EAChBC,uBAAuB,EAyBxB;IACC,MAAMC,YAAYd,cAAc;IAChC,MAAMe,0BAA0B;QAC9BrB;QACAQ;QACAC;QACAI;QACAN;QACAe,GAAG,EAAEpB,0BAAAA,OAAQqB,OAAO;QACpBX;IACF;IAEA,MAAMY,SAAS,IAAI/B,UAAU;QAC3BO;QACAyB,MAAMT;QACNU,aAAa;QACbC,iBAAiB;YACf1B;YACA2B,UAAUR,YAAYvB,iBAAiBI,QAAQA;YAC/CK;YACAI;YACAmB,kBAAkB;gBAChBZ;gBACAa,SAASlC,eAAemC,gBAAgB;gBACxCC,yBAAyB;gBACzBC,yBAAyB;gBACzBnB;gBACAC;gBACAG;YACF;YACAP;YACAQ;YACAe,eAAe,OAAOC;gBACpB,IAAIA,cAAclC,MAAM;oBACtB,OAAO;wBACL,GAAGoB,uBAAuB;wBAC1Be,WAAWjC,QAAQoB,OAAO;wBAC1Bc,YAAYlC,QAAQa,MAAM,IAAI,CAAC;wBAC/BsB,gBAAgBnC,QAAQmC,cAAc;wBACtCC,oBAAoBpC,QAAQoC,kBAAkB;wBAC9CC,gBAAgBrC,QAAQqC,cAAc;wBACtCC,cAActC;wBACdiB,WAAW,CAAC,CAACjB,QAAQuC,YAAY;wBACjCzC,MAAMkC;wBACNQ,aAAaxC,QAAQwC,WAAW;oBAClC;gBACF;gBAEA,kEAAkE;gBAClE,IAAIR,cAAc,UAAU9B,aAAa;oBACvC,OAAO;wBACL,GAAGgB,uBAAuB;wBAC1Be,WAAW/B,YAAYkB,OAAO;wBAC9Bc,YAAYhC,YAAYW,MAAM,IAAI,CAAC;wBACnCsB,gBAAgBjC,YAAYiC,cAAc;wBAC1CC,oBAAoBlC,YAAYkC,kBAAkB;wBAClDC,gBAAgBnC,YAAYmC,cAAc;wBAC1CC,cAAcpC;wBACdJ,MAAMkC;wBACNQ,aAAatC,YAAYsC,WAAW;oBACtC;gBACF;gBAEA,IAAIR,cAAc,WAAW;oBAC3B,OAAO;wBACL,GAAGd,uBAAuB;wBAC1Be,WAAWhC,SAASmB,OAAO;wBAC3Bc,YAAYjC,SAASY,MAAM,IAAI,CAAC;wBAChCsB,gBAAgBlC,SAASkC,cAAc;wBACvCC,oBAAoBnC,SAASmC,kBAAkB;wBAC/CC,gBAAgBpC,SAASoC,cAAc;wBACvCC,cAAcrC;wBACdH,MAAMkC;wBACNQ,aAAavC,SAASuC,WAAW;oBACnC;gBACF;gBAEA,OAAO;YACT;QACF;IACF;IAEA,MAAMC,UAAUpB,OAAOqB,iBAAiB;IAExC,OAAO,eAAeC,OACpBC,OAAwB,EACxBC,KAAsB;QAEtB,MAAMC,cAAc,IAAIvD,eAAeqD;QACvC,MAAMG,cAAc,IAAIvD;QAExBiD,QAAQK,aAAaC;QACrB,MAAMC,SAAS,MAAMD,YAAYE,UAAU;QAE3C,IAAIJ,yBAAAA,MAAOK,SAAS,EAAE;YACpB,MAAMC,mBAAmBxD;YACzB,IAAIwD,kBAAkB;gBACpBN,MAAMK,SAAS,CAACC;YAClB;QACF;QAEA,OAAOH;IACT;AACF"}