.

node_modules/next/dist/build/webpack/loaders/css-loader/src/CssSyntaxError.d.ts

@@ -0,0 +1,4 @@
+export default class CssSyntaxError extends Error {
+    stack: any;
+    constructor(error: any);
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return CssSyntaxError;
+    }
+});
+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/build/webpack/loaders/css-loader/src/CssSyntaxError.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/loaders/css-loader/src/CssSyntaxError.ts"],"sourcesContent":["export default class CssSyntaxError extends Error {\n  stack: any\n  constructor(error: any) {\n    super(error)\n\n    const { reason, line, column } = error\n\n    this.name = 'CssSyntaxError'\n\n    // Based on https://github.com/postcss/postcss/blob/master/lib/css-syntax-error.es6#L132\n    // We don't need `plugin` and `file` properties.\n    this.message = `${this.name}\\n\\n`\n\n    if (typeof line !== 'undefined') {\n      this.message += `(${line}:${column}) `\n    }\n\n    this.message += reason\n\n    const code = error.showSourceCode()\n\n    if (code) {\n      this.message += `\\n\\n${code}\\n`\n    }\n\n    // We don't need stack https://github.com/postcss/postcss/blob/master/docs/guidelines/runner.md#31-dont-show-js-stack-for-csssyntaxerror\n    this.stack = false\n  }\n}\n"],"names":["CssSyntaxError","Error","constructor","error","reason","line","column","name","message","code","showSourceCode","stack"],"mappings":";;;;+BAAA;;;eAAqBA;;;AAAN,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,GAAG,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","ignoreList":[0]}

node_modules/next/dist/build/webpack/loaders/css-loader/src/camelcase.d.ts

@@ -0,0 +1,2 @@
+declare const camelCase: (input: string | string[], options?: any) => string;
+export default camelCase;

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

@@ -0,0 +1,93 @@
+/*
+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.
+*/ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+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 Object.defineProperty(new TypeError('Expected the input to be `string | string[]`'), "__NEXT_ERROR_CODE", {
+            value: "E613",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    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);
+};
+const _default = camelCase;
+
+//# sourceMappingURL=camelcase.js.map

node_modules/next/dist/build/webpack/loaders/css-loader/src/index.d.ts

@@ -0,0 +1 @@
+export default function loader(this: any, content: string, map: any, meta: any): Promise<void>;

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

@@ -0,0 +1,288 @@
+/*
+  MIT License http://www.opensource.org/licenses/mit-license.php
+  Author Tobias Koppers @sokra
+*/ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return loader;
+    }
+});
+const _CssSyntaxError = /*#__PURE__*/ _interop_require_default(require("./CssSyntaxError"));
+const _Warning = /*#__PURE__*/ _interop_require_default(require("../../postcss-loader/src/Warning"));
+const _stringifyrequest = require("../../../stringify-request");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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: '',
+        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 Object.defineProperty(new Error('The "modules.namedExport" option requires the "esModules" option to be enabled'), "__NEXT_ERROR_CODE", {
+                value: "E103",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (modulesOptions.exportLocalsConvention !== 'camelCaseOnly') {
+            throw Object.defineProperty(new Error('The "modules.namedExport" option requires the "modules.exportLocalsConvention" option to be "camelCaseOnly"'), "__NEXT_ERROR_CODE", {
+                value: "E23",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    return modulesOptions;
+}
+function normalizeOptions(rawOptions, loaderContext) {
+    if (rawOptions.icss) {
+        loaderContext.emitWarning(Object.defineProperty(new Error('The "icss" option is deprecated, use "modules.compileType: "icss"" instead'), "__NEXT_ERROR_CODE", {
+            value: "E476",
+            enumerable: false,
+            configurable: true
+        }));
+    }
+    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
+    };
+}
+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 exports1 = 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)=>(0, _stringifyrequest.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)=>(0, _stringifyrequest.stringifyRequest)(this, url),
+                deploymentId: rawOptions.deploymentId
+            }));
+        }
+        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: exports1,
+                context: this.context,
+                rootContext: this.rootContext,
+                resolver: icssResolver,
+                urlHandler: (url)=>(0, _stringifyrequest.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') {
+                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' ? Object.defineProperty(new _CssSyntaxError.default(error), "__NEXT_ERROR_CODE", {
+                value: "E394",
+                enumerable: false,
+                configurable: true
+            }) : error;
+        }
+        for (const warning of result.warnings()){
+            this.emitWarning(Object.defineProperty(new _Warning.default(warning), "__NEXT_ERROR_CODE", {
+                value: "E394",
+                enumerable: false,
+                configurable: true
+            }));
+        }
+        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: (0, _stringifyrequest.stringifyRequest)(this, require.resolve('./runtime/api'))
+            });
+        }
+        const importCode = getImportCode(imports, options);
+        const moduleCode = getModuleCode(result, api, replacements, options, this);
+        const exportCode = getExportCode(exports1, replacements, options);
+        return `${importCode}${moduleCode}${exportCode}`;
+    }).then((code)=>{
+        callback(null, code);
+    }, (err)=>{
+        callback(err);
+    });
+}
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/build/webpack/loaders/css-loader/src/plugins/index.d.ts

@@ -0,0 +1,4 @@
+import importParser from './postcss-import-parser';
+import icssParser from './postcss-icss-parser';
+import urlParser from './postcss-url-parser';
+export { importParser, icssParser, urlParser };

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    icssParser: null,
+    importParser: null,
+    urlParser: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    icssParser: function() {
+        return _postcssicssparser.default;
+    },
+    importParser: function() {
+        return _postcssimportparser.default;
+    },
+    urlParser: function() {
+        return _postcssurlparser.default;
+    }
+});
+const _postcssimportparser = /*#__PURE__*/ _interop_require_default(require("./postcss-import-parser"));
+const _postcssicssparser = /*#__PURE__*/ _interop_require_default(require("./postcss-icss-parser"));
+const _postcssurlparser = /*#__PURE__*/ _interop_require_default(require("./postcss-url-parser"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/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"],"sourcesContent":["import importParser from './postcss-import-parser'\nimport icssParser from './postcss-icss-parser'\nimport urlParser from './postcss-url-parser'\n\nexport { importParser, icssParser, urlParser }\n"],"names":["icssParser","importParser","urlParser"],"mappings":";;;;;;;;;;;;;;;;IAIuBA,UAAU;eAAVA,0BAAU;;IAAxBC,YAAY;eAAZA,4BAAY;;IAAcC,SAAS;eAATA,yBAAS;;;4EAJnB;0EACF;yEACD","ignoreList":[0]}

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

@@ -0,0 +1,8 @@
+declare const plugin: {
+    (options?: any): {
+        postcssPlugin: string;
+        OnceExit(root: any): Promise<void>;
+    };
+    postcss: boolean;
+};
+export default plugin;

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _icssutils = require("next/dist/compiled/icss-utils");
+const _utils = require("../utils");
+const plugin = (options = {})=>{
+    return {
+        postcssPlugin: 'postcss-icss-parser',
+        async OnceExit (root) {
+            const importReplacements = Object.create(null);
+            const { icssImports, icssExports } = (0, _icssutils.extractICSS)(root);
+            const imports = new Map();
+            const tasks = [];
+            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 = (0, _utils.requestify)((0, _utils.normalizeUrl)(normalizedUrl, true), options.rootContext);
+                const doResolve = async ()=>{
+                    const { resolver, context } = options;
+                    const resolvedUrl = await (0, _utils.resolveRequests)(resolver, context, [
+                        ...new Set([
+                            normalizedUrl,
+                            request
+                        ])
+                    ]);
+                    if (!resolvedUrl) {
+                        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) {
+                (0, _icssutils.replaceSymbols)(root, importReplacements);
+            }
+            for (const name of Object.keys(icssExports)){
+                const value = (0, _icssutils.replaceValueSymbols)(icssExports[name], importReplacements);
+                options.exports.push({
+                    name,
+                    value
+                });
+            }
+        }
+    };
+};
+plugin.postcss = true;
+const _default = plugin;
+
+//# sourceMappingURL=postcss-icss-parser.js.map

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

@@ -0,0 +1,13 @@
+declare const plugin: {
+    (options?: any): {
+        postcssPlugin: string;
+        prepare(result: any): {
+            AtRule: {
+                import(atRule: any): void;
+            };
+            OnceExit(): Promise<void>;
+        };
+    };
+    postcss: boolean;
+};
+export default plugin;

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

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _postcssvalueparser = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/postcss-value-parser"));
+const _utils = require("../utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+        if (matched && matched[2] === 'true') {
+            return;
+        }
+    }
+    const prevNode = atRule.prev();
+    if (prevNode && prevNode.type === 'comment') {
+        const matched = prevNode.text.match(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+        if (matched && matched[2] === 'true') {
+            return;
+        }
+    }
+    // Nodes do not exists - `@import url('http://') :root {}`
+    if (atRule.nodes) {
+        const error = Object.defineProperty(new Error("It looks like you didn't end your @import statement correctly. Child nodes are attached to it."), "__NEXT_ERROR_CODE", {
+            value: "E341",
+            enumerable: false,
+            configurable: true
+        });
+        error.node = atRule;
+        throw error;
+    }
+    const { nodes: paramsNodes } = (0, _postcssvalueparser.default)(atRule[key]);
+    // No nodes - `@import ;`
+    // Invalid type - `@import foo-bar;`
+    if (paramsNodes.length === 0 || paramsNodes[0].type !== 'string' && paramsNodes[0].type !== 'function') {
+        const error = Object.defineProperty(new Error(`Unable to find uri in "${atRule.toString()}"`), "__NEXT_ERROR_CODE", {
+            value: "E215",
+            enumerable: false,
+            configurable: true
+        });
+        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 = Object.defineProperty(new Error(`Unable to find uri in "${atRule.toString()}"`), "__NEXT_ERROR_CODE", {
+                value: "E215",
+                enumerable: false,
+                configurable: true
+            });
+            error.node = atRule;
+            throw error;
+        }
+        isStringValue = paramsNodes[0].nodes.length !== 0 && paramsNodes[0].nodes[0].type === 'string';
+        url = isStringValue ? paramsNodes[0].nodes[0].value : _postcssvalueparser.default.stringify(paramsNodes[0].nodes);
+    }
+    url = (0, _utils.normalizeUrl)(url, isStringValue);
+    const isRequestable = (0, _utils.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 = Object.defineProperty(new Error(`Unable to find uri in "${atRule.toString()}"`), "__NEXT_ERROR_CODE", {
+            value: "E215",
+            enumerable: false,
+            configurable: true
+        });
+        error.node = atRule;
+        throw error;
+    }
+    const mediaNodes = paramsNodes.slice(1);
+    let media;
+    if (mediaNodes.length > 0) {
+        media = _postcssvalueparser.default.stringify(mediaNodes).trim().toLowerCase();
+    }
+    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 = (0, _utils.requestify)(url, options.rootContext);
+                            const { resolver, context } = options;
+                            const resolvedUrl = await (0, _utils.resolveRequests)(resolver, context, [
+                                ...new Set([
+                                    request,
+                                    url
+                                ])
+                            ]);
+                            if (!resolvedUrl) {
+                                return;
+                            }
+                            if (resolvedUrl === options.resourcePath) {
+                                atRule.remove();
+                                return;
+                            }
+                            atRule.remove();
+                            return {
+                                url: resolvedUrl,
+                                media,
+                                prefix,
+                                isRequestable
+                            };
+                        }
+                        atRule.remove();
+                        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;
+const _default = plugin;
+
+//# sourceMappingURL=postcss-import-parser.js.map

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

@@ -0,0 +1,11 @@
+declare const plugin: {
+    (options?: any): {
+        postcssPlugin: string;
+        prepare(result: any): {
+            Declaration(declaration: any): void;
+            OnceExit(): Promise<void>;
+        };
+    };
+    postcss: boolean;
+};
+export default plugin;

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

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _postcssvalueparser = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/postcss-value-parser"));
+const _utils = require("../utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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) {
+        return;
+    }
+    if (prevValueNode.type === 'space') {
+        if (!nodes[index - 2]) {
+            return;
+        }
+        prevValueNode = nodes[index - 2];
+    }
+    if (prevValueNode.type !== 'comment') {
+        return;
+    }
+    const matched = prevValueNode.value.match(_utils.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 ((0, _utils.isDataUrl)(url) && isSupportDataURLInNewURL) {
+        try {
+            decodeURIComponent(url);
+        } catch (ignoreError) {
+            return false;
+        }
+        return true;
+    }
+    if (!(0, _utils.isUrlRequestable)(url)) {
+        return false;
+    }
+    return true;
+}
+function parseDeclaration(declaration, key, result, isSupportDataURLInNewURL) {
+    if (!needParseDeclaration.test(declaration[key])) {
+        return;
+    }
+    const parsed = (0, _postcssvalueparser.default)(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(_utils.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(_utils.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) {
+                    needIgnore = undefined;
+                }
+                return;
+            }
+            const { nodes } = valueNode;
+            const isStringValue = nodes.length !== 0 && nodes[0].type === 'string';
+            let url = isStringValue ? nodes[0].value : _postcssvalueparser.default.stringify(nodes);
+            url = (0, _utils.normalizeUrl)(url, isStringValue);
+            // Do not traverse inside `url`
+            if (!shouldHandleURL(url, declaration, result, isSupportDataURLInNewURL)) {
+                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
+            });
+            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) {
+                            needIgnore = undefined;
+                        }
+                        continue;
+                    }
+                    const { nodes } = nNode;
+                    const isStringValue = nodes.length !== 0 && nodes[0].type === 'string';
+                    let url = isStringValue ? nodes[0].value : _postcssvalueparser.default.stringify(nodes);
+                    url = (0, _utils.normalizeUrl)(url, isStringValue);
+                    // Do not traverse inside `url`
+                    if (!shouldHandleURL(url, declaration, result, isSupportDataURLInNewURL)) {
+                        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) {
+                            needIgnore = undefined;
+                        }
+                        continue;
+                    }
+                    let url = (0, _utils.normalizeUrl)(value, true);
+                    // Do not traverse inside `url`
+                    if (!shouldHandleURL(url, declaration, result, isSupportDataURLInNewURL)) {
+                        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`
+            return false;
+        }
+    });
+    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) {
+                                return;
+                            }
+                        }
+                        if ((0, _utils.isDataUrl)(url)) {
+                            return parsedDeclaration;
+                        }
+                        const [pathname, query, hashOrQuery] = url.split(/(\?)?#/, 3);
+                        let hash = '';
+                        // Build query string with deployment ID before the hash fragment
+                        if (query || options.deploymentId) {
+                            hash += '?';
+                        }
+                        if (options.deploymentId) {
+                            hash += `dpl=${options.deploymentId}`;
+                        }
+                        hash += hashOrQuery ? `#${hashOrQuery}` : '';
+                        const { needToResolveURL, rootContext } = options;
+                        const request = (0, _utils.requestify)(pathname, rootContext, // @ts-expect-error TODO: only 2 arguments allowed.
+                        needToResolveURL);
+                        if (!needToResolveURL) {
+                            return {
+                                ...parsedDeclaration,
+                                url: request,
+                                hash
+                            };
+                        }
+                        const { resolver, context } = options;
+                        const resolvedUrl = await (0, _utils.resolveRequests)(resolver, context, [
+                            ...new Set([
+                                request,
+                                url
+                            ])
+                        ]);
+                        if (!resolvedUrl) {
+                            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
+                            });
+                        }
+                        item.node.type = 'word';
+                        item.node.value = replacementName;
+                        item.declaration.value = item.parsed.toString();
+                    }
+                }
+            };
+        }
+    };
+};
+plugin.postcss = true;
+const _default = plugin;
+
+//# sourceMappingURL=postcss-url-parser.js.map

node_modules/next/dist/build/webpack/loaders/css-loader/src/runtime/api.d.ts

@@ -0,0 +1,2 @@
+declare function cssWithMappingToString(item: any, useSourceMap: any): any;
+declare function toComment(sourceMap: any): string;

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

@@ -0,0 +1,83 @@
+/*
+  MIT License http://www.opensource.org/licenses/mit-license.php
+  Author Tobias Koppers @sokra
+*/ // css base code, injected by the css-loader
+"use strict";
+module.exports = function(useSourceMap) {
+    var list = [] // return the list of modules as css string
+    ;
+    list.toString = function toString() {
+        return this.map(function(item) {
+            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
+    ;
+    // @ts-expect-error TODO: fix type
+    list.i = function(modules, mediaQuery, dedupe) {
+        if (typeof modules === 'string') {
+            modules = [
+                [
+                    null,
+                    modules,
+                    ''
+                ]
+            ];
+        }
+        var alreadyImportedModules = {};
+        if (dedupe) {
+            for(var i = 0; i < this.length; i++){
+                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] || '';
+    var cssMapping = item[3];
+    if (!cssMapping) {
+        return content;
+    }
+    if (useSourceMap && typeof btoa === 'function') {
+        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) {
+    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/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"],"sourcesContent":["/*\n  MIT License http://www.opensource.org/licenses/mit-license.php\n  Author Tobias Koppers @sokra\n*/\n// css base code, injected by the css-loader\nmodule.exports = function (useSourceMap: any) {\n  var list: any[] = [] // return the list of modules as css string\n\n  list.toString = function toString() {\n    return this.map(function (item) {\n      var content = cssWithMappingToString(item, useSourceMap)\n\n      if (item[2]) {\n        return '@media '.concat(item[2], ' {').concat(content, '}')\n      }\n\n      return content\n    }).join('')\n  } // import a list of modules into the list\n\n  // @ts-expect-error TODO: fix type\n  list.i = function (modules: any, mediaQuery: any, dedupe: any) {\n    if (typeof modules === 'string') {\n      modules = [[null, modules, '']]\n    }\n\n    var alreadyImportedModules: any = {}\n\n    if (dedupe) {\n      for (var i = 0; i < this.length; i++) {\n        var id = this[i][0]\n\n        if (id != null) {\n          alreadyImportedModules[id] = true\n        }\n      }\n    }\n\n    for (var _i = 0; _i < modules.length; _i++) {\n      var item: any = [].concat(modules[_i])\n\n      if (dedupe && alreadyImportedModules[item[0]]) {\n        continue\n      }\n\n      if (mediaQuery) {\n        if (!item[2]) {\n          item[2] = mediaQuery\n        } else {\n          item[2] = ''.concat(mediaQuery, ' and ').concat(item[2])\n        }\n      }\n\n      list.push(item)\n    }\n  }\n\n  return list\n}\n\nfunction cssWithMappingToString(item: any, useSourceMap: any) {\n  var content = item[1] || ''\n\n  var cssMapping = item[3]\n\n  if (!cssMapping) {\n    return content\n  }\n\n  if (useSourceMap && typeof btoa === 'function') {\n    var sourceMapping = toComment(cssMapping)\n    var sourceURLs = cssMapping.sources.map(function (source: string) {\n      return '/*# sourceURL='\n        .concat(cssMapping.sourceRoot || '')\n        .concat(source, ' */')\n    })\n    return [content].concat(sourceURLs).concat([sourceMapping]).join('\\n')\n  }\n\n  return [content].join('\\n')\n} // Adapted from convert-source-map (MIT)\n\nfunction toComment(sourceMap: any) {\n  var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))))\n  var data =\n    'sourceMappingURL=data:application/json;charset=utf-8;base64,'.concat(\n      base64\n    )\n  return '/*# '.concat(data, ' */')\n}\n"],"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;;AAC5CA,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,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;;IAE3C,kCAAkC;IAClCP,KAAKQ,CAAC,GAAG,SAAUC,OAAY,EAAEC,UAAe,EAAEC,MAAW;QAC3D,IAAI,OAAOF,YAAY,UAAU;YAC/BA,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,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;gBAC7C;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;IAEzB,IAAIc,aAAad,IAAI,CAAC,EAAE;IAExB,IAAI,CAACc,YAAY;QACf,OAAOb;IACT;IAEA,IAAIL,gBAAgB,OAAOmB,SAAS,YAAY;QAC9C,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,IAAIC,SAASR,KAAKS,SAASC,mBAAmBC,KAAKC,SAAS,CAACL;IAC7D,IAAIM,OACF,+DAA+DzB,MAAM,CACnEoB;IAEJ,OAAO,OAAOpB,MAAM,CAACyB,MAAM;AAC7B","ignoreList":[0]}

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

@@ -0,0 +1,23 @@
+"use strict";
+module.exports = function(url, options) {
+    if (!options) {
+        options = {};
+    }
+    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)) {
+        url = url.slice(1, -1);
+    }
+    if (options.hash) {
+        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/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"],"sourcesContent":["module.exports = function (url: any, options: any) {\n  if (!options) {\n    options = {}\n  }\n\n  url = url && url.__esModule ? url.default : url\n\n  if (typeof url !== 'string') {\n    return url\n  } // If url is already wrapped in quotes, remove them\n\n  if (/^['\"].*['\"]$/.test(url)) {\n    url = url.slice(1, -1)\n  }\n\n  if (options.hash) {\n    url += options.hash\n  } // Should url be wrapped?\n  // See https://drafts.csswg.org/css-values-3/#urls\n\n  if (/[\"'() \\t\\n]/.test(url) || options.needQuotes) {\n    return '\"'.concat(url.replace(/\"/g, '\\\\\"').replace(/\\n/g, '\\\\n'), '\"')\n  }\n\n  return url\n}\n"],"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;QACZA,UAAU,CAAC;IACb;IAEAD,MAAMA,OAAOA,IAAIE,UAAU,GAAGF,IAAIG,OAAO,GAAGH;IAE5C,IAAI,OAAOA,QAAQ,UAAU;QAC3B,OAAOA;IACT,EAAE,mDAAmD;IAErD,IAAI,eAAeI,IAAI,CAACJ,MAAM;QAC5BA,MAAMA,IAAIK,KAAK,CAAC,GAAG,CAAC;IACtB;IAEA,IAAIJ,QAAQK,IAAI,EAAE;QAChBN,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","ignoreList":[0]}

node_modules/next/dist/build/webpack/loaders/css-loader/src/utils.d.ts

@@ -0,0 +1,40 @@
+declare function normalizeUrl(url: string, isStringValue: boolean): string;
+declare function requestify(url: string, rootContext: string): any;
+declare function getFilter(filter: any, resourcePath: string): (...args: any[]) => any;
+declare function shouldUseImportPlugin(options: any): any;
+declare function shouldUseURLPlugin(options: any): any;
+declare function shouldUseModulesPlugins(options: any): boolean;
+declare function shouldUseIcssPlugin(options: any): boolean;
+declare function getModulesPlugins(options: any, loaderContext: any, meta: any): any[];
+declare function normalizeSourceMap(map: any, resourcePath: string): any;
+declare function getPreRequester({ loaders, loaderIndex }: any): (number: any) => any;
+declare function getImportCode(imports: any, options: any): string;
+declare function normalizeSourceMapForRuntime(map: any, loaderContext: any): string;
+declare function getModuleCode(result: {
+    map: any;
+    css: any;
+}, api: any, replacements: any, options: {
+    modules: {
+        exportOnlyLocals: boolean;
+        namedExport: any;
+    };
+    sourceMap: any;
+}, loaderContext: any): string;
+declare function dashesCamelCase(str: string): string;
+declare function getExportCode(exports: any, replacements: any, options: {
+    modules: {
+        namedExport: any;
+        exportLocalsConvention: any;
+        exportOnlyLocals: any;
+    };
+    esModule: any;
+}): string;
+declare function resolveRequests(resolve: (arg0: any, arg1: any) => Promise<any>, context: any, possibleRequests: any[]): Promise<any>;
+declare function isUrlRequestable(url: string): boolean;
+declare function sort(a: {
+    index: number;
+}, b: {
+    index: number;
+}): number;
+declare function isDataUrl(url: string): boolean;
+export { isDataUrl, shouldUseModulesPlugins, shouldUseImportPlugin, shouldUseURLPlugin, shouldUseIcssPlugin, normalizeUrl, requestify, getFilter, getModulesPlugins, normalizeSourceMap, getPreRequester, getImportCode, getModuleCode, getExportCode, resolveRequests, isUrlRequestable, sort, normalizeSourceMapForRuntime, dashesCamelCase, };

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

@@ -0,0 +1,459 @@
+/*
+  MIT License http://www.opensource.org/licenses/mit-license.php
+  Author Tobias Koppers @sokra
+*/ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    dashesCamelCase: null,
+    getExportCode: null,
+    getFilter: null,
+    getImportCode: null,
+    getModuleCode: null,
+    getModulesPlugins: null,
+    getPreRequester: null,
+    isDataUrl: null,
+    isUrlRequestable: null,
+    normalizeSourceMap: null,
+    normalizeSourceMapForRuntime: null,
+    normalizeUrl: null,
+    requestify: null,
+    resolveRequests: null,
+    shouldUseIcssPlugin: null,
+    shouldUseImportPlugin: null,
+    shouldUseModulesPlugins: null,
+    shouldUseURLPlugin: null,
+    sort: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    dashesCamelCase: function() {
+        return dashesCamelCase;
+    },
+    getExportCode: function() {
+        return getExportCode;
+    },
+    getFilter: function() {
+        return getFilter;
+    },
+    getImportCode: function() {
+        return getImportCode;
+    },
+    getModuleCode: function() {
+        return getModuleCode;
+    },
+    getModulesPlugins: function() {
+        return getModulesPlugins;
+    },
+    getPreRequester: function() {
+        return getPreRequester;
+    },
+    isDataUrl: function() {
+        return isDataUrl;
+    },
+    isUrlRequestable: function() {
+        return isUrlRequestable;
+    },
+    normalizeSourceMap: function() {
+        return normalizeSourceMap;
+    },
+    // For lightningcss-loader
+    normalizeSourceMapForRuntime: function() {
+        return normalizeSourceMapForRuntime;
+    },
+    normalizeUrl: function() {
+        return normalizeUrl;
+    },
+    requestify: function() {
+        return requestify;
+    },
+    resolveRequests: function() {
+        return resolveRequests;
+    },
+    shouldUseIcssPlugin: function() {
+        return shouldUseIcssPlugin;
+    },
+    shouldUseImportPlugin: function() {
+        return shouldUseImportPlugin;
+    },
+    shouldUseModulesPlugins: function() {
+        return shouldUseModulesPlugins;
+    },
+    shouldUseURLPlugin: function() {
+        return shouldUseURLPlugin;
+    },
+    sort: function() {
+        return sort;
+    }
+});
+const _url = require("url");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _loaderutils3 = require("next/dist/compiled/loader-utils3");
+const _postcssmodulesvalues = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/postcss-modules-values"));
+const _postcssmoduleslocalbydefault = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/postcss-modules-local-by-default"));
+const _postcssmodulesextractimports = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/postcss-modules-extract-imports"));
+const _postcssmodulesscope = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/postcss-modules-scope"));
+const _camelcase = /*#__PURE__*/ _interop_require_default(require("./camelcase"));
+const _normalizepath = require("../../../../../lib/normalize-path");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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;
+        // 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) : String.fromCharCode(high >> 10 | 0xd800, high & 0x3ff | 0xdc00);
+    });
+}
+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);
+    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 (0, _url.fileURLToPath)(url);
+    }
+    if (/^[a-z][a-z0-9+.-]*:/i.test(url)) {
+        return url;
+    }
+    return url.charAt(0) === '/' ? (0, _loaderutils3.urlToRequest)(url, rootContext) : (0, _loaderutils3.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 = [
+            _postcssmodulesvalues.default,
+            (0, _postcssmoduleslocalbydefault.default)({
+                mode
+            }),
+            (0, _postcssmodulesextractimports.default)(),
+            (0, _postcssmodulesscope.default)({
+                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.startsWith('<')) {
+                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.default.resolve(sourceRoot, (0, _normalizepath.normalizePath)(source)) : (0, _normalizepath.normalizePath)(source);
+                return _path.default.relative(_path.default.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.startsWith('<')) {
+                return source;
+            }
+            const sourceType = getURLType(source);
+            if (sourceType !== 'path-relative') {
+                return source;
+            }
+            const resourceDirname = _path.default.dirname(loaderContext.resourcePath);
+            const absoluteSource = _path.default.resolve(resourceDirname, source);
+            const contextifyPath = (0, _normalizepath.normalizePath)(_path.default.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((0, _camelcase.default)(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(exports1, replacements, options) {
+    let code = '// Exports\n';
+    let localsCode = '';
+    const addExportToLocalsCode = (name, value)=>{
+        if (options.modules.namedExport) {
+            localsCode += `export const ${(0, _camelcase.default)(name)} = ${JSON.stringify(value)};\n`;
+        } else {
+            if (localsCode) {
+                localsCode += `,\n`;
+            }
+            localsCode += `\t${JSON.stringify(name)}: ${JSON.stringify(value)}`;
+        }
+    };
+    for (const { name, value } of exports1){
+        switch(options.modules.exportLocalsConvention){
+            case 'camelCase':
+                {
+                    addExportToLocalsCode(name, value);
+                    const modifiedName = (0, _camelcase.default)(name);
+                    if (modifiedName !== name) {
+                        addExportToLocalsCode(modifiedName, value);
+                    }
+                    break;
+                }
+            case 'camelCaseOnly':
+                {
+                    addExportToLocalsCode((0, _camelcase.default)(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((0, _camelcase.default)(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;
+}
+
+//# sourceMappingURL=utils.js.map

node_modules/next/dist/build/webpack/loaders/devtool/devtool-style-inject.js

@@ -0,0 +1,129 @@
+/* @ts-check */ /**
+ * Style injection mechanism for Next.js devtools with shadow DOM support
+ * Handles caching of style elements when the nextjs-portal shadow root is not available
+ */ // Global cache for style elements when shadow root is not available
+"use strict";
+if (typeof window !== 'undefined') {
+    window._nextjsDevtoolsStyleCache = window._nextjsDevtoolsStyleCache || {
+        pendingElements: [],
+        isObserving: false,
+        lastInsertedElement: null,
+        cachedShadowRoot: null
+    };
+}
+/**
+ * @returns {ShadowRoot | null}
+ */ function getShadowRoot() {
+    const cache = window._nextjsDevtoolsStyleCache;
+    // Return cached shadow root if available
+    if (cache.cachedShadowRoot) {
+        return cache.cachedShadowRoot;
+    }
+    // Query the DOM and cache the result if found
+    const portal = document.querySelector('nextjs-portal');
+    const shadowRoot = (portal == null ? void 0 : portal.shadowRoot) || null;
+    if (shadowRoot) {
+        cache.cachedShadowRoot = shadowRoot;
+    }
+    return shadowRoot;
+}
+/**
+ * @param {HTMLElement} element
+ * @param {ShadowRoot} shadowRoot
+ */ function insertElementIntoShadowRoot(element, shadowRoot) {
+    const cache = window._nextjsDevtoolsStyleCache;
+    if (!cache.lastInsertedElement) {
+        shadowRoot.insertBefore(element, shadowRoot.firstChild);
+    } else if (cache.lastInsertedElement.nextSibling) {
+        shadowRoot.insertBefore(element, cache.lastInsertedElement.nextSibling);
+    } else {
+        shadowRoot.appendChild(element);
+    }
+    cache.lastInsertedElement = element;
+}
+function flushCachedElements() {
+    const cache = window._nextjsDevtoolsStyleCache;
+    const shadowRoot = getShadowRoot();
+    if (!shadowRoot) {
+        return;
+    }
+    cache.pendingElements.forEach((element)=>{
+        insertElementIntoShadowRoot(element, shadowRoot);
+    });
+    cache.pendingElements = [];
+}
+function startObservingForPortal() {
+    const cache = window._nextjsDevtoolsStyleCache;
+    if (cache.isObserving) {
+        return;
+    }
+    cache.isObserving = true;
+    // First check if the portal already exists
+    const shadowRoot = getShadowRoot() // This will cache it if found
+    ;
+    if (shadowRoot) {
+        flushCachedElements();
+        return;
+    }
+    // Set up MutationObserver to watch for the portal element
+    const observer = new MutationObserver((mutations)=>{
+        if (mutations.length === 0) {
+            return;
+        }
+        // Check all mutations and all added nodes
+        for (const mutation of mutations){
+            if (mutation.addedNodes.length === 0) continue;
+            for (const addedNode of mutation.addedNodes){
+                if (addedNode.nodeType !== Node.ELEMENT_NODE) continue;
+                const mutationNode = addedNode;
+                let portalNode = null;
+                if (// app router: body > script[data-nextjs-dev-overlay] > nextjs-portal
+                mutationNode.tagName === 'SCRIPT' && mutationNode.getAttribute('data-nextjs-dev-overlay')) {
+                    portalNode = mutationNode.firstChild;
+                } else if (// pages router: body > nextjs-portal
+                mutationNode.tagName === 'NEXTJS-PORTAL') {
+                    portalNode = mutationNode;
+                }
+                if (portalNode) {
+                    // Wait until shadow root is available
+                    const checkShadowRoot = ()=>{
+                        if (getShadowRoot()) {
+                            flushCachedElements();
+                            observer.disconnect();
+                            cache.isObserving = false;
+                        } else {
+                            // Try again after a short delay
+                            setTimeout(checkShadowRoot, 20);
+                        }
+                    };
+                    checkShadowRoot();
+                    return; // Exit early once we find a portal
+                }
+            }
+        }
+    });
+    observer.observe(document.body, {
+        childList: true,
+        subtree: true
+    });
+}
+/**
+ * @param {HTMLElement} element
+ */ function insertAtTop(element) {
+    // Add special recognizable data prop to element
+    element.setAttribute('data-nextjs-dev-tool-style', 'true');
+    const shadowRoot = getShadowRoot();
+    if (shadowRoot) {
+        // Shadow root is available, insert directly
+        insertElementIntoShadowRoot(element, shadowRoot);
+    } else {
+        // Shadow root not available, cache the element
+        const cache = window._nextjsDevtoolsStyleCache;
+        cache.pendingElements.push(element);
+        // Start observing for the portal if not already observing
+        startObservingForPortal();
+    }
+}
+module.exports = insertAtTop;
+
+//# sourceMappingURL=devtool-style-inject.js.map

node_modules/next/dist/build/webpack/loaders/empty-loader.d.ts

@@ -0,0 +1,3 @@
+import type { webpack } from 'next/dist/compiled/webpack/webpack';
+declare const EmptyLoader: webpack.LoaderDefinitionFunction;
+export default EmptyLoader;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const EmptyLoader = ()=>'export default {}';
+const _default = EmptyLoader;
+
+//# sourceMappingURL=empty-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/empty-loader.ts"],"sourcesContent":["import type { webpack } from 'next/dist/compiled/webpack/webpack'\n\nconst EmptyLoader: webpack.LoaderDefinitionFunction = () => 'export default {}'\nexport default EmptyLoader\n"],"names":["EmptyLoader"],"mappings":";;;;+BAGA;;;eAAA;;;AADA,MAAMA,cAAgD,IAAM;MAC5D,WAAeA","ignoreList":[0]}

node_modules/next/dist/build/webpack/loaders/error-loader.d.ts

@@ -0,0 +1,3 @@
+import type { webpack } from 'next/dist/compiled/webpack/webpack';
+declare const ErrorLoader: webpack.LoaderDefinitionFunction;
+export default ErrorLoader;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _picocolors = require("../../../lib/picocolors");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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.default.relative(context, resource) : resource : null;
+    const err = Object.defineProperty(new Error(reason + (issuer ? `\nLocation: ${(0, _picocolors.cyan)(issuer)}` : '')), "__NEXT_ERROR_CODE", {
+        value: "E339",
+        enumerable: false,
+        configurable: true
+    });
+    this.emitError(err);
+};
+const _default = ErrorLoader;
+
+//# sourceMappingURL=error-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/error-loader.ts"],"sourcesContent":["import { cyan } from '../../../lib/picocolors'\nimport path from 'path'\nimport type { webpack } from 'next/dist/compiled/webpack/webpack'\n\nconst ErrorLoader: webpack.LoaderDefinitionFunction = function () {\n  // @ts-ignore exists\n  const options = this.getOptions() || ({} as any)\n\n  const { reason = 'An unknown error has occurred' } = options\n\n  // @ts-expect-error\n  const resource = this._module?.issuer?.resource ?? null\n  const context = this.rootContext ?? this._compiler?.context\n\n  const issuer = resource\n    ? context\n      ? path.relative(context, resource)\n      : resource\n    : null\n\n  const err = new Error(reason + (issuer ? `\\nLocation: ${cyan(issuer)}` : ''))\n  this.emitError(err)\n}\n\nexport default ErrorLoader\n"],"names":["ErrorLoader","options","getOptions","reason","resource","_module","issuer","context","rootContext","_compiler","path","relative","err","Error","cyan","emitError"],"mappings":";;;;+BAwBA;;;eAAA;;;4BAxBqB;6DACJ;;;;;;AAGjB,MAAMA,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,UACEG,aAAI,CAACC,QAAQ,CAACJ,SAASH,YACvBA,WACF;IAEJ,MAAMQ,MAAM,qBAAiE,CAAjE,IAAIC,MAAMV,SAAUG,CAAAA,SAAS,CAAC,YAAY,EAAEQ,IAAAA,gBAAI,EAACR,SAAS,GAAG,EAAC,IAA9D,qBAAA;eAAA;oBAAA;sBAAA;IAAgE;IAC5E,IAAI,CAACS,SAAS,CAACH;AACjB;MAEA,WAAeZ","ignoreList":[0]}

node_modules/next/dist/build/webpack/loaders/get-module-build-info.d.ts

@@ -0,0 +1,62 @@
+import type { ProxyConfig, ProxyMatcher, RSCModuleType } from '../../analysis/get-page-static-info';
+import type { webpack } from 'next/dist/compiled/webpack/webpack';
+export type ModuleBuildInfo = {
+    nextEdgeMiddleware?: EdgeMiddlewareMeta;
+    nextEdgeApiFunction?: EdgeMiddlewareMeta;
+    nextEdgeSSR?: EdgeSSRMeta;
+    nextWasmMiddlewareBinding?: AssetBinding;
+    nextAssetMiddlewareBinding?: AssetBinding;
+    usingIndirectEval?: boolean | Set<string>;
+    route?: RouteMeta;
+    importLocByPath?: Map<string, any>;
+    rootDir?: string;
+    rsc?: RSCMeta;
+};
+/**
+ * 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 declare function getModuleBuildInfo(webpackModule: webpack.Module): ModuleBuildInfo;
+/**
+ * Location info for a server action (1-indexed line and column)
+ */
+export interface ServerActionLocation {
+    line: number;
+    col: number;
+}
+/**
+ * Server action info including name and optional source location
+ */
+export interface ServerActionInfo {
+    name: string;
+    loc?: ServerActionLocation;
+}
+export interface RSCMeta {
+    type: RSCModuleType;
+    /** Map of action ID to export name (old format) or action info (new format with location) */
+    actionIds?: Record<string, string | ServerActionInfo>;
+    clientRefs?: string[];
+    clientEntryType?: 'cjs' | 'auto';
+    isClientRef?: boolean;
+    requests?: string[];
+}
+export interface RouteMeta {
+    page: string;
+    absolutePagePath: string;
+    preferredRegion: string | string[] | undefined;
+    middlewareConfig: ProxyConfig;
+    relatedModules?: string[];
+}
+export interface EdgeMiddlewareMeta {
+    page: string;
+    matchers?: ProxyMatcher[];
+}
+export interface EdgeSSRMeta {
+    isServerComponent: boolean;
+    isAppDir?: boolean;
+    page: string;
+}
+export interface AssetBinding {
+    filePath: string;
+    name: string;
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getModuleBuildInfo", {
+    enumerable: true,
+    get: function() {
+        return getModuleBuildInfo;
+    }
+});
+function getModuleBuildInfo(webpackModule) {
+    return webpackModule.buildInfo;
+}
+
+//# sourceMappingURL=get-module-build-info.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/get-module-build-info.ts"],"sourcesContent":["import type {\n  ProxyConfig,\n  ProxyMatcher,\n  RSCModuleType,\n} from '../../analysis/get-page-static-info'\nimport type { webpack } from 'next/dist/compiled/webpack/webpack'\n\nexport type ModuleBuildInfo = {\n  nextEdgeMiddleware?: EdgeMiddlewareMeta\n  nextEdgeApiFunction?: EdgeMiddlewareMeta\n  nextEdgeSSR?: EdgeSSRMeta\n  nextWasmMiddlewareBinding?: AssetBinding\n  nextAssetMiddlewareBinding?: AssetBinding\n  usingIndirectEval?: boolean | Set<string>\n  route?: RouteMeta\n  importLocByPath?: Map<string, any>\n  rootDir?: string\n  rsc?: RSCMeta\n}\n\n/**\n * A getter for module build info that casts to the type it should have.\n * We also expose here types to make easier to use it.\n */\nexport function getModuleBuildInfo(webpackModule: webpack.Module) {\n  return webpackModule.buildInfo as ModuleBuildInfo\n}\n\n/**\n * Location info for a server action (1-indexed line and column)\n */\nexport interface ServerActionLocation {\n  line: number\n  col: number\n}\n\n/**\n * Server action info including name and optional source location\n */\nexport interface ServerActionInfo {\n  name: string\n  loc?: ServerActionLocation\n}\n\nexport interface RSCMeta {\n  type: RSCModuleType\n  /** Map of action ID to export name (old format) or action info (new format with location) */\n  actionIds?: Record<string, string | ServerActionInfo>\n  clientRefs?: string[]\n  clientEntryType?: 'cjs' | 'auto'\n  isClientRef?: boolean\n  requests?: string[] // client requests in flight client entry\n}\n\nexport interface RouteMeta {\n  page: string\n  absolutePagePath: string\n  preferredRegion: string | string[] | undefined\n  middlewareConfig: ProxyConfig\n  // references to other modules that this route needs\n  // e.g. related routes, not-found routes, etc\n  relatedModules?: string[]\n}\n\nexport interface EdgeMiddlewareMeta {\n  page: string\n  matchers?: ProxyMatcher[]\n}\n\nexport interface EdgeSSRMeta {\n  isServerComponent: boolean\n  isAppDir?: boolean\n  page: string\n}\n\nexport interface AssetBinding {\n  filePath: string\n  name: string\n}\n"],"names":["getModuleBuildInfo","webpackModule","buildInfo"],"mappings":";;;;+BAwBgBA;;;eAAAA;;;AAAT,SAASA,mBAAmBC,aAA6B;IAC9D,OAAOA,cAAcC,SAAS;AAChC","ignoreList":[0]}

node_modules/next/dist/build/webpack/loaders/lightningcss-loader/src/codegen.d.ts

@@ -0,0 +1,34 @@
+import type { LoaderContext } from 'next/dist/compiled/webpack/webpack';
+export interface CssImport {
+    icss?: boolean;
+    importName: string;
+    url: string;
+    type?: 'url' | string;
+    index?: number;
+}
+export interface CssExport {
+    name: string;
+    value: string;
+}
+export interface ApiParam {
+    url?: string;
+    importName?: string;
+    layer?: string;
+    supports?: string;
+    media?: string;
+    dedupe?: boolean;
+    index?: number;
+}
+export interface ApiReplacement {
+    replacementName: string;
+    localName?: string;
+    importName: string;
+    needQuotes?: boolean;
+    hash?: string;
+}
+export declare function getImportCode(imports: CssImport[], options: any): string;
+export declare function getModuleCode(result: {
+    map: any;
+    css: any;
+}, api: ApiParam[], replacements: ApiReplacement[], options: any, loaderContext: LoaderContext<any>): string;
+export declare function getExportCode(exports: CssExport[], replacements: ApiReplacement[], options: any): string;

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

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getExportCode: null,
+    getImportCode: null,
+    getModuleCode: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getExportCode: function() {
+        return getExportCode;
+    },
+    getImportCode: function() {
+        return getImportCode;
+    },
+    getModuleCode: function() {
+        return getModuleCode;
+    }
+});
+const _camelcase = /*#__PURE__*/ _interop_require_default(require("../../css-loader/src/camelcase"));
+const _utils = require("../../css-loader/src/utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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 getModuleCode(result, api, replacements, options, loaderContext) {
+    if (options.modules.exportOnlyLocals === true) {
+        return '';
+    }
+    const sourceMapValue = options.sourceMap ? `,${(0, _utils.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((0, _camelcase.default)(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 getExportCode(exports1, replacements, options) {
+    let code = '// Exports\n';
+    let localsCode = '';
+    const addExportToLocalsCode = (name, value)=>{
+        if (options.modules.namedExport) {
+            localsCode += `export const ${(0, _camelcase.default)(name)} = ${JSON.stringify(value)};\n`;
+        } else {
+            if (localsCode) {
+                localsCode += `,\n`;
+            }
+            localsCode += `\t${JSON.stringify(name)}: ${JSON.stringify(value)}`;
+        }
+    };
+    for (const { name, value } of exports1){
+        switch(options.modules.exportLocalsConvention){
+            case 'camelCase':
+                {
+                    addExportToLocalsCode(name, value);
+                    const modifiedName = (0, _camelcase.default)(name);
+                    if (modifiedName !== name) {
+                        addExportToLocalsCode(modifiedName, value);
+                    }
+                    break;
+                }
+            case 'camelCaseOnly':
+                {
+                    addExportToLocalsCode((0, _camelcase.default)(name), value);
+                    break;
+                }
+            case 'dashes':
+                {
+                    addExportToLocalsCode(name, value);
+                    const modifiedName = (0, _utils.dashesCamelCase)(name);
+                    if (modifiedName !== name) {
+                        addExportToLocalsCode(modifiedName, value);
+                    }
+                    break;
+                }
+            case 'dashesOnly':
+                {
+                    addExportToLocalsCode((0, _utils.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((0, _camelcase.default)(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/build/webpack/loaders/lightningcss-loader/src/index.d.ts

@@ -0,0 +1,3 @@
+import { LightningCssLoader } from './loader';
+export { LightningCssMinifyPlugin } from './minify';
+export default LightningCssLoader;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    LightningCssMinifyPlugin: null,
+    default: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    LightningCssMinifyPlugin: function() {
+        return _minify.LightningCssMinifyPlugin;
+    },
+    default: function() {
+        return _default;
+    }
+});
+const _loader = require("./loader");
+const _minify = require("./minify");
+const _default = _loader.LightningCssLoader;
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/loaders/lightningcss-loader/src/index.ts"],"sourcesContent":["import { LightningCssLoader } from './loader'\n\nexport { LightningCssMinifyPlugin } from './minify'\nexport default LightningCssLoader\n"],"names":["LightningCssMinifyPlugin","LightningCssLoader"],"mappings":";;;;;;;;;;;;;;;IAESA,wBAAwB;eAAxBA,gCAAwB;;IACjC,OAAiC;eAAjC;;;wBAHmC;wBAEM;MACzC,WAAeC,0BAAkB","ignoreList":[0]}

node_modules/next/dist/build/webpack/loaders/lightningcss-loader/src/interface.d.ts

@@ -0,0 +1,4 @@
+export declare enum ECacheKey {
+    loader = "loader",
+    minify = "minify"
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ECacheKey", {
+    enumerable: true,
+    get: function() {
+        return ECacheKey;
+    }
+});
+var ECacheKey = /*#__PURE__*/ function(ECacheKey) {
+    ECacheKey["loader"] = "loader";
+    ECacheKey["minify"] = "minify";
+    return ECacheKey;
+}({});
+
+//# sourceMappingURL=interface.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/loaders/lightningcss-loader/src/interface.ts"],"sourcesContent":["export enum ECacheKey {\n  loader = 'loader',\n  minify = 'minify',\n}\n"],"names":["ECacheKey"],"mappings":";;;;+BAAYA;;;eAAAA;;;AAAL,IAAA,AAAKA,mCAAAA;;;WAAAA","ignoreList":[0]}

node_modules/next/dist/build/webpack/loaders/lightningcss-loader/src/loader.d.ts

@@ -0,0 +1,3 @@
+import type { LoaderContext } from 'webpack';
+export declare function LightningCssLoader(this: LoaderContext<any>, source: string, prevMap?: Record<string, any>): Promise<void>;
+export declare const raw = true;

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

@@ -0,0 +1,438 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    LightningCssLoader: null,
+    raw: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    LightningCssLoader: function() {
+        return LightningCssLoader;
+    },
+    raw: function() {
+        return raw;
+    }
+});
+const _utils = require("./utils");
+const _codegen = require("./codegen");
+const _utils1 = require("../../css-loader/src/utils");
+const _stringifyrequest = require("../../../stringify-request");
+const _interface = require("./interface");
+const _swc = require("../../../../../build/swc");
+const _installbindings = require("../../../../../build/swc/install-bindings");
+const encoder = new TextEncoder();
+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 ((0, _utils1.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 = (0, _utils1.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`;
+async function LightningCssLoader(source, prevMap) {
+    var _options_modules, _options_lightningCssFeatures, _options_lightningCssFeatures1;
+    const done = this.async();
+    const options = this.getOptions();
+    // Install bindings early so they are definitely available to the loader.
+    // When run by webpack in next this is already done with correct configuration so this is a no-op.
+    // In turbopack loaders are run in a subprocess so it may or may not be done.
+    await (0, _installbindings.installBindings)();
+    const { implementation, targets: userTargets, ...opts } = options;
+    options.modules ??= {};
+    if (implementation && typeof implementation.transformCss !== 'function') {
+        done(Object.defineProperty(new TypeError(`[${LOADER_NAME}]: options.implementation.transformCss must be an 'lightningcss' transform function. Received ${typeof implementation.transformCss}`), "__NEXT_ERROR_CODE", {
+            value: "E1033",
+            enumerable: false,
+            configurable: true
+        }));
+        return;
+    }
+    if (options.postcss) {
+        var _postcssWithPlugins_plugins;
+        const { postcssWithPlugins } = await options.postcss();
+        if ((postcssWithPlugins == null ? void 0 : (_postcssWithPlugins_plugins = postcssWithPlugins.plugins) == null ? void 0 : _postcssWithPlugins_plugins.length) > 0) {
+            throw Object.defineProperty(new Error(`[${LOADER_NAME}]: experimental.useLightningcss does not work with postcss plugins. Please remove 'useLightningcss: true' from your configuration.`), "__NEXT_ERROR_CODE", {
+                value: "E999",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    const exports1 = [];
+    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: (0, _stringifyrequest.stringifyRequest)(this, require.resolve('../../css-loader/src/runtime/api'))
+        });
+    }
+    const transform = (implementation == null ? void 0 : implementation.transformCss) ?? (0, _swc.getBindingsSync)().css.lightning.transform;
+    const replacedUrls = new Map();
+    const icssReplacedUrls = new Map();
+    const replacedImportUrls = new Map();
+    const urlImportVisitor = createUrlAndImportVisitor({
+        urlHandler: (url)=>(0, _stringifyrequest.stringifyRequest)(this, (0, _utils1.getPreRequester)(this)(options.importLoaders ?? 0) + url),
+        urlFilter: (0, _utils1.getFilter)(options.url, this.resourcePath),
+        importFilter: (0, _utils1.getFilter)(options.import, this.resourcePath),
+        context: this.context
+    }, apis, imports, replacements, replacedUrls, replacedImportUrls);
+    const icssVisitor = createIcssVisitor({
+        apis,
+        imports: icssImports,
+        replacements,
+        replacedUrls: icssReplacedUrls,
+        urlHandler: (url)=>(0, _stringifyrequest.stringifyRequest)(this, (0, _utils1.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
+    };
+    // Compute feature include/exclude masks from user config.
+    // Default: always transpile nesting (bit 0). User `include` adds flags,
+    // user `exclude` removes them from both include and exclude masks.
+    const featureNamesToMask = (0, _swc.getBindingsSync)().css.lightning.featureNamesToMask;
+    const userIncludeMask = ((_options_lightningCssFeatures = options.lightningCssFeatures) == null ? void 0 : _options_lightningCssFeatures.include) ? featureNamesToMask(options.lightningCssFeatures.include) : 0;
+    const userExcludeMask = ((_options_lightningCssFeatures1 = options.lightningCssFeatures) == null ? void 0 : _options_lightningCssFeatures1.exclude) ? featureNamesToMask(options.lightningCssFeatures.exclude) : 0;
+    const includeMask = (1 | userIncludeMask) & ~userExcludeMask // 1 = Features.Nesting
+    ;
+    try {
+        const { code, map, exports: moduleExports } = transform({
+            ...opts,
+            visitor,
+            cssModules: options.modules ? {
+                pattern: process.env.__NEXT_TEST_MODE ? '[name]__[local]' : '[name]__[hash]__[local]'
+            } : undefined,
+            filename: this.resourcePath,
+            code: encoder.encode(source),
+            sourceMap: this.sourceMap,
+            targets: (0, _utils.getTargets)({
+                targets: userTargets,
+                key: _interface.ECacheKey.loader
+            }),
+            inputSourceMap: this.sourceMap && prevMap ? JSON.stringify(prevMap) : undefined,
+            include: includeMask,
+            exclude: userExcludeMask
+        });
+        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}`;
+                    }
+                    exports1.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 = (0, _utils1.requestify)(pathname, this.rootContext);
+                const resolvedUrl = await (0, _utils1.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 = (0, _utils1.requestify)(pathname, this.rootContext);
+                const resolvedUrl = await (0, _utils1.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 = (0, _utils1.requestify)(pathname, this.rootContext);
+                const resolvedUrl = await (0, _utils1.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 = (0, _codegen.getImportCode)(imports, options);
+        const moduleCode = (0, _codegen.getModuleCode)({
+            css: cssCodeAsString,
+            map
+        }, apis, replacements, options, this);
+        const exportCode = (0, _codegen.getExportCode)(exports1, 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);
+    }
+}
+const raw = true;
+
+//# sourceMappingURL=loader.js.map

node_modules/next/dist/build/webpack/loaders/lightningcss-loader/src/minify.d.ts

@@ -0,0 +1,8 @@
+import type { Compiler } from 'webpack';
+export declare class LightningCssMinifyPlugin {
+    private readonly options;
+    private transform;
+    constructor(opts?: any);
+    apply(compiler: Compiler): void;
+    private transformAssets;
+}

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

@@ -0,0 +1,94 @@
+// @ts-ignore
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LightningCssMinifyPlugin", {
+    enumerable: true,
+    get: function() {
+        return LightningCssMinifyPlugin;
+    }
+});
+const _webpack = require("next/dist/compiled/webpack/webpack");
+const _webpacksources3 = require("next/dist/compiled/webpack-sources3");
+const _interface = require("./interface");
+const _utils = require("./utils");
+const _buffer = require("buffer");
+const _swc = require("../../../../../build/swc");
+const PLUGIN_NAME = 'lightning-css-minify';
+const CSS_FILE_REG = /\.css(?:\?.*)?$/i;
+class LightningCssMinifyPlugin {
+    constructor(opts = {}){
+        const { implementation, ...otherOpts } = opts;
+        if (implementation && typeof implementation.transformCss !== 'function') {
+            throw Object.defineProperty(new TypeError(`[LightningCssMinifyPlugin]: implementation.transformCss must be an 'lightningcss' transform function. Received ${typeof implementation.transformCss}`), "__NEXT_ERROR_CODE", {
+                value: "E561",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        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.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) {
+            this.transform = (0, _swc.getBindingsSync)().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) && _webpack.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.Buffer.from(source) : source;
+            const targets = (0, _utils.getTargets)({
+                targets: userTargets,
+                key: _interface.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 _webpacksources3.SourceMapSource(codeString, asset.name, JSON.parse(result.map.toString()), sourceAsString, map, true) : new _webpacksources3.RawSource(codeString), {
+                ...asset.info,
+                minimized: true
+            });
+        }));
+    }
+}
+
+//# sourceMappingURL=minify.js.map

node_modules/next/dist/build/webpack/loaders/lightningcss-loader/src/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const getTargets: (opts: {
+    targets?: string[];
+    key: any;
+}) => any;

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getTargets", {
+    enumerable: true,
+    get: function() {
+        return getTargets;
+    }
+});
+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;
+    }, {});
+}
+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/build/webpack/loaders/lightningcss-loader/src/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/loaders/lightningcss-loader/src/utils.ts"],"sourcesContent":["let targetsCache: Record<string, any> = {}\n\n/**\n * Convert a version number to a single 24-bit number\n *\n * https://github.com/lumeland/lume/blob/4cc75599006df423a14befc06d3ed8493c645b09/plugins/lightningcss.ts#L160\n */\nfunction version(major: number, minor = 0, patch = 0): number {\n  return (major << 16) | (minor << 8) | patch\n}\n\nfunction parseVersion(v: string) {\n  return v.split('.').reduce(\n    (acc, val) => {\n      if (!acc) {\n        return null\n      }\n\n      const parsed = parseInt(val, 10)\n      if (isNaN(parsed)) {\n        return null\n      }\n      acc.push(parsed)\n      return acc\n    },\n    [] as Array<number> | null\n  )\n}\n\nfunction browserslistToTargets(targets: Array<string>) {\n  return targets.reduce(\n    (acc, value) => {\n      const [name, v] = value.split(' ')\n      const parsedVersion = parseVersion(v)\n\n      if (!parsedVersion) {\n        return acc\n      }\n      const versionDigit = version(\n        parsedVersion[0],\n        parsedVersion[1],\n        parsedVersion[2]\n      )\n\n      if (\n        name === 'and_qq' ||\n        name === 'and_uc' ||\n        name === 'baidu' ||\n        name === 'bb' ||\n        name === 'kaios' ||\n        name === 'op_mini'\n      ) {\n        return acc\n      }\n\n      if (acc[name] == null || versionDigit < acc[name]) {\n        acc[name] = versionDigit\n      }\n\n      return acc\n    },\n    {} as Record<string, number>\n  )\n}\n\nexport const getTargets = (opts: { targets?: string[]; key: any }) => {\n  const cache = targetsCache[opts.key]\n  if (cache) {\n    return cache\n  }\n\n  const result = browserslistToTargets(opts.targets ?? [])\n  return (targetsCache[opts.key] = result)\n}\n"],"names":["getTargets","targetsCache","version","major","minor","patch","parseVersion","v","split","reduce","acc","val","parsed","parseInt","isNaN","push","browserslistToTargets","targets","value","name","parsedVersion","versionDigit","opts","cache","key","result"],"mappings":";;;;+BAiEaA;;;eAAAA;;;AAjEb,IAAIC,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,CACxB,CAACC,KAAKC;QACJ,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,GACA,EAAE;AAEN;AAEA,SAASM,sBAAsBC,OAAsB;IACnD,OAAOA,QAAQR,MAAM,CACnB,CAACC,KAAKQ;QACJ,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,GACA,CAAC;AAEL;AAEO,MAAMV,aAAa,CAACsB;IACzB,MAAMC,QAAQtB,YAAY,CAACqB,KAAKE,GAAG,CAAC;IACpC,IAAID,OAAO;QACT,OAAOA;IACT;IAEA,MAAME,SAAST,sBAAsBM,KAAKL,OAAO,IAAI,EAAE;IACvD,OAAQhB,YAAY,CAACqB,KAAKE,GAAG,CAAC,GAAGC;AACnC","ignoreList":[0]}

node_modules/next/dist/build/webpack/loaders/metadata/discover.d.ts

@@ -0,0 +1,11 @@
+import type { CollectingMetadata } from './types';
+import type { MetadataResolver } from '../next-app-loader';
+import type { PageExtensions } from '../../../page-extensions-type';
+export declare function createStaticMetadataFromRoute(resolvedDir: string, { segment, metadataResolver, isRootLayoutOrRootPage, pageExtensions, basePath, }: {
+    segment: string;
+    metadataResolver: MetadataResolver;
+    isRootLayoutOrRootPage: boolean;
+    pageExtensions: PageExtensions;
+    basePath: string;
+}): Promise<CollectingMetadata | null>;
+export declare function createMetadataExportsCode(metadata: Awaited<ReturnType<typeof createStaticMetadataFromRoute>>): string;

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createMetadataExportsCode: null,
+    createStaticMetadataFromRoute: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createMetadataExportsCode: function() {
+        return createMetadataExportsCode;
+    },
+    createStaticMetadataFromRoute: function() {
+        return createStaticMetadataFromRoute;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _querystring = require("querystring");
+const _ismetadataroute = require("../../../../lib/metadata/is-metadata-route");
+const _constants = require("../../../../lib/constants");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const METADATA_TYPE = 'metadata';
+const NUMERIC_SUFFIX_ARRAY = Array(10).fill(0);
+// 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 = [];
+    // Collect <filename>.<ext>, <filename>[].<ext>
+    const possibleFileNames = [
+        filename
+    ].concat(numericSuffix ? NUMERIC_SUFFIX_ARRAY.map((_, index)=>filename + index) : []);
+    for (const name of possibleFileNames){
+        const resolved = await metadataResolver(dir, name, extensions);
+        collectedFiles.push(...resolved);
+    }
+    return collectedFiles;
+}
+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.default.parse(manifestFile[0]);
+                const extension = staticManifestExtension.includes(ext.slice(1)) ? ext.slice(1) : 'webmanifest';
+                staticImagesMetadata.manifest = JSON.stringify(`${basePath}/${name}.${extension}`);
+            }
+            return;
+        }
+        const isFavicon = type === 'favicon';
+        const resolvedMetadataFiles = await enumMetadataFiles(resolvedDir, _ismetadataroute.STATIC_METADATA_IMAGES[type].filename, [
+            ..._ismetadataroute.STATIC_METADATA_IMAGES[type].extensions,
+            ...isFavicon ? [] : pageExtensions
+        ], {
+            metadataResolver,
+            numericSuffix: !isFavicon
+        });
+        resolvedMetadataFiles.sort((a, b)=>a.localeCompare(b)).forEach((filepath)=>{
+            const imageModuleImportSource = `next-metadata-image-loader?${(0, _querystring.stringify)({
+                type,
+                segment,
+                basePath,
+                pageExtensions
+            })}!${filepath}?${_constants.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;
+}
+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/build/webpack/loaders/metadata/resolve-route-data.d.ts

@@ -0,0 +1,5 @@
+import type { MetadataRoute } from '../../../../lib/metadata/types/metadata-interface';
+export declare function resolveRobots(data: MetadataRoute.Robots): string;
+export declare function resolveSitemap(data: MetadataRoute.Sitemap): string;
+export declare function resolveManifest(data: MetadataRoute.Manifest): string;
+export declare function resolveRouteData(data: MetadataRoute.Robots | MetadataRoute.Sitemap | MetadataRoute.Manifest, fileType: 'robots' | 'sitemap' | 'manifest'): string;

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

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    resolveManifest: null,
+    resolveRobots: null,
+    resolveRouteData: null,
+    resolveSitemap: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    resolveManifest: function() {
+        return resolveManifest;
+    },
+    resolveRobots: function() {
+        return resolveRobots;
+    },
+    resolveRouteData: function() {
+        return resolveRouteData;
+    },
+    resolveSitemap: function() {
+        return resolveSitemap;
+    }
+});
+const _utils = require("../../../../lib/metadata/generate/utils");
+function resolveRobots(data) {
+    let content = '';
+    const rules = Array.isArray(data.rules) ? data.rules : [
+        data.rules
+    ];
+    for (const rule of rules){
+        const userAgent = (0, _utils.resolveArray)(rule.userAgent || [
+            '*'
+        ]);
+        for (const agent of userAgent){
+            content += `User-Agent: ${agent}\n`;
+        }
+        if (rule.allow) {
+            const allow = (0, _utils.resolveArray)(rule.allow);
+            for (const item of allow){
+                content += `Allow: ${item}\n`;
+            }
+        }
+        if (rule.disallow) {
+            const disallow = (0, _utils.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 = (0, _utils.resolveArray)(data.sitemap);
+        // TODO-METADATA: support injecting sitemap url into robots.txt
+        sitemap.forEach((item)=>{
+            content += `Sitemap: ${item}\n`;
+        });
+    }
+    return content;
+}
+function resolveSitemap(data) {
+    const hasAlternates = data.some((item)=>Object.keys(item.alternates ?? {}).length > 0);
+    const hasImages = data.some((item)=>{
+        var _item_images;
+        return Boolean((_item_images = item.images) == null ? void 0 : _item_images.length);
+    });
+    const hasVideos = data.some((item)=>{
+        var _item_videos;
+        return Boolean((_item_videos = item.videos) == null ? void 0 : _item_videos.length);
+    });
+    let content = '';
+    content += '<?xml version="1.0" encoding="UTF-8"?>\n';
+    content += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"';
+    if (hasImages) {
+        content += ' xmlns:image="http://www.google.com/schemas/sitemap-image/1.1"';
+    }
+    if (hasVideos) {
+        content += ' xmlns:video="http://www.google.com/schemas/sitemap-video/1.1"';
+    }
+    if (hasAlternates) {
+        content += ' xmlns:xhtml="http://www.w3.org/1999/xhtml">\n';
+    } else {
+        content += '>\n';
+    }
+    for (const item of data){
+        var _item_alternates, _item_images, _item_videos;
+        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_images = item.images) == null ? void 0 : _item_images.length) {
+            for (const image of item.images){
+                content += `<image:image>\n<image:loc>${image}</image:loc>\n</image:image>\n`;
+            }
+        }
+        if ((_item_videos = item.videos) == null ? void 0 : _item_videos.length) {
+            for (const video of item.videos){
+                let videoFields = [
+                    `<video:video>`,
+                    `<video:title>${video.title}</video:title>`,
+                    `<video:thumbnail_loc>${video.thumbnail_loc}</video:thumbnail_loc>`,
+                    `<video:description>${video.description}</video:description>`,
+                    video.content_loc && `<video:content_loc>${video.content_loc}</video:content_loc>`,
+                    video.player_loc && `<video:player_loc>${video.player_loc}</video:player_loc>`,
+                    video.duration && `<video:duration>${video.duration}</video:duration>`,
+                    video.view_count && `<video:view_count>${video.view_count}</video:view_count>`,
+                    video.tag && `<video:tag>${video.tag}</video:tag>`,
+                    video.rating && `<video:rating>${video.rating}</video:rating>`,
+                    video.expiration_date && `<video:expiration_date>${video.expiration_date}</video:expiration_date>`,
+                    video.publication_date && `<video:publication_date>${video.publication_date}</video:publication_date>`,
+                    video.family_friendly && `<video:family_friendly>${video.family_friendly}</video:family_friendly>`,
+                    video.requires_subscription && `<video:requires_subscription>${video.requires_subscription}</video:requires_subscription>`,
+                    video.live && `<video:live>${video.live}</video:live>`,
+                    video.restriction && `<video:restriction relationship="${video.restriction.relationship}">${video.restriction.content}</video:restriction>`,
+                    video.platform && `<video:platform relationship="${video.platform.relationship}">${video.platform.content}</video:platform>`,
+                    video.uploader && `<video:uploader${video.uploader.info && ` info="${video.uploader.info}"`}>${video.uploader.content}</video:uploader>`,
+                    `</video:video>\n`
+                ].filter(Boolean);
+                content += videoFields.join('\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;
+}
+function resolveManifest(data) {
+    return JSON.stringify(data);
+}
+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/build/webpack/loaders/metadata/types.d.ts

@@ -0,0 +1,28 @@
+export type ModuleGetter = () => any;
+export type ModuleTuple = [getModule: ModuleGetter, filePath: string];
+export type CollectingMetadata = {
+    icon: string[];
+    apple: string[];
+    twitter: string[];
+    openGraph: string[];
+    manifest?: string;
+};
+export type CollectedMetadata = {
+    icon: ModuleGetter[];
+    apple: ModuleGetter[];
+    twitter: ModuleGetter[] | null;
+    openGraph: ModuleGetter[] | null;
+    manifest?: string;
+};
+export type MetadataImageModule = {
+    url: string;
+    type?: string;
+    alt?: string;
+} & ({
+    sizes?: string;
+} | {
+    width?: number;
+    height?: number;
+});
+export type PossibleImageFileNameConvention = 'icon' | 'apple' | 'favicon' | 'twitter' | 'openGraph';
+export type PossibleStaticMetadataFileNameConvention = PossibleImageFileNameConvention | 'manifest';

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

@@ -0,0 +1,7 @@
+// TODO-APP: check if this can be narrowed.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/metadata/types.ts"],"sourcesContent":["// TODO-APP: check if this can be narrowed.\nexport type ModuleGetter = () => any\n\nexport type ModuleTuple = [getModule: ModuleGetter, filePath: string]\n\n// Contain the collecting image module paths\nexport type CollectingMetadata = {\n  icon: string[]\n  apple: string[]\n  twitter: string[]\n  openGraph: string[]\n  manifest?: string\n}\n\n// Contain the collecting evaluated image module\nexport type CollectedMetadata = {\n  icon: ModuleGetter[]\n  apple: ModuleGetter[]\n  twitter: ModuleGetter[] | null\n  openGraph: ModuleGetter[] | null\n  manifest?: string\n}\n\nexport type MetadataImageModule = {\n  url: string\n  type?: string\n  alt?: string\n} & (\n  | { sizes?: string }\n  | {\n      width?: number\n      height?: number\n    }\n)\n\nexport type PossibleImageFileNameConvention =\n  | 'icon'\n  | 'apple'\n  | 'favicon'\n  | 'twitter'\n  | 'openGraph'\n\nexport type PossibleStaticMetadataFileNameConvention =\n  | PossibleImageFileNameConvention\n  | 'manifest'\n"],"names":[],"mappings":"AAAA,2CAA2C","ignoreList":[0]}

node_modules/next/dist/build/webpack/loaders/modularize-import-loader.d.ts

@@ -0,0 +1,19 @@
+export type ModularizeImportLoaderOptions = {
+    name: string;
+    join?: string;
+    from: 'default' | 'named';
+    as: 'default' | 'named';
+};
+/**
+ * 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(this: any): string;

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * 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.
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return transformSource;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function transformSource() {
+    const { name, from, as, join } = this.getOptions();
+    const { resourcePath } = this;
+    const fullPath = join ? _path.default.join(_path.default.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/build/webpack/loaders/modularize-import-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/modularize-import-loader.ts"],"sourcesContent":["import path from 'path'\n\nexport type ModularizeImportLoaderOptions = {\n  name: string\n  join?: string\n  from: 'default' | 'named'\n  as: 'default' | 'named'\n}\n\n/**\n * This loader is to create special re-exports from a specific file.\n * For example, the following loader:\n *\n * modularize-import-loader?name=Arrow&from=Arrow&as=default&join=./icons/Arrow!lucide-react\n *\n * will be used to create a re-export of:\n *\n * export { Arrow as default } from \"join(resolve_path('lucide-react'), '/icons/Arrow')\"\n *\n * This works even if there's no export field in the package.json of the package.\n */\nexport default function transformSource(this: any) {\n  const { name, from, as, join }: ModularizeImportLoaderOptions =\n    this.getOptions()\n  const { resourcePath } = this\n  const fullPath = join\n    ? path.join(path.dirname(resourcePath), join)\n    : resourcePath\n\n  return `\nexport {\n  ${from === 'default' ? 'default' : name} as ${\n    as === 'default' ? 'default' : name\n  }\n} from ${JSON.stringify(fullPath)}\n`\n}\n"],"names":["transformSource","name","from","as","join","getOptions","resourcePath","fullPath","path","dirname","JSON","stringify"],"mappings":";;;;+BASA;;;;;;;;;;;CAWC,GACD;;;eAAwBA;;;6DArBP;;;;;;AAqBF,SAASA;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,OACbI,aAAI,CAACJ,IAAI,CAACI,aAAI,CAACC,OAAO,CAACH,eAAeF,QACtCE;IAEJ,OAAO,CAAC;;EAER,EAAEJ,SAAS,YAAY,YAAYD,KAAK,IAAI,EAC1CE,OAAO,YAAY,YAAYF,KAChC;OACI,EAAES,KAAKC,SAAS,CAACJ,UAAU;AAClC,CAAC;AACD","ignoreList":[0]}

node_modules/next/dist/build/webpack/loaders/next-app-loader/create-app-route-code.d.ts

@@ -0,0 +1,11 @@
+import type { NextConfig } from '../../../../server/config-shared';
+import type { PageExtensions } from '../../../page-extensions-type';
+export declare function createAppRouteCode({ appDir, name, page, pagePath, resolveAppRoute, pageExtensions, nextConfigOutput, }: {
+    appDir: string;
+    name: string;
+    page: string;
+    pagePath: string;
+    resolveAppRoute: (pathname: string) => Promise<string | undefined> | string | undefined;
+    pageExtensions: PageExtensions;
+    nextConfigOutput: NextConfig['output'];
+}): Promise<string>;

node_modules/next/dist/build/webpack/loaders/next-app-loader/create-app-route-code.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createAppRouteCode", {
+    enumerable: true,
+    get: function() {
+        return createAppRouteCode;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _querystring = require("querystring");
+const _constants = require("../../../../lib/constants");
+const _ismetadataroute = require("../../../../lib/metadata/is-metadata-route");
+const _appbundlepathnormalizer = require("../../../../server/normalizers/built/app/app-bundle-path-normalizer");
+const _apppathnamenormalizer = require("../../../../server/normalizers/built/app/app-pathname-normalizer");
+const _loadentrypoint = require("../../../load-entrypoint");
+const _nextmetadatarouteloader = require("../next-metadata-route-loader");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function createAppRouteCode({ appDir, 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 Object.defineProperty(new Error(`Invariant: could not resolve page path for ${name} at ${routePath}`), "__NEXT_ERROR_CODE", {
+            value: "E281",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // If this is a metadata route file, then we need to use the metadata-loader
+    // for the route to ensure that the route is generated.
+    const fileBaseName = _path.default.parse(resolvedPagePath).name;
+    const appDirRelativePath = resolvedPagePath.slice(appDir.length);
+    const isMetadataEntryFile = (0, _ismetadataroute.isMetadataRouteFile)(appDirRelativePath, _ismetadataroute.DEFAULT_METADATA_ROUTE_EXTENSIONS, true);
+    if (isMetadataEntryFile) {
+        const { ext } = (0, _nextmetadatarouteloader.getFilenameAndExtension)(resolvedPagePath);
+        const isDynamicRouteExtension = pageExtensions.includes(ext);
+        resolvedPagePath = `next-metadata-route-loader?${(0, _querystring.stringify)({
+            filePath: resolvedPagePath,
+            isDynamicRouteExtension: isDynamicRouteExtension ? '1' : '0'
+        })}!?${_constants.WEBPACK_RESOURCE_QUERIES.metadataRoute}`;
+    }
+    const pathname = new _apppathnamenormalizer.AppPathnameNormalizer().normalize(page);
+    const bundlePath = new _appbundlepathnormalizer.AppBundlePathNormalizer().normalize(page);
+    return await (0, _loadentrypoint.loadEntrypoint)('app-route', {
+        VAR_USERLAND: resolvedPagePath,
+        VAR_DEFINITION_PAGE: page,
+        VAR_DEFINITION_PATHNAME: pathname,
+        VAR_DEFINITION_FILENAME: fileBaseName,
+        VAR_DEFINITION_BUNDLE_PATH: bundlePath,
+        VAR_RESOLVED_PAGE_PATH: resolvedPagePath
+    }, {
+        nextConfigOutput: JSON.stringify(nextConfigOutput)
+    });
+}
+
+//# sourceMappingURL=create-app-route-code.js.map

node_modules/next/dist/build/webpack/loaders/next-app-loader/index.d.ts

@@ -0,0 +1,47 @@
+import type webpack from 'next/dist/compiled/webpack/webpack';
+import { type ValueOf } from '../../../../shared/lib/constants';
+import type { ModuleTuple, CollectedMetadata } from '../metadata/types';
+import type { NextConfig } from '../../../../server/config-shared';
+import type { PageExtensions } from '../../../page-extensions-type';
+export type AppLoaderOptions = {
+    name: string;
+    page: string;
+    pagePath: string;
+    appDir: string;
+    appPaths: readonly string[] | null;
+    allNormalizedAppPaths: readonly string[] | null;
+    preferredRegion: string | string[] | undefined;
+    pageExtensions: PageExtensions;
+    assetPrefix: string;
+    rootDir?: string;
+    tsconfigPath?: string;
+    isDev?: true;
+    basePath: string;
+    nextConfigOutput?: NextConfig['output'];
+    middlewareConfig: string;
+    isGlobalNotFoundEnabled: true | undefined;
+};
+type AppLoader = webpack.LoaderDefinitionFunction<AppLoaderOptions>;
+declare const FILE_TYPES: {
+    readonly 'not-found': "not-found";
+    readonly forbidden: "forbidden";
+    readonly unauthorized: "unauthorized";
+    readonly layout: "layout";
+    readonly template: "template";
+    readonly error: "error";
+    readonly loading: "loading";
+    readonly 'global-error': "global-error";
+    readonly 'global-not-found': "global-not-found";
+};
+export type MetadataResolver = (dir: string, filename: string, extensions: readonly string[]) => Promise<string[]>;
+export type AppDirModules = {
+    readonly [moduleKey in ValueOf<typeof FILE_TYPES>]?: ModuleTuple;
+} & {
+    readonly page?: ModuleTuple;
+} & {
+    readonly metadata?: CollectedMetadata;
+} & {
+    readonly defaultPage?: ModuleTuple;
+};
+declare const nextAppLoader: AppLoader;
+export default nextAppLoader;

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

@@ -0,0 +1,834 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default1;
+    }
+});
+const _constants = require("../../../../shared/lib/constants");
+const _entryconstants = require("../../../../shared/lib/entry-constants");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _picocolors = require("../../../../lib/picocolors");
+const _getmodulebuildinfo = require("../get-module-build-info");
+const _verifyrootlayout = require("../../../../lib/verify-root-layout");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../output/log"));
+const _constants1 = require("../../../../lib/constants");
+const _discover = require("../metadata/discover");
+const _fs = require("fs");
+const _isapprouteroute = require("../../../../lib/is-app-route-route");
+const _apppathnamenormalizer = require("../../../../server/normalizers/built/app/app-pathname-normalizer");
+const _utils = require("../../../utils");
+const _loadentrypoint = require("../../../load-entrypoint");
+const _segment = require("../../../../shared/lib/segment");
+const _getfilesindir = require("../../../../lib/get-files-in-dir");
+const _default = require("../../../../client/components/builtin/default");
+const _defaultnull = require("../../../../client/components/builtin/default-null");
+const _createapproutecode = require("./create-app-route-code");
+const _missingdefaultparallelrouteerror = require("../../../../shared/lib/errors/missing-default-parallel-route-error");
+const _interceptionroutes = require("../../../../shared/lib/router/utils/interception-routes");
+const _apppaths = require("../../../../shared/lib/router/utils/app-paths");
+const _normalizepathsep = require("../../../../shared/lib/page-path/normalize-path-sep");
+const _installbindings = require("../../../swc/install-bindings");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const HTTP_ACCESS_FALLBACKS = {
+    'not-found': 'not-found',
+    forbidden: 'forbidden',
+    unauthorized: 'unauthorized'
+};
+const defaultHTTPAccessFallbackPaths = {
+    'not-found': 'next/dist/client/components/builtin/not-found.js',
+    forbidden: 'next/dist/client/components/builtin/forbidden.js',
+    unauthorized: 'next/dist/client/components/builtin/unauthorized.js'
+};
+const FILE_TYPES = {
+    layout: 'layout',
+    template: 'template',
+    error: 'error',
+    loading: 'loading',
+    'global-error': 'global-error',
+    'global-not-found': 'global-not-found',
+    ...HTTP_ACCESS_FALLBACKS
+};
+const GLOBAL_ERROR_FILE_TYPE = 'global-error';
+const GLOBAL_NOT_FOUND_FILE_TYPE = 'global-not-found';
+const PAGE_SEGMENT = 'page$';
+const PARALLEL_VIRTUAL_SEGMENT = 'slot$';
+const defaultGlobalErrorPath = 'next/dist/client/components/builtin/global-error.js';
+const defaultNotFoundPath = 'next/dist/client/components/builtin/not-found.js';
+const defaultEmptyStubPath = 'next/dist/client/components/builtin/empty-stub.js';
+const defaultLayoutPath = 'next/dist/client/components/builtin/layout.js';
+const defaultGlobalNotFoundPath = 'next/dist/client/components/builtin/global-not-found.js';
+const appErrorPath = 'next/dist/client/components/builtin/app-error.js';
+const normalizeParallelKey = (key)=>key.startsWith('@') ? key.slice(1) : key;
+const isCatchAllSegment = (segment)=>segment.startsWith('[...') || segment.startsWith('[[...');
+const isDynamicSegment = (segment)=>segment.startsWith('[') && segment.endsWith(']');
+const isDirectory = async (pathname)=>{
+    try {
+        const stat = await _fs.promises.stat(pathname);
+        return stat.isDirectory();
+    } catch (err) {
+        return false;
+    }
+};
+async function createTreeCodeFromPath(pagePath, { page, resolveDir, resolver, resolveParallelSegments, hasChildRoutesForSegment, getStaticSiblingSegments, metadataResolver, pageExtensions, basePath, collectedDeclarations, isGlobalNotFoundEnabled, isDev }) {
+    const splittedPath = pagePath.split(/[\\/]/, 1);
+    const isNotFoundRoute = page === _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY;
+    const isAppErrorRoute = page === _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY;
+    const isDefaultNotFound = (0, _utils.isAppBuiltinPage)(pagePath);
+    const appDirPrefix = isDefaultNotFound ? _constants1.APP_DIR_ALIAS : splittedPath[0];
+    let rootLayout;
+    let globalError = defaultGlobalErrorPath;
+    let globalNotFound = defaultNotFoundPath;
+    async function resolveAdjacentParallelSegments(segmentPath) {
+        const absoluteSegmentPath = 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.promises.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, nestedCollectedDeclarations) {
+        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}`;
+        const resolvedRouteDir = resolveDir(routerDirPath);
+        if (resolvedRouteDir && // Do not collect metadata for app-error route as it's for generating pure static 500.html
+        !(0, _normalizepathsep.normalizePathSep)(pagePath).endsWith(appErrorPath)) {
+            metadata = await (0, _discover.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) {
+                    const varName = `page${nestedCollectedDeclarations.length}`;
+                    nestedCollectedDeclarations.push([
+                        varName,
+                        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)] = `['${_segment.PAGE_SEGMENT_KEY}', {}, {
+          page: [${varName}, ${JSON.stringify(resolvedPagePath)}],
+          ${(0, _discover.createMetadataExportsCode)(metadata)}
+        }]`;
+                    continue;
+                } else {
+                    throw Object.defineProperty(new Error(`Can't resolve ${matchedPagePath}`), "__NEXT_ERROR_CODE", {
+                        value: "E1007",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+            }
+            // 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_VIRTUAL_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 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 filePathEntries = 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 filePaths = new Map(filePathEntries);
+            // Resolve global-* convention files at the root layer
+            if (isRootLayer) {
+                const resolvedGlobalErrorPath = await resolver(`${appDirPrefix}/${GLOBAL_ERROR_FILE_TYPE}`);
+                if (resolvedGlobalErrorPath) {
+                    globalError = resolvedGlobalErrorPath;
+                }
+                // TODO(global-not-found): remove this flag assertion condition
+                //  once global-not-found is stable
+                if (isGlobalNotFoundEnabled) {
+                    const resolvedGlobalNotFoundPath = await resolver(`${appDirPrefix}/${GLOBAL_NOT_FOUND_FILE_TYPE}`);
+                    if (resolvedGlobalNotFoundPath) {
+                        globalNotFound = resolvedGlobalNotFoundPath;
+                    }
+                    // Add global-not-found to root layer's filePaths, so that it's always available,
+                    // by default it's the built-in global-not-found.js
+                    filePaths.set(GLOBAL_NOT_FOUND_FILE_TYPE, globalNotFound);
+                }
+            }
+            // Add global-error to ALL layers' filePaths, so that it's always available.
+            // By default it's the built-in global-error.js, or user's custom one if defined.
+            filePaths.set(GLOBAL_ERROR_FILE_TYPE, globalError);
+            let definedFilePaths = Array.from(filePaths.entries()).filter(([, filePath])=>filePath !== undefined);
+            // Add default access fallback as root fallback if not present
+            const existedConventionNames = new Set(definedFilePaths.map(([type])=>type));
+            // If the first layer is a group route, we treat it as root layer
+            const isFirstLayerGroupRoute = segments.length === 1 && subSegmentPath.filter((seg)=>(0, _segment.isGroupSegment)(seg)).length === 1;
+            if (isRootLayer || isFirstLayerGroupRoute) {
+                const accessFallbackTypes = Object.keys(defaultHTTPAccessFallbackPaths);
+                for (const type of accessFallbackTypes){
+                    const hasRootFallbackFile = await resolver(`${appDirPrefix}/${FILE_TYPES[type]}`);
+                    const hasLayerFallbackFile = existedConventionNames.has(type);
+                    // If you already have a root access error fallback, don't insert default access error boundary to group routes root
+                    if (// Is treated as root layout and without boundary
+                    !(hasRootFallbackFile && isFirstLayerGroupRoute) && // Does not have a fallback boundary file
+                    !hasLayerFallbackFile) {
+                        const defaultFallbackPath = defaultHTTPAccessFallbackPaths[type];
+                        if (!(isDefaultNotFound && type === 'not-found')) {
+                            definedFilePaths.push([
+                                type,
+                                defaultFallbackPath
+                            ]);
+                        }
+                    }
+                }
+            }
+            if (!rootLayout) {
+                var _definedFilePaths_find;
+                const layoutPath = (_definedFilePaths_find = definedFilePaths.find(([type])=>type === 'layout')) == null ? void 0 : _definedFilePaths_find[1];
+                rootLayout = layoutPath;
+                // When `global-not-found` is disabled, we insert a default layout if
+                // root layout is presented. This logic and the default layout will be removed
+                // once `global-not-found` is stabilized.
+                if (!isGlobalNotFoundEnabled && isDefaultNotFound && !layoutPath && !rootLayout) {
+                    rootLayout = defaultLayoutPath;
+                    definedFilePaths.push([
+                        'layout',
+                        rootLayout
+                    ]);
+                }
+            }
+            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_VIRTUAL_SEGMENT || parallelSegmentKey === PAGE_SEGMENT ? '(__SLOT__)' : parallelSegmentKey;
+            const normalizedParallelKey = normalizeParallelKey(parallelKey);
+            let subtreeCode;
+            // If it's root not found page, set not-found boundary as children page
+            if (isNotFoundRoute) {
+                if (normalizedParallelKey === 'children') {
+                    var _definedFilePaths_find1;
+                    const matchedGlobalNotFound = isGlobalNotFoundEnabled ? ((_definedFilePaths_find1 = definedFilePaths.find(([type])=>type === GLOBAL_NOT_FOUND_FILE_TYPE)) == null ? void 0 : _definedFilePaths_find1[1]) ?? defaultGlobalNotFoundPath : undefined;
+                    // If custom global-not-found.js is defined, use global-not-found.js
+                    if (matchedGlobalNotFound) {
+                        const varName = `notFound${nestedCollectedDeclarations.length}`;
+                        nestedCollectedDeclarations.push([
+                            varName,
+                            matchedGlobalNotFound
+                        ]);
+                        const layoutName = `layout${nestedCollectedDeclarations.length}`;
+                        nestedCollectedDeclarations.push([
+                            layoutName,
+                            defaultEmptyStubPath
+                        ]);
+                        subtreeCode = `{
+              children: [${JSON.stringify(_constants.UNDERSCORE_NOT_FOUND_ROUTE)}, {
+                children: ['${_segment.PAGE_SEGMENT_KEY}', {}, {
+                  layout: [
+                    ${varName},
+                    ${JSON.stringify(matchedGlobalNotFound)}
+                  ],
+                  page: [
+                    ${layoutName},
+                    ${JSON.stringify(defaultEmptyStubPath)}
+                  ]
+                }]
+              }, {}]
+            }`;
+                    } else {
+                        var _definedFilePaths_find2;
+                        // If custom not-found.js is found, use it and layout to compose the page,
+                        // and fallback to built-in not-found component if doesn't exist.
+                        const notFoundPath = ((_definedFilePaths_find2 = definedFilePaths.find(([type])=>type === 'not-found')) == null ? void 0 : _definedFilePaths_find2[1]) ?? defaultNotFoundPath;
+                        const varName = `notFound${nestedCollectedDeclarations.length}`;
+                        nestedCollectedDeclarations.push([
+                            varName,
+                            notFoundPath
+                        ]);
+                        subtreeCode = `{
+              children: [${JSON.stringify(_constants.UNDERSCORE_NOT_FOUND_ROUTE.slice(1))}, {
+                children: ['${_segment.PAGE_SEGMENT_KEY}', {}, {
+                  page: [
+                    ${varName},
+                    ${JSON.stringify(notFoundPath)}
+                  ]
+                }]
+              }, {}]
+            }`;
+                    }
+                }
+            }
+            // If it's app-error route, set app-error as children page
+            if (isAppErrorRoute) {
+                const varName = `appError${nestedCollectedDeclarations.length}`;
+                nestedCollectedDeclarations.push([
+                    varName,
+                    appErrorPath
+                ]);
+                subtreeCode = `{
+          children: [${JSON.stringify(_constants.UNDERSCORE_GLOBAL_ERROR_ROUTE.slice(1))}, {
+            children: ['${_segment.PAGE_SEGMENT_KEY}', {}, {
+              page: [
+                ${varName},
+                ${JSON.stringify(appErrorPath)}
+              ]
+            }]
+          }, {}]
+        }`;
+            }
+            // For 404 route
+            // if global-not-found is in definedFilePaths, remove root layout for /_not-found,
+            // and change it to global-not-found route.
+            // TODO: remove this once global-not-found is stable.
+            if (isNotFoundRoute && isGlobalNotFoundEnabled) {
+                var _definedFilePaths_find3;
+                definedFilePaths = definedFilePaths.filter(([type])=>type !== 'layout');
+                // Replace the layout to global-not-found
+                definedFilePaths.push([
+                    'layout',
+                    ((_definedFilePaths_find3 = definedFilePaths.find(([type])=>type === GLOBAL_NOT_FOUND_FILE_TYPE)) == null ? void 0 : _definedFilePaths_find3[1]) ?? defaultGlobalNotFoundPath
+                ]);
+            }
+            if (isAppErrorRoute) {
+                definedFilePaths = definedFilePaths.filter(([type])=>type !== 'layout');
+            }
+            const modulesCode = `{
+        ${definedFilePaths.map(([file, filePath])=>{
+                const varName = `module${nestedCollectedDeclarations.length}`;
+                nestedCollectedDeclarations.push([
+                    varName,
+                    filePath
+                ]);
+                return `'${file}': [${varName}, ${JSON.stringify(filePath)}],`;
+            }).join('\n')}
+        ${(0, _discover.createMetadataExportsCode)(metadata)}
+      }`;
+            if (!subtreeCode) {
+                const { treeCode: pageSubtreeCode } = await createSubtreePropsFromSegmentPath(subSegmentPath, nestedCollectedDeclarations);
+                subtreeCode = pageSubtreeCode;
+            }
+            // Compute static siblings for dynamic segments. In dev mode, routes are
+            // compiled on-demand so we don't know all siblings; pass null.
+            const staticSiblingsCode = isDev ? 'null' : `${JSON.stringify(getStaticSiblingSegments(parallelSegmentPath))}`;
+            props[normalizedParallelKey] = `[
+        '${parallelSegmentKey}',
+        ${subtreeCode},
+        ${modulesCode},
+        ${staticSiblingsCode}
+      ]`;
+        }
+        const adjacentParallelSegments = await resolveAdjacentParallelSegments(segmentPath);
+        for (const adjacentParallelSegment of adjacentParallelSegments){
+            if (!props[normalizeParallelKey(adjacentParallelSegment)]) {
+                const actualSegment = adjacentParallelSegment === 'children' ? '' : `/${adjacentParallelSegment}`;
+                // Use the default path if it's found, otherwise if it's a children
+                // slot, then use the fallback (which triggers a `notFound()`). If this
+                // isn't a children slot, then throw an error, as it produces a silent
+                // 404 if we'd used the fallback.
+                const fullSegmentPath = `${appDirPrefix}${segmentPath}${actualSegment}`;
+                let defaultPath = await resolver(`${fullSegmentPath}/default`);
+                if (!defaultPath) {
+                    if (adjacentParallelSegment === 'children') {
+                        // When we host applications on Vercel, the status code affects the
+                        // underlying behavior of the route, which when we are missing the
+                        // children slot of an interception route, will yield a full 404
+                        // response for the RSC request instead. For this reason, we expect
+                        // that if a default file is missing when we're rendering an
+                        // interception route, we instead always render null for the default
+                        // slot to avoid the full 404 response.
+                        if ((0, _interceptionroutes.isInterceptionRouteAppPath)(page)) {
+                            defaultPath = _defaultnull.PARALLEL_ROUTE_DEFAULT_NULL_PATH;
+                        } else {
+                            defaultPath = _default.PARALLEL_ROUTE_DEFAULT_PATH;
+                        }
+                    } else {
+                        // Check if we're inside a catch-all route (i.e., the parallel route is a child
+                        // of a catch-all segment). Only skip validation if the slot is UNDER a catch-all.
+                        // For example:
+                        //   /[...catchAll]/@slot - isInsideCatchAll = true (skip validation) ✓
+                        //   /@slot/[...catchAll] - isInsideCatchAll = false (require default) ✓
+                        // The catch-all provides fallback behavior, so default.js is not required.
+                        const isInsideCatchAll = segments.some(isCatchAllSegment);
+                        // Check if this is a leaf segment (no child routes).
+                        // Leaf segments don't need default.js because there are no child routes
+                        // that could cause the parallel slot to unmatch. For example:
+                        //   /repo-overview/@slot/page with no child routes - isLeafSegment = true (skip validation) ✓
+                        //   /repo-overview/@slot/page with /repo-overview/child/page - isLeafSegment = false (require default) ✓
+                        // This also handles route groups correctly by filtering them out.
+                        const isLeafSegment = !hasChildRoutesForSegment(segmentPath);
+                        if (!isInsideCatchAll && !isLeafSegment) {
+                            // Replace internal webpack alias with user-facing directory name
+                            const userFacingPath = fullSegmentPath.replace(_constants1.APP_DIR_ALIAS, 'app');
+                            throw new _missingdefaultparallelrouteerror.MissingDefaultParallelRouteError(userFacingPath, adjacentParallelSegment);
+                        }
+                        defaultPath = _default.PARALLEL_ROUTE_DEFAULT_PATH;
+                    }
+                }
+                const varName = `default${nestedCollectedDeclarations.length}`;
+                nestedCollectedDeclarations.push([
+                    varName,
+                    defaultPath
+                ]);
+                props[normalizeParallelKey(adjacentParallelSegment)] = `[
+          '${_segment.DEFAULT_SEGMENT_KEY}',
+          {},
+          {
+            defaultPage: [${varName}, ${JSON.stringify(defaultPath)}],
+          }
+        ]`;
+            }
+        }
+        return {
+            treeCode: `{
+        ${Object.entries(props).map(([key, value])=>`${key}: ${value}`).join(',\n')}
+      }`
+        };
+    }
+    const { treeCode } = await createSubtreePropsFromSegmentPath([], collectedDeclarations);
+    return {
+        treeCode: `${treeCode}.children;`,
+        rootLayout,
+        globalError,
+        globalNotFound
+    };
+}
+function createAbsolutePath(appDir, pathToTurnAbsolute) {
+    return pathToTurnAbsolute// Replace all POSIX path separators with the current OS path separator
+    .replace(/\//g, _path.default.sep).replace(/^private-next-app-dir/, appDir);
+}
+const filesInDirMapMap = new WeakMap();
+const nextAppLoader = async function nextAppLoader() {
+    // install native bindings early so they are always available.
+    // When run by webpack, next will have already done this, so this will be fast,
+    // but if run by turbopack in a subprocess it is required.  In that case we cannot pass the
+    // `useWasmBinary` flag, but that is ok since turbopack doesn't currently support wasm.
+    await (0, _installbindings.installBindings)();
+    const loaderOptions = this.getOptions();
+    const { name, appDir, appPaths, allNormalizedAppPaths: allNormalizedAppPathsOption, pagePath, pageExtensions, rootDir, tsconfigPath, isDev, nextConfigOutput, preferredRegion, basePath, middlewareConfig: middlewareConfigBase64 } = loaderOptions;
+    const isGlobalNotFoundEnabled = !!loaderOptions.isGlobalNotFoundEnabled;
+    // Update FILE_TYPES on the very top-level of the loader
+    if (!isGlobalNotFoundEnabled) {
+        // @ts-expect-error this delete is only necessary while experimental
+        delete FILE_TYPES['global-not-found'];
+    }
+    const buildInfo = (0, _getmodulebuildinfo.getModuleBuildInfo)(this._module);
+    const collectedDeclarations = [];
+    // Use the page from loaderOptions directly instead of deriving it from name.
+    // The name (bundlePath) may have been normalized with normalizePagePath()
+    // which is designed for Pages Router and incorrectly duplicates /index paths
+    // (e.g., /index/page -> /index/index/page). The page parameter contains the
+    // correct unnormalized value.
+    const page = loaderOptions.page;
+    const middlewareConfig = JSON.parse(Buffer.from(middlewareConfigBase64, 'base64').toString());
+    buildInfo.route = {
+        page,
+        absolutePagePath: createAbsolutePath(appDir, pagePath),
+        preferredRegion,
+        middlewareConfig,
+        relatedModules: []
+    };
+    const extensions = typeof pageExtensions === 'string' ? [
+        pageExtensions
+    ] : pageExtensions.map((extension)=>`.${extension}`);
+    const normalizedAppPaths = typeof appPaths === 'string' ? [
+        appPaths
+    ] : appPaths || [];
+    // All normalized app paths for computing static siblings across route groups
+    const allNormalizedAppPaths = allNormalizedAppPathsOption ?? [];
+    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_VIRTUAL_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 Object.defineProperty(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`), "__NEXT_ERROR_CODE", {
+                            value: "E28",
+                            enumerable: false,
+                            configurable: true
+                        });
+                    }
+                }
+                existingChildrenPath = appPath;
+                matched.children = rest[0];
+            }
+        }
+        return Object.entries(matched);
+    };
+    const hasChildRoutesForSegment = (segmentPath)=>{
+        const pathPrefix = segmentPath ? `${segmentPath}/` : '';
+        for (const appPath of normalizedAppPaths){
+            if (appPath.startsWith(pathPrefix)) {
+                var _routeSegments_;
+                const rest = appPath.slice(pathPrefix.length).split('/');
+                // Filter out route groups to get the actual route segments
+                // Route groups (e.g., "(group)") don't contribute to the URL path
+                const routeSegments = rest.filter((segment)=>!(0, _segment.isGroupSegment)(segment));
+                // If it's just 'page' at this level, skip (not a child route)
+                if (routeSegments.length === 1 && routeSegments[0] === 'page') {
+                    continue;
+                }
+                // If the first segment (after filtering route groups) is a parallel route, skip
+                if ((_routeSegments_ = routeSegments[0]) == null ? void 0 : _routeSegments_.startsWith('@')) {
+                    continue;
+                }
+                // If we have more than just 'page', then there are child routes
+                // Examples:
+                //   ['child', 'page'] -> true (has child route)
+                //   ['page'] -> false (already filtered above)
+                //   ['grandchild', 'deeper', 'page'] -> true (has nested child routes)
+                if (routeSegments.length > 1 || routeSegments.length === 1 && routeSegments[0] !== 'page') {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    /**
+   * For a given segment path (in file system space, e.g., "(group)/products/[id]"),
+   * find all static sibling segments at the same URL path level.
+   *
+   * This accounts for route groups - siblings may exist in different parts of the
+   * file system tree but at the same URL level.
+   *
+   * For example:
+   *   /app/(marketing)/products/sale/page.tsx -> /products/sale
+   *   /app/(shop)/products/[id]/page.tsx -> /products/[id]
+   *
+   * When called with "(shop)/products/[id]", this would return ['sale'].
+   *
+   * TODO: This function, along with resolveParallelSegments and
+   * hasChildRoutesForSegment, repeatedly scans normalizedAppPaths. A more
+   * optimal approach would build an intermediate tree structure first
+   * (representing the URL namespace with route groups collapsed), then derive
+   * all this information in a single pass. The Turbopack implementation
+   * already uses a more tree-oriented approach (DirectoryTree ->
+   * AppPageLoaderTree), so this is less urgent to refactor given Turbopack is
+   * the canonical implementation going forward.
+   */ const getStaticSiblingSegments = (segmentPath)=>{
+        // Normalize the current path to URL space
+        // Add a trailing /page so normalizeAppPath strips it properly
+        const currentUrlPath = (0, _apppaths.normalizeAppPath)(segmentPath + '/page');
+        const currentUrlSegments = currentUrlPath.split('/').filter(Boolean);
+        // If the path is empty (root level), there are no siblings
+        if (currentUrlSegments.length === 0) {
+            return [];
+        }
+        const currentSegment = currentUrlSegments[currentUrlSegments.length - 1];
+        const parentUrlPath = currentUrlSegments.length === 1 ? '/' : '/' + currentUrlSegments.slice(0, -1).join('/');
+        // The URL level at which we're looking for siblings (0-indexed)
+        const siblingLevel = currentUrlSegments.length - 1;
+        // Only compute siblings for dynamic segments
+        if (!isDynamicSegment(currentSegment)) {
+            return [];
+        }
+        // Use a Set to avoid duplicates (multiple paths may share the same sibling segment)
+        const siblings = new Set();
+        for (const appPath of allNormalizedAppPaths){
+            // Normalize each path to URL space (strip route groups, parallel routes, and /page suffix)
+            const urlPath = (0, _apppaths.normalizeAppPath)(appPath);
+            const urlSegments = urlPath.split('/').filter(Boolean);
+            // Path must have at least enough segments to reach the sibling level
+            if (urlSegments.length <= siblingLevel) {
+                continue;
+            }
+            // Check if the parent path matches (all segments before the sibling level)
+            const pathParent = siblingLevel === 0 ? '/' : '/' + urlSegments.slice(0, siblingLevel).join('/');
+            if (pathParent !== parentUrlPath) {
+                continue;
+            }
+            // Get the segment at the same level as the current segment
+            const segmentAtLevel = urlSegments[siblingLevel];
+            // Check if this is a sibling: different segment and static
+            if (segmentAtLevel !== currentSegment && !isDynamicSegment(segmentAtLevel)) {
+                siblings.add(segmentAtLevel);
+            }
+        }
+        return Array.from(siblings);
+    };
+    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 fileExistsInDirectory = async (dirname, fileName)=>{
+        // I don't think we should ever hit this code path, but if we do we should handle it gracefully.
+        if (this._compilation === undefined) {
+            try {
+                return (await (0, _getfilesindir.getFilesInDir)(dirname).catch(()=>new Set())).has(fileName);
+            } catch (e) {
+                return false;
+            }
+        }
+        const map = filesInDirMapMap.get(this._compilation) || new Map();
+        if (!filesInDirMapMap.has(this._compilation)) {
+            filesInDirMapMap.set(this._compilation, map);
+        }
+        if (!map.has(dirname)) {
+            map.set(dirname, (0, _getfilesindir.getFilesInDir)(dirname).catch(()=>new Set()));
+        }
+        return (await map.get(dirname) || new Set()).has(fileName);
+    };
+    const resolver = async (pathname)=>{
+        const absolutePath = createAbsolutePath(appDir, pathname);
+        const filenameIndex = absolutePath.lastIndexOf(_path.default.sep);
+        const dirname = absolutePath.slice(0, filenameIndex);
+        const filename = absolutePath.slice(filenameIndex + 1);
+        const checks = await Promise.all(extensions.map(async (ext)=>{
+            const absolutePathWithExtension = `${absolutePath}${ext}`;
+            const exists = await fileExistsInDirectory(dirname, `${filename}${ext}`);
+            // Call `addMissingDependency` for all files even if they didn't match,
+            // because they might be added or removed during development.
+            this.addMissingDependency(absolutePathWithExtension);
+            return exists ? absolutePathWithExtension : undefined;
+        }));
+        return checks.find((result)=>result);
+    };
+    const metadataResolver = async (dirname, filename, exts)=>{
+        const absoluteDir = createAbsolutePath(appDir, dirname);
+        const checks = await Promise.all(exts.map(async (ext)=>{
+            // 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.default.sep}${filenameWithExt}`;
+            const exists = await fileExistsInDirectory(dirname, filenameWithExt);
+            // Call `addMissingDependency` for all files even if they didn't match,
+            // because they might be added or removed during development.
+            this.addMissingDependency(absolutePathWithExtension);
+            return exists ? absolutePathWithExtension : undefined;
+        }));
+        return checks.filter((result)=>result !== undefined);
+    };
+    if ((0, _isapprouteroute.isAppRouteRoute)(name)) {
+        return (0, _createapproutecode.createAppRouteCode)({
+            appDir,
+            // 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,
+        hasChildRoutesForSegment,
+        getStaticSiblingSegments,
+        loaderContext: this,
+        pageExtensions,
+        basePath,
+        collectedDeclarations,
+        isGlobalNotFoundEnabled,
+        isDev: !!isDev
+    });
+    const isGlobalNotFoundPath = page === _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY && !!treeCodeResult.globalNotFound && isGlobalNotFoundEnabled;
+    const isAppErrorRoute = page === _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY;
+    if (!treeCodeResult.rootLayout && !isGlobalNotFoundPath && !isAppErrorRoute) {
+        if (!isDev) {
+            // If we're building and missing a root layout, exit the build
+            _log.error(`${(0, _picocolors.bold)(pagePath.replace(`${_constants1.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 {
+            var _filesInDirMapMap_get;
+            // In dev we'll try to create a root layout
+            const [createdRootLayout, rootLayoutPath] = await (0, _verifyrootlayout.verifyRootLayout)({
+                appDir: appDir,
+                dir: rootDir,
+                tsconfigPath: tsconfigPath,
+                pagePath,
+                pageExtensions
+            });
+            if (!createdRootLayout) {
+                let message = `${(0, _picocolors.bold)(pagePath.replace(`${_constants1.APP_DIR_ALIAS}/`, ''))} doesn't have a root layout. `;
+                if (rootLayoutPath) {
+                    var _this__compiler;
+                    message += `We tried to create ${(0, _picocolors.bold)(_path.default.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 Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+                    value: "E1024",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            // Clear fs cache, get the new result with the created root layout.
+            if (this._compilation) (_filesInDirMapMap_get = filesInDirMapMap.get(this._compilation)) == null ? void 0 : _filesInDirMapMap_get.clear();
+            treeCodeResult = await createTreeCodeFromPath(pagePath, {
+                page,
+                resolveDir,
+                resolver,
+                metadataResolver,
+                resolveParallelSegments,
+                hasChildRoutesForSegment,
+                getStaticSiblingSegments,
+                loaderContext: this,
+                pageExtensions,
+                basePath,
+                collectedDeclarations,
+                isGlobalNotFoundEnabled,
+                isDev: !!isDev
+            });
+        }
+    }
+    const pathname = new _apppathnamenormalizer.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 (0, _loadentrypoint.loadEntrypoint)('app-page', {
+        VAR_DEFINITION_PAGE: page,
+        VAR_DEFINITION_PATHNAME: pathname
+    }, {
+        tree: treeCodeResult.treeCode,
+        __next_app_require__: '__webpack_require__',
+        // all modules are in the entry chunk, so we never actually need to load chunks in webpack
+        __next_app_load_chunk__: '() => Promise.resolve()'
+    });
+    // Lazily evaluate the imported modules in the generated code
+    const header = collectedDeclarations.map(([varName, modulePath])=>{
+        return `const ${varName} = () => import(/* webpackMode: "eager" */ ${JSON.stringify(modulePath)});\n`;
+    }).join('');
+    return header + code;
+};
+const _default1 = nextAppLoader;
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/build/webpack/loaders/next-barrel-loader.d.ts

@@ -0,0 +1,91 @@
+/**
+ * ## 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 type webpack from 'webpack';
+declare const NextBarrelLoader: (this: webpack.LoaderContext<{
+    names: string[];
+    swcCacheDir: string;
+}>) => Promise<void>;
+export default NextBarrelLoader;

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

@@ -0,0 +1,268 @@
+/**
+ * ## 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.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _swc = require("../../swc");
+const _installbindings = require("../../swc/install-bindings");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+// 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)=>(0, _swc.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.default.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);
+    // Install bindings early so they are definitely available.
+    // When run by webpack in next this is already done with correct configuration so this is a no-op.
+    // In turbopack loaders are run in a subprocess so it may or may not be done.
+    await (0, _installbindings.installBindings)();
+    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);
+};
+const _default = NextBarrelLoader;
+
+//# sourceMappingURL=next-barrel-loader.js.map

node_modules/next/dist/build/webpack/loaders/next-client-pages-loader.d.ts

@@ -0,0 +1,6 @@
+export type ClientPagesLoaderOptions = {
+    absolutePagePath: string;
+    page: string;
+};
+declare function nextClientPagesLoader(this: any): any;
+export default nextClientPagesLoader;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _stringifyrequest = require("../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 = (0, _stringifyrequest.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}])
+      });
+    }
+  `;
+    });
+}
+const _default = nextClientPagesLoader;
+
+//# sourceMappingURL=next-client-pages-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-client-pages-loader.ts"],"sourcesContent":["import { stringifyRequest } from '../stringify-request'\n\nexport type ClientPagesLoaderOptions = {\n  absolutePagePath: string\n  page: string\n}\n\n// this parameter: https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters\nfunction nextClientPagesLoader(this: any) {\n  const pagesLoaderSpan = this.currentTraceSpan.traceChild(\n    'next-client-pages-loader'\n  )\n\n  return pagesLoaderSpan.traceFn(() => {\n    const { absolutePagePath, page } =\n      this.getOptions() as ClientPagesLoaderOptions\n\n    pagesLoaderSpan.setAttribute('absolutePagePath', absolutePagePath)\n\n    const stringifiedPageRequest = stringifyRequest(this, absolutePagePath)\n    const stringifiedPage = JSON.stringify(page)\n\n    return `\n    (window.__NEXT_P = window.__NEXT_P || []).push([\n      ${stringifiedPage},\n      function () {\n        return require(${stringifiedPageRequest});\n      }\n    ]);\n    if(module.hot) {\n      module.hot.dispose(function () {\n        window.__NEXT_P.push([${stringifiedPage}])\n      });\n    }\n  `\n  })\n}\n\nexport default nextClientPagesLoader\n"],"names":["nextClientPagesLoader","pagesLoaderSpan","currentTraceSpan","traceChild","traceFn","absolutePagePath","page","getOptions","setAttribute","stringifiedPageRequest","stringifyRequest","stringifiedPage","JSON","stringify"],"mappings":";;;;+BAsCA;;;eAAA;;;kCAtCiC;AAOjC,8FAA8F;AAC9F,SAASA;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,yBAAyBC,IAAAA,kCAAgB,EAAC,IAAI,EAAEL;QACtD,MAAMM,kBAAkBC,KAAKC,SAAS,CAACP;QAEvC,OAAO,CAAC;;MAEN,EAAEK,gBAAgB;;uBAED,EAAEF,uBAAuB;;;;;8BAKlB,EAAEE,gBAAgB;;;EAG9C,CAAC;IACD;AACF;MAEA,WAAeX","ignoreList":[0]}

node_modules/next/dist/build/webpack/loaders/next-edge-app-route-loader/index.d.ts

@@ -0,0 +1,12 @@
+import type { webpack } from 'next/dist/compiled/webpack/webpack';
+export type EdgeAppRouteLoaderQuery = {
+    absolutePagePath: string;
+    page: string;
+    appDirLoader: string;
+    preferredRegion: string | string[] | undefined;
+    middlewareConfig: string;
+    cacheHandler?: string;
+    cacheHandlers: string;
+};
+declare const EdgeAppRouteLoader: webpack.LoaderDefinitionFunction<EdgeAppRouteLoaderQuery>;
+export default EdgeAppRouteLoader;

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _getmodulebuildinfo = require("../get-module-build-info");
+const _stringifyrequest = require("../../stringify-request");
+const _constants = require("../../../../lib/constants");
+const _loadentrypoint = require("../../../load-entrypoint");
+const _ismetadataroute = require("../../../../lib/metadata/is-metadata-route");
+function getCacheHandlersSetup(cacheHandlersStringified, contextifyImportPath) {
+    const cacheHandlers = JSON.parse(cacheHandlersStringified || '{}');
+    const definedCacheHandlers = Object.entries(cacheHandlers).filter((entry)=>Boolean(entry[1]));
+    const cacheHandlerImports = [];
+    const edgeCacheHandlersRegistration = [];
+    for (const [index, [kind, handlerPath]] of definedCacheHandlers.entries()){
+        const cacheHandlerVarName = `edgeCacheHandler_${index}`;
+        const cacheHandlerImportPath = contextifyImportPath(handlerPath);
+        cacheHandlerImports.push(`import ${cacheHandlerVarName} from ${JSON.stringify(cacheHandlerImportPath)}`);
+        edgeCacheHandlersRegistration.push(`edgeCacheHandlers[${JSON.stringify(kind)}] = ${cacheHandlerVarName}`);
+    }
+    return {
+        cacheHandlerImports: cacheHandlerImports.join('\n') || '\n',
+        edgeCacheHandlersRegistration: edgeCacheHandlersRegistration.join('\n') || '\n'
+    };
+}
+const EdgeAppRouteLoader = async function() {
+    const { page, absolutePagePath, preferredRegion, appDirLoader: appDirLoaderBase64 = '', middlewareConfig: middlewareConfigBase64 = '', cacheHandler, cacheHandlers: cacheHandlersStringified } = this.getOptions();
+    const appDirLoader = Buffer.from(appDirLoaderBase64, 'base64').toString();
+    const middlewareConfig = JSON.parse(Buffer.from(middlewareConfigBase64, 'base64').toString());
+    const cacheHandlersSetup = getCacheHandlersSetup(cacheHandlersStringified, (handlerPath)=>this.utils.contextify(this.context || this.rootContext, handlerPath));
+    const incrementalCacheHandler = cacheHandler ? this.utils.contextify(this.context || this.rootContext, cacheHandler) : null;
+    // Ensure we only run this loader for as a module.
+    if (!this._module) throw Object.defineProperty(new Error('This loader is only usable as a module'), "__NEXT_ERROR_CODE", {
+        value: "E433",
+        enumerable: false,
+        configurable: true
+    });
+    const buildInfo = (0, _getmodulebuildinfo.getModuleBuildInfo)(this._module);
+    buildInfo.nextEdgeSSR = {
+        isServerComponent: !(0, _ismetadataroute.isMetadataRoute)(page),
+        page: page,
+        isAppDir: true
+    };
+    buildInfo.route = {
+        page,
+        absolutePagePath,
+        preferredRegion,
+        middlewareConfig
+    };
+    const stringifiedPagePath = (0, _stringifyrequest.stringifyRequest)(this, absolutePagePath);
+    const modulePath = `${appDirLoader}${stringifiedPagePath.substring(1, stringifiedPagePath.length - 1)}?${_constants.WEBPACK_RESOURCE_QUERIES.edgeSSREntry}`;
+    return await (0, _loadentrypoint.loadEntrypoint)('edge-app-route', {
+        VAR_USERLAND: modulePath,
+        VAR_PAGE: page
+    }, cacheHandlersSetup, {
+        incrementalCacheHandler
+    });
+};
+const _default = EdgeAppRouteLoader;
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/build/webpack/loaders/next-edge-function-loader.d.ts

@@ -0,0 +1,11 @@
+import type webpack from 'webpack';
+export type EdgeFunctionLoaderOptions = {
+    absolutePagePath: string;
+    page: string;
+    rootDir: string;
+    preferredRegion: string | string[] | undefined;
+    middlewareConfig: string;
+    cacheHandler?: string;
+};
+declare const nextEdgeFunctionLoader: webpack.LoaderDefinitionFunction<EdgeFunctionLoaderOptions>;
+export default nextEdgeFunctionLoader;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _getmodulebuildinfo = require("./get-module-build-info");
+const _stringifyrequest = require("../stringify-request");
+const nextEdgeFunctionLoader = function nextEdgeFunctionLoader() {
+    const { absolutePagePath, page, rootDir, preferredRegion, middlewareConfig: middlewareConfigBase64, cacheHandler } = this.getOptions();
+    const stringifiedPagePath = (0, _stringifyrequest.stringifyRequest)(this, absolutePagePath);
+    const stringifiedCacheHandlerPath = cacheHandler ? (0, _stringifyrequest.stringifyRequest)(this, cacheHandler) : null;
+    const buildInfo = (0, _getmodulebuildinfo.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'
+        ${stringifiedCacheHandlerPath ? `import incrementalCacheHandler from ${stringifiedCacheHandlerPath}` : 'const incrementalCacheHandler = null'}
+
+        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,
+              incrementalCacheHandler,
+              page: ${JSON.stringify(page)},
+              handler: wrapApiHandler(${JSON.stringify(page)}, handler),
+          })
+        }
+    `;
+};
+const _default = nextEdgeFunctionLoader;
+
+//# sourceMappingURL=next-edge-function-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-edge-function-loader.ts"],"sourcesContent":["import type webpack from 'webpack'\nimport { getModuleBuildInfo } from './get-module-build-info'\nimport { stringifyRequest } from '../stringify-request'\nimport type { ProxyConfig } from '../../analysis/get-page-static-info'\n\nexport type EdgeFunctionLoaderOptions = {\n  absolutePagePath: string\n  page: string\n  rootDir: string\n  preferredRegion: string | string[] | undefined\n  middlewareConfig: string\n  cacheHandler?: string\n}\n\nconst nextEdgeFunctionLoader: webpack.LoaderDefinitionFunction<EdgeFunctionLoaderOptions> =\n  function nextEdgeFunctionLoader(this) {\n    const {\n      absolutePagePath,\n      page,\n      rootDir,\n      preferredRegion,\n      middlewareConfig: middlewareConfigBase64,\n      cacheHandler,\n    }: EdgeFunctionLoaderOptions = this.getOptions()\n    const stringifiedPagePath = stringifyRequest(this, absolutePagePath)\n    const stringifiedCacheHandlerPath = cacheHandler\n      ? stringifyRequest(this, cacheHandler)\n      : null\n    const buildInfo = getModuleBuildInfo(this._module as any)\n    const middlewareConfig: ProxyConfig = JSON.parse(\n      Buffer.from(middlewareConfigBase64, 'base64').toString()\n    )\n    buildInfo.route = {\n      page: page || '/',\n      absolutePagePath,\n      preferredRegion,\n      middlewareConfig,\n    }\n    buildInfo.nextEdgeApiFunction = {\n      page: page || '/',\n    }\n    buildInfo.rootDir = rootDir\n\n    return `\n        import 'next/dist/esm/server/web/globals'\n        import { adapter } from 'next/dist/esm/server/web/adapter'\n        import { IncrementalCache } from 'next/dist/esm/server/lib/incremental-cache'\n        import { wrapApiHandler } from 'next/dist/esm/server/api-utils'\n        ${\n          stringifiedCacheHandlerPath\n            ? `import incrementalCacheHandler from ${stringifiedCacheHandlerPath}`\n            : 'const incrementalCacheHandler = null'\n        }\n\n        import handler from ${stringifiedPagePath}\n\n        if (typeof handler !== 'function') {\n          throw new Error('The Edge Function \"pages${page}\" must export a \\`default\\` function');\n        }\n\n        export default function nHandler (opts) {\n          return adapter({\n              ...opts,\n              IncrementalCache,\n              incrementalCacheHandler,\n              page: ${JSON.stringify(page)},\n              handler: wrapApiHandler(${JSON.stringify(page)}, handler),\n          })\n        }\n    `\n  }\n\nexport default nextEdgeFunctionLoader\n"],"names":["nextEdgeFunctionLoader","absolutePagePath","page","rootDir","preferredRegion","middlewareConfig","middlewareConfigBase64","cacheHandler","getOptions","stringifiedPagePath","stringifyRequest","stringifiedCacheHandlerPath","buildInfo","getModuleBuildInfo","_module","JSON","parse","Buffer","from","toString","route","nextEdgeApiFunction","stringify"],"mappings":";;;;+BAwEA;;;eAAA;;;oCAvEmC;kCACF;AAYjC,MAAMA,yBACJ,SAASA;IACP,MAAM,EACJC,gBAAgB,EAChBC,IAAI,EACJC,OAAO,EACPC,eAAe,EACfC,kBAAkBC,sBAAsB,EACxCC,YAAY,EACb,GAA8B,IAAI,CAACC,UAAU;IAC9C,MAAMC,sBAAsBC,IAAAA,kCAAgB,EAAC,IAAI,EAAET;IACnD,MAAMU,8BAA8BJ,eAChCG,IAAAA,kCAAgB,EAAC,IAAI,EAAEH,gBACvB;IACJ,MAAMK,YAAYC,IAAAA,sCAAkB,EAAC,IAAI,CAACC,OAAO;IACjD,MAAMT,mBAAgCU,KAAKC,KAAK,CAC9CC,OAAOC,IAAI,CAACZ,wBAAwB,UAAUa,QAAQ;IAExDP,UAAUQ,KAAK,GAAG;QAChBlB,MAAMA,QAAQ;QACdD;QACAG;QACAC;IACF;IACAO,UAAUS,mBAAmB,GAAG;QAC9BnB,MAAMA,QAAQ;IAChB;IACAU,UAAUT,OAAO,GAAGA;IAEpB,OAAO,CAAC;;;;;QAKJ,EACEQ,8BACI,CAAC,oCAAoC,EAAEA,6BAA6B,GACpE,uCACL;;4BAEmB,EAAEF,oBAAoB;;;mDAGC,EAAEP,KAAK;;;;;;;;oBAQtC,EAAEa,KAAKO,SAAS,CAACpB,MAAM;sCACL,EAAEa,KAAKO,SAAS,CAACpB,MAAM;;;IAGzD,CAAC;AACH;MAEF,WAAeF","ignoreList":[0]}

node_modules/next/dist/build/webpack/loaders/next-edge-ssr-loader/index.d.ts

@@ -0,0 +1,26 @@
+import type webpack from 'webpack';
+import type { SizeLimit } from '../../../../types';
+import type { PAGE_TYPES } from '../../../../lib/page-types';
+export type EdgeSSRLoaderQuery = {
+    absolute500Path: string;
+    absoluteAppPath: string;
+    absoluteDocumentPath: string;
+    absoluteErrorPath: string;
+    absolutePagePath: string;
+    dev: boolean;
+    isServerComponent: boolean;
+    page: string;
+    appDirLoader?: string;
+    pagesType: PAGE_TYPES;
+    sriEnabled: boolean;
+    cacheHandler?: string;
+    cacheHandlers?: string;
+    preferredRegion: string | string[] | undefined;
+    middlewareConfig: string;
+    serverActions?: {
+        bodySizeLimit?: SizeLimit;
+        allowedOrigins?: string[];
+    };
+};
+declare const edgeSSRLoader: webpack.LoaderDefinitionFunction<EdgeSSRLoaderQuery>;
+export default edgeSSRLoader;

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _getmodulebuildinfo = require("../get-module-build-info");
+const _constants = require("../../../../lib/constants");
+const _routekind = require("../../../../server/route-kind");
+const _normalizepagepath = require("../../../../shared/lib/page-path/normalize-page-path");
+const _loadentrypoint = require("../../../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.RouteKind.PAGES,
+            page: (0, _normalizepagepath.normalizePagePath)(page),
+            pathname: page,
+            // The following aren't used in production.
+            bundlePath: '',
+            filename: ''
+        }
+    };
+    return options;
+}
+function getCacheHandlersSetup(cacheHandlersStringified, contextifyImportPath) {
+    const cacheHandlers = JSON.parse(cacheHandlersStringified || '{}');
+    const definedCacheHandlers = Object.entries(cacheHandlers).filter((entry)=>Boolean(entry[1]));
+    const cacheHandlerImports = [];
+    const cacheHandlerRegistration = [];
+    for (const [index, [kind, handlerPath]] of definedCacheHandlers.entries()){
+        const cacheHandlerVarName = `edgeCacheHandler_${index}`;
+        const cacheHandlerImportPath = contextifyImportPath(handlerPath);
+        cacheHandlerImports.push(`import ${cacheHandlerVarName} from ${JSON.stringify(cacheHandlerImportPath)}`);
+        cacheHandlerRegistration.push(`  cacheHandlers.setCacheHandler(${JSON.stringify(kind)}, ${cacheHandlerVarName})`);
+    }
+    return {
+        cacheHandlerImports: cacheHandlerImports.join('\n') || '\n',
+        cacheHandlerRegistration: cacheHandlerRegistration.join('\n') || '\n'
+    };
+}
+const edgeSSRLoader = async function edgeSSRLoader() {
+    const { page, absolutePagePath, absoluteAppPath, absoluteDocumentPath, absolute500Path, absoluteErrorPath, isServerComponent, appDirLoader: appDirLoaderBase64, pagesType, cacheHandler, cacheHandlers: cacheHandlersStringified, preferredRegion, middlewareConfig: middlewareConfigBase64 } = this.getOptions();
+    const cacheHandlersSetup = getCacheHandlersSetup(cacheHandlersStringified, (handlerPath)=>this.utils.contextify(this.context || this.rootContext, handlerPath));
+    const incrementalCacheHandler = cacheHandler ? this.utils.contextify(this.context || this.rootContext, cacheHandler) : null;
+    const middlewareConfig = JSON.parse(Buffer.from(middlewareConfigBase64, 'base64').toString());
+    const appDirLoader = Buffer.from(appDirLoaderBase64 || '', 'base64').toString();
+    const isAppDir = pagesType === 'app';
+    const buildInfo = (0, _getmodulebuildinfo.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 = absoluteAppPath ? this.utils.contextify(this.context || this.rootContext, swapDistFolderWithEsmDistFolder(absoluteAppPath)) : '';
+    const errorPath = absoluteErrorPath ? this.utils.contextify(this.context || this.rootContext, swapDistFolderWithEsmDistFolder(absoluteErrorPath)) : '';
+    const documentPath = absoluteDocumentPath ? 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 ? `?${_constants.WEBPACK_RESOURCE_QUERIES.edgeSSREntry}` : ''}`;
+    if (isAppDir) {
+        return await (0, _loadentrypoint.loadEntrypoint)('edge-ssr-app', {
+            VAR_USERLAND: pageModPath,
+            VAR_PAGE: page
+        }, cacheHandlersSetup, {
+            incrementalCacheHandler
+        });
+    } else {
+        return await (0, _loadentrypoint.loadEntrypoint)('edge-ssr', {
+            VAR_USERLAND: pageModPath,
+            VAR_DEFINITION_PATHNAME: page,
+            VAR_MODULE_DOCUMENT: documentPath,
+            VAR_MODULE_APP: appPath,
+            VAR_MODULE_GLOBAL_ERROR: errorPath
+        }, {
+            pageRouteModuleOptions: JSON.stringify(getRouteModuleOptions(page)),
+            errorRouteModuleOptions: JSON.stringify(getRouteModuleOptions('/_error')),
+            user500RouteModuleOptions: JSON.stringify(getRouteModuleOptions('/500')),
+            ...cacheHandlersSetup ?? {}
+        }, {
+            userland500Page: userland500Path,
+            incrementalCacheHandler
+        });
+    }
+};
+const _default = edgeSSRLoader;
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/build/webpack/loaders/next-error-browser-binary-loader.d.ts

@@ -0,0 +1,2 @@
+import type { webpack } from 'next/dist/compiled/webpack/webpack';
+export default function nextErrorBrowserBinaryLoader(this: webpack.LoaderContext<any>): void;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return nextErrorBrowserBinaryLoader;
+    }
+});
+function nextErrorBrowserBinaryLoader() {
+    const { resourcePath, rootContext } = this;
+    const relativePath = resourcePath.slice(rootContext.length + 1);
+    throw Object.defineProperty(new Error(`Node.js binary module ./${relativePath} is not supported in the browser. Please only use the module on server side`), "__NEXT_ERROR_CODE", {
+        value: "E79",
+        enumerable: false,
+        configurable: true
+    });
+}
+
+//# sourceMappingURL=next-error-browser-binary-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-error-browser-binary-loader.ts"],"sourcesContent":["import type { webpack } from 'next/dist/compiled/webpack/webpack'\n\nexport default function nextErrorBrowserBinaryLoader(\n  this: webpack.LoaderContext<any>\n) {\n  const { resourcePath, rootContext } = this\n  const relativePath = resourcePath.slice(rootContext.length + 1)\n  throw new Error(\n    `Node.js binary module ./${relativePath} is not supported in the browser. Please only use the module on server side`\n  )\n}\n"],"names":["nextErrorBrowserBinaryLoader","resourcePath","rootContext","relativePath","slice","length","Error"],"mappings":";;;;+BAEA;;;eAAwBA;;;AAAT,SAASA;IAGtB,MAAM,EAAEC,YAAY,EAAEC,WAAW,EAAE,GAAG,IAAI;IAC1C,MAAMC,eAAeF,aAAaG,KAAK,CAACF,YAAYG,MAAM,GAAG;IAC7D,MAAM,qBAEL,CAFK,IAAIC,MACR,CAAC,wBAAwB,EAAEH,aAAa,2EAA2E,CAAC,GADhH,qBAAA;eAAA;oBAAA;sBAAA;IAEN;AACF","ignoreList":[0]}

node_modules/next/dist/build/webpack/loaders/next-flight-action-entry-loader.d.ts

@@ -0,0 +1,14 @@
+import type { webpack } from 'next/dist/compiled/webpack/webpack';
+export type NextFlightActionEntryLoaderOptions = {
+    actions: string;
+};
+export type FlightActionEntryLoaderActions = [
+    path: string,
+    actions: {
+        id: string;
+        exportedName?: string;
+        filename?: string;
+    }[]
+][];
+declare function nextFlightActionEntryLoader(this: webpack.LoaderContext<NextFlightActionEntryLoaderOptions>): string;
+export default nextFlightActionEntryLoader;

node_modules/next/dist/build/webpack/loaders/next-flight-action-entry-loader.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+function nextFlightActionEntryLoader() {
+    const { actions } = this.getOptions();
+    const actionList = JSON.parse(actions);
+    const individualActions = actionList.map(([path, actionsFromModule])=>{
+        return actionsFromModule.map(({ id, exportedName })=>{
+            return [
+                id,
+                path,
+                exportedName
+            ];
+        });
+    }).flat();
+    return `
+${individualActions.map(([id, path, exportedName])=>{
+        // Re-export the same functions from the original module path as action IDs.
+        return `export { ${exportedName} as "${id}" } from ${JSON.stringify(path)}`;
+    }).join('\n')}
+`;
+}
+const _default = nextFlightActionEntryLoader;
+
+//# sourceMappingURL=next-flight-action-entry-loader.js.map

node_modules/next/dist/build/webpack/loaders/next-flight-action-entry-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-flight-action-entry-loader.ts"],"sourcesContent":["import type { webpack } from 'next/dist/compiled/webpack/webpack'\n\nexport type NextFlightActionEntryLoaderOptions = {\n  actions: string\n}\n\nexport type FlightActionEntryLoaderActions = [\n  path: string,\n  actions: { id: string; exportedName?: string; filename?: string }[],\n][]\n\nfunction nextFlightActionEntryLoader(\n  this: webpack.LoaderContext<NextFlightActionEntryLoaderOptions>\n) {\n  const { actions }: NextFlightActionEntryLoaderOptions = this.getOptions()\n\n  const actionList = JSON.parse(actions) as FlightActionEntryLoaderActions\n  const individualActions = actionList\n    .map(([path, actionsFromModule]) => {\n      return actionsFromModule.map(({ id, exportedName }) => {\n        return [id, path, exportedName] as const\n      })\n    })\n    .flat()\n\n  return `\n${individualActions\n  .map(([id, path, exportedName]) => {\n    // Re-export the same functions from the original module path as action IDs.\n    return `export { ${exportedName} as \"${id}\" } from ${JSON.stringify(path)}`\n  })\n  .join('\\n')}\n`\n}\n\nexport default nextFlightActionEntryLoader\n"],"names":["nextFlightActionEntryLoader","actions","getOptions","actionList","JSON","parse","individualActions","map","path","actionsFromModule","id","exportedName","flat","stringify","join"],"mappings":";;;;+BAmCA;;;eAAA;;;AAxBA,SAASA;IAGP,MAAM,EAAEC,OAAO,EAAE,GAAuC,IAAI,CAACC,UAAU;IAEvE,MAAMC,aAAaC,KAAKC,KAAK,CAACJ;IAC9B,MAAMK,oBAAoBH,WACvBI,GAAG,CAAC,CAAC,CAACC,MAAMC,kBAAkB;QAC7B,OAAOA,kBAAkBF,GAAG,CAAC,CAAC,EAAEG,EAAE,EAAEC,YAAY,EAAE;YAChD,OAAO;gBAACD;gBAAIF;gBAAMG;aAAa;QACjC;IACF,GACCC,IAAI;IAEP,OAAO,CAAC;AACV,EAAEN,kBACCC,GAAG,CAAC,CAAC,CAACG,IAAIF,MAAMG,aAAa;QAC5B,4EAA4E;QAC5E,OAAO,CAAC,SAAS,EAAEA,aAAa,KAAK,EAAED,GAAG,SAAS,EAAEN,KAAKS,SAAS,CAACL,OAAO;IAC7E,GACCM,IAAI,CAAC,MAAM;AACd,CAAC;AACD;MAEA,WAAed","ignoreList":[0]}

node_modules/next/dist/build/webpack/loaders/next-flight-client-entry-loader.d.ts

@@ -0,0 +1,16 @@
+import type { webpack } from 'next/dist/compiled/webpack/webpack';
+/**
+ * { [client import path]: [exported names] }
+ */
+export type ClientComponentImports = Record<string, Set<string>>;
+export type CssImports = Record<string, string[]>;
+export type NextFlightClientEntryLoaderOptions = {
+    modules: string[] | string;
+    /** This is transmitted as a string to `getOptions` */
+    server: boolean | 'true' | 'false';
+};
+export type FlightClientEntryModuleItem = {
+    request: string;
+    ids: string[];
+};
+export default function transformSource(this: webpack.LoaderContext<NextFlightClientEntryLoaderOptions>): string;

node_modules/next/dist/build/webpack/loaders/next-flight-client-entry-loader.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return transformSource;
+    }
+});
+const _constants = require("../../../shared/lib/constants");
+const _getmodulebuildinfo = require("./get-module-build-info");
+const _utils = require("./utils");
+function transformSource() {
+    let { modules, server } = this.getOptions();
+    const isServer = server === 'true';
+    if (!Array.isArray(modules)) {
+        modules = modules ? [
+            modules
+        ] : [];
+    }
+    const code = modules.map((x)=>JSON.parse(x))// Filter out CSS files in the SSR compilation
+    .filter(({ request })=>isServer ? !_utils.regexCSS.test(request) : true).map(({ request, ids })=>{
+        const importPath = JSON.stringify(request.startsWith(_constants.BARREL_OPTIMIZATION_PREFIX) ? request.replace(':', '!=!') : request);
+        // When we cannot determine the export names, we use eager mode to include the whole module.
+        // Otherwise, we use eager mode with webpackExports to only include the necessary exports.
+        // If we have '*' in the ids, we include all the imports
+        if (ids.length === 0 || ids.includes('*')) {
+            return `import(/* webpackMode: "eager" */ ${importPath});\n`;
+        } else {
+            return `import(/* webpackMode: "eager", webpackExports: ${JSON.stringify(ids)} */ ${importPath});\n`;
+        }
+    }).join(';\n');
+    const buildInfo = (0, _getmodulebuildinfo.getModuleBuildInfo)(this._module);
+    buildInfo.rsc = {
+        type: _constants.RSC_MODULE_TYPES.client
+    };
+    if (process.env.BUILTIN_FLIGHT_CLIENT_ENTRY_PLUGIN) {
+        const rscModuleInformationJson = JSON.stringify(buildInfo.rsc);
+        return `/* __rspack_internal_rsc_module_information_do_not_use__ ${rscModuleInformationJson} */\n` + code;
+    }
+    return code;
+}
+
+//# sourceMappingURL=next-flight-client-entry-loader.js.map