main repo

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/metadata/discover.ts"],"names":["path","stringify","STATIC_METADATA_IMAGES","WEBPACK_RESOURCE_QUERIES","METADATA_TYPE","enumMetadataFiles","dir","filename","extensions","metadataResolver","numericSuffix","collectedFiles","possibleFileNames","concat","Array","fill","map","_","index","name","resolved","push","createStaticMetadataFromRoute","resolvedDir","segment","isRootLayoutOrRootPage","pageExtensions","basePath","hasStaticMetadataFiles","staticImagesMetadata","icon","apple","twitter","openGraph","manifest","undefined","collectIconModuleIfExists","type","staticManifestExtension","manifestFile","length","ext","parse","extension","includes","slice","JSON","resolvedMetadataFiles","sort","a","b","localeCompare","forEach","filepath","imageModuleImportSource","metadata","imageModule","unshift","createMetadataExportsCode","join"],"mappings":"AAIA,OAAOA,UAAU,OAAM;AACvB,SAASC,SAAS,QAAQ,cAAa;AACvC,SAASC,sBAAsB,QAAQ,6CAA4C;AACnF,SAASC,wBAAwB,QAAQ,4BAA2B;AAGpE,MAAMC,gBAAgB;AAEtB,mGAAmG;AACnG,eAAeC,kBACbC,GAAW,EACXC,QAAgB,EAChBC,UAA6B,EAC7B,EACEC,gBAAgB,EAChB,uFAAuF;AACvFC,aAAa,EAId;IAED,MAAMC,iBAA2B,EAAE;IAEnC,MAAMC,oBAAoB;QAACL;KAAS,CAACM,MAAM,CACzCH,gBACII,MAAM,IACHC,IAAI,CAAC,GACLC,GAAG,CAAC,CAACC,GAAGC,QAAUX,WAAWW,SAChC,EAAE;IAER,KAAK,MAAMC,QAAQP,kBAAmB;QACpC,MAAMQ,WAAW,MAAMX,iBAAiBH,KAAKa,MAAMX;QACnD,IAAIY,UAAU;YACZT,eAAeU,IAAI,CAACD;QACtB;IACF;IAEA,OAAOT;AACT;AAEA,OAAO,eAAeW,8BACpBC,WAAmB,EACnB,EACEC,OAAO,EACPf,gBAAgB,EAChBgB,sBAAsB,EACtBC,cAAc,EACdC,QAAQ,EAOT;IAED,IAAIC,yBAAyB;IAC7B,MAAMC,uBAA2C;QAC/CC,MAAM,EAAE;QACRC,OAAO,EAAE;QACTC,SAAS,EAAE;QACXC,WAAW,EAAE;QACbC,UAAUC;IACZ;IAEA,eAAeC,0BACbC,IAA8C;QAE9C,IAAIA,SAAS,YAAY;YACvB,MAAMC,0BAA0B;gBAAC;gBAAe;aAAO;YACvD,MAAMC,eAAe,MAAMlC,kBACzBkB,aACA,YACAe,wBAAwBzB,MAAM,CAACa,iBAC/B;gBAAEjB;gBAAkBC,eAAe;YAAM;YAE3C,IAAI6B,aAAaC,MAAM,GAAG,GAAG;gBAC3BZ,yBAAyB;gBACzB,MAAM,EAAET,IAAI,EAAEsB,GAAG,EAAE,GAAGzC,KAAK0C,KAAK,CAACH,YAAY,CAAC,EAAE;gBAChD,MAAMI,YAAYL,wBAAwBM,QAAQ,CAACH,IAAII,KAAK,CAAC,MACzDJ,IAAII,KAAK,CAAC,KACV;gBACJhB,qBAAqBK,QAAQ,GAAGY,KAAK7C,SAAS,CAAC,CAAC,CAAC,EAAEkB,KAAK,CAAC,EAAEwB,UAAU,CAAC;YACxE;YACA;QACF;QAEA,MAAMI,wBAAwB,MAAM1C,kBAClCkB,aACArB,sBAAsB,CAACmC,KAAK,CAAC9B,QAAQ,EACrC;eACKL,sBAAsB,CAACmC,KAAK,CAAC7B,UAAU;eACtC6B,SAAS,YAAY,EAAE,GAAGX;SAC/B,EACD;YAAEjB;YAAkBC,eAAe;QAAK;QAE1CqC,sBACGC,IAAI,CAAC,CAACC,GAAGC,IAAMD,EAAEE,aAAa,CAACD,IAC/BE,OAAO,CAAC,CAACC;YACR,MAAMC,0BAA0B,CAAC,2BAA2B,EAAErD,UAC5D;gBACEoC;gBACAb;gBACAG;gBACAD;YACF,GAEA,CAAC,EAAE2B,SAAS,CAAC,EAAElD,yBAAyBoD,QAAQ,CAAC,CAAC;YAEpD,MAAMC,cAAc,CAAC,2DAA2D,EAAEV,KAAK7C,SAAS,CAC9FqD,yBACA,kBAAkB,CAAC;YACrB1B,yBAAyB;YACzB,IAAIS,SAAS,WAAW;gBACtBR,qBAAqBC,IAAI,CAAC2B,OAAO,CAACD;YACpC,OAAO;gBACL3B,oBAAoB,CAACQ,KAAK,CAAChB,IAAI,CAACmC;YAClC;QACF;IACJ;IAEA,iEAAiE;IACjE,MAAMpB,0BAA0B;IAChC,MAAMA,0BAA0B;IAChC,MAAMA,0BAA0B;IAChC,MAAMA,0BAA0B;IAChC,IAAIX,wBAAwB;QAC1B,MAAMW,0BAA0B;QAChC,MAAMA,0BAA0B;IAClC;IAEA,OAAOR,yBAAyBC,uBAAuB;AACzD;AAEA,OAAO,SAAS6B,0BACdH,QAAmE;IAEnE,OAAOA,WACH,CAAC,EAAEnD,cAAc;WACZ,EAAEmD,SAASzB,IAAI,CAAC6B,IAAI,CAAC,KAAK;YACzB,EAAEJ,SAASxB,KAAK,CAAC4B,IAAI,CAAC,KAAK;gBACvB,EAAEJ,SAAStB,SAAS,CAAC0B,IAAI,CAAC,KAAK;cACjC,EAAEJ,SAASvB,OAAO,CAAC2B,IAAI,CAAC,KAAK;cAC7B,EAAEJ,SAASrB,QAAQ,GAAGqB,SAASrB,QAAQ,GAAG,YAAY;GACjE,CAAC,GACE;AACN"}

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

@@ -0,0 +1,84 @@
+import { resolveArray } from "../../../../lib/metadata/generate/utils";
+// convert robots data to txt string
+export function resolveRobots(data) {
+    let content = "";
+    const rules = Array.isArray(data.rules) ? data.rules : [
+        data.rules
+    ];
+    for (const rule of rules){
+        const userAgent = resolveArray(rule.userAgent || [
+            "*"
+        ]);
+        for (const agent of userAgent){
+            content += `User-Agent: ${agent}\n`;
+        }
+        if (rule.allow) {
+            const allow = resolveArray(rule.allow);
+            for (const item of allow){
+                content += `Allow: ${item}\n`;
+            }
+        }
+        if (rule.disallow) {
+            const disallow = resolveArray(rule.disallow);
+            for (const item of disallow){
+                content += `Disallow: ${item}\n`;
+            }
+        }
+        if (rule.crawlDelay) {
+            content += `Crawl-delay: ${rule.crawlDelay}\n`;
+        }
+        content += "\n";
+    }
+    if (data.host) {
+        content += `Host: ${data.host}\n`;
+    }
+    if (data.sitemap) {
+        const sitemap = resolveArray(data.sitemap);
+        // TODO-METADATA: support injecting sitemap url into robots.txt
+        sitemap.forEach((item)=>{
+            content += `Sitemap: ${item}\n`;
+        });
+    }
+    return content;
+}
+// TODO-METADATA: support multi sitemap files
+// convert sitemap data to xml string
+export function resolveSitemap(data) {
+    let content = "";
+    content += '<?xml version="1.0" encoding="UTF-8"?>\n';
+    content += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n';
+    for (const item of data){
+        content += "<url>\n";
+        content += `<loc>${item.url}</loc>\n`;
+        if (item.lastModified) {
+            const serializedDate = item.lastModified instanceof Date ? item.lastModified.toISOString() : item.lastModified;
+            content += `<lastmod>${serializedDate}</lastmod>\n`;
+        }
+        if (item.changeFrequency) {
+            content += `<changefreq>${item.changeFrequency}</changefreq>\n`;
+        }
+        if (typeof item.priority === "number") {
+            content += `<priority>${item.priority}</priority>\n`;
+        }
+        content += "</url>\n";
+    }
+    content += "</urlset>\n";
+    return content;
+}
+export function resolveManifest(data) {
+    return JSON.stringify(data);
+}
+export function resolveRouteData(data, fileType) {
+    if (fileType === "robots") {
+        return resolveRobots(data);
+    }
+    if (fileType === "sitemap") {
+        return resolveSitemap(data);
+    }
+    if (fileType === "manifest") {
+        return resolveManifest(data);
+    }
+    return "";
+}
+
+//# sourceMappingURL=resolve-route-data.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/metadata/resolve-route-data.ts"],"names":["resolveArray","resolveRobots","data","content","rules","Array","isArray","rule","userAgent","agent","allow","item","disallow","crawlDelay","host","sitemap","forEach","resolveSitemap","url","lastModified","serializedDate","Date","toISOString","changeFrequency","priority","resolveManifest","JSON","stringify","resolveRouteData","fileType"],"mappings":"AACA,SAASA,YAAY,QAAQ,0CAAyC;AAEtE,oCAAoC;AACpC,OAAO,SAASC,cAAcC,IAA0B;IACtD,IAAIC,UAAU;IACd,MAAMC,QAAQC,MAAMC,OAAO,CAACJ,KAAKE,KAAK,IAAIF,KAAKE,KAAK,GAAG;QAACF,KAAKE,KAAK;KAAC;IACnE,KAAK,MAAMG,QAAQH,MAAO;QACxB,MAAMI,YAAYR,aAAaO,KAAKC,SAAS,IAAI;YAAC;SAAI;QACtD,KAAK,MAAMC,SAASD,UAAW;YAC7BL,WAAW,CAAC,YAAY,EAAEM,MAAM,EAAE,CAAC;QACrC;QACA,IAAIF,KAAKG,KAAK,EAAE;YACd,MAAMA,QAAQV,aAAaO,KAAKG,KAAK;YACrC,KAAK,MAAMC,QAAQD,MAAO;gBACxBP,WAAW,CAAC,OAAO,EAAEQ,KAAK,EAAE,CAAC;YAC/B;QACF;QACA,IAAIJ,KAAKK,QAAQ,EAAE;YACjB,MAAMA,WAAWZ,aAAaO,KAAKK,QAAQ;YAC3C,KAAK,MAAMD,QAAQC,SAAU;gBAC3BT,WAAW,CAAC,UAAU,EAAEQ,KAAK,EAAE,CAAC;YAClC;QACF;QACA,IAAIJ,KAAKM,UAAU,EAAE;YACnBV,WAAW,CAAC,aAAa,EAAEI,KAAKM,UAAU,CAAC,EAAE,CAAC;QAChD;QACAV,WAAW;IACb;IACA,IAAID,KAAKY,IAAI,EAAE;QACbX,WAAW,CAAC,MAAM,EAAED,KAAKY,IAAI,CAAC,EAAE,CAAC;IACnC;IACA,IAAIZ,KAAKa,OAAO,EAAE;QAChB,MAAMA,UAAUf,aAAaE,KAAKa,OAAO;QACzC,+DAA+D;QAC/DA,QAAQC,OAAO,CAAC,CAACL;YACfR,WAAW,CAAC,SAAS,EAAEQ,KAAK,EAAE,CAAC;QACjC;IACF;IAEA,OAAOR;AACT;AAEA,6CAA6C;AAC7C,qCAAqC;AACrC,OAAO,SAASc,eAAef,IAA2B;IACxD,IAAIC,UAAU;IACdA,WAAW;IACXA,WAAW;IAEX,KAAK,MAAMQ,QAAQT,KAAM;QACvBC,WAAW;QACXA,WAAW,CAAC,KAAK,EAAEQ,KAAKO,GAAG,CAAC,QAAQ,CAAC;QAErC,IAAIP,KAAKQ,YAAY,EAAE;YACrB,MAAMC,iBACJT,KAAKQ,YAAY,YAAYE,OACzBV,KAAKQ,YAAY,CAACG,WAAW,KAC7BX,KAAKQ,YAAY;YAEvBhB,WAAW,CAAC,SAAS,EAAEiB,eAAe,YAAY,CAAC;QACrD;QAEA,IAAIT,KAAKY,eAAe,EAAE;YACxBpB,WAAW,CAAC,YAAY,EAAEQ,KAAKY,eAAe,CAAC,eAAe,CAAC;QACjE;QAEA,IAAI,OAAOZ,KAAKa,QAAQ,KAAK,UAAU;YACrCrB,WAAW,CAAC,UAAU,EAAEQ,KAAKa,QAAQ,CAAC,aAAa,CAAC;QACtD;QAEArB,WAAW;IACb;IAEAA,WAAW;IAEX,OAAOA;AACT;AAEA,OAAO,SAASsB,gBAAgBvB,IAA4B;IAC1D,OAAOwB,KAAKC,SAAS,CAACzB;AACxB;AAEA,OAAO,SAAS0B,iBACd1B,IAA2E,EAC3E2B,QAA2C;IAE3C,IAAIA,aAAa,UAAU;QACzB,OAAO5B,cAAcC;IACvB;IACA,IAAI2B,aAAa,WAAW;QAC1B,OAAOZ,eAAef;IACxB;IACA,IAAI2B,aAAa,YAAY;QAC3B,OAAOJ,gBAAgBvB;IACzB;IACA,OAAO;AACT"}

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,157 @@
+/**
+ * ## 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.
+ */ const NextBarrelLoader = async function() {
+    this.async();
+    const { names, wildcard } = this.getOptions();
+    const source = await new Promise((resolve, reject)=>{
+        this.loadModule(`__barrel_transform__${wildcard ? "?wildcard" : ""}!=!${this.resourcePath}`, (err, src)=>{
+            if (err) {
+                reject(err);
+            } else {
+                resolve(src);
+            }
+        });
+    });
+    const matches = source.match(/^([^]*)export const __next_private_export_map__ = ('[^']+'|"[^"]+")/);
+    if (!matches) {
+        // 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 wildcardExports = [
+        ...source.matchAll(/export \* from "([^"]+)"/g)
+    ];
+    // It needs to keep the prefix for comments and directives like "use client".
+    const prefix = matches[1];
+    const exportList = JSON.parse(matches[2].slice(1, -1));
+    const exportMap = new Map();
+    for (const [name, path, orig] of exportList){
+        exportMap.set(name, [
+            path,
+            orig
+        ]);
+    }
+    let output = prefix;
+    let missedNames = [];
+    for (const name of names){
+        // If the name matches
+        if (exportMap.has(name)) {
+            const decl = exportMap.get(name);
+            // 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 (this.resourcePath).
+            if (wildcard && !decl[0]) {
+                // E.g. the file contains `export const a = 1`
+                decl[0] = this.resourcePath;
+                decl[1] = 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 match of wildcardExports){
+            const path = match[1];
+            output += `\nexport * from ${JSON.stringify(path.replace("__PLACEHOLDER__", missedNames.join(",") + "&wildcard"))}`;
+        }
+    }
+    this.callback(null, output);
+};
+export default NextBarrelLoader;
+
+//# sourceMappingURL=next-barrel-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-barrel-loader.ts"],"names":["NextBarrelLoader","async","names","wildcard","getOptions","source","Promise","resolve","reject","loadModule","resourcePath","err","src","matches","match","callback","JSON","stringify","wildcardExports","matchAll","prefix","exportList","parse","slice","exportMap","Map","name","path","orig","set","output","missedNames","has","decl","get","push","length","replace","join"],"mappings":"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"}

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,166 @@
+import { getModuleBuildInfo } from "../get-module-build-info";
+import { WEBPACK_RESOURCE_QUERIES } from "../../../../lib/constants";
+import { stringifyRequest } from "../../stringify-request";
+import { RouteKind } from "../../../../server/future/route-kind";
+import { normalizePagePath } from "../../../../shared/lib/page-path/normalize-page-path";
+/*
+For pages SSR'd at the edge, we bundle them with the ESM version of Next in order to
+benefit from the better tree-shaking and thus, smaller bundle sizes.
+
+The absolute paths for _app, _error and _document, used in this loader, link to the regular CJS modules.
+They are generated in `createPagesMapping` where we don't have access to `isEdgeRuntime`,
+so we have to do it here. It's not that bad because it keeps all references to ESM modules magic in this place.
+*/ function swapDistFolderWithEsmDistFolder(path) {
+    return path.replace("next/dist/pages", "next/dist/esm/pages");
+}
+function getRouteModuleOptions(page) {
+    const options = {
+        definition: {
+            kind: RouteKind.PAGES,
+            page: normalizePagePath(page),
+            pathname: page,
+            // The following aren't used in production.
+            bundlePath: "",
+            filename: ""
+        }
+    };
+    return options;
+}
+const edgeSSRLoader = function edgeSSRLoader() {
+    const { dev, page, buildId, absolutePagePath, absoluteAppPath, absoluteDocumentPath, absolute500Path, absoluteErrorPath, isServerComponent, stringifiedConfig: stringifiedConfigBase64, appDirLoader: appDirLoaderBase64, pagesType, sriEnabled, incrementalCacheHandlerPath, preferredRegion, middlewareConfig: middlewareConfigBase64, serverActionsBodySizeLimit } = this.getOptions();
+    const middlewareConfig = JSON.parse(Buffer.from(middlewareConfigBase64, "base64").toString());
+    const stringifiedConfig = Buffer.from(stringifiedConfigBase64 || "", "base64").toString();
+    const appDirLoader = Buffer.from(appDirLoaderBase64 || "", "base64").toString();
+    const isAppDir = pagesType === "app";
+    const buildInfo = getModuleBuildInfo(this._module);
+    buildInfo.nextEdgeSSR = {
+        // @ts-expect-error === 'true' is correct because loader options are serialized as searchParams. Type needs to be fixed somehow.
+        isServerComponent: isServerComponent === "true",
+        page: page,
+        isAppDir
+    };
+    buildInfo.route = {
+        page,
+        absolutePagePath,
+        preferredRegion,
+        middlewareConfig
+    };
+    const stringifiedPagePath = stringifyRequest(this, absolutePagePath);
+    const stringifiedAppPath = stringifyRequest(this, swapDistFolderWithEsmDistFolder(absoluteAppPath));
+    const stringifiedErrorPath = stringifyRequest(this, swapDistFolderWithEsmDistFolder(absoluteErrorPath));
+    const stringifiedDocumentPath = stringifyRequest(this, swapDistFolderWithEsmDistFolder(absoluteDocumentPath));
+    const stringified500Path = absolute500Path ? stringifyRequest(this, absolute500Path) : null;
+    const pageModPath = `${appDirLoader}${stringifiedPagePath.substring(1, stringifiedPagePath.length - 1)}${isAppDir ? `?${WEBPACK_RESOURCE_QUERIES.edgeSSREntry}` : ""}`;
+    const transformed = `
+    import 'next/dist/esm/server/web/globals'
+    import { adapter } from 'next/dist/esm/server/web/adapter'
+    import { getRender } from 'next/dist/esm/build/webpack/loaders/next-edge-ssr-loader/render'
+    import { IncrementalCache } from 'next/dist/esm/server/lib/incremental-cache'
+
+    const pagesType = ${JSON.stringify(pagesType)}
+    ${isAppDir ? `
+      import { renderToHTMLOrFlight as renderToHTML } from 'next/dist/esm/server/app-render/app-render'
+      import * as pageMod from ${JSON.stringify(pageModPath)}
+      const Document = null
+      const appMod = null
+      const errorMod = null
+      const error500Mod = null
+    ` : `
+      import Document from ${stringifiedDocumentPath}
+      import * as appMod from ${stringifiedAppPath}
+      import * as userlandPage from ${stringifiedPagePath}
+      import * as userlandErrorPage from ${stringifiedErrorPath}
+      ${stringified500Path ? `import * as userland500Page from ${stringified500Path}` : ""}
+
+      // TODO: re-enable this once we've refactored to use implicit matches
+      // const renderToHTML = undefined
+
+      import { renderToHTML } from 'next/dist/esm/server/render'
+      import RouteModule from "next/dist/esm/server/future/route-modules/pages/module"
+
+      const pageMod = {
+        ...userlandPage,
+        routeModule: new RouteModule({
+          ...${JSON.stringify(getRouteModuleOptions(page))},
+          components: {
+            App: appMod.default,
+            Document,
+          },
+          userland: userlandPage,
+        }),
+      }
+
+      const errorMod = {
+        ...userlandErrorPage,
+        routeModule: new RouteModule({
+          ...${JSON.stringify(getRouteModuleOptions("/_error"))},
+          components: {
+            App: appMod.default,
+            Document,
+          },
+          userland: userlandErrorPage,
+        }),
+      }
+
+      const error500Mod = ${stringified500Path ? `{
+        ...userland500Page,
+        routeModule: new RouteModule({
+          ...${JSON.stringify(getRouteModuleOptions("/500"))},
+          components: {
+            App: appMod.default,
+            Document,
+          },
+          userland: userland500Page,
+        }),
+      }` : "null"}`}
+
+    ${incrementalCacheHandlerPath ? `import incrementalCacheHandler from ${JSON.stringify(incrementalCacheHandlerPath)}` : "const incrementalCacheHandler = null"}
+
+    const maybeJSONParse = (str) => str ? JSON.parse(str) : undefined
+
+    const buildManifest = self.__BUILD_MANIFEST
+    const prerenderManifest = maybeJSONParse(self.__PRERENDER_MANIFEST)
+    const reactLoadableManifest = maybeJSONParse(self.__REACT_LOADABLE_MANIFEST)
+    const rscManifest = self.__RSC_MANIFEST?.[${JSON.stringify(page)}]
+    const rscServerManifest = maybeJSONParse(self.__RSC_SERVER_MANIFEST)
+    const subresourceIntegrityManifest = ${sriEnabled ? "maybeJSONParse(self.__SUBRESOURCE_INTEGRITY_MANIFEST)" : "undefined"}
+    const nextFontManifest = maybeJSONParse(self.__NEXT_FONT_MANIFEST)
+
+    const render = getRender({
+      pagesType,
+      dev: ${dev},
+      page: ${JSON.stringify(page)},
+      appMod,
+      pageMod,
+      errorMod,
+      error500Mod,
+      Document,
+      buildManifest,
+      isAppPath: ${!!isAppDir},
+      prerenderManifest,
+      renderToHTML,
+      reactLoadableManifest,
+      clientReferenceManifest: ${isServerComponent} ? rscManifest : null,
+      serverActionsManifest: ${isServerComponent} ? rscServerManifest : null,
+      serverActionsBodySizeLimit: ${isServerComponent} ? ${typeof serverActionsBodySizeLimit === "undefined" ? "undefined" : JSON.stringify(serverActionsBodySizeLimit)} : undefined,
+      subresourceIntegrityManifest,
+      config: ${stringifiedConfig},
+      buildId: ${JSON.stringify(buildId)},
+      nextFontManifest,
+      incrementalCacheHandler,
+    })
+
+    export const ComponentMod = pageMod
+
+    export default function(opts) {
+      return adapter({
+        ...opts,
+        IncrementalCache,
+        handler: render
+      })
+    }`;
+    return transformed;
+};
+export default edgeSSRLoader;
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-edge-ssr-loader/index.ts"],"names":["getModuleBuildInfo","WEBPACK_RESOURCE_QUERIES","stringifyRequest","RouteKind","normalizePagePath","swapDistFolderWithEsmDistFolder","path","replace","getRouteModuleOptions","page","options","definition","kind","PAGES","pathname","bundlePath","filename","edgeSSRLoader","dev","buildId","absolutePagePath","absoluteAppPath","absoluteDocumentPath","absolute500Path","absoluteErrorPath","isServerComponent","stringifiedConfig","stringifiedConfigBase64","appDirLoader","appDirLoaderBase64","pagesType","sriEnabled","incrementalCacheHandlerPath","preferredRegion","middlewareConfig","middlewareConfigBase64","serverActionsBodySizeLimit","getOptions","JSON","parse","Buffer","from","toString","isAppDir","buildInfo","_module","nextEdgeSSR","route","stringifiedPagePath","stringifiedAppPath","stringifiedErrorPath","stringifiedDocumentPath","stringified500Path","pageModPath","substring","length","edgeSSREntry","transformed","stringify"],"mappings":"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"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-edge-ssr-loader/render.ts"],"names":["WebServer","WebNextRequest","WebNextResponse","SERVER_RUNTIME","normalizeAppPath","getRender","dev","page","appMod","pageMod","errorMod","error500Mod","pagesType","Document","buildManifest","prerenderManifest","reactLoadableManifest","renderToHTML","clientReferenceManifest","subresourceIntegrityManifest","serverActionsManifest","serverActionsBodySizeLimit","config","buildId","nextFontManifest","incrementalCacheHandler","isAppPath","baseLoadComponentResult","App","default","server","conf","minimalMode","webServerConfig","pathname","extendRenderOpts","runtime","experimentalEdge","supportsDynamicHTML","disableOptimizedLoading","loadComponent","inputPage","Component","pageConfig","getStaticProps","getServerSideProps","getStaticPaths","ComponentMod","__next_app__","routeModule","handler","getRequestHandler","render","request","extendedReq","extendedRes","toResponse"],"mappings":"AAQA,OAAOA,eAAe,gCAA+B;AACrD,SACEC,cAAc,EACdC,eAAe,QACV,mCAAkC;AACzC,SAASC,cAAc,QAAQ,4BAA2B;AAE1D,SAASC,gBAAgB,QAAQ,gDAA+C;AAGhF,OAAO,SAASC,UAAU,EACxBC,GAAG,EACHC,IAAI,EACJC,MAAM,EACNC,OAAO,EACPC,QAAQ,EACRC,WAAW,EACXC,SAAS,EACTC,QAAQ,EACRC,aAAa,EACbC,iBAAiB,EACjBC,qBAAqB,EACrBC,YAAY,EACZC,uBAAuB,EACvBC,4BAA4B,EAC5BC,qBAAqB,EACrBC,0BAA0B,EAC1BC,MAAM,EACNC,OAAO,EACPC,gBAAgB,EAChBC,uBAAuB,EAuBxB;IACC,MAAMC,YAAYd,cAAc;IAChC,MAAMe,0BAA0B;QAC9BrB;QACAQ;QACAE;QACAG;QACAN;QACAe,GAAG,EAAEpB,0BAAAA,OAAQqB,OAAO;QACpBX;IACF;IAEA,MAAMY,SAAS,IAAI9B,UAAU;QAC3BM;QACAyB,MAAMT;QACNU,aAAa;QACbC,iBAAiB;YACf1B;YACA2B,UAAUR,YAAYtB,iBAAiBG,QAAQA;YAC/CK;YACAG;YACAoB,kBAAkB;gBAChBZ;gBACAa,SAASjC,eAAekC,gBAAgB;gBACxCC,qBAAqB;gBACrBC,yBAAyB;gBACzBnB;gBACAC;gBACAG;YACF;YACAP;YACAQ;YACAe,eAAe,OAAOC;gBACpB,IAAIA,cAAclC,MAAM;oBACtB,OAAO;wBACL,GAAGoB,uBAAuB;wBAC1Be,WAAWjC,QAAQoB,OAAO;wBAC1Bc,YAAYlC,QAAQa,MAAM,IAAI,CAAC;wBAC/BsB,gBAAgBnC,QAAQmC,cAAc;wBACtCC,oBAAoBpC,QAAQoC,kBAAkB;wBAC9CC,gBAAgBrC,QAAQqC,cAAc;wBACtCC,cAActC;wBACdiB,WAAW,CAAC,CAACjB,QAAQuC,YAAY;wBACjCzC,MAAMkC;wBACNQ,aAAaxC,QAAQwC,WAAW;oBAClC;gBACF;gBAEA,kEAAkE;gBAClE,IAAIR,cAAc,UAAU9B,aAAa;oBACvC,OAAO;wBACL,GAAGgB,uBAAuB;wBAC1Be,WAAW/B,YAAYkB,OAAO;wBAC9Bc,YAAYhC,YAAYW,MAAM,IAAI,CAAC;wBACnCsB,gBAAgBjC,YAAYiC,cAAc;wBAC1CC,oBAAoBlC,YAAYkC,kBAAkB;wBAClDC,gBAAgBnC,YAAYmC,cAAc;wBAC1CC,cAAcpC;wBACdJ,MAAMkC;wBACNQ,aAAatC,YAAYsC,WAAW;oBACtC;gBACF;gBAEA,IAAIR,cAAc,WAAW;oBAC3B,OAAO;wBACL,GAAGd,uBAAuB;wBAC1Be,WAAWhC,SAASmB,OAAO;wBAC3Bc,YAAYjC,SAASY,MAAM,IAAI,CAAC;wBAChCsB,gBAAgBlC,SAASkC,cAAc;wBACvCC,oBAAoBnC,SAASmC,kBAAkB;wBAC/CC,gBAAgBpC,SAASoC,cAAc;wBACvCC,cAAcrC;wBACdH,MAAMkC;wBACNQ,aAAavC,SAASuC,WAAW;oBACnC;gBACF;gBAEA,OAAO;YACT;QACF;IACF;IAEA,MAAMC,UAAUpB,OAAOqB,iBAAiB;IAExC,OAAO,eAAeC,OAAOC,OAAgB;QAC3C,MAAMC,cAAc,IAAIrD,eAAeoD;QACvC,MAAME,cAAc,IAAIrD;QAExBgD,QAAQI,aAAaC;QAErB,OAAO,MAAMA,YAAYC,UAAU;IACrC;AACF"}

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

@@ -0,0 +1,37 @@
+import { generateActionId } from "./utils";
+function nextFlightActionEntryLoader() {
+    const { actions } = this.getOptions();
+    const actionList = JSON.parse(actions);
+    const individualActions = actionList.map(([path, names])=>{
+        return names.map((name)=>{
+            const id = generateActionId(path, name);
+            return [
+                id,
+                path,
+                name
+            ];
+        });
+    }).flat();
+    return `
+const actions = {
+${individualActions.map(([id, path, name])=>{
+        return `'${id}': () => import(/* webpackMode: "eager" */ ${JSON.stringify(path)}).then(mod => mod[${JSON.stringify(name)}]),`;
+    }).join("\n")}
+}
+
+async function endpoint(id, ...args) {
+  const action = await actions[id]()
+  return action.apply(null, args)
+}
+
+// Using CJS to avoid this to be tree-shaken away due to unused exports.
+module.exports = {
+${individualActions.map(([id])=>{
+        return `  '${id}': endpoint.bind(null, '${id}'),`;
+    }).join("\n")}
+}
+`;
+}
+export default nextFlightActionEntryLoader;
+
+//# sourceMappingURL=next-flight-action-entry-loader.js.map

node_modules/next/dist/esm/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"],"names":["generateActionId","nextFlightActionEntryLoader","actions","getOptions","actionList","JSON","parse","individualActions","map","path","names","name","id","flat","stringify","join"],"mappings":"AAAA,SAASA,gBAAgB,QAAQ,UAAS;AAM1C,SAASC;IACP,MAAM,EAAEC,OAAO,EAAE,GAAuC,IAAI,CAACC,UAAU;IAEvE,MAAMC,aAAaC,KAAKC,KAAK,CAACJ;IAC9B,MAAMK,oBAAoBH,WACvBI,GAAG,CAAC,CAAC,CAACC,MAAMC,MAAM;QACjB,OAAOA,MAAMF,GAAG,CAAC,CAACG;YAChB,MAAMC,KAAKZ,iBAAiBS,MAAME;YAClC,OAAO;gBAACC;gBAAIH;gBAAME;aAAK;QACzB;IACF,GACCE,IAAI;IAEP,OAAO,CAAC;;AAEV,EAAEN,kBACCC,GAAG,CAAC,CAAC,CAACI,IAAIH,MAAME,KAAK;QACpB,OAAO,CAAC,CAAC,EAAEC,GAAG,2CAA2C,EAAEP,KAAKS,SAAS,CACvEL,MACA,kBAAkB,EAAEJ,KAAKS,SAAS,CAACH,MAAM,GAAG,CAAC;IACjD,GACCI,IAAI,CAAC,MAAM;;;;;;;;;;AAUd,EAAER,kBACCC,GAAG,CAAC,CAAC,CAACI,GAAG;QACR,OAAO,CAAC,GAAG,EAAEA,GAAG,wBAAwB,EAAEA,GAAG,GAAG,CAAC;IACnD,GACCG,IAAI,CAAC,MAAM;;AAEd,CAAC;AACD;AAEA,eAAed,4BAA2B"}

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

@@ -0,0 +1,22 @@
+import { RSC_MODULE_TYPES } from "../../../shared/lib/constants";
+import { getModuleBuildInfo } from "./get-module-build-info";
+import { regexCSS } from "./utils";
+export default function transformSource() {
+    let { modules, server } = this.getOptions();
+    const isServer = server === "true";
+    if (!Array.isArray(modules)) {
+        modules = modules ? [
+            modules
+        ] : [];
+    }
+    const requests = modules;
+    const code = requests// Filter out CSS files in the SSR compilation
+    .filter((request)=>isServer ? !regexCSS.test(request) : true).map((request)=>`import(/* webpackMode: "eager" */ ${JSON.stringify(request)})`).join(";\n");
+    const buildInfo = getModuleBuildInfo(this._module);
+    buildInfo.rsc = {
+        type: RSC_MODULE_TYPES.client
+    };
+    return code;
+}
+
+//# sourceMappingURL=next-flight-client-entry-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-flight-client-entry-loader.ts"],"names":["RSC_MODULE_TYPES","getModuleBuildInfo","regexCSS","transformSource","modules","server","getOptions","isServer","Array","isArray","requests","code","filter","request","test","map","JSON","stringify","join","buildInfo","_module","rsc","type","client"],"mappings":"AAAA,SAASA,gBAAgB,QAAQ,gCAA+B;AAChE,SAASC,kBAAkB,QAAQ,0BAAyB;AAC5D,SAASC,QAAQ,QAAQ,UAAS;AAWlC,eAAe,SAASC;IACtB,IAAI,EAAEC,OAAO,EAAEC,MAAM,EAAE,GACrB,IAAI,CAACC,UAAU;IACjB,MAAMC,WAAWF,WAAW;IAE5B,IAAI,CAACG,MAAMC,OAAO,CAACL,UAAU;QAC3BA,UAAUA,UAAU;YAACA;SAAQ,GAAG,EAAE;IACpC;IAEA,MAAMM,WAAWN;IACjB,MAAMO,OAAOD,QACX,8CAA8C;KAC7CE,MAAM,CAAC,CAACC,UAAaN,WAAW,CAACL,SAASY,IAAI,CAACD,WAAW,MAC1DE,GAAG,CACF,CAACF,UACC,CAAC,kCAAkC,EAAEG,KAAKC,SAAS,CAACJ,SAAS,CAAC,CAAC,EAElEK,IAAI,CAAC;IAER,MAAMC,YAAYlB,mBAAmB,IAAI,CAACmB,OAAO;IAEjDD,UAAUE,GAAG,GAAG;QACdC,MAAMtB,iBAAiBuB,MAAM;IAC/B;IAEA,OAAOZ;AACT"}

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

@@ -0,0 +1,27 @@
+import { getRSCModuleInformation } from "../../analysis/get-page-static-info";
+import { getModuleBuildInfo } from "./get-module-build-info";
+export default function transformSource(source, sourceMap) {
+    // Avoid buffer to be consumed
+    if (typeof source !== "string") {
+        throw new Error("Expected source to have been transformed to a string.");
+    }
+    // Assign the RSC meta information to buildInfo.
+    const buildInfo = getModuleBuildInfo(this._module);
+    buildInfo.rsc = getRSCModuleInformation(source, false);
+    // This is a server action entry module in the client layer. We need to attach
+    // noop exports of `callServer` wrappers for each action.
+    if (buildInfo.rsc.actions) {
+        source = `
+import { callServer } from 'next/dist/client/app-call-server'
+
+function __build_action__(action, args) {
+  return callServer(action.$$id, args)
+}
+
+${source}
+`;
+    }
+    return this.callback(null, source, sourceMap);
+}
+
+//# sourceMappingURL=next-flight-client-module-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-flight-client-module-loader.ts"],"names":["getRSCModuleInformation","getModuleBuildInfo","transformSource","source","sourceMap","Error","buildInfo","_module","rsc","actions","callback"],"mappings":"AAAA,SAASA,uBAAuB,QAAQ,sCAAqC;AAC7E,SAASC,kBAAkB,QAAQ,0BAAyB;AAE5D,eAAe,SAASC,gBAEtBC,MAAc,EACdC,SAAc;IAEd,8BAA8B;IAC9B,IAAI,OAAOD,WAAW,UAAU;QAC9B,MAAM,IAAIE,MAAM;IAClB;IAEA,gDAAgD;IAChD,MAAMC,YAAYL,mBAAmB,IAAI,CAACM,OAAO;IACjDD,UAAUE,GAAG,GAAGR,wBAAwBG,QAAQ;IAEhD,8EAA8E;IAC9E,yDAAyD;IACzD,IAAIG,UAAUE,GAAG,CAACC,OAAO,EAAE;QACzBN,SAAS,CAAC;;;;;;;AAOd,EAAEA,OAAO;AACT,CAAC;IACC;IAEA,OAAO,IAAI,CAACO,QAAQ,CAAC,MAAMP,QAAQC;AACrC"}

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

@@ -0,0 +1,37 @@
+/**
+ * For server-side CSS imports, we need to ignore the actual module content but
+ * still trigger the hot-reloading diff mechanism. So here we put the content
+ * inside a comment.
+ */ import crypto from "crypto";
+const NextServerCSSLoader = function(content) {
+    this.cacheable && this.cacheable();
+    const options = this.getOptions();
+    let isCSSModule = options.cssModules;
+    // Only add the checksum during development.
+    if (process.env.NODE_ENV !== "production") {
+        // This check is only for backwards compatibility.
+        // TODO: Remove this in the next major version (next 14)
+        if (isCSSModule === undefined) {
+            this.emitWarning(new Error("No 'cssModules' option was found for the next-flight-css-loader plugin."));
+            isCSSModule = this.resourcePath.match(/\.module\.(css|sass|scss)$/) !== null;
+        }
+        const checksum = crypto.createHash("sha1").update(typeof content === "string" ? Buffer.from(content) : content).digest().toString("hex").substring(0, 12);
+        if (isCSSModule) {
+            return `\
+${content}
+module.exports.__checksum = ${JSON.stringify(checksum)}
+`;
+        }
+        // Server CSS imports are always available for HMR, so we attach
+        // `module.hot.accept()` to the generated module.
+        const hmrCode = "if (module.hot) { module.hot.accept() }";
+        return `\
+export default ${JSON.stringify(checksum)}
+${hmrCode}
+`;
+    }
+    return content;
+};
+export default NextServerCSSLoader;
+
+//# sourceMappingURL=next-flight-css-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-flight-css-loader.ts"],"names":["crypto","NextServerCSSLoader","content","cacheable","options","getOptions","isCSSModule","cssModules","process","env","NODE_ENV","undefined","emitWarning","Error","resourcePath","match","checksum","createHash","update","Buffer","from","digest","toString","substring","JSON","stringify","hmrCode"],"mappings":"AAAA;;;;CAIC,GAED,OAAOA,YAAY,SAAQ;AAO3B,MAAMC,sBACJ,SAAUC,OAAO;IACf,IAAI,CAACC,SAAS,IAAI,IAAI,CAACA,SAAS;IAChC,MAAMC,UAAU,IAAI,CAACC,UAAU;IAC/B,IAAIC,cAAcF,QAAQG,UAAU;IAEpC,4CAA4C;IAC5C,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QACzC,kDAAkD;QAClD,wDAAwD;QACxD,IAAIJ,gBAAgBK,WAAW;YAC7B,IAAI,CAACC,WAAW,CACd,IAAIC,MACF;YAGJP,cACE,IAAI,CAACQ,YAAY,CAACC,KAAK,CAAC,kCAAkC;QAC9D;QACA,MAAMC,WAAWhB,OACdiB,UAAU,CAAC,QACXC,MAAM,CAAC,OAAOhB,YAAY,WAAWiB,OAAOC,IAAI,CAAClB,WAAWA,SAC5DmB,MAAM,GACNC,QAAQ,CAAC,OACTC,SAAS,CAAC,GAAG;QAEhB,IAAIjB,aAAa;YACf,OAAO,CAAC;AAChB,EAAEJ,QAAQ;4BACkB,EAAEsB,KAAKC,SAAS,CAACT,UAAU;AACvD,CAAC;QACK;QAEA,gEAAgE;QAChE,iDAAiD;QACjD,MAAMU,UAAU;QAEhB,OAAO,CAAC;eACC,EAAEF,KAAKC,SAAS,CAACT,UAAU;AAC1C,EAAEU,QAAQ;AACV,CAAC;IACG;IAEA,OAAOxB;AACT;AAEF,eAAeD,oBAAmB"}

node_modules/next/dist/esm/build/webpack/loaders/next-flight-loader/action-client-wrapper.js

@@ -0,0 +1,15 @@
+// This file must be bundled in the app's client layer, it shouldn't be directly
+// imported by the server.
+import { callServer } from "next/dist/client/app-call-server";
+// A noop wrapper to let the Flight client create the server reference.
+// See also: https://github.com/facebook/react/pull/26632
+export function createServerReference(id) {
+    // Since we're using the Edge build of Flight client for SSR [1], here we need to
+    // also use the same Edge build to create the reference. For the client bundle,
+    // we use the default and let Webpack to resolve it to the correct version.
+    // 1: https://github.com/vercel/next.js/blob/16eb80b0b0be13f04a6407943664b5efd8f3d7d0/packages/next/src/server/app-render/use-flight-response.tsx#L24-L26
+    const { createServerReference: createServerReferenceImpl } = !!process.env.NEXT_RUNTIME ? require("react-server-dom-webpack/client.edge") : require("react-server-dom-webpack/client");
+    return createServerReferenceImpl(id, callServer);
+}
+
+//# sourceMappingURL=action-client-wrapper.js.map

node_modules/next/dist/esm/build/webpack/loaders/next-flight-loader/action-client-wrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-flight-loader/action-client-wrapper.ts"],"names":["callServer","createServerReference","id","createServerReferenceImpl","process","env","NEXT_RUNTIME","require"],"mappings":"AAAA,gFAAgF;AAChF,0BAA0B;AAE1B,SAASA,UAAU,QAAQ,mCAAkC;AAE7D,uEAAuE;AACvE,yDAAyD;AACzD,OAAO,SAASC,sBAAsBC,EAAU;IAC9C,iFAAiF;IACjF,+EAA+E;IAC/E,2EAA2E;IAC3E,yJAAyJ;IACzJ,MAAM,EAAED,uBAAuBE,yBAAyB,EAAE,GACxD,CAAC,CAACC,QAAQC,GAAG,CAACC,YAAY,GAEtBC,QAAQ,0CAERA,QAAQ;IAGd,OAAOJ,0BAA0BD,IAAIF;AACvC"}

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

@@ -0,0 +1,43 @@
+const SERVER_REFERENCE_TAG = Symbol.for("react.server.reference");
+export function createActionProxy(id, bound, action, originalAction) {
+    function bindImpl(_, ...boundArgs) {
+        const currentAction = this;
+        const newAction = async function(...args) {
+            if (originalAction) {
+                return originalAction(newAction.$$bound.concat(args));
+            } else {
+                // In this case we're calling the user-defined action directly.
+                return currentAction(...newAction.$$bound, ...args);
+            }
+        };
+        for (const key of [
+            "$$typeof",
+            "$$id",
+            "$$FORM_ACTION"
+        ]){
+            // @ts-ignore
+            newAction[key] = currentAction[key];
+        }
+        // Rebind args
+        newAction.$$bound = (currentAction.$$bound || []).concat(boundArgs);
+        // Assign bind method
+        newAction.bind = bindImpl.bind(newAction);
+        return newAction;
+    }
+    Object.defineProperties(action, {
+        $$typeof: {
+            value: SERVER_REFERENCE_TAG
+        },
+        $$id: {
+            value: id
+        },
+        $$bound: {
+            value: bound
+        },
+        bind: {
+            value: bindImpl
+        }
+    });
+}
+
+//# sourceMappingURL=action-proxy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-flight-loader/action-proxy.ts"],"names":["SERVER_REFERENCE_TAG","Symbol","for","createActionProxy","id","bound","action","originalAction","bindImpl","_","boundArgs","currentAction","newAction","args","$$bound","concat","key","bind","Object","defineProperties","$$typeof","value","$$id"],"mappings":"AAAA,MAAMA,uBAAuBC,OAAOC,GAAG,CAAC;AAExC,OAAO,SAASC,kBACdC,EAAU,EACVC,KAAmB,EACnBC,MAAW,EACXC,cAAoB;IAEpB,SAASC,SAAoBC,CAAM,EAAE,GAAGC,SAAgB;QACtD,MAAMC,gBAAgB,IAAI;QAE1B,MAAMC,YAAY,eAAgB,GAAGC,IAAW;YAC9C,IAAIN,gBAAgB;gBAClB,OAAOA,eAAeK,UAAUE,OAAO,CAACC,MAAM,CAACF;YACjD,OAAO;gBACL,+DAA+D;gBAC/D,OAAOF,iBAAiBC,UAAUE,OAAO,KAAKD;YAChD;QACF;QAEA,KAAK,MAAMG,OAAO;YAAC;YAAY;YAAQ;SAAgB,CAAE;YACvD,aAAa;YACbJ,SAAS,CAACI,IAAI,GAAGL,aAAa,CAACK,IAAI;QACrC;QAEA,cAAc;QACdJ,UAAUE,OAAO,GAAG,AAACH,CAAAA,cAAcG,OAAO,IAAI,EAAE,AAAD,EAAGC,MAAM,CAACL;QAEzD,qBAAqB;QACrBE,UAAUK,IAAI,GAAGT,SAASS,IAAI,CAACL;QAE/B,OAAOA;IACT;IAEAM,OAAOC,gBAAgB,CAACb,QAAQ;QAC9Bc,UAAU;YACRC,OAAOrB;QACT;QACAsB,MAAM;YACJD,OAAOjB;QACT;QACAU,SAAS;YACPO,OAAOhB;QACT;QACAY,MAAM;YACJI,OAAOb;QACT;IACF;AACF"}

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

@@ -0,0 +1,13 @@
+// This function ensures that all the exported values are valid server actions,
+// during the runtime. By definition all actions are required to be async
+// functions, but here we can only check that they are functions.
+export function ensureServerEntryExports(actions) {
+    for(let i = 0; i < actions.length; i++){
+        const action = actions[i];
+        if (typeof action !== "function") {
+            throw new Error(`A "use server" file can only export async functions, found ${typeof action}.`);
+        }
+    }
+}
+
+//# sourceMappingURL=action-validate.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-flight-loader/action-validate.ts"],"names":["ensureServerEntryExports","actions","i","length","action","Error"],"mappings":"AAAA,+EAA+E;AAC/E,yEAAyE;AACzE,iEAAiE;AACjE,OAAO,SAASA,yBAAyBC,OAAc;IACrD,IAAK,IAAIC,IAAI,GAAGA,IAAID,QAAQE,MAAM,EAAED,IAAK;QACvC,MAAME,SAASH,OAAO,CAACC,EAAE;QACzB,IAAI,OAAOE,WAAW,YAAY;YAChC,MAAM,IAAIC,MACR,CAAC,2DAA2D,EAAE,OAAOD,OAAO,CAAC,CAAC;QAElF;IACF;AACF"}

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

@@ -0,0 +1,82 @@
+import { RSC_MOD_REF_PROXY_ALIAS } from "../../../../lib/constants";
+import { RSC_MODULE_TYPES } from "../../../../shared/lib/constants";
+import { warnOnce } from "../../../../shared/lib/utils/warn-once";
+import { getRSCModuleInformation } from "../../../analysis/get-page-static-info";
+import { getModuleBuildInfo } from "../get-module-build-info";
+const noopHeadPath = require.resolve("next/dist/client/components/noop-head");
+// For edge runtime it will be aliased to esm version by webpack
+const MODULE_PROXY_PATH = "next/dist/build/webpack/loaders/next-flight-loader/module-proxy";
+export default function transformSource(source, sourceMap) {
+    var _buildInfo_rsc, _buildInfo_rsc1;
+    // Avoid buffer to be consumed
+    if (typeof source !== "string") {
+        throw new Error("Expected source to have been transformed to a string.");
+    }
+    // Assign the RSC meta information to buildInfo.
+    // Exclude next internal files which are not marked as client files
+    const buildInfo = getModuleBuildInfo(this._module);
+    buildInfo.rsc = getRSCModuleInformation(source, true);
+    // A client boundary.
+    if (((_buildInfo_rsc = buildInfo.rsc) == null ? void 0 : _buildInfo_rsc.type) === RSC_MODULE_TYPES.client) {
+        var _this__module_parser, _this__module;
+        const sourceType = (_this__module = this._module) == null ? void 0 : (_this__module_parser = _this__module.parser) == null ? void 0 : _this__module_parser.sourceType;
+        const detectedClientEntryType = buildInfo.rsc.clientEntryType;
+        const clientRefs = buildInfo.rsc.clientRefs;
+        // It's tricky to detect the type of a client boundary, but we should always
+        // use the `module` type when we can, to support `export *` and `export from`
+        // syntax in other modules that import this client boundary.
+        let assumedSourceType = sourceType;
+        if (assumedSourceType === "auto" && detectedClientEntryType === "auto") {
+            if (clientRefs.length === 0 || clientRefs.length === 1 && clientRefs[0] === "") {
+                // If there's zero export detected in the client boundary, and it's the
+                // `auto` type, we can safely assume it's a CJS module because it doesn't
+                // have ESM exports.
+                assumedSourceType = "commonjs";
+            } else if (!clientRefs.includes("*")) {
+                // Otherwise, we assume it's an ESM module.
+                assumedSourceType = "module";
+            }
+        }
+        if (assumedSourceType === "module") {
+            if (clientRefs.includes("*")) {
+                this.callback(new Error(`It's currently unsupported to use "export *" in a client boundary. Please use named exports instead.`));
+                return;
+            }
+            let esmSource = `\
+import { createProxy } from "${MODULE_PROXY_PATH}"
+const proxy = createProxy(String.raw\`${this.resourcePath}\`)
+
+// Accessing the __esModule property and exporting $$typeof are required here.
+// The __esModule getter forces the proxy target to create the default export
+// and the $$typeof value is for rendering logic to determine if the module
+// is a client boundary.
+const { __esModule, $$typeof } = proxy;
+const __default__ = proxy.default;
+`;
+            let cnt = 0;
+            for (const ref of clientRefs){
+                if (ref === "") {
+                    esmSource += `\nexports[''] = proxy[''];`;
+                } else if (ref === "default") {
+                    esmSource += `
+export { __esModule, $$typeof };
+export default __default__;`;
+                } else {
+                    esmSource += `
+const e${cnt} = proxy["${ref}"];
+export { e${cnt++} as ${ref} };`;
+                }
+            }
+            this.callback(null, esmSource, sourceMap);
+            return;
+        }
+    }
+    if (((_buildInfo_rsc1 = buildInfo.rsc) == null ? void 0 : _buildInfo_rsc1.type) !== RSC_MODULE_TYPES.client) {
+        if (noopHeadPath === this.resourcePath) {
+            warnOnce(`Warning: You're using \`next/head\` inside the \`app\` directory, please migrate to the Metadata API. See https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration#step-3-migrating-nexthead for more details.`);
+        }
+    }
+    this.callback(null, source.replace(RSC_MOD_REF_PROXY_ALIAS, MODULE_PROXY_PATH), sourceMap);
+}
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-flight-loader/index.ts"],"names":["RSC_MOD_REF_PROXY_ALIAS","RSC_MODULE_TYPES","warnOnce","getRSCModuleInformation","getModuleBuildInfo","noopHeadPath","require","resolve","MODULE_PROXY_PATH","transformSource","source","sourceMap","buildInfo","Error","_module","rsc","type","client","sourceType","parser","detectedClientEntryType","clientEntryType","clientRefs","assumedSourceType","length","includes","callback","esmSource","resourcePath","cnt","ref","replace"],"mappings":"AAAA,SAASA,uBAAuB,QAAQ,4BAA2B;AACnE,SAASC,gBAAgB,QAAQ,mCAAkC;AACnE,SAASC,QAAQ,QAAQ,yCAAwC;AACjE,SAASC,uBAAuB,QAAQ,yCAAwC;AAChF,SAASC,kBAAkB,QAAQ,2BAA0B;AAE7D,MAAMC,eAAeC,QAAQC,OAAO,CAAC;AACrC,gEAAgE;AAChE,MAAMC,oBACJ;AAEF,eAAe,SAASC,gBAEtBC,MAAc,EACdC,SAAc;QAaVC,gBAiEAA;IA5EJ,8BAA8B;IAC9B,IAAI,OAAOF,WAAW,UAAU;QAC9B,MAAM,IAAIG,MAAM;IAClB;IAEA,gDAAgD;IAChD,mEAAmE;IACnE,MAAMD,YAAYR,mBAAmB,IAAI,CAACU,OAAO;IACjDF,UAAUG,GAAG,GAAGZ,wBAAwBO,QAAQ;IAEhD,qBAAqB;IACrB,IAAIE,EAAAA,iBAAAA,UAAUG,GAAG,qBAAbH,eAAeI,IAAI,MAAKf,iBAAiBgB,MAAM,EAAE;YAChC,sBAAA;QAAnB,MAAMC,cAAa,gBAAA,IAAI,CAACJ,OAAO,sBAAZ,uBAAA,cAAcK,MAAM,qBAApB,qBAAsBD,UAAU;QACnD,MAAME,0BAA0BR,UAAUG,GAAG,CAACM,eAAe;QAC7D,MAAMC,aAAaV,UAAUG,GAAG,CAACO,UAAU;QAE3C,4EAA4E;QAC5E,6EAA6E;QAC7E,4DAA4D;QAC5D,IAAIC,oBAAoBL;QACxB,IAAIK,sBAAsB,UAAUH,4BAA4B,QAAQ;YACtE,IACEE,WAAWE,MAAM,KAAK,KACrBF,WAAWE,MAAM,KAAK,KAAKF,UAAU,CAAC,EAAE,KAAK,IAC9C;gBACA,uEAAuE;gBACvE,yEAAyE;gBACzE,oBAAoB;gBACpBC,oBAAoB;YACtB,OAAO,IAAI,CAACD,WAAWG,QAAQ,CAAC,MAAM;gBACpC,2CAA2C;gBAC3CF,oBAAoB;YACtB;QACF;QAEA,IAAIA,sBAAsB,UAAU;YAClC,IAAID,WAAWG,QAAQ,CAAC,MAAM;gBAC5B,IAAI,CAACC,QAAQ,CACX,IAAIb,MACF,CAAC,oGAAoG,CAAC;gBAG1G;YACF;YAEA,IAAIc,YAAY,CAAC;6BACM,EAAEnB,kBAAkB;sCACX,EAAE,IAAI,CAACoB,YAAY,CAAC;;;;;;;;AAQ1D,CAAC;YACK,IAAIC,MAAM;YACV,KAAK,MAAMC,OAAOR,WAAY;gBAC5B,IAAIQ,QAAQ,IAAI;oBACdH,aAAa,CAAC,0BAA0B,CAAC;gBAC3C,OAAO,IAAIG,QAAQ,WAAW;oBAC5BH,aAAa,CAAC;;2BAEG,CAAC;gBACpB,OAAO;oBACLA,aAAa,CAAC;OACjB,EAAEE,IAAI,UAAU,EAAEC,IAAI;UACnB,EAAED,MAAM,IAAI,EAAEC,IAAI,GAAG,CAAC;gBACxB;YACF;YAEA,IAAI,CAACJ,QAAQ,CAAC,MAAMC,WAAWhB;YAC/B;QACF;IACF;IAEA,IAAIC,EAAAA,kBAAAA,UAAUG,GAAG,qBAAbH,gBAAeI,IAAI,MAAKf,iBAAiBgB,MAAM,EAAE;QACnD,IAAIZ,iBAAiB,IAAI,CAACuB,YAAY,EAAE;YACtC1B,SACE,CAAC,0OAA0O,CAAC;QAEhP;IACF;IAEA,IAAI,CAACwB,QAAQ,CACX,MACAhB,OAAOqB,OAAO,CAAC/B,yBAAyBQ,oBACxCG;AAEJ"}

node_modules/next/dist/esm/build/webpack/loaders/next-flight-loader/module-proxy.js

@@ -0,0 +1,5 @@
+/* eslint-disable import/no-extraneous-dependencies */ import { createClientModuleProxy } from "react-server-dom-webpack/server.edge";
+// Re-assign to make it typed.
+export const createProxy = createClientModuleProxy;
+
+//# sourceMappingURL=module-proxy.js.map

node_modules/next/dist/esm/build/webpack/loaders/next-flight-loader/module-proxy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-flight-loader/module-proxy.ts"],"names":["createClientModuleProxy","createProxy"],"mappings":"AAAA,oDAAoD,GACpD,SAASA,uBAAuB,QAAQ,uCAAsC;AAE9E,8BAA8B;AAC9B,OAAO,MAAMC,cAAyCD,wBAAuB"}

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

@@ -0,0 +1,105 @@
+import path from "path";
+import chalk from "next/dist/compiled/chalk";
+import loaderUtils from "next/dist/compiled/loader-utils3";
+import postcssNextFontPlugin from "./postcss-next-font";
+import { promisify } from "util";
+export default async function nextFontLoader() {
+    const nextFontLoaderSpan = this.currentTraceSpan.traceChild("next-font-loader");
+    return nextFontLoaderSpan.traceAsyncFn(async ()=>{
+        const callback = this.async();
+        /**
+     * The next-swc plugin next-transform-font turns font function calls into CSS imports.
+     * At the end of the import, it adds the call arguments and some additional data as a resourceQuery.
+     * e.g:
+     * const inter = Inter({ subset: ['latin'] })
+     * ->
+     * import inter from 'next/font/google/target.css?{"import":"Inter","subsets":["latin"]}'
+     *
+     * Here we parse the resourceQuery to get the font function name, call arguments, and the path to the file that called the font function.
+     */ const { path: relativeFilePathFromRoot, import: functionName, arguments: data, variableName } = JSON.parse(this.resourceQuery.slice(1));
+        // Throw error if @next/font is used in _document.js
+        if (/pages[\\/]_document\./.test(relativeFilePathFromRoot)) {
+            const err = new Error(`${chalk.bold("Cannot")} be used within ${chalk.cyan("pages/_document.js")}.`);
+            err.name = "NextFontError";
+            callback(err);
+            return;
+        }
+        const { isDev, isServer, assetPrefix, fontLoaderPath, postcss: getPostcss } = this.getOptions();
+        if (assetPrefix && !/^\/|https?:\/\//.test(assetPrefix)) {
+            const err = new Error("assetPrefix must start with a leading slash or be an absolute URL(http:// or https://)");
+            err.name = "NextFontError";
+            callback(err);
+            return;
+        }
+        /**
+     * Emit font files to .next/static/media as [hash].[ext].
+     *
+     * If the font should be preloaded, add .p to the filename: [hash].p.[ext]
+     * NextFontManifestPlugin adds these files to the next/font manifest.
+     *
+     * If the font is using a size-adjust fallback font, add -s to the filename: [hash]-s.[ext]
+     * NextFontManifestPlugin uses this to see if fallback fonts are being used.
+     * This is used to collect stats on fallback fonts usage by the Google Aurora team.
+     */ const emitFontFile = (content, ext, preload, isUsingSizeAdjust)=>{
+            const opts = {
+                context: this.rootContext,
+                content
+            };
+            const interpolatedName = loaderUtils.interpolateName(this, `static/media/[hash]${isUsingSizeAdjust ? "-s" : ""}${preload ? ".p" : ""}.${ext}`, opts);
+            const outputPath = `${assetPrefix}/_next/${interpolatedName}`;
+            // Only the client emits the font file
+            if (!isServer) {
+                this.emitFile(interpolatedName, content, null);
+            }
+            // But both the server and client must get the resulting path
+            return outputPath;
+        };
+        try {
+            // Import the font loader function from either next/font/local or next/font/google
+            // The font loader function emits font files and returns @font-faces and fallback font metrics
+            const fontLoader = require(fontLoaderPath).default;
+            let { css, fallbackFonts, adjustFontFallback, weight, style, variable } = await nextFontLoaderSpan.traceChild("font-loader").traceAsyncFn(()=>fontLoader({
+                    functionName,
+                    variableName,
+                    data,
+                    emitFontFile,
+                    resolve: (src)=>promisify(this.resolve)(path.dirname(path.join(this.rootContext, relativeFilePathFromRoot)), src.startsWith(".") ? src : `./${src}`),
+                    isDev,
+                    isServer,
+                    loaderContext: this
+                }));
+            const { postcss } = await getPostcss();
+            // Exports will be exported as is from css-loader instead of a CSS module export
+            const exports = [];
+            // Generate a hash from the CSS content. Used to generate classnames and font families
+            const fontFamilyHash = loaderUtils.getHashDigest(Buffer.from(css), "sha1", "hex", 6);
+            // Add CSS classes, exports and make the font-family locally scoped by turning it unguessable
+            const result = await nextFontLoaderSpan.traceChild("postcss").traceAsyncFn(()=>postcss(postcssNextFontPlugin({
+                    exports,
+                    fontFamilyHash,
+                    fallbackFonts,
+                    weight,
+                    style,
+                    adjustFontFallback,
+                    variable
+                })).process(css, {
+                    from: undefined
+                }));
+            const ast = {
+                type: "postcss",
+                version: result.processor.version,
+                root: result.root
+            };
+            // Return the resulting CSS and send the postcss ast, font exports and the hash to the css-loader in the meta argument.
+            callback(null, result.css, null, {
+                exports,
+                ast,
+                fontFamilyHash
+            });
+        } catch (err) {
+            callback(err);
+        }
+    });
+}
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-font-loader/index.ts"],"names":["path","chalk","loaderUtils","postcssNextFontPlugin","promisify","nextFontLoader","nextFontLoaderSpan","currentTraceSpan","traceChild","traceAsyncFn","callback","async","relativeFilePathFromRoot","import","functionName","arguments","data","variableName","JSON","parse","resourceQuery","slice","test","err","Error","bold","cyan","name","isDev","isServer","assetPrefix","fontLoaderPath","postcss","getPostcss","getOptions","emitFontFile","content","ext","preload","isUsingSizeAdjust","opts","context","rootContext","interpolatedName","interpolateName","outputPath","emitFile","fontLoader","require","default","css","fallbackFonts","adjustFontFallback","weight","style","variable","resolve","src","dirname","join","startsWith","loaderContext","exports","fontFamilyHash","getHashDigest","Buffer","from","result","process","undefined","ast","type","version","processor","root"],"mappings":"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"}

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

@@ -0,0 +1,151 @@
+import postcss from "postcss";
+/**
+ * The next/font postcss plugin recieves the @font-face declarations returned from the next/font loaders.
+ *
+ * It hashes the font-family name to make it unguessable, it shouldn't be globally accessible.
+ * If it were global, we wouldn't be able to tell which pages are using which fonts when generating preload tags.
+ *
+ * If the font loader returned fallback metrics, generate a fallback @font-face.
+ *
+ * If the font loader returned a variable name, add a CSS class that declares a variable containing the font and fallback fonts.
+ *
+ * Lastly, it adds the font-family to the exports object.
+ * This enables you to access the actual font-family name, not just through the CSS class.
+ * e.g:
+ * const inter = Inter({ subsets: ['latin'] })
+ * inter.style.fontFamily // => '__Inter_123456'
+ */ const postcssNextFontPlugin = ({ exports, fontFamilyHash, fallbackFonts = [], adjustFontFallback, variable, weight, style })=>{
+    return {
+        postcssPlugin: "postcss-next-font",
+        Once (root) {
+            let fontFamily;
+            const normalizeFamily = (family)=>{
+                return family.replace(/['"]/g, "");
+            };
+            const formatFamily = (family)=>{
+                // Turn the font family unguessable to make it locally scoped
+                return `'__${family.replace(/ /g, "_")}_${fontFamilyHash}'`;
+            };
+            // Hash font-family names
+            for (const node of root.nodes){
+                if (node.type === "atrule" && node.name === "font-face") {
+                    const familyNode = node.nodes.find((decl)=>decl.prop === "font-family");
+                    if (!familyNode) {
+                        continue;
+                    }
+                    if (!fontFamily) {
+                        fontFamily = normalizeFamily(familyNode.value);
+                    }
+                    familyNode.value = formatFamily(fontFamily);
+                }
+            }
+            if (!fontFamily) {
+                throw new Error("Font loaders must return one or more @font-face's");
+            }
+            // Add fallback @font-face with the provided override values
+            let adjustFontFallbackFamily;
+            if (adjustFontFallback) {
+                adjustFontFallbackFamily = formatFamily(`${fontFamily} Fallback`);
+                const fallbackFontFace = postcss.atRule({
+                    name: "font-face"
+                });
+                const { fallbackFont, ascentOverride, descentOverride, lineGapOverride, sizeAdjust } = adjustFontFallback;
+                fallbackFontFace.nodes = [
+                    new postcss.Declaration({
+                        prop: "font-family",
+                        value: adjustFontFallbackFamily
+                    }),
+                    new postcss.Declaration({
+                        prop: "src",
+                        value: `local("${fallbackFont}")`
+                    }),
+                    ...ascentOverride ? [
+                        new postcss.Declaration({
+                            prop: "ascent-override",
+                            value: ascentOverride
+                        })
+                    ] : [],
+                    ...descentOverride ? [
+                        new postcss.Declaration({
+                            prop: "descent-override",
+                            value: descentOverride
+                        })
+                    ] : [],
+                    ...lineGapOverride ? [
+                        new postcss.Declaration({
+                            prop: "line-gap-override",
+                            value: lineGapOverride
+                        })
+                    ] : [],
+                    ...sizeAdjust ? [
+                        new postcss.Declaration({
+                            prop: "size-adjust",
+                            value: sizeAdjust
+                        })
+                    ] : []
+                ];
+                root.nodes.push(fallbackFontFace);
+            }
+            // Variable fonts can define ranges of values
+            const isRange = (value)=>value.trim().includes(" ");
+            // Format the font families to be used in the CSS
+            const formattedFontFamilies = [
+                formatFamily(fontFamily),
+                ...adjustFontFallbackFamily ? [
+                    adjustFontFallbackFamily
+                ] : [],
+                ...fallbackFonts
+            ].join(", ");
+            // Add class with family, weight and style
+            const classRule = new postcss.Rule({
+                selector: ".className"
+            });
+            classRule.nodes = [
+                new postcss.Declaration({
+                    prop: "font-family",
+                    value: formattedFontFamilies
+                }),
+                // If the font only has one weight or style, we can set it on the class
+                ...weight && !isRange(weight) ? [
+                    new postcss.Declaration({
+                        prop: "font-weight",
+                        value: weight
+                    })
+                ] : [],
+                ...style && !isRange(style) ? [
+                    new postcss.Declaration({
+                        prop: "font-style",
+                        value: style
+                    })
+                ] : []
+            ];
+            root.nodes.push(classRule);
+            // Add CSS class that defines a variable with the font families
+            if (variable) {
+                const varialbeRule = new postcss.Rule({
+                    selector: ".variable"
+                });
+                varialbeRule.nodes = [
+                    new postcss.Declaration({
+                        prop: variable,
+                        value: formattedFontFamilies
+                    })
+                ];
+                root.nodes.push(varialbeRule);
+            }
+            // Export @font-face values as is
+            exports.push({
+                name: "style",
+                value: {
+                    fontFamily: formattedFontFamilies,
+                    fontWeight: !Number.isNaN(Number(weight)) ? Number(weight) : undefined,
+                    fontStyle: style && !isRange(style) ? style : undefined
+                }
+            });
+        }
+    };
+};
+postcssNextFontPlugin.postcss = true;
+export default postcssNextFontPlugin;
+
+//# sourceMappingURL=postcss-next-font.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-font-loader/postcss-next-font.ts"],"names":["postcss","postcssNextFontPlugin","exports","fontFamilyHash","fallbackFonts","adjustFontFallback","variable","weight","style","postcssPlugin","Once","root","fontFamily","normalizeFamily","family","replace","formatFamily","node","nodes","type","name","familyNode","find","decl","prop","value","Error","adjustFontFallbackFamily","fallbackFontFace","atRule","fallbackFont","ascentOverride","descentOverride","lineGapOverride","sizeAdjust","Declaration","push","isRange","trim","includes","formattedFontFamilies","join","classRule","Rule","selector","varialbeRule","fontWeight","Number","isNaN","undefined","fontStyle"],"mappings":"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"}

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

@@ -0,0 +1,58 @@
+import isAnimated from "next/dist/compiled/is-animated";
+import { optimizeImage } from "../../../../server/image-optimizer";
+const BLUR_IMG_SIZE = 8;
+const BLUR_QUALITY = 70;
+const VALID_BLUR_EXT = [
+    "jpeg",
+    "png",
+    "webp",
+    "avif"
+] // should match other usages
+;
+export async function getBlurImage(content, extension, imageSize, { basePath, outputPath, isDev, tracing = ()=>({
+        traceFn: (fn)=>(...args)=>fn(...args),
+        traceAsyncFn: (fn)=>(...args)=>fn(...args)
+    }) }) {
+    let blurDataURL;
+    let blurWidth = 0;
+    let blurHeight = 0;
+    if (VALID_BLUR_EXT.includes(extension) && !isAnimated(content)) {
+        // Shrink the image's largest dimension
+        if (imageSize.width >= imageSize.height) {
+            blurWidth = BLUR_IMG_SIZE;
+            blurHeight = Math.max(Math.round(imageSize.height / imageSize.width * BLUR_IMG_SIZE), 1);
+        } else {
+            blurWidth = Math.max(Math.round(imageSize.width / imageSize.height * BLUR_IMG_SIZE), 1);
+            blurHeight = BLUR_IMG_SIZE;
+        }
+        if (isDev) {
+            // During `next dev`, we don't want to generate blur placeholders with webpack
+            // because it can delay starting the dev server. Instead, we inline a
+            // special url to lazily generate the blur placeholder at request time.
+            const prefix = "http://localhost";
+            const url = new URL(`${basePath || ""}/_next/image`, prefix);
+            url.searchParams.set("url", outputPath);
+            url.searchParams.set("w", String(blurWidth));
+            url.searchParams.set("q", String(BLUR_QUALITY));
+            blurDataURL = url.href.slice(prefix.length);
+        } else {
+            const resizeImageSpan = tracing("image-resize");
+            const resizedImage = await resizeImageSpan.traceAsyncFn(()=>optimizeImage({
+                    buffer: content,
+                    width: blurWidth,
+                    height: blurHeight,
+                    contentType: `image/${extension}`,
+                    quality: BLUR_QUALITY
+                }));
+            const blurDataURLSpan = tracing("image-base64-tostring");
+            blurDataURL = blurDataURLSpan.traceFn(()=>`data:image/${extension};base64,${resizedImage.toString("base64")}`);
+        }
+    }
+    return {
+        dataURL: blurDataURL,
+        width: blurWidth,
+        height: blurHeight
+    };
+}
+
+//# sourceMappingURL=blur.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-image-loader/blur.ts"],"names":["isAnimated","optimizeImage","BLUR_IMG_SIZE","BLUR_QUALITY","VALID_BLUR_EXT","getBlurImage","content","extension","imageSize","basePath","outputPath","isDev","tracing","traceFn","fn","args","traceAsyncFn","blurDataURL","blurWidth","blurHeight","includes","width","height","Math","max","round","prefix","url","URL","searchParams","set","String","href","slice","length","resizeImageSpan","resizedImage","buffer","contentType","quality","blurDataURLSpan","toString","dataURL"],"mappings":"AAAA,OAAOA,gBAAgB,iCAAgC;AACvD,SAASC,aAAa,QAAQ,qCAAoC;AAElE,MAAMC,gBAAgB;AACtB,MAAMC,eAAe;AACrB,MAAMC,iBAAiB;IAAC;IAAQ;IAAO;IAAQ;CAAO,CAAC,4BAA4B;;AAEnF,OAAO,eAAeC,aACpBC,OAAe,EACfC,SAAiB,EACjBC,SAA4C,EAC5C,EACEC,QAAQ,EACRC,UAAU,EACVC,KAAK,EACLC,UAAU,IAAO,CAAA;QACfC,SACE,CAACC,KACD,CAAC,GAAGC,OACFD,MAAMC;QACVC,cACE,CAACF,KACD,CAAC,GAAGC,OACFD,MAAMC;IACZ,CAAA,CAAE,EASH;IAED,IAAIE;IACJ,IAAIC,YAAoB;IACxB,IAAIC,aAAqB;IAEzB,IAAIf,eAAegB,QAAQ,CAACb,cAAc,CAACP,WAAWM,UAAU;QAC9D,uCAAuC;QACvC,IAAIE,UAAUa,KAAK,IAAIb,UAAUc,MAAM,EAAE;YACvCJ,YAAYhB;YACZiB,aAAaI,KAAKC,GAAG,CACnBD,KAAKE,KAAK,CAAC,AAACjB,UAAUc,MAAM,GAAGd,UAAUa,KAAK,GAAInB,gBAClD;QAEJ,OAAO;YACLgB,YAAYK,KAAKC,GAAG,CAClBD,KAAKE,KAAK,CAAC,AAACjB,UAAUa,KAAK,GAAGb,UAAUc,MAAM,GAAIpB,gBAClD;YAEFiB,aAAajB;QACf;QAEA,IAAIS,OAAO;YACT,8EAA8E;YAC9E,qEAAqE;YACrE,uEAAuE;YACvE,MAAMe,SAAS;YACf,MAAMC,MAAM,IAAIC,IAAI,CAAC,EAAEnB,YAAY,GAAG,YAAY,CAAC,EAAEiB;YACrDC,IAAIE,YAAY,CAACC,GAAG,CAAC,OAAOpB;YAC5BiB,IAAIE,YAAY,CAACC,GAAG,CAAC,KAAKC,OAAOb;YACjCS,IAAIE,YAAY,CAACC,GAAG,CAAC,KAAKC,OAAO5B;YACjCc,cAAcU,IAAIK,IAAI,CAACC,KAAK,CAACP,OAAOQ,MAAM;QAC5C,OAAO;YACL,MAAMC,kBAAkBvB,QAAQ;YAChC,MAAMwB,eAAe,MAAMD,gBAAgBnB,YAAY,CAAC,IACtDf,cAAc;oBACZoC,QAAQ/B;oBACRe,OAAOH;oBACPI,QAAQH;oBACRmB,aAAa,CAAC,MAAM,EAAE/B,UAAU,CAAC;oBACjCgC,SAASpC;gBACX;YAEF,MAAMqC,kBAAkB5B,QAAQ;YAChCK,cAAcuB,gBAAgB3B,OAAO,CACnC,IACE,CAAC,WAAW,EAAEN,UAAU,QAAQ,EAAE6B,aAAaK,QAAQ,CAAC,UAAU,CAAC;QAEzE;IACF;IACA,OAAO;QACLC,SAASzB;QACTI,OAAOH;QACPI,QAAQH;IACV;AACF"}

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

@@ -0,0 +1,53 @@
+import path from "path";
+import loaderUtils from "next/dist/compiled/loader-utils3";
+import { getImageSize } from "../../../../server/image-optimizer";
+import { getBlurImage } from "./blur";
+function nextImageLoader(content) {
+    const imageLoaderSpan = this.currentTraceSpan.traceChild("next-image-loader");
+    return imageLoaderSpan.traceAsyncFn(async ()=>{
+        const options = this.getOptions();
+        const { compilerType, isDev, assetPrefix, basePath } = options;
+        const context = this.rootContext;
+        const opts = {
+            context,
+            content
+        };
+        const interpolatedName = loaderUtils.interpolateName(this, "/static/media/[name].[hash:8].[ext]", opts);
+        const outputPath = assetPrefix + "/_next" + interpolatedName;
+        let extension = loaderUtils.interpolateName(this, "[ext]", opts);
+        if (extension === "jpg") {
+            extension = "jpeg";
+        }
+        const imageSizeSpan = imageLoaderSpan.traceChild("image-size-calculation");
+        const imageSize = await imageSizeSpan.traceAsyncFn(()=>getImageSize(content, extension).catch((err)=>err));
+        if (imageSize instanceof Error) {
+            const err = imageSize;
+            err.name = "InvalidImageFormatError";
+            throw err;
+        }
+        const { dataURL: blurDataURL, width: blurWidth, height: blurHeight } = await getBlurImage(content, extension, imageSize, {
+            basePath,
+            outputPath,
+            isDev,
+            tracing: imageLoaderSpan.traceChild.bind(imageLoaderSpan)
+        });
+        const stringifiedData = imageLoaderSpan.traceChild("image-data-stringify").traceFn(()=>JSON.stringify({
+                src: outputPath,
+                height: imageSize.height,
+                width: imageSize.width,
+                blurDataURL,
+                blurWidth,
+                blurHeight
+            }));
+        if (compilerType === "client") {
+            this.emitFile(interpolatedName, content, null);
+        } else {
+            this.emitFile(path.join("..", isDev || compilerType === "edge-server" ? "" : "..", interpolatedName), content, null);
+        }
+        return `export default ${stringifiedData};`;
+    });
+}
+export const raw = true;
+export default nextImageLoader;
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-image-loader/index.ts"],"names":["path","loaderUtils","getImageSize","getBlurImage","nextImageLoader","content","imageLoaderSpan","currentTraceSpan","traceChild","traceAsyncFn","options","getOptions","compilerType","isDev","assetPrefix","basePath","context","rootContext","opts","interpolatedName","interpolateName","outputPath","extension","imageSizeSpan","imageSize","catch","err","Error","name","dataURL","blurDataURL","width","blurWidth","height","blurHeight","tracing","bind","stringifiedData","traceFn","JSON","stringify","src","emitFile","join","raw"],"mappings":"AAEA,OAAOA,UAAU,OAAM;AACvB,OAAOC,iBAAiB,mCAAkC;AAC1D,SAASC,YAAY,QAAQ,qCAAoC;AACjE,SAASC,YAAY,QAAQ,SAAQ;AASrC,SAASC,gBAA2BC,OAAe;IACjD,MAAMC,kBAAkB,IAAI,CAACC,gBAAgB,CAACC,UAAU,CAAC;IACzD,OAAOF,gBAAgBG,YAAY,CAAC;QAClC,MAAMC,UAAmB,IAAI,CAACC,UAAU;QACxC,MAAM,EAAEC,YAAY,EAAEC,KAAK,EAAEC,WAAW,EAAEC,QAAQ,EAAE,GAAGL;QACvD,MAAMM,UAAU,IAAI,CAACC,WAAW;QAEhC,MAAMC,OAAO;YAAEF;YAASX;QAAQ;QAChC,MAAMc,mBAAmBlB,YAAYmB,eAAe,CAClD,IAAI,EACJ,uCACAF;QAEF,MAAMG,aAAaP,cAAc,WAAWK;QAC5C,IAAIG,YAAYrB,YAAYmB,eAAe,CAAC,IAAI,EAAE,SAASF;QAC3D,IAAII,cAAc,OAAO;YACvBA,YAAY;QACd;QAEA,MAAMC,gBAAgBjB,gBAAgBE,UAAU,CAAC;QACjD,MAAMgB,YAAY,MAAMD,cAAcd,YAAY,CAAC,IACjDP,aAAaG,SAASiB,WAAWG,KAAK,CAAC,CAACC,MAAQA;QAGlD,IAAIF,qBAAqBG,OAAO;YAC9B,MAAMD,MAAMF;YACZE,IAAIE,IAAI,GAAG;YACX,MAAMF;QACR;QAEA,MAAM,EACJG,SAASC,WAAW,EACpBC,OAAOC,SAAS,EAChBC,QAAQC,UAAU,EACnB,GAAG,MAAM/B,aAAaE,SAASiB,WAAWE,WAAW;YACpDT;YACAM;YACAR;YACAsB,SAAS7B,gBAAgBE,UAAU,CAAC4B,IAAI,CAAC9B;QAC3C;QAEA,MAAM+B,kBAAkB/B,gBACrBE,UAAU,CAAC,wBACX8B,OAAO,CAAC,IACPC,KAAKC,SAAS,CAAC;gBACbC,KAAKpB;gBACLY,QAAQT,UAAUS,MAAM;gBACxBF,OAAOP,UAAUO,KAAK;gBACtBD;gBACAE;gBACAE;YACF;QAGJ,IAAItB,iBAAiB,UAAU;YAC7B,IAAI,CAAC8B,QAAQ,CAACvB,kBAAkBd,SAAS;QAC3C,OAAO;YACL,IAAI,CAACqC,QAAQ,CACX1C,KAAK2C,IAAI,CACP,MACA9B,SAASD,iBAAiB,gBAAgB,KAAK,MAC/CO,mBAEFd,SACA;QAEJ;QAEA,OAAO,CAAC,eAAe,EAAEgC,gBAAgB,CAAC,CAAC;IAC7C;AACF;AACA,OAAO,MAAMO,MAAM,KAAI;AACvB,eAAexC,gBAAe"}

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

@@ -0,0 +1,6 @@
+export default function nextInvalidImportErrorLoader() {
+    const { message } = this.getOptions();
+    throw new Error(message);
+}
+
+//# sourceMappingURL=next-invalid-import-error-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-invalid-import-error-loader.ts"],"names":["nextInvalidImportErrorLoader","message","getOptions","Error"],"mappings":"AAAA,eAAe,SAASA;IACtB,MAAM,EAAEC,OAAO,EAAE,GAAG,IAAI,CAACC,UAAU;IACnC,MAAM,IAAIC,MAAMF;AAClB"}

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

@@ -0,0 +1,137 @@
+/*
+ * This loader is responsible for extracting the metadata image info for rendering in html
+ */ import fs from "fs/promises";
+import path from "path";
+import loaderUtils from "next/dist/compiled/loader-utils3";
+import { getImageSize } from "../../../server/image-optimizer";
+import { imageExtMimeTypeMap } from "../../../lib/mime-type";
+import { fileExists } from "../../../lib/file-exists";
+import { WEBPACK_RESOURCE_QUERIES } from "../../../lib/constants";
+import { normalizePathSep } from "../../../shared/lib/page-path/normalize-path-sep";
+// [NOTE] For turbopack
+// refer loader_tree's write_static|dynamic_metadata for corresponding features
+async function nextMetadataImageLoader(content) {
+    const options = this.getOptions();
+    const { type, segment, pageExtensions, basePath } = options;
+    const { resourcePath, rootContext: context } = this;
+    const { name: fileNameBase, ext } = path.parse(resourcePath);
+    const useNumericSizes = type === "twitter" || type === "openGraph";
+    let extension = ext.slice(1);
+    if (extension === "jpg") {
+        extension = "jpeg";
+    }
+    const opts = {
+        context,
+        content
+    };
+    // No hash query for favicon.ico
+    const contentHash = type === "favicon" ? "" : loaderUtils.interpolateName(this, "[contenthash]", opts);
+    const interpolatedName = loaderUtils.interpolateName(this, "[name].[ext]", opts);
+    const isDynamicResource = pageExtensions.includes(extension);
+    const pageSegment = isDynamicResource ? fileNameBase : interpolatedName;
+    const hashQuery = contentHash ? "?" + contentHash : "";
+    const pathnamePrefix = normalizePathSep(path.join(basePath, segment));
+    if (isDynamicResource) {
+        var _mod_dependencies;
+        const mod = await new Promise((res, rej)=>{
+            this.loadModule(resourcePath, (err, _source, _sourceMap, module)=>{
+                if (err) {
+                    return rej(err);
+                }
+                res(module);
+            });
+        });
+        const exportedFieldsExcludingDefault = ((_mod_dependencies = mod.dependencies) == null ? void 0 : _mod_dependencies.filter((dep)=>{
+            return [
+                "HarmonyExportImportedSpecifierDependency",
+                "HarmonyExportSpecifierDependency"
+            ].includes(dep.constructor.name) && "name" in dep && dep.name !== "default";
+        }).map((dep)=>{
+            return dep.name;
+        })) || [];
+        // re-export and spread as `exportedImageData` to avoid non-exported error
+        return `\
+    import {
+      ${exportedFieldsExcludingDefault.map((field)=>`${field} as _${field}`).join(",")}
+    } from ${JSON.stringify(// This is an arbitrary resource query to ensure it's a new request, instead
+        // of sharing the same module with next-metadata-route-loader.
+        // Since here we only need export fields such as `size`, `alt` and
+        // `generateImageMetadata`, avoid sharing the same module can make this entry
+        // smaller.
+        resourcePath + "?" + WEBPACK_RESOURCE_QUERIES.metadataImageMeta)}
+    import { fillMetadataSegment } from 'next/dist/lib/metadata/get-metadata-route'
+
+    const imageModule = {
+      ${exportedFieldsExcludingDefault.map((field)=>`${field}: _${field}`).join(",")}
+    }
+
+    export default async function (props) {
+      const { __metadata_id__: _, ...params } = props.params
+      const imageUrl = fillMetadataSegment(${JSON.stringify(pathnamePrefix)}, params, ${JSON.stringify(pageSegment)})
+
+      const { generateImageMetadata } = imageModule
+
+      function getImageMetadata(imageMetadata, idParam) {
+        const data = {
+          alt: imageMetadata.alt,
+          type: imageMetadata.contentType || 'image/png',
+          url: imageUrl + (idParam ? ('/' + idParam) : '') + ${JSON.stringify(hashQuery)},
+        }
+        const { size } = imageMetadata
+        if (size) {
+          ${type === "twitter" || type === "openGraph" ? "data.width = size.width; data.height = size.height;" : 'data.sizes = size.width + "x" + size.height;'}
+        }
+        return data
+      }
+
+      if (generateImageMetadata) {
+        const imageMetadataArray = await generateImageMetadata({ params })
+        return imageMetadataArray.map((imageMetadata, index) => {
+          const idParam = (imageMetadata.id || index) + ''
+          return getImageMetadata(imageMetadata, idParam)
+        })
+      } else {
+        return [getImageMetadata(imageModule, '')]
+      }
+    }`;
+    }
+    const imageSize = await getImageSize(content, extension).catch((err)=>err);
+    if (imageSize instanceof Error) {
+        const err = imageSize;
+        err.name = "InvalidImageFormatError";
+        throw err;
+    }
+    const imageData = {
+        ...extension in imageExtMimeTypeMap && {
+            type: imageExtMimeTypeMap[extension]
+        },
+        ...useNumericSizes && imageSize.width != null && imageSize.height != null ? imageSize : {
+            sizes: // For SVGs, skip sizes and use "any" to let it scale automatically based on viewport,
+            // For the images doesn't provide the size properly, use "any" as well.
+            // If the size is presented, use the actual size for the image.
+            extension !== "svg" && imageSize.width != null && imageSize.height != null ? `${imageSize.width}x${imageSize.height}` : "any"
+        }
+    };
+    if (type === "openGraph" || type === "twitter") {
+        const altPath = path.join(path.dirname(resourcePath), fileNameBase + ".alt.txt");
+        if (await fileExists(altPath)) {
+            imageData.alt = await fs.readFile(altPath, "utf8");
+        }
+    }
+    return `\
+  import { fillMetadataSegment } from 'next/dist/lib/metadata/get-metadata-route'
+
+  export default (props) => {
+    const imageData = ${JSON.stringify(imageData)}
+    const imageUrl = fillMetadataSegment(${JSON.stringify(pathnamePrefix)}, props.params, ${JSON.stringify(pageSegment)})
+
+    return [{
+      ...imageData,
+      url: imageUrl + ${JSON.stringify(type === "favicon" ? "" : hashQuery)},
+    }]
+  }`;
+}
+export const raw = true;
+export default nextMetadataImageLoader;
+
+//# sourceMappingURL=next-metadata-image-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-metadata-image-loader.ts"],"names":["fs","path","loaderUtils","getImageSize","imageExtMimeTypeMap","fileExists","WEBPACK_RESOURCE_QUERIES","normalizePathSep","nextMetadataImageLoader","content","options","getOptions","type","segment","pageExtensions","basePath","resourcePath","rootContext","context","name","fileNameBase","ext","parse","useNumericSizes","extension","slice","opts","contentHash","interpolateName","interpolatedName","isDynamicResource","includes","pageSegment","hashQuery","pathnamePrefix","join","mod","Promise","res","rej","loadModule","err","_source","_sourceMap","module","exportedFieldsExcludingDefault","dependencies","filter","dep","constructor","map","field","JSON","stringify","metadataImageMeta","imageSize","catch","Error","imageData","width","height","sizes","altPath","dirname","alt","readFile","raw"],"mappings":"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"}

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

@@ -0,0 +1,196 @@
+import fs from "fs";
+import path from "path";
+import { imageExtMimeTypeMap } from "../../../lib/mime-type";
+const cacheHeader = {
+    none: "no-cache, no-store",
+    longCache: "public, immutable, no-transform, max-age=31536000",
+    revalidate: "public, max-age=0, must-revalidate"
+};
+export function getFilenameAndExtension(resourcePath) {
+    const filename = path.basename(resourcePath);
+    const [name, ext] = filename.split(".");
+    return {
+        name,
+        ext
+    };
+}
+function getContentType(resourcePath) {
+    let { name, ext } = getFilenameAndExtension(resourcePath);
+    if (ext === "jpg") ext = "jpeg";
+    if (name === "favicon" && ext === "ico") return "image/x-icon";
+    if (name === "sitemap") return "application/xml";
+    if (name === "robots") return "text/plain";
+    if (name === "manifest") return "application/manifest+json";
+    if (ext === "png" || ext === "jpeg" || ext === "ico" || ext === "svg") {
+        return imageExtMimeTypeMap[ext];
+    }
+    return "text/plain";
+}
+// Strip metadata resource query string from `import.meta.url` to make sure the fs.readFileSync get the right path.
+async function getStaticRouteCode(resourcePath, fileBaseName) {
+    const cache = fileBaseName === "favicon" ? "public, max-age=0, must-revalidate" : process.env.NODE_ENV !== "production" ? cacheHeader.none : cacheHeader.longCache;
+    const code = `\
+import { NextResponse } from 'next/server'
+
+const contentType = ${JSON.stringify(getContentType(resourcePath))}
+const buffer = Buffer.from(${JSON.stringify((await fs.promises.readFile(resourcePath)).toString("base64"))}, 'base64'
+  )
+
+export function GET() {
+  return new NextResponse(buffer, {
+    headers: {
+      'Content-Type': contentType,
+      'Cache-Control': ${JSON.stringify(cache)},
+    },
+  })
+}
+
+export const dynamic = 'force-static'
+`;
+    return code;
+}
+function getDynamicTextRouteCode(resourcePath) {
+    return `\
+import { NextResponse } from 'next/server'
+import handler from ${JSON.stringify(resourcePath)}
+import { resolveRouteData } from 'next/dist/build/webpack/loaders/metadata/resolve-route-data'
+
+const contentType = ${JSON.stringify(getContentType(resourcePath))}
+const fileType = ${JSON.stringify(getFilenameAndExtension(resourcePath).name)}
+
+export async function GET() {
+  const data = await handler()
+  const content = resolveRouteData(data, fileType)
+
+  return new NextResponse(content, {
+    headers: {
+      'Content-Type': contentType,
+      'Cache-Control': ${JSON.stringify(cacheHeader.revalidate)},
+    },
+  })
+}
+`;
+}
+// <metadata-image>/[id]/route.js
+function getDynamicImageRouteCode(resourcePath) {
+    return `\
+import { NextResponse } from 'next/server'
+import * as _imageModule from ${JSON.stringify(resourcePath)}
+
+const imageModule = { ..._imageModule }
+
+const handler = imageModule.default
+const generateImageMetadata = imageModule.generateImageMetadata
+
+export async function GET(_, ctx) {
+  const { __metadata_id__ = [], ...params } = ctx.params || {}
+  const targetId = __metadata_id__[0]
+  let id = undefined
+  const imageMetadata = generateImageMetadata ? await generateImageMetadata({ params }) : null
+
+  if (imageMetadata) {
+    id = imageMetadata.find((item) => {
+      if (process.env.NODE_ENV !== 'production') {
+        if (item?.id == null) {
+          throw new Error('id property is required for every item returned from generateImageMetadata')
+        }
+      }
+      return item.id.toString() === targetId
+    })?.id
+    if (id == null) {
+      return new NextResponse('Not Found', {
+        status: 404,
+      })
+    }
+  }
+  return handler({ params: ctx.params ? params : undefined, id })
+}
+`;
+}
+function getDynamicSiteMapRouteCode(resourcePath, page) {
+    let staticGenerationCode = "";
+    if (process.env.NODE_ENV === "production" && page.includes("[__metadata_id__]")) {
+        staticGenerationCode = `\
+export async function generateStaticParams() {
+  const sitemaps = await generateSitemaps()
+  const params = []
+
+  for (const item of sitemaps) {
+    params.push({ __metadata_id__: item.id.toString() + '.xml' })
+  }
+  return params
+}
+    `;
+    }
+    const code = `\
+import { NextResponse } from 'next/server'
+import * as _sitemapModule from ${JSON.stringify(resourcePath)}
+import { resolveRouteData } from 'next/dist/build/webpack/loaders/metadata/resolve-route-data'
+
+const sitemapModule = { ..._sitemapModule }
+const handler = sitemapModule.default
+const generateSitemaps = sitemapModule.generateSitemaps
+const contentType = ${JSON.stringify(getContentType(resourcePath))}
+const fileType = ${JSON.stringify(getFilenameAndExtension(resourcePath).name)}
+
+export async function GET(_, ctx) {
+  const { __metadata_id__ = [], ...params } = ctx.params || {}
+  const targetId = __metadata_id__[0]
+  let id = undefined
+  const sitemaps = generateSitemaps ? await generateSitemaps() : null
+
+  if (sitemaps) {
+    id = sitemaps.find((item) => {
+      if (process.env.NODE_ENV !== 'production') {
+        if (item?.id == null) {
+          throw new Error('id property is required for every item returned from generateSitemaps')
+        }
+      }
+      return item.id.toString() === targetId
+    })?.id
+    if (id == null) {
+      return new NextResponse('Not Found', {
+        status: 404,
+      })
+    }
+  }
+
+  const data = await handler({ id })
+  const content = resolveRouteData(data, fileType)
+
+  return new NextResponse(content, {
+    headers: {
+      'Content-Type': contentType,
+      'Cache-Control': ${JSON.stringify(cacheHeader.revalidate)},
+    },
+  })
+}
+
+${staticGenerationCode}
+`;
+    return code;
+}
+// `import.meta.url` is the resource name of the current module.
+// When it's static route, it could be favicon.ico, sitemap.xml, robots.txt etc.
+// TODO-METADATA: improve the cache control strategy
+const nextMetadataRouterLoader = async function() {
+    const { resourcePath } = this;
+    const { page, isDynamic } = this.getOptions();
+    const { name: fileBaseName } = getFilenameAndExtension(resourcePath);
+    let code = "";
+    if (isDynamic === "1") {
+        if (fileBaseName === "robots" || fileBaseName === "manifest") {
+            code = getDynamicTextRouteCode(resourcePath);
+        } else if (fileBaseName === "sitemap") {
+            code = getDynamicSiteMapRouteCode(resourcePath, page);
+        } else {
+            code = getDynamicImageRouteCode(resourcePath);
+        }
+    } else {
+        code = await getStaticRouteCode(resourcePath, fileBaseName);
+    }
+    return code;
+};
+export default nextMetadataRouterLoader;
+
+//# sourceMappingURL=next-metadata-route-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-metadata-route-loader.ts"],"names":["fs","path","imageExtMimeTypeMap","cacheHeader","none","longCache","revalidate","getFilenameAndExtension","resourcePath","filename","basename","name","ext","split","getContentType","getStaticRouteCode","fileBaseName","cache","process","env","NODE_ENV","code","JSON","stringify","promises","readFile","toString","getDynamicTextRouteCode","getDynamicImageRouteCode","getDynamicSiteMapRouteCode","page","staticGenerationCode","includes","nextMetadataRouterLoader","isDynamic","getOptions"],"mappings":"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"}

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

@@ -0,0 +1,19 @@
+import loaderUtils from "next/dist/compiled/loader-utils3";
+import { getModuleBuildInfo } from "./get-module-build-info";
+export default function MiddlewareAssetLoader(source) {
+    const name = loaderUtils.interpolateName(this, "[name].[hash].[ext]", {
+        context: this.rootContext,
+        content: source
+    });
+    const filePath = `edge-chunks/asset_${name}`;
+    const buildInfo = getModuleBuildInfo(this._module);
+    buildInfo.nextAssetMiddlewareBinding = {
+        filePath: `server/${filePath}`,
+        name
+    };
+    this.emitFile(filePath, source);
+    return `module.exports = ${JSON.stringify(`blob:${name}`)}`;
+}
+export const raw = true;
+
+//# sourceMappingURL=next-middleware-asset-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-middleware-asset-loader.ts"],"names":["loaderUtils","getModuleBuildInfo","MiddlewareAssetLoader","source","name","interpolateName","context","rootContext","content","filePath","buildInfo","_module","nextAssetMiddlewareBinding","emitFile","JSON","stringify","raw"],"mappings":"AAAA,OAAOA,iBAAiB,mCAAkC;AAC1D,SAASC,kBAAkB,QAAQ,0BAAyB;AAE5D,eAAe,SAASC,sBAAiCC,MAAc;IACrE,MAAMC,OAAOJ,YAAYK,eAAe,CAAC,IAAI,EAAE,uBAAuB;QACpEC,SAAS,IAAI,CAACC,WAAW;QACzBC,SAASL;IACX;IACA,MAAMM,WAAW,CAAC,kBAAkB,EAAEL,KAAK,CAAC;IAC5C,MAAMM,YAAYT,mBAAmB,IAAI,CAACU,OAAO;IACjDD,UAAUE,0BAA0B,GAAG;QACrCH,UAAU,CAAC,OAAO,EAAEA,SAAS,CAAC;QAC9BL;IACF;IACA,IAAI,CAACS,QAAQ,CAACJ,UAAUN;IACxB,OAAO,CAAC,iBAAiB,EAAEW,KAAKC,SAAS,CAAC,CAAC,KAAK,EAAEX,KAAK,CAAC,EAAE,CAAC;AAC7D;AAEA,OAAO,MAAMY,MAAM,KAAI"}

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

@@ -0,0 +1,51 @@
+import { getModuleBuildInfo } from "./get-module-build-info";
+import { stringifyRequest } from "../stringify-request";
+import { MIDDLEWARE_LOCATION_REGEXP } from "../../../lib/constants";
+// matchers can have special characters that break the loader params
+// parsing so we base64 encode/decode the string
+export function encodeMatchers(matchers) {
+    return Buffer.from(JSON.stringify(matchers)).toString("base64");
+}
+export function decodeMatchers(encodedMatchers) {
+    return JSON.parse(Buffer.from(encodedMatchers, "base64").toString());
+}
+export default function middlewareLoader() {
+    const { absolutePagePath, page, rootDir, matchers: encodedMatchers, preferredRegion, middlewareConfig: middlewareConfigBase64 } = this.getOptions();
+    const matchers = encodedMatchers ? decodeMatchers(encodedMatchers) : undefined;
+    const stringifiedPagePath = stringifyRequest(this, absolutePagePath);
+    const middlewareConfig = JSON.parse(Buffer.from(middlewareConfigBase64, "base64").toString());
+    const buildInfo = getModuleBuildInfo(this._module);
+    buildInfo.nextEdgeMiddleware = {
+        matchers,
+        page: page.replace(new RegExp(`/${MIDDLEWARE_LOCATION_REGEXP}$`), "") || "/"
+    };
+    buildInfo.rootDir = rootDir;
+    buildInfo.route = {
+        page,
+        absolutePagePath,
+        preferredRegion,
+        middlewareConfig
+    };
+    return `
+        import 'next/dist/esm/server/web/globals'
+        import { adapter } from 'next/dist/esm/server/web/adapter'
+        import * as _mod from ${stringifiedPagePath}
+
+        const mod = { ..._mod }
+        const handler = mod.middleware || mod.default
+
+        if (typeof handler !== 'function') {
+          throw new Error('The Middleware "pages${page}" must export a \`middleware\` or a \`default\` function');
+        }
+
+        export default function (opts) {
+          return adapter({
+            ...opts,
+            page: ${JSON.stringify(page)},
+            handler,
+          })
+        }
+    `;
+}
+
+//# sourceMappingURL=next-middleware-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-middleware-loader.ts"],"names":["getModuleBuildInfo","stringifyRequest","MIDDLEWARE_LOCATION_REGEXP","encodeMatchers","matchers","Buffer","from","JSON","stringify","toString","decodeMatchers","encodedMatchers","parse","middlewareLoader","absolutePagePath","page","rootDir","preferredRegion","middlewareConfig","middlewareConfigBase64","getOptions","undefined","stringifiedPagePath","buildInfo","_module","nextEdgeMiddleware","replace","RegExp","route"],"mappings":"AAIA,SAASA,kBAAkB,QAAQ,0BAAyB;AAC5D,SAASC,gBAAgB,QAAQ,uBAAsB;AACvD,SAASC,0BAA0B,QAAQ,yBAAwB;AAWnE,oEAAoE;AACpE,gDAAgD;AAChD,OAAO,SAASC,eAAeC,QAA6B;IAC1D,OAAOC,OAAOC,IAAI,CAACC,KAAKC,SAAS,CAACJ,WAAWK,QAAQ,CAAC;AACxD;AAEA,OAAO,SAASC,eAAeC,eAAuB;IACpD,OAAOJ,KAAKK,KAAK,CACfP,OAAOC,IAAI,CAACK,iBAAiB,UAAUF,QAAQ;AAEnD;AAEA,eAAe,SAASI;IACtB,MAAM,EACJC,gBAAgB,EAChBC,IAAI,EACJC,OAAO,EACPZ,UAAUO,eAAe,EACzBM,eAAe,EACfC,kBAAkBC,sBAAsB,EACzC,GAA4B,IAAI,CAACC,UAAU;IAC5C,MAAMhB,WAAWO,kBAAkBD,eAAeC,mBAAmBU;IACrE,MAAMC,sBAAsBrB,iBAAiB,IAAI,EAAEa;IACnD,MAAMI,mBAAqCX,KAAKK,KAAK,CACnDP,OAAOC,IAAI,CAACa,wBAAwB,UAAUV,QAAQ;IAExD,MAAMc,YAAYvB,mBAAmB,IAAI,CAACwB,OAAO;IACjDD,UAAUE,kBAAkB,GAAG;QAC7BrB;QACAW,MACEA,KAAKW,OAAO,CAAC,IAAIC,OAAO,CAAC,CAAC,EAAEzB,2BAA2B,CAAC,CAAC,GAAG,OAAO;IACvE;IACAqB,UAAUP,OAAO,GAAGA;IACpBO,UAAUK,KAAK,GAAG;QAChBb;QACAD;QACAG;QACAC;IACF;IAEA,OAAO,CAAC;;;8BAGoB,EAAEI,oBAAoB;;;;;;gDAMJ,EAAEP,KAAK;;;;;;kBAMrC,EAAER,KAAKC,SAAS,CAACO,MAAM;;;;IAIrC,CAAC;AACL"}

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

@@ -0,0 +1,19 @@
+import { getModuleBuildInfo } from "./get-module-build-info";
+import crypto from "crypto";
+function sha1(source) {
+    return crypto.createHash("sha1").update(source).digest("hex");
+}
+export default function MiddlewareWasmLoader(source) {
+    const name = `wasm_${sha1(source)}`;
+    const filePath = `edge-chunks/${name}.wasm`;
+    const buildInfo = getModuleBuildInfo(this._module);
+    buildInfo.nextWasmMiddlewareBinding = {
+        filePath: `server/${filePath}`,
+        name
+    };
+    this.emitFile(`/${filePath}`, source, null);
+    return `module.exports = ${name};`;
+}
+export const raw = true;
+
+//# sourceMappingURL=next-middleware-wasm-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-middleware-wasm-loader.ts"],"names":["getModuleBuildInfo","crypto","sha1","source","createHash","update","digest","MiddlewareWasmLoader","name","filePath","buildInfo","_module","nextWasmMiddlewareBinding","emitFile","raw"],"mappings":"AAAA,SAASA,kBAAkB,QAAQ,0BAAyB;AAC5D,OAAOC,YAAY,SAAQ;AAE3B,SAASC,KAAKC,MAAuB;IACnC,OAAOF,OAAOG,UAAU,CAAC,QAAQC,MAAM,CAACF,QAAQG,MAAM,CAAC;AACzD;AAEA,eAAe,SAASC,qBAAgCJ,MAAc;IACpE,MAAMK,OAAO,CAAC,KAAK,EAAEN,KAAKC,QAAQ,CAAC;IACnC,MAAMM,WAAW,CAAC,YAAY,EAAED,KAAK,KAAK,CAAC;IAC3C,MAAME,YAAYV,mBAAmB,IAAI,CAACW,OAAO;IACjDD,UAAUE,yBAAyB,GAAG;QAAEH,UAAU,CAAC,OAAO,EAAEA,SAAS,CAAC;QAAED;IAAK;IAC7E,IAAI,CAACK,QAAQ,CAAC,CAAC,CAAC,EAAEJ,SAAS,CAAC,EAAEN,QAAQ;IACtC,OAAO,CAAC,iBAAiB,EAAEK,KAAK,CAAC,CAAC;AACpC;AAEA,OAAO,MAAMM,MAAM,KAAI"}

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

@@ -0,0 +1,112 @@
+import { stringify } from "querystring";
+import { getModuleBuildInfo } from "../get-module-build-info";
+import { RouteKind } from "../../../../server/future/route-kind";
+import { normalizePagePath } from "../../../../shared/lib/page-path/normalize-page-path";
+import { decodeFromBase64, encodeToBase64 } from "../utils";
+import { isInstrumentationHookFile } from "../../../worker";
+import { loadEntrypoint } from "../../../load-entrypoint";
+/**
+ * Returns the loader entry for a given page.
+ *
+ * @param options the options to create the loader entry
+ * @returns the encoded loader entry
+ */ export function getRouteLoaderEntry(options) {
+    switch(options.kind){
+        case RouteKind.PAGES:
+            {
+                const query = {
+                    kind: options.kind,
+                    page: options.page,
+                    preferredRegion: options.preferredRegion,
+                    absolutePagePath: options.absolutePagePath,
+                    // These are the path references to the internal components that may be
+                    // overridden by userland components.
+                    absoluteAppPath: options.pages["/_app"],
+                    absoluteDocumentPath: options.pages["/_document"],
+                    middlewareConfigBase64: encodeToBase64(options.middlewareConfig)
+                };
+                return `next-route-loader?${stringify(query)}!`;
+            }
+        case RouteKind.PAGES_API:
+            {
+                const query = {
+                    kind: options.kind,
+                    page: options.page,
+                    preferredRegion: options.preferredRegion,
+                    absolutePagePath: options.absolutePagePath,
+                    middlewareConfigBase64: encodeToBase64(options.middlewareConfig)
+                };
+                return `next-route-loader?${stringify(query)}!`;
+            }
+        default:
+            {
+                throw new Error("Invariant: Unexpected route kind");
+            }
+    }
+}
+const loadPages = async ({ page, absolutePagePath, absoluteDocumentPath, absoluteAppPath, preferredRegion, middlewareConfigBase64 }, buildInfo)=>{
+    const middlewareConfig = decodeFromBase64(middlewareConfigBase64);
+    // Attach build info to the module.
+    buildInfo.route = {
+        page,
+        absolutePagePath,
+        preferredRegion,
+        middlewareConfig
+    };
+    let file = await loadEntrypoint("pages", {
+        VAR_USERLAND: absolutePagePath,
+        VAR_MODULE_DOCUMENT: absoluteDocumentPath,
+        VAR_MODULE_APP: absoluteAppPath,
+        VAR_DEFINITION_PAGE: normalizePagePath(page),
+        VAR_DEFINITION_PATHNAME: page
+    });
+    if (isInstrumentationHookFile(page)) {
+        // When we're building the instrumentation page (only when the
+        // instrumentation file conflicts with a page also labeled
+        // /instrumentation) hoist the `register` method.
+        file += '\nexport const register = hoist(userland, "register")';
+    }
+    return file;
+};
+const loadPagesAPI = async ({ page, absolutePagePath, preferredRegion, middlewareConfigBase64 }, buildInfo)=>{
+    const middlewareConfig = decodeFromBase64(middlewareConfigBase64);
+    // Attach build info to the module.
+    buildInfo.route = {
+        page,
+        absolutePagePath,
+        preferredRegion,
+        middlewareConfig
+    };
+    return await loadEntrypoint("pages-api", {
+        VAR_USERLAND: absolutePagePath,
+        VAR_DEFINITION_PAGE: normalizePagePath(page),
+        VAR_DEFINITION_PATHNAME: page
+    });
+};
+/**
+ * Handles the `next-route-loader` options.
+ * @returns the loader definition function
+ */ const loader = async function() {
+    if (!this._module) {
+        throw new Error("Invariant: expected this to reference a module");
+    }
+    const buildInfo = getModuleBuildInfo(this._module);
+    const opts = this.getOptions();
+    switch(opts.kind){
+        case RouteKind.PAGES:
+            {
+                return await loadPages(opts, buildInfo);
+            }
+        case RouteKind.PAGES_API:
+            {
+                return await loadPagesAPI(opts, buildInfo);
+            }
+        default:
+            {
+                throw new Error("Invariant: Unexpected route kind");
+            }
+    }
+};
+export default loader;
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-route-loader/index.ts"],"names":["stringify","getModuleBuildInfo","RouteKind","normalizePagePath","decodeFromBase64","encodeToBase64","isInstrumentationHookFile","loadEntrypoint","getRouteLoaderEntry","options","kind","PAGES","query","page","preferredRegion","absolutePagePath","absoluteAppPath","pages","absoluteDocumentPath","middlewareConfigBase64","middlewareConfig","PAGES_API","Error","loadPages","buildInfo","route","file","VAR_USERLAND","VAR_MODULE_DOCUMENT","VAR_MODULE_APP","VAR_DEFINITION_PAGE","VAR_DEFINITION_PATHNAME","loadPagesAPI","loader","_module","opts","getOptions"],"mappings":"AAGA,SAASA,SAAS,QAAQ,cAAa;AACvC,SAEEC,kBAAkB,QACb,2BAA0B;AACjC,SAASC,SAAS,QAAQ,uCAAsC;AAChE,SAASC,iBAAiB,QAAQ,uDAAsD;AACxF,SAASC,gBAAgB,EAAEC,cAAc,QAAQ,WAAU;AAC3D,SAASC,yBAAyB,QAAQ,kBAAiB;AAC3D,SAASC,cAAc,QAAQ,2BAA0B;AAsFzD;;;;;CAKC,GACD,OAAO,SAASC,oBAAoBC,OAAgC;IAClE,OAAQA,QAAQC,IAAI;QAClB,KAAKR,UAAUS,KAAK;YAAE;gBACpB,MAAMC,QAAiC;oBACrCF,MAAMD,QAAQC,IAAI;oBAClBG,MAAMJ,QAAQI,IAAI;oBAClBC,iBAAiBL,QAAQK,eAAe;oBACxCC,kBAAkBN,QAAQM,gBAAgB;oBAC1C,uEAAuE;oBACvE,qCAAqC;oBACrCC,iBAAiBP,QAAQQ,KAAK,CAAC,QAAQ;oBACvCC,sBAAsBT,QAAQQ,KAAK,CAAC,aAAa;oBACjDE,wBAAwBd,eAAeI,QAAQW,gBAAgB;gBACjE;gBAEA,OAAO,CAAC,kBAAkB,EAAEpB,UAAUY,OAAO,CAAC,CAAC;YACjD;QACA,KAAKV,UAAUmB,SAAS;YAAE;gBACxB,MAAMT,QAAoC;oBACxCF,MAAMD,QAAQC,IAAI;oBAClBG,MAAMJ,QAAQI,IAAI;oBAClBC,iBAAiBL,QAAQK,eAAe;oBACxCC,kBAAkBN,QAAQM,gBAAgB;oBAC1CI,wBAAwBd,eAAeI,QAAQW,gBAAgB;gBACjE;gBAEA,OAAO,CAAC,kBAAkB,EAAEpB,UAAUY,OAAO,CAAC,CAAC;YACjD;QACA;YAAS;gBACP,MAAM,IAAIU,MAAM;YAClB;IACF;AACF;AAEA,MAAMC,YAAY,OAChB,EACEV,IAAI,EACJE,gBAAgB,EAChBG,oBAAoB,EACpBF,eAAe,EACfF,eAAe,EACfK,sBAAsB,EACE,EAC1BK;IAEA,MAAMJ,mBAAqChB,iBACzCe;IAGF,mCAAmC;IACnCK,UAAUC,KAAK,GAAG;QAChBZ;QACAE;QACAD;QACAM;IACF;IAEA,IAAIM,OAAO,MAAMnB,eAAe,SAAS;QACvCoB,cAAcZ;QACda,qBAAqBV;QACrBW,gBAAgBb;QAChBc,qBAAqB3B,kBAAkBU;QACvCkB,yBAAyBlB;IAC3B;IAEA,IAAIP,0BAA0BO,OAAO;QACnC,8DAA8D;QAC9D,0DAA0D;QAC1D,iDAAiD;QACjDa,QAAQ;IACV;IAEA,OAAOA;AACT;AAEA,MAAMM,eAAe,OACnB,EACEnB,IAAI,EACJE,gBAAgB,EAChBD,eAAe,EACfK,sBAAsB,EACK,EAC7BK;IAEA,MAAMJ,mBAAqChB,iBACzCe;IAGF,mCAAmC;IACnCK,UAAUC,KAAK,GAAG;QAChBZ;QACAE;QACAD;QACAM;IACF;IAEA,OAAO,MAAMb,eAAe,aAAa;QACvCoB,cAAcZ;QACde,qBAAqB3B,kBAAkBU;QACvCkB,yBAAyBlB;IAC3B;AACF;AAEA;;;CAGC,GACD,MAAMoB,SACJ;IACE,IAAI,CAAC,IAAI,CAACC,OAAO,EAAE;QACjB,MAAM,IAAIZ,MAAM;IAClB;IAEA,MAAME,YAAYvB,mBAAmB,IAAI,CAACiC,OAAO;IACjD,MAAMC,OAAO,IAAI,CAACC,UAAU;IAE5B,OAAQD,KAAKzB,IAAI;QACf,KAAKR,UAAUS,KAAK;YAAE;gBACpB,OAAO,MAAMY,UAAUY,MAAMX;YAC/B;QACA,KAAKtB,UAAUmB,SAAS;YAAE;gBACxB,OAAO,MAAMW,aAAaG,MAAMX;YAClC;QACA;YAAS;gBACP,MAAM,IAAIF,MAAM;YAClB;IACF;AACF;AAEF,eAAeW,OAAM"}

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

@@ -0,0 +1,208 @@
+import path from "path";
+import { stringifyRequest } from "../../stringify-request";
+const loaderApi = ()=>{};
+loaderApi.pitch = function loader(request) {
+    const loaderSpan = this.currentTraceSpan.traceChild("next-style-loader");
+    return loaderSpan.traceFn(()=>{
+        const options = this.getOptions();
+        const insert = typeof options.insert === "undefined" ? '"head"' : typeof options.insert === "string" ? JSON.stringify(options.insert) : options.insert.toString();
+        const injectType = options.injectType || "styleTag";
+        const esModule = typeof options.esModule !== "undefined" ? options.esModule : false;
+        delete options.esModule;
+        switch(injectType){
+            case "linkTag":
+                {
+                    const hmrCode = this.hot ? `
+if (module.hot) {
+  module.hot.accept(
+    ${stringifyRequest(this, `!!${request}`)},
+    function() {
+     ${esModule ? "update(content);" : `content = require(${stringifyRequest(this, `!!${request}`)});
+
+           content = content.__esModule ? content.default : content;
+
+           update(content);`}
+    }
+  );
+
+  module.hot.dispose(function() {
+    update();
+  });
+}` : "";
+                    return `${esModule ? `import api from ${stringifyRequest(this, `!${path.join(__dirname, "runtime/injectStylesIntoLinkTag.js")}`)};
+            import content from ${stringifyRequest(this, `!!${request}`)};` : `var api = require(${stringifyRequest(this, `!${path.join(__dirname, "runtime/injectStylesIntoLinkTag.js")}`)});
+            var content = require(${stringifyRequest(this, `!!${request}`)});
+
+            content = content.__esModule ? content.default : content;`}
+
+var options = ${JSON.stringify(options)};
+
+options.insert = ${insert};
+
+var update = api(content, options);
+
+${hmrCode}
+
+${esModule ? "export default {}" : ""}`;
+                }
+            case "lazyStyleTag":
+            case "lazySingletonStyleTag":
+                {
+                    const isSingleton = injectType === "lazySingletonStyleTag";
+                    const hmrCode = this.hot ? `
+if (module.hot) {
+  if (!content.locals || module.hot.invalidate) {
+    var isEqualLocals = ${require("./runtime/isEqualLocals").toString()};
+    console.log({isEqualLocals})
+    var oldLocals = content.locals;
+
+    module.hot.accept(
+      ${stringifyRequest(this, `!!${request}`)},
+      function () {
+        ${esModule ? `if (!isEqualLocals(oldLocals, content.locals)) {
+                module.hot.invalidate();
+
+                return;
+              }
+
+              oldLocals = content.locals;
+
+              if (update && refs > 0) {
+                update(content);
+              }` : `content = require(${stringifyRequest(this, `!!${request}`)});
+
+              content = content.__esModule ? content.default : content;
+
+              if (!isEqualLocals(oldLocals, content.locals)) {
+                module.hot.invalidate();
+
+                return;
+              }
+
+              oldLocals = content.locals;
+
+              if (update && refs > 0) {
+                update(content);
+              }`}
+      }
+    )
+  }
+
+  module.hot.dispose(function() {
+    if (update) {
+      update();
+    }
+  });
+}` : "";
+                    return `${esModule ? `import api from ${stringifyRequest(this, `!${path.join(__dirname, "runtime/injectStylesIntoStyleTag.js")}`)};
+            import content from ${stringifyRequest(this, `!!${request}`)};` : `var api = require(${stringifyRequest(this, `!${path.join(__dirname, "runtime/injectStylesIntoStyleTag.js")}`)});
+            var content = require(${stringifyRequest(this, `!!${request}`)});
+
+            content = content.__esModule ? content.default : content;
+
+            if (typeof content === 'string') {
+              content = [[module.id, content, '']];
+            }`}
+
+var refs = 0;
+var update;
+var options = ${JSON.stringify(options)};
+
+options.insert = ${insert};
+options.singleton = ${isSingleton};
+
+var exported = {};
+
+exported.locals = content.locals || {};
+exported.use = function() {
+  if (!(refs++)) {
+    update = api(content, options);
+  }
+
+  return exported;
+};
+exported.unuse = function() {
+  if (refs > 0 && !--refs) {
+    update();
+    update = null;
+  }
+};
+
+${hmrCode}
+
+${esModule ? "export default" : "module.exports ="} exported;`;
+                }
+            case "styleTag":
+            case "singletonStyleTag":
+            default:
+                {
+                    const isSingleton = injectType === "singletonStyleTag";
+                    const hmrCode = this.hot ? `
+if (module.hot) {
+  if (!content.locals || module.hot.invalidate) {
+    var isEqualLocals = ${require("./runtime/isEqualLocals").toString()};
+    var oldLocals = content.locals;
+
+    module.hot.accept(
+      ${stringifyRequest(this, `!!${request}`)},
+      function () {
+        ${esModule ? `if (!isEqualLocals(oldLocals, content.locals)) {
+                module.hot.invalidate();
+
+                return;
+              }
+
+              oldLocals = content.locals;
+
+              update(content);` : `content = require(${stringifyRequest(this, `!!${request}`)});
+
+              content = content.__esModule ? content.default : content;
+
+              if (typeof content === 'string') {
+                content = [[module.id, content, '']];
+              }
+
+              if (!isEqualLocals(oldLocals, content.locals)) {
+                module.hot.invalidate();
+
+                return;
+              }
+
+              oldLocals = content.locals;
+
+              update(content);`}
+      }
+    )
+  }
+
+  module.hot.dispose(function() {
+    update();
+  });
+}` : "";
+                    return `${esModule ? `import api from ${stringifyRequest(this, `!${path.join(__dirname, "runtime/injectStylesIntoStyleTag.js")}`)};
+            import content from ${stringifyRequest(this, `!!${request}`)};` : `var api = require(${stringifyRequest(this, `!${path.join(__dirname, "runtime/injectStylesIntoStyleTag.js")}`)});
+            var content = require(${stringifyRequest(this, `!!${request}`)});
+
+            content = content.__esModule ? content.default : content;
+
+            if (typeof content === 'string') {
+              content = [[module.id, content, '']];
+            }`}
+
+var options = ${JSON.stringify(options)};
+
+options.insert = ${insert};
+options.singleton = ${isSingleton};
+
+var update = api(content, options);
+
+${hmrCode}
+
+${esModule ? "export default" : "module.exports ="} content.locals || {};`;
+                }
+        }
+    });
+};
+module.exports = loaderApi;
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-style-loader/index.ts"],"names":["path","stringifyRequest","loaderApi","pitch","loader","request","loaderSpan","currentTraceSpan","traceChild","traceFn","options","getOptions","insert","JSON","stringify","toString","injectType","esModule","hmrCode","hot","join","__dirname","isSingleton","require","module","exports"],"mappings":"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"}

node_modules/next/dist/esm/build/webpack/loaders/next-style-loader/runtime/injectStylesIntoLinkTag.js

@@ -0,0 +1,56 @@
+const getTarget = (()=>{
+    const memo = {};
+    return function memorize(target) {
+        if (typeof memo[target] === "undefined") {
+            let styleTarget = document.querySelector(target);
+            // Special case to return head of iframe instead of iframe itself
+            if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {
+                try {
+                    // This will throw an exception if access to iframe is blocked
+                    // due to cross-origin restrictions
+                    styleTarget = styleTarget.contentDocument.head;
+                } catch (e) {
+                    // istanbul ignore next
+                    styleTarget = null;
+                }
+            }
+            memo[target] = styleTarget;
+        }
+        return memo[target];
+    };
+})();
+module.exports = (url, options)=>{
+    options = options || {};
+    options.attributes = typeof options.attributes === "object" ? options.attributes : {};
+    if (typeof options.attributes.nonce === "undefined") {
+        const nonce = // eslint-disable-next-line no-undef
+        typeof __webpack_nonce__ !== "undefined" ? __webpack_nonce__ : null;
+        if (nonce) {
+            options.attributes.nonce = nonce;
+        }
+    }
+    const link = document.createElement("link");
+    link.rel = "stylesheet";
+    link.href = url;
+    Object.keys(options.attributes).forEach((key)=>{
+        link.setAttribute(key, options.attributes[key]);
+    });
+    if (typeof options.insert === "function") {
+        options.insert(link);
+    } else {
+        const target = getTarget(options.insert || "head");
+        if (!target) {
+            throw new Error("Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.");
+        }
+        target.appendChild(link);
+    }
+    return (newUrl)=>{
+        if (typeof newUrl === "string") {
+            link.href = newUrl;
+        } else {
+            link.parentNode.removeChild(link);
+        }
+    };
+};
+
+//# sourceMappingURL=injectStylesIntoLinkTag.js.map

node_modules/next/dist/esm/build/webpack/loaders/next-style-loader/runtime/injectStylesIntoLinkTag.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/loaders/next-style-loader/runtime/injectStylesIntoLinkTag.ts"],"names":["getTarget","memo","memorize","target","styleTarget","document","querySelector","window","HTMLIFrameElement","contentDocument","head","e","module","exports","url","options","attributes","nonce","__webpack_nonce__","link","createElement","rel","href","Object","keys","forEach","key","setAttribute","insert","Error","appendChild","newUrl","parentNode","removeChild"],"mappings":"AAAA,MAAMA,YAAY,AAAC,CAAA;IACjB,MAAMC,OAAY,CAAC;IAEnB,OAAO,SAASC,SAASC,MAAW;QAClC,IAAI,OAAOF,IAAI,CAACE,OAAO,KAAK,aAAa;YACvC,IAAIC,cAAcC,SAASC,aAAa,CAACH;YAEzC,iEAAiE;YACjE,IACEI,OAAOC,iBAAiB,IACxBJ,uBAAuBG,OAAOC,iBAAiB,EAC/C;gBACA,IAAI;oBACF,8DAA8D;oBAC9D,mCAAmC;oBACnCJ,cAAc,AAACA,YAAoBK,eAAe,CAACC,IAAI;gBACzD,EAAE,OAAOC,GAAG;oBACV,uBAAuB;oBACvBP,cAAc;gBAChB;YACF;YAEAH,IAAI,CAACE,OAAO,GAAGC;QACjB;QAEA,OAAOH,IAAI,CAACE,OAAO;IACrB;AACF,CAAA;AAIAS,OAAOC,OAAO,GAAG,CAACC,KAAUC;IAC1BA,UAAUA,WAAW,CAAC;IACtBA,QAAQC,UAAU,GAChB,OAAOD,QAAQC,UAAU,KAAK,WAAWD,QAAQC,UAAU,GAAG,CAAC;IAEjE,IAAI,OAAOD,QAAQC,UAAU,CAACC,KAAK,KAAK,aAAa;QACnD,MAAMA,QACJ,oCAAoC;QACpC,OAAOC,sBAAsB,cAAcA,oBAAoB;QAEjE,IAAID,OAAO;YACTF,QAAQC,UAAU,CAACC,KAAK,GAAGA;QAC7B;IACF;IAEA,MAAME,OAAOd,SAASe,aAAa,CAAC;IAEpCD,KAAKE,GAAG,GAAG;IACXF,KAAKG,IAAI,GAAGR;IAEZS,OAAOC,IAAI,CAACT,QAAQC,UAAU,EAAES,OAAO,CAAC,CAACC;QACvCP,KAAKQ,YAAY,CAACD,KAAKX,QAAQC,UAAU,CAACU,IAAI;IAChD;IAEA,IAAI,OAAOX,QAAQa,MAAM,KAAK,YAAY;QACxCb,QAAQa,MAAM,CAACT;IACjB,OAAO;QACL,MAAMhB,SAASH,UAAUe,QAAQa,MAAM,IAAI;QAE3C,IAAI,CAACzB,QAAQ;YACX,MAAM,IAAI0B,MACR;QAEJ;QAEA1B,OAAO2B,WAAW,CAACX;IACrB;IAEA,OAAO,CAACY;QACN,IAAI,OAAOA,WAAW,UAAU;YAC9BZ,KAAKG,IAAI,GAAGS;QACd,OAAO;YACLZ,KAAKa,UAAU,CAAEC,WAAW,CAACd;QAC/B;IACF;AACF"}

node_modules/next/dist/esm/build/webpack/loaders/next-style-loader/runtime/injectStylesIntoStyleTag.js

@@ -0,0 +1,217 @@
+const isOldIE = function isOldIE() {
+    let memo;
+    return function memorize() {
+        if (typeof memo === "undefined") {
+            // Test for IE <= 9 as proposed by Browserhacks
+            // @see http://browserhacks.com/#hack-e71d8692f65334173fee715c222cb805
+            // Tests for existence of standard globals is to allow style-loader
+            // to operate correctly into non-standard environments
+            // @see https://github.com/webpack-contrib/style-loader/issues/177
+            memo = Boolean(window && document && document.all && !window.atob);
+        }
+        return memo;
+    };
+}();
+const getTargetElement = function() {
+    const memo = {};
+    return function memorize(target) {
+        if (typeof memo[target] === "undefined") {
+            let styleTarget = document.querySelector(target);
+            // Special case to return head of iframe instead of iframe itself
+            if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {
+                try {
+                    // This will throw an exception if access to iframe is blocked
+                    // due to cross-origin restrictions
+                    styleTarget = styleTarget.contentDocument.head;
+                } catch (e) {
+                    // istanbul ignore next
+                    styleTarget = null;
+                }
+            }
+            memo[target] = styleTarget;
+        }
+        return memo[target];
+    };
+}();
+const stylesInDom = [];
+function getIndexByIdentifier(identifier) {
+    let result = -1;
+    for(let i = 0; i < stylesInDom.length; i++){
+        if (stylesInDom[i].identifier === identifier) {
+            result = i;
+            break;
+        }
+    }
+    return result;
+}
+function modulesToDom(list, options) {
+    const idCountMap = {};
+    const identifiers = [];
+    for(let i = 0; i < list.length; i++){
+        const item = list[i];
+        const id = options.base ? item[0] + options.base : item[0];
+        const count = idCountMap[id] || 0;
+        const identifier = id + " " + count.toString();
+        idCountMap[id] = count + 1;
+        const index = getIndexByIdentifier(identifier);
+        const obj = {
+            css: item[1],
+            media: item[2],
+            sourceMap: item[3]
+        };
+        if (index !== -1) {
+            stylesInDom[index].references++;
+            stylesInDom[index].updater(obj);
+        } else {
+            stylesInDom.push({
+                identifier: identifier,
+                // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                updater: addStyle(obj, options),
+                references: 1
+            });
+        }
+        identifiers.push(identifier);
+    }
+    return identifiers;
+}
+function insertStyleElement(options) {
+    const style = document.createElement("style");
+    const attributes = options.attributes || {};
+    if (typeof attributes.nonce === "undefined") {
+        const nonce = // eslint-disable-next-line no-undef
+        typeof __webpack_nonce__ !== "undefined" ? __webpack_nonce__ : null;
+        if (nonce) {
+            attributes.nonce = nonce;
+        }
+    }
+    Object.keys(attributes).forEach(function(key) {
+        style.setAttribute(key, attributes[key]);
+    });
+    if (typeof options.insert === "function") {
+        options.insert(style);
+    } else {
+        const target = getTargetElement(options.insert || "head");
+        if (!target) {
+            throw new Error("Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.");
+        }
+        target.appendChild(style);
+    }
+    return style;
+}
+function removeStyleElement(style) {
+    // istanbul ignore if
+    if (style.parentNode === null) {
+        return false;
+    }
+    style.parentNode.removeChild(style);
+}
+/* istanbul ignore next  */ const replaceText = function replaceText() {
+    const textStore = [];
+    return function replace(index, replacement) {
+        textStore[index] = replacement;
+        return textStore.filter(Boolean).join("\n");
+    };
+}();
+function applyToSingletonTag(style, index, remove, obj) {
+    const css = remove ? "" : obj.media ? "@media " + obj.media + " {" + obj.css + "}" : obj.css;
+    // For old IE
+    /* istanbul ignore if  */ if (style.styleSheet) {
+        style.styleSheet.cssText = replaceText(index, css);
+    } else {
+        const cssNode = document.createTextNode(css);
+        const childNodes = style.childNodes;
+        if (childNodes[index]) {
+            style.removeChild(childNodes[index]);
+        }
+        if (childNodes.length) {
+            style.insertBefore(cssNode, childNodes[index]);
+        } else {
+            style.appendChild(cssNode);
+        }
+    }
+}
+function applyToTag(style, _options, obj) {
+    let css = obj.css;
+    const media = obj.media;
+    const sourceMap = obj.sourceMap;
+    if (media) {
+        style.setAttribute("media", media);
+    } else {
+        style.removeAttribute("media");
+    }
+    if (sourceMap && typeof btoa !== "undefined") {
+        css += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + " */";
+    }
+    // For old IE
+    /* istanbul ignore if  */ if (style.styleSheet) {
+        style.styleSheet.cssText = css;
+    } else {
+        while(style.firstChild){
+            style.removeChild(style.firstChild);
+        }
+        style.appendChild(document.createTextNode(css));
+    }
+}
+let singleton = null;
+let singletonCounter = 0;
+function addStyle(obj, options) {
+    let style;
+    let update;
+    let remove;
+    if (options.singleton) {
+        const styleIndex = singletonCounter++;
+        style = singleton || (singleton = insertStyleElement(options));
+        update = applyToSingletonTag.bind(null, style, styleIndex, false);
+        remove = applyToSingletonTag.bind(null, style, styleIndex, true);
+    } else {
+        style = insertStyleElement(options);
+        update = applyToTag.bind(null, style, options);
+        remove = function() {
+            removeStyleElement(style);
+        };
+    }
+    update(obj);
+    return function updateStyle(newObj) {
+        if (newObj) {
+            if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap) {
+                return;
+            }
+            update(obj = newObj);
+        } else {
+            remove();
+        }
+    };
+}
+module.exports = function(list, options) {
+    options = options || {};
+    // Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
+    // tags it will allow on a page
+    if (!options.singleton && typeof options.singleton !== "boolean") {
+        options.singleton = isOldIE();
+    }
+    list = list || [];
+    let lastIdentifiers = modulesToDom(list, options);
+    return function update(newList) {
+        newList = newList || [];
+        if (Object.prototype.toString.call(newList) !== "[object Array]") {
+            return;
+        }
+        for(let i = 0; i < lastIdentifiers.length; i++){
+            const identifier = lastIdentifiers[i];
+            const index = getIndexByIdentifier(identifier);
+            stylesInDom[index].references--;
+        }
+        const newLastIdentifiers = modulesToDom(newList, options);
+        for(let i = 0; i < lastIdentifiers.length; i++){
+            const identifier = lastIdentifiers[i];
+            const index = getIndexByIdentifier(identifier);
+            if (stylesInDom[index].references === 0) {
+                stylesInDom[index].updater();
+                stylesInDom.splice(index, 1);
+            }
+        }
+        lastIdentifiers = newLastIdentifiers;
+    };
+};
+
+//# sourceMappingURL=injectStylesIntoStyleTag.js.map

node_modules/next/dist/esm/build/webpack/loaders/next-style-loader/runtime/isEqualLocals.js

@@ -0,0 +1,26 @@
+function isEqualLocals(a, b, isNamedExport) {
+    if (!a && b || a && !b) {
+        return false;
+    }
+    let p;
+    for(p in a){
+        if (isNamedExport && p === "default") {
+            continue;
+        }
+        if (a[p] !== b[p]) {
+            return false;
+        }
+    }
+    for(p in b){
+        if (isNamedExport && p === "default") {
+            continue;
+        }
+        if (!a[p]) {
+            return false;
+        }
+    }
+    return true;
+}
+module.exports = isEqualLocals;
+
+//# sourceMappingURL=isEqualLocals.js.map

node_modules/next/dist/esm/build/webpack/loaders/next-style-loader/runtime/isEqualLocals.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/build/webpack/loaders/next-style-loader/runtime/isEqualLocals.ts"],"names":["isEqualLocals","a","b","isNamedExport","p","module","exports"],"mappings":"AAAA,SAASA,cAAcC,CAAM,EAAEC,CAAM,EAAEC,aAAkB;IACvD,IAAI,AAAC,CAACF,KAAKC,KAAOD,KAAK,CAACC,GAAI;QAC1B,OAAO;IACT;IAEA,IAAIE;IAEJ,IAAKA,KAAKH,EAAG;QACX,IAAIE,iBAAiBC,MAAM,WAAW;YAEpC;QACF;QAEA,IAAIH,CAAC,CAACG,EAAE,KAAKF,CAAC,CAACE,EAAE,EAAE;YACjB,OAAO;QACT;IACF;IAEA,IAAKA,KAAKF,EAAG;QACX,IAAIC,iBAAiBC,MAAM,WAAW;YAEpC;QACF;QAEA,IAAI,CAACH,CAAC,CAACG,EAAE,EAAE;YACT,OAAO;QACT;IACF;IAEA,OAAO;AACT;AAEAC,OAAOC,OAAO,GAAGN"}

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

@@ -0,0 +1,126 @@
+/*
+Copyright (c) 2017 The swc Project Developers
+
+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.
+*/ import { isWasm, transform } from "../../swc";
+import { getLoaderSWCOptions } from "../../swc/options";
+import path, { isAbsolute } from "path";
+async function loaderTransform(parentTrace, source, inputSourceMap) {
+    var _nextConfig_experimental, _nextConfig_experimental1, _nextConfig_experimental2, _nextConfig_experimental3;
+    // Make the loader async
+    const filename = this.resourcePath;
+    let loaderOptions = this.getOptions() || {};
+    const { isServer, rootDir, pagesDir, appDir, hasReactRefresh, nextConfig, jsConfig, supportedBrowsers, swcCacheDir, hasServerComponents, isServerLayer, optimizeBarrelExports, bundleTarget } = loaderOptions;
+    const isPageFile = filename.startsWith(pagesDir);
+    const relativeFilePathFromRoot = path.relative(rootDir, filename);
+    // For testing purposes
+    if (process.env.NEXT_TEST_MODE) {
+        if (loaderOptions.optimizeBarrelExports) {
+            console.log("optimizeBarrelExports:", filename);
+        }
+    }
+    const swcOptions = getLoaderSWCOptions({
+        pagesDir,
+        appDir,
+        filename,
+        isServer,
+        isPageFile,
+        development: this.mode === "development",
+        hasReactRefresh,
+        modularizeImports: nextConfig == null ? void 0 : nextConfig.modularizeImports,
+        optimizePackageImports: nextConfig == null ? void 0 : (_nextConfig_experimental = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental.optimizePackageImports,
+        swcPlugins: nextConfig == null ? void 0 : (_nextConfig_experimental1 = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental1.swcPlugins,
+        compilerOptions: nextConfig == null ? void 0 : nextConfig.compiler,
+        optimizeServerReact: nextConfig == null ? void 0 : (_nextConfig_experimental2 = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental2.optimizeServerReact,
+        jsConfig,
+        supportedBrowsers,
+        swcCacheDir,
+        relativeFilePathFromRoot,
+        hasServerComponents,
+        isServerActionsEnabled: nextConfig == null ? void 0 : (_nextConfig_experimental3 = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental3.serverActions,
+        isServerLayer,
+        optimizeBarrelExports,
+        bundleTarget
+    });
+    const programmaticOptions = {
+        ...swcOptions,
+        filename,
+        inputSourceMap: inputSourceMap ? JSON.stringify(inputSourceMap) : undefined,
+        // Set the default sourcemap behavior based on Webpack's mapping flag,
+        sourceMaps: this.sourceMap,
+        inlineSourcesContent: this.sourceMap,
+        // Ensure that Webpack will get a full absolute path in the sourcemap
+        // so that it can properly map the module back to its internal cached
+        // modules.
+        sourceFileName: filename
+    };
+    if (!programmaticOptions.inputSourceMap) {
+        delete programmaticOptions.inputSourceMap;
+    }
+    // auto detect development mode
+    if (this.mode && programmaticOptions.jsc && programmaticOptions.jsc.transform && programmaticOptions.jsc.transform.react && !Object.prototype.hasOwnProperty.call(programmaticOptions.jsc.transform.react, "development")) {
+        programmaticOptions.jsc.transform.react.development = this.mode === "development";
+    }
+    const swcSpan = parentTrace.traceChild("next-swc-transform");
+    return swcSpan.traceAsyncFn(()=>transform(source, programmaticOptions).then((output)=>{
+            if (output.eliminatedPackages && this.eliminatedPackages) {
+                for (const pkg of JSON.parse(output.eliminatedPackages)){
+                    this.eliminatedPackages.add(pkg);
+                }
+            }
+            return [
+                output.code,
+                output.map ? JSON.parse(output.map) : undefined
+            ];
+        }));
+}
+const EXCLUDED_PATHS = /[\\/](cache[\\/][^\\/]+\.zip[\\/]node_modules|__virtual__)[\\/]/g;
+export function pitch() {
+    const callback = this.async();
+    (async ()=>{
+        if (// TODO: investigate swc file reading in PnP mode?
+        !process.versions.pnp && !EXCLUDED_PATHS.test(this.resourcePath) && this.loaders.length - 1 === this.loaderIndex && isAbsolute(this.resourcePath) && !await isWasm()) {
+            const loaderSpan = this.currentTraceSpan.traceChild("next-swc-loader");
+            this.addDependency(this.resourcePath);
+            return loaderSpan.traceAsyncFn(()=>loaderTransform.call(this, loaderSpan));
+        }
+    })().then((r)=>{
+        if (r) return callback(null, ...r);
+        callback();
+    }, callback);
+}
+export default function swcLoader(inputSource, inputSourceMap) {
+    const loaderSpan = this.currentTraceSpan.traceChild("next-swc-loader");
+    const callback = this.async();
+    loaderSpan.traceAsyncFn(()=>loaderTransform.call(this, loaderSpan, inputSource, inputSourceMap)).then(([transformedSource, outputSourceMap])=>{
+        callback(null, transformedSource, outputSourceMap || inputSourceMap);
+    }, (err)=>{
+        callback(err);
+    });
+}
+// accept Buffers instead of strings
+export const raw = true;
+
+//# sourceMappingURL=next-swc-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/next-swc-loader.ts"],"names":["isWasm","transform","getLoaderSWCOptions","path","isAbsolute","loaderTransform","parentTrace","source","inputSourceMap","nextConfig","filename","resourcePath","loaderOptions","getOptions","isServer","rootDir","pagesDir","appDir","hasReactRefresh","jsConfig","supportedBrowsers","swcCacheDir","hasServerComponents","isServerLayer","optimizeBarrelExports","bundleTarget","isPageFile","startsWith","relativeFilePathFromRoot","relative","process","env","NEXT_TEST_MODE","console","log","swcOptions","development","mode","modularizeImports","optimizePackageImports","experimental","swcPlugins","compilerOptions","compiler","optimizeServerReact","isServerActionsEnabled","serverActions","programmaticOptions","JSON","stringify","undefined","sourceMaps","sourceMap","inlineSourcesContent","sourceFileName","jsc","react","Object","prototype","hasOwnProperty","call","swcSpan","traceChild","traceAsyncFn","then","output","eliminatedPackages","pkg","parse","add","code","map","EXCLUDED_PATHS","pitch","callback","async","versions","pnp","test","loaders","length","loaderIndex","loaderSpan","currentTraceSpan","addDependency","r","swcLoader","inputSource","transformedSource","outputSourceMap","err","raw"],"mappings":"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"}

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

@@ -0,0 +1,4 @@
+const NoopLoader = (source)=>source;
+export default NoopLoader;
+
+//# sourceMappingURL=noop-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/webpack/loaders/noop-loader.ts"],"names":["NoopLoader","source"],"mappings":"AAEA,MAAMA,aAA+C,CAACC,SAAWA;AACjE,eAAeD,WAAU"}