inital commit

node_modules/next/dist/build/analysis/extract-const-value.d.ts

@@ -0,0 +1,23 @@
+import type { Module } from '@swc/core';
+export declare class NoSuchDeclarationError extends Error {
+}
+export declare class UnsupportedValueError extends Error {
+    /** @example `config.runtime[0].value` */
+    path?: string;
+    constructor(message: string, paths?: string[]);
+}
+/**
+ * Extracts the value of an exported const variable named `exportedName`
+ * (e.g. "export const config = { runtime: 'edge' }") from swc's AST.
+ * The value must be one of (or throws UnsupportedValueError):
+ *   - string
+ *   - boolean
+ *   - number
+ *   - null
+ *   - undefined
+ *   - array containing values listed in this list
+ *   - object containing values listed in this list
+ *
+ * Throws NoSuchDeclarationError if the declaration is not found.
+ */
+export declare function extractExportedConstValue(module: Module, exportedName: string): any;

node_modules/next/dist/build/analysis/extract-const-value.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    NoSuchDeclarationError: null,
+    UnsupportedValueError: null,
+    extractExportedConstValue: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NoSuchDeclarationError: function() {
+        return NoSuchDeclarationError;
+    },
+    UnsupportedValueError: function() {
+        return UnsupportedValueError;
+    },
+    extractExportedConstValue: function() {
+        return extractExportedConstValue;
+    }
+});
+class NoSuchDeclarationError extends Error {
+}
+function isExportDeclaration(node) {
+    return node.type === 'ExportDeclaration';
+}
+function isVariableDeclaration(node) {
+    return node.type === 'VariableDeclaration';
+}
+function isIdentifier(node) {
+    return node.type === 'Identifier';
+}
+function isBooleanLiteral(node) {
+    return node.type === 'BooleanLiteral';
+}
+function isNullLiteral(node) {
+    return node.type === 'NullLiteral';
+}
+function isStringLiteral(node) {
+    return node.type === 'StringLiteral';
+}
+function isNumericLiteral(node) {
+    return node.type === 'NumericLiteral';
+}
+function isArrayExpression(node) {
+    return node.type === 'ArrayExpression';
+}
+function isObjectExpression(node) {
+    return node.type === 'ObjectExpression';
+}
+function isKeyValueProperty(node) {
+    return node.type === 'KeyValueProperty';
+}
+function isRegExpLiteral(node) {
+    return node.type === 'RegExpLiteral';
+}
+function isTemplateLiteral(node) {
+    return node.type === 'TemplateLiteral';
+}
+function isTsSatisfiesExpression(node) {
+    return node.type === 'TsSatisfiesExpression';
+}
+class UnsupportedValueError extends Error {
+    constructor(message, paths){
+        super(message);
+        // Generating "path" that looks like "config.runtime[0].value"
+        let codePath;
+        if (paths) {
+            codePath = '';
+            for (const path of paths){
+                if (path[0] === '[') {
+                    // "array" + "[0]"
+                    codePath += path;
+                } else {
+                    if (codePath === '') {
+                        codePath = path;
+                    } else {
+                        // "object" + ".key"
+                        codePath += `.${path}`;
+                    }
+                }
+            }
+        }
+        this.path = codePath;
+    }
+}
+function extractValue(node, path) {
+    if (isNullLiteral(node)) {
+        return null;
+    } else if (isBooleanLiteral(node)) {
+        // e.g. true / false
+        return node.value;
+    } else if (isStringLiteral(node)) {
+        // e.g. "abc"
+        return node.value;
+    } else if (isNumericLiteral(node)) {
+        // e.g. 123
+        return node.value;
+    } else if (isRegExpLiteral(node)) {
+        // e.g. /abc/i
+        return new RegExp(node.pattern, node.flags);
+    } else if (isIdentifier(node)) {
+        switch(node.value){
+            case 'undefined':
+                return undefined;
+            default:
+                throw new UnsupportedValueError(`Unknown identifier "${node.value}"`, path);
+        }
+    } else if (isArrayExpression(node)) {
+        // e.g. [1, 2, 3]
+        const arr = [];
+        for(let i = 0, len = node.elements.length; i < len; i++){
+            const elem = node.elements[i];
+            if (elem) {
+                if (elem.spread) {
+                    // e.g. [ ...a ]
+                    throw new UnsupportedValueError('Unsupported spread operator in the Array Expression', path);
+                }
+                arr.push(extractValue(elem.expression, path && [
+                    ...path,
+                    `[${i}]`
+                ]));
+            } else {
+                // e.g. [1, , 2]
+                //         ^^
+                arr.push(undefined);
+            }
+        }
+        return arr;
+    } else if (isObjectExpression(node)) {
+        // e.g. { a: 1, b: 2 }
+        const obj = {};
+        for (const prop of node.properties){
+            if (!isKeyValueProperty(prop)) {
+                // e.g. { ...a }
+                throw new UnsupportedValueError('Unsupported spread operator in the Object Expression', path);
+            }
+            let key;
+            if (isIdentifier(prop.key)) {
+                // e.g. { a: 1, b: 2 }
+                key = prop.key.value;
+            } else if (isStringLiteral(prop.key)) {
+                // e.g. { "a": 1, "b": 2 }
+                key = prop.key.value;
+            } else {
+                throw new UnsupportedValueError(`Unsupported key type "${prop.key.type}" in the Object Expression`, path);
+            }
+            obj[key] = extractValue(prop.value, path && [
+                ...path,
+                key
+            ]);
+        }
+        return obj;
+    } else if (isTemplateLiteral(node)) {
+        // e.g. `abc`
+        if (node.expressions.length !== 0) {
+            // TODO: should we add support for `${'e'}d${'g'}'e'`?
+            throw new UnsupportedValueError('Unsupported template literal with expressions', path);
+        }
+        // When TemplateLiteral has 0 expressions, the length of quasis is always 1.
+        // Because when parsing TemplateLiteral, the parser yields the first quasi,
+        // then the first expression, then the next quasi, then the next expression, etc.,
+        // until the last quasi.
+        // Thus if there is no expression, the parser ends at the frst and also last quasis
+        //
+        // A "cooked" interpretation where backslashes have special meaning, while a
+        // "raw" interpretation where backslashes do not have special meaning
+        // https://exploringjs.com/impatient-js/ch_template-literals.html#template-strings-cooked-vs-raw
+        const [{ cooked, raw }] = node.quasis;
+        return cooked ?? raw;
+    } else if (isTsSatisfiesExpression(node)) {
+        return extractValue(node.expression);
+    } else {
+        throw new UnsupportedValueError(`Unsupported node type "${node.type}"`, path);
+    }
+}
+function extractExportedConstValue(module1, exportedName) {
+    for (const moduleItem of module1.body){
+        if (!isExportDeclaration(moduleItem)) {
+            continue;
+        }
+        const declaration = moduleItem.declaration;
+        if (!isVariableDeclaration(declaration)) {
+            continue;
+        }
+        if (declaration.kind !== 'const') {
+            continue;
+        }
+        for (const decl of declaration.declarations){
+            if (isIdentifier(decl.id) && decl.id.value === exportedName && decl.init) {
+                return extractValue(decl.init, [
+                    exportedName
+                ]);
+            }
+        }
+    }
+    throw new NoSuchDeclarationError();
+}
+
+//# sourceMappingURL=extract-const-value.js.map

node_modules/next/dist/build/analysis/get-page-static-info.d.ts

@@ -0,0 +1,81 @@
+import type { NextConfig } from '../../server/config-shared';
+import type { RouteHas } from '../../lib/load-custom-routes';
+import type { RSCMeta } from '../webpack/loaders/get-module-build-info';
+import { PAGE_TYPES } from '../../lib/page-types';
+import { type AppSegmentConfig } from '../segment-config/app/app-segment-config';
+import { type PagesSegmentConfig, type PagesSegmentConfigConfig } from '../segment-config/pages/pages-segment-config';
+export type MiddlewareMatcher = {
+    regexp: string;
+    locale?: false;
+    has?: RouteHas[];
+    missing?: RouteHas[];
+    originalSource: string;
+};
+export type MiddlewareConfig = {
+    /**
+     * The matcher for the middleware. Read more: [Next.js Docs: Middleware `matcher`](https://nextjs.org/docs/app/api-reference/file-conventions/middleware#matcher),
+     * [Next.js Docs: Middleware matching paths](https://nextjs.org/docs/app/building-your-application/routing/middleware#matching-paths)
+     */
+    matchers?: MiddlewareMatcher[];
+    /**
+     * The regions that the middleware should run in.
+     */
+    regions?: string | string[];
+    /**
+     * A glob, or an array of globs, ignoring dynamic code evaluation for specific
+     * files. The globs are relative to your application root folder.
+     */
+    unstable_allowDynamic?: string[];
+};
+export interface AppPageStaticInfo {
+    type: PAGE_TYPES.APP;
+    ssg?: boolean;
+    ssr?: boolean;
+    rsc?: RSCModuleType;
+    generateStaticParams?: boolean;
+    generateSitemaps?: boolean;
+    generateImageMetadata?: boolean;
+    middleware?: MiddlewareConfig;
+    config: Omit<AppSegmentConfig, 'runtime' | 'maxDuration'> | undefined;
+    runtime: AppSegmentConfig['runtime'] | undefined;
+    preferredRegion: AppSegmentConfig['preferredRegion'] | undefined;
+    maxDuration: number | undefined;
+}
+export interface PagesPageStaticInfo {
+    type: PAGE_TYPES.PAGES;
+    getStaticProps?: boolean;
+    getServerSideProps?: boolean;
+    rsc?: RSCModuleType;
+    generateStaticParams?: boolean;
+    generateSitemaps?: boolean;
+    generateImageMetadata?: boolean;
+    middleware?: MiddlewareConfig;
+    config: (Omit<PagesSegmentConfig, 'runtime' | 'config' | 'maxDuration'> & {
+        config?: Omit<PagesSegmentConfigConfig, 'runtime' | 'maxDuration'>;
+    }) | undefined;
+    runtime: PagesSegmentConfig['runtime'] | undefined;
+    preferredRegion: PagesSegmentConfigConfig['regions'] | undefined;
+    maxDuration: number | undefined;
+}
+export type PageStaticInfo = AppPageStaticInfo | PagesPageStaticInfo;
+export type RSCModuleType = 'server' | 'client';
+export declare function getRSCModuleInformation(source: string, isReactServerLayer: boolean): RSCMeta;
+export declare let hadUnsupportedValue: boolean;
+type GetPageStaticInfoParams = {
+    pageFilePath: string;
+    nextConfig: Partial<NextConfig>;
+    isDev?: boolean;
+    page: string;
+    pageType: PAGE_TYPES;
+};
+export declare function getAppPageStaticInfo({ pageFilePath, nextConfig, isDev, page, }: GetPageStaticInfoParams): Promise<AppPageStaticInfo>;
+export declare function getPagesPageStaticInfo({ pageFilePath, nextConfig, isDev, page, }: GetPageStaticInfoParams): Promise<PagesPageStaticInfo>;
+/**
+ * For a given pageFilePath and nextConfig, if the config supports it, this
+ * function will read the file and return the runtime that should be used.
+ * It will look into the file content only if the page *requires* a runtime
+ * to be specified, that is, when gSSP or gSP is used.
+ * Related discussion: https://github.com/vercel/next.js/discussions/34179
+ */
+export declare function getPageStaticInfo(params: GetPageStaticInfoParams): Promise<PageStaticInfo>;
+export {};

node_modules/next/dist/build/analysis/get-page-static-info.js

@@ -0,0 +1,485 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getAppPageStaticInfo: null,
+    getMiddlewareMatchers: null,
+    getPageStaticInfo: null,
+    getPagesPageStaticInfo: null,
+    getRSCModuleInformation: null,
+    hadUnsupportedValue: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getAppPageStaticInfo: function() {
+        return getAppPageStaticInfo;
+    },
+    getMiddlewareMatchers: function() {
+        return getMiddlewareMatchers;
+    },
+    getPageStaticInfo: function() {
+        return getPageStaticInfo;
+    },
+    getPagesPageStaticInfo: function() {
+        return getPagesPageStaticInfo;
+    },
+    getRSCModuleInformation: function() {
+        return getRSCModuleInformation;
+    },
+    hadUnsupportedValue: function() {
+        return hadUnsupportedValue;
+    }
+});
+const _fs = require("fs");
+const _lrucache = require("../../server/lib/lru-cache");
+const _extractconstvalue = require("./extract-const-value");
+const _parsemodule = require("./parse-module");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../output/log"));
+const _constants = require("../../lib/constants");
+const _trytoparsepath = require("../../lib/try-to-parse-path");
+const _isapiroute = require("../../lib/is-api-route");
+const _isedgeruntime = require("../../lib/is-edge-runtime");
+const _constants1 = require("../../shared/lib/constants");
+const _pagetypes = require("../../lib/page-types");
+const _appsegmentconfig = require("../segment-config/app/app-segment-config");
+const _zod = require("../../shared/lib/zod");
+const _pagessegmentconfig = require("../segment-config/pages/pages-segment-config");
+const _middlewareconfig = require("../segment-config/middleware/middleware-config");
+const _apppaths = require("../../shared/lib/router/utils/app-paths");
+const _normalizepagepath = require("../../shared/lib/page-path/normalize-page-path");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const PARSE_PATTERN = /(?<!(_jsx|jsx-))runtime|preferredRegion|getStaticProps|getServerSideProps|generateStaticParams|export const|generateImageMetadata|generateSitemaps/;
+const CLIENT_MODULE_LABEL = /\/\* __next_internal_client_entry_do_not_use__ ([^ ]*) (cjs|auto) \*\//;
+const ACTION_MODULE_LABEL = /\/\* __next_internal_action_entry_do_not_use__ (\{[^}]+\}) \*\//;
+const CLIENT_DIRECTIVE = 'use client';
+const SERVER_ACTION_DIRECTIVE = 'use server';
+function getRSCModuleInformation(source, isReactServerLayer) {
+    const actionsJson = source.match(ACTION_MODULE_LABEL);
+    const parsedActionsMeta = actionsJson ? JSON.parse(actionsJson[1]) : undefined;
+    const clientInfoMatch = source.match(CLIENT_MODULE_LABEL);
+    const isClientRef = !!clientInfoMatch;
+    if (!isReactServerLayer) {
+        return {
+            type: _constants1.RSC_MODULE_TYPES.client,
+            actionIds: parsedActionsMeta,
+            isClientRef
+        };
+    }
+    const clientRefsString = clientInfoMatch == null ? void 0 : clientInfoMatch[1];
+    const clientRefs = clientRefsString ? clientRefsString.split(',') : [];
+    const clientEntryType = clientInfoMatch == null ? void 0 : clientInfoMatch[2];
+    const type = clientInfoMatch ? _constants1.RSC_MODULE_TYPES.client : _constants1.RSC_MODULE_TYPES.server;
+    return {
+        type,
+        actionIds: parsedActionsMeta,
+        clientRefs,
+        clientEntryType,
+        isClientRef
+    };
+}
+/**
+ * Receives a parsed AST from SWC and checks if it belongs to a module that
+ * requires a runtime to be specified. Those are:
+ *   - Modules with `export function getStaticProps | getServerSideProps`
+ *   - Modules with `export { getStaticProps | getServerSideProps } <from ...>`
+ *   - Modules with `export const runtime = ...`
+ */ function checkExports(ast, expectedExports, page) {
+    const exportsSet = new Set([
+        'getStaticProps',
+        'getServerSideProps',
+        'generateImageMetadata',
+        'generateSitemaps',
+        'generateStaticParams'
+    ]);
+    if (!Array.isArray(ast == null ? void 0 : ast.body)) {
+        return {};
+    }
+    try {
+        let getStaticProps = false;
+        let getServerSideProps = false;
+        let generateImageMetadata = false;
+        let generateSitemaps = false;
+        let generateStaticParams = false;
+        let exports1 = new Set();
+        let directives = new Set();
+        let hasLeadingNonDirectiveNode = false;
+        for (const node of ast.body){
+            var _node_declaration, _node_declaration1, _node_declaration_identifier, _node_declaration2;
+            // There should be no non-string literals nodes before directives
+            if (node.type === 'ExpressionStatement' && node.expression.type === 'StringLiteral') {
+                if (!hasLeadingNonDirectiveNode) {
+                    const directive = node.expression.value;
+                    if (CLIENT_DIRECTIVE === directive) {
+                        directives.add('client');
+                    }
+                    if (SERVER_ACTION_DIRECTIVE === directive) {
+                        directives.add('server');
+                    }
+                }
+            } else {
+                hasLeadingNonDirectiveNode = true;
+            }
+            if (node.type === 'ExportDeclaration' && ((_node_declaration = node.declaration) == null ? void 0 : _node_declaration.type) === 'VariableDeclaration') {
+                var _node_declaration3;
+                for (const declaration of (_node_declaration3 = node.declaration) == null ? void 0 : _node_declaration3.declarations){
+                    if (expectedExports.includes(declaration.id.value)) {
+                        exports1.add(declaration.id.value);
+                    }
+                }
+            }
+            if (node.type === 'ExportDeclaration' && ((_node_declaration1 = node.declaration) == null ? void 0 : _node_declaration1.type) === 'FunctionDeclaration' && exportsSet.has((_node_declaration_identifier = node.declaration.identifier) == null ? void 0 : _node_declaration_identifier.value)) {
+                const id = node.declaration.identifier.value;
+                getServerSideProps = id === 'getServerSideProps';
+                getStaticProps = id === 'getStaticProps';
+                generateImageMetadata = id === 'generateImageMetadata';
+                generateSitemaps = id === 'generateSitemaps';
+                generateStaticParams = id === 'generateStaticParams';
+            }
+            if (node.type === 'ExportDeclaration' && ((_node_declaration2 = node.declaration) == null ? void 0 : _node_declaration2.type) === 'VariableDeclaration') {
+                var _node_declaration_declarations_, _node_declaration4;
+                const id = (_node_declaration4 = node.declaration) == null ? void 0 : (_node_declaration_declarations_ = _node_declaration4.declarations[0]) == null ? void 0 : _node_declaration_declarations_.id.value;
+                if (exportsSet.has(id)) {
+                    getServerSideProps = id === 'getServerSideProps';
+                    getStaticProps = id === 'getStaticProps';
+                    generateImageMetadata = id === 'generateImageMetadata';
+                    generateSitemaps = id === 'generateSitemaps';
+                    generateStaticParams = id === 'generateStaticParams';
+                }
+            }
+            if (node.type === 'ExportNamedDeclaration') {
+                for (const specifier of node.specifiers){
+                    var _specifier_orig;
+                    if (specifier.type === 'ExportSpecifier' && ((_specifier_orig = specifier.orig) == null ? void 0 : _specifier_orig.type) === 'Identifier') {
+                        const value = specifier.orig.value;
+                        if (!getServerSideProps && value === 'getServerSideProps') {
+                            getServerSideProps = true;
+                        }
+                        if (!getStaticProps && value === 'getStaticProps') {
+                            getStaticProps = true;
+                        }
+                        if (!generateImageMetadata && value === 'generateImageMetadata') {
+                            generateImageMetadata = true;
+                        }
+                        if (!generateSitemaps && value === 'generateSitemaps') {
+                            generateSitemaps = true;
+                        }
+                        if (!generateStaticParams && value === 'generateStaticParams') {
+                            generateStaticParams = true;
+                        }
+                        if (expectedExports.includes(value) && !exports1.has(value)) {
+                            // An export was found that was actually a re-export, and not a
+                            // literal value. We should warn here.
+                            _log.warn(`Next.js can't recognize the exported \`${value}\` field in "${page}", it may be re-exported from another file. The default config will be used instead.`);
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            getStaticProps,
+            getServerSideProps,
+            generateImageMetadata,
+            generateSitemaps,
+            generateStaticParams,
+            directives,
+            exports: exports1
+        };
+    } catch  {}
+    return {};
+}
+async function tryToReadFile(filePath, shouldThrow) {
+    try {
+        return await _fs.promises.readFile(filePath, {
+            encoding: 'utf8'
+        });
+    } catch (error) {
+        if (shouldThrow) {
+            error.message = `Next.js ERROR: Failed to read file ${filePath}:\n${error.message}`;
+            throw error;
+        }
+    }
+}
+function getMiddlewareMatchers(matcherOrMatchers, nextConfig) {
+    const matchers = Array.isArray(matcherOrMatchers) ? matcherOrMatchers : [
+        matcherOrMatchers
+    ];
+    const { i18n } = nextConfig;
+    return matchers.map((matcher)=>{
+        matcher = typeof matcher === 'string' ? {
+            source: matcher
+        } : matcher;
+        const originalSource = matcher.source;
+        let { source, ...rest } = matcher;
+        const isRoot = source === '/';
+        if ((i18n == null ? void 0 : i18n.locales) && matcher.locale !== false) {
+            source = `/:nextInternalLocale((?!_next/)[^/.]{1,})${isRoot ? '' : source}`;
+        }
+        source = `/:nextData(_next/data/[^/]{1,})?${source}${isRoot ? `(${nextConfig.i18n ? '|\\.json|' : ''}/?index|/?index\\.json)?` : '{(\\.json)}?'}`;
+        if (nextConfig.basePath) {
+            source = `${nextConfig.basePath}${source}`;
+        }
+        // Validate that the source is still.
+        const result = _middlewareconfig.SourceSchema.safeParse(source);
+        if (!result.success) {
+            (0, _zod.reportZodError)('Failed to parse middleware source', result.error);
+            // We need to exit here because middleware being built occurs before we
+            // finish setting up the server. Exiting here is the only way to ensure
+            // that we don't hang.
+            process.exit(1);
+        }
+        return {
+            ...rest,
+            // We know that parsed.regexStr is not undefined because we already
+            // checked that the source is valid.
+            regexp: (0, _trytoparsepath.tryToParsePath)(result.data).regexStr,
+            originalSource: originalSource || source
+        };
+    });
+}
+function parseMiddlewareConfig(page, rawConfig, nextConfig) {
+    // If there's no config to parse, then return nothing.
+    if (typeof rawConfig !== 'object' || !rawConfig) return {};
+    const input = _middlewareconfig.MiddlewareConfigInputSchema.safeParse(rawConfig);
+    if (!input.success) {
+        (0, _zod.reportZodError)(`${page} contains invalid middleware config`, input.error);
+        // We need to exit here because middleware being built occurs before we
+        // finish setting up the server. Exiting here is the only way to ensure
+        // that we don't hang.
+        process.exit(1);
+    }
+    const config = {};
+    if (input.data.matcher) {
+        config.matchers = getMiddlewareMatchers(input.data.matcher, nextConfig);
+    }
+    if (input.data.unstable_allowDynamic) {
+        config.unstable_allowDynamic = Array.isArray(input.data.unstable_allowDynamic) ? input.data.unstable_allowDynamic : [
+            input.data.unstable_allowDynamic
+        ];
+    }
+    if (input.data.regions) {
+        config.regions = input.data.regions;
+    }
+    return config;
+}
+const apiRouteWarnings = new _lrucache.LRUCache(250);
+function warnAboutExperimentalEdge(apiRoute) {
+    if (process.env.NODE_ENV === 'production' && process.env.NEXT_PRIVATE_BUILD_WORKER === '1') {
+        return;
+    }
+    if (apiRouteWarnings.has(apiRoute)) {
+        return;
+    }
+    _log.warn(apiRoute ? `${apiRoute} provided runtime 'experimental-edge'. It can be updated to 'edge' instead.` : `You are using an experimental edge runtime, the API might change.`);
+    apiRouteWarnings.set(apiRoute, 1);
+}
+let hadUnsupportedValue = false;
+const warnedUnsupportedValueMap = new _lrucache.LRUCache(250, ()=>1);
+function warnAboutUnsupportedValue(pageFilePath, page, error) {
+    hadUnsupportedValue = true;
+    const isProductionBuild = process.env.NODE_ENV === 'production';
+    if (// we only log for the server compilation so it's not
+    // duplicated due to webpack build worker having fresh
+    // module scope for each compiler
+    process.env.NEXT_COMPILER_NAME !== 'server' || isProductionBuild && warnedUnsupportedValueMap.has(pageFilePath)) {
+        return;
+    }
+    warnedUnsupportedValueMap.set(pageFilePath, true);
+    const message = `Next.js can't recognize the exported \`config\` field in ` + (page ? `route "${page}"` : `"${pageFilePath}"`) + ':\n' + error.message + (error.path ? ` at "${error.path}"` : '') + '.\n' + 'Read More - https://nextjs.org/docs/messages/invalid-page-config';
+    // for a build we use `Log.error` instead of throwing
+    // so that all errors can be logged before exiting the process
+    if (isProductionBuild) {
+        _log.error(message);
+    } else {
+        throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+async function getAppPageStaticInfo({ pageFilePath, nextConfig, isDev, page }) {
+    const content = await tryToReadFile(pageFilePath, !isDev);
+    if (!content || !PARSE_PATTERN.test(content)) {
+        return {
+            type: _pagetypes.PAGE_TYPES.APP,
+            config: undefined,
+            runtime: undefined,
+            preferredRegion: undefined,
+            maxDuration: undefined
+        };
+    }
+    const ast = await (0, _parsemodule.parseModule)(pageFilePath, content);
+    const { generateStaticParams, generateImageMetadata, generateSitemaps, exports: exports1, directives } = checkExports(ast, _appsegmentconfig.AppSegmentConfigSchemaKeys, page);
+    const { type: rsc } = getRSCModuleInformation(content, true);
+    const exportedConfig = {};
+    if (exports1) {
+        for (const property of exports1){
+            try {
+                exportedConfig[property] = (0, _extractconstvalue.extractExportedConstValue)(ast, property);
+            } catch (e) {
+                if (e instanceof _extractconstvalue.UnsupportedValueError) {
+                    warnAboutUnsupportedValue(pageFilePath, page, e);
+                }
+            }
+        }
+    }
+    try {
+        exportedConfig.config = (0, _extractconstvalue.extractExportedConstValue)(ast, 'config');
+    } catch (e) {
+        if (e instanceof _extractconstvalue.UnsupportedValueError) {
+            warnAboutUnsupportedValue(pageFilePath, page, e);
+        }
+    // `export config` doesn't exist, or other unknown error thrown by swc, silence them
+    }
+    const route = (0, _apppaths.normalizeAppPath)(page);
+    const config = (0, _appsegmentconfig.parseAppSegmentConfig)(exportedConfig, route);
+    // Prevent edge runtime and generateStaticParams in the same file.
+    if ((0, _isedgeruntime.isEdgeRuntime)(config.runtime) && generateStaticParams) {
+        throw Object.defineProperty(new Error(`Page "${page}" cannot use both \`export const runtime = 'edge'\` and export \`generateStaticParams\`.`), "__NEXT_ERROR_CODE", {
+            value: "E42",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // Prevent use client and generateStaticParams in the same file.
+    if ((directives == null ? void 0 : directives.has('client')) && generateStaticParams) {
+        throw Object.defineProperty(new Error(`Page "${page}" cannot use both "use client" and export function "generateStaticParams()".`), "__NEXT_ERROR_CODE", {
+            value: "E475",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return {
+        type: _pagetypes.PAGE_TYPES.APP,
+        rsc,
+        generateImageMetadata,
+        generateSitemaps,
+        generateStaticParams,
+        config,
+        middleware: parseMiddlewareConfig(page, exportedConfig.config, nextConfig),
+        runtime: config.runtime,
+        preferredRegion: config.preferredRegion,
+        maxDuration: config.maxDuration
+    };
+}
+async function getPagesPageStaticInfo({ pageFilePath, nextConfig, isDev, page }) {
+    var _config_config, _config_config1, _config_config2;
+    const content = await tryToReadFile(pageFilePath, !isDev);
+    if (!content || !PARSE_PATTERN.test(content)) {
+        return {
+            type: _pagetypes.PAGE_TYPES.PAGES,
+            config: undefined,
+            runtime: undefined,
+            preferredRegion: undefined,
+            maxDuration: undefined
+        };
+    }
+    const ast = await (0, _parsemodule.parseModule)(pageFilePath, content);
+    const { getServerSideProps, getStaticProps, exports: exports1 } = checkExports(ast, _pagessegmentconfig.PagesSegmentConfigSchemaKeys, page);
+    const { type: rsc } = getRSCModuleInformation(content, true);
+    const exportedConfig = {};
+    if (exports1) {
+        for (const property of exports1){
+            try {
+                exportedConfig[property] = (0, _extractconstvalue.extractExportedConstValue)(ast, property);
+            } catch (e) {
+                if (e instanceof _extractconstvalue.UnsupportedValueError) {
+                    warnAboutUnsupportedValue(pageFilePath, page, e);
+                }
+            }
+        }
+    }
+    try {
+        exportedConfig.config = (0, _extractconstvalue.extractExportedConstValue)(ast, 'config');
+    } catch (e) {
+        if (e instanceof _extractconstvalue.UnsupportedValueError) {
+            warnAboutUnsupportedValue(pageFilePath, page, e);
+        }
+    // `export config` doesn't exist, or other unknown error thrown by swc, silence them
+    }
+    // Validate the config.
+    const route = (0, _normalizepagepath.normalizePagePath)(page);
+    const config = (0, _pagessegmentconfig.parsePagesSegmentConfig)(exportedConfig, route);
+    const isAnAPIRoute = (0, _isapiroute.isAPIRoute)(route);
+    const resolvedRuntime = config.runtime ?? ((_config_config = config.config) == null ? void 0 : _config_config.runtime);
+    if (resolvedRuntime === _constants.SERVER_RUNTIME.experimentalEdge) {
+        warnAboutExperimentalEdge(isAnAPIRoute ? page : null);
+    }
+    if (resolvedRuntime === _constants.SERVER_RUNTIME.edge && page && !isAnAPIRoute) {
+        const message = `Page ${page} provided runtime 'edge', the edge runtime for rendering is currently experimental. Use runtime 'experimental-edge' instead.`;
+        if (isDev) {
+            _log.error(message);
+        } else {
+            throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+                value: "E394",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    return {
+        type: _pagetypes.PAGE_TYPES.PAGES,
+        getStaticProps,
+        getServerSideProps,
+        rsc,
+        config,
+        middleware: parseMiddlewareConfig(page, exportedConfig.config, nextConfig),
+        runtime: resolvedRuntime,
+        preferredRegion: (_config_config1 = config.config) == null ? void 0 : _config_config1.regions,
+        maxDuration: config.maxDuration ?? ((_config_config2 = config.config) == null ? void 0 : _config_config2.maxDuration)
+    };
+}
+async function getPageStaticInfo(params) {
+    if (params.pageType === _pagetypes.PAGE_TYPES.APP) {
+        return getAppPageStaticInfo(params);
+    }
+    return getPagesPageStaticInfo(params);
+}
+
+//# sourceMappingURL=get-page-static-info.js.map

node_modules/next/dist/build/analysis/parse-module.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Parses a module with SWC using an LRU cache where the parsed module will
+ * be indexed by a sha of its content holding up to 500 entries.
+ */
+export declare const parseModule: (_: string, content: string) => Promise<any>;

node_modules/next/dist/build/analysis/parse-module.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseModule", {
+    enumerable: true,
+    get: function() {
+        return parseModule;
+    }
+});
+const _lrucache = require("../../server/lib/lru-cache");
+const _withpromisecache = require("../../lib/with-promise-cache");
+const _crypto = require("crypto");
+const _swc = require("../swc");
+const parseModule = (0, _withpromisecache.withPromiseCache)(new _lrucache.LRUCache(500), async (filename, content)=>(0, _swc.parse)(content, {
+        isModule: 'unknown',
+        filename
+    }).catch(()=>null), (_, content)=>(0, _crypto.createHash)('sha1').update(content).digest('hex'));
+
+//# sourceMappingURL=parse-module.js.map

node_modules/next/dist/build/analysis/parse-module.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/build/analysis/parse-module.ts"],"sourcesContent":["import { LRUCache } from '../../server/lib/lru-cache'\nimport { withPromiseCache } from '../../lib/with-promise-cache'\nimport { createHash } from 'crypto'\nimport { parse } from '../swc'\n\n/**\n * Parses a module with SWC using an LRU cache where the parsed module will\n * be indexed by a sha of its content holding up to 500 entries.\n */\nexport const parseModule = withPromiseCache(\n  new LRUCache<any>(500),\n  async (filename: string, content: string) =>\n    parse(content, { isModule: 'unknown', filename }).catch(() => null),\n  (_, content) => createHash('sha1').update(content).digest('hex')\n)\n"],"names":["parseModule","withPromiseCache","LRUCache","filename","content","parse","isModule","catch","_","createHash","update","digest"],"mappings":";;;;+BASaA;;;eAAAA;;;0BATY;kCACQ;wBACN;qBACL;AAMf,MAAMA,cAAcC,IAAAA,kCAAgB,EACzC,IAAIC,kBAAQ,CAAM,MAClB,OAAOC,UAAkBC,UACvBC,IAAAA,UAAK,EAACD,SAAS;QAAEE,UAAU;QAAWH;IAAS,GAAGI,KAAK,CAAC,IAAM,OAChE,CAACC,GAAGJ,UAAYK,IAAAA,kBAAU,EAAC,QAAQC,MAAM,CAACN,SAASO,MAAM,CAAC"}

node_modules/next/dist/build/babel/loader/get-config.d.ts

@@ -0,0 +1,10 @@
+import type { NextBabelLoaderOptions, NextJsLoaderContext } from './types';
+type BabelConfig = any;
+export default function getConfig(this: NextJsLoaderContext, { source, target, loaderOptions, filename, inputSourceMap, }: {
+    source: string;
+    loaderOptions: NextBabelLoaderOptions;
+    target: string;
+    filename: string;
+    inputSourceMap?: object | null;
+}): BabelConfig;
+export {};

node_modules/next/dist/build/babel/loader/get-config.js

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return getConfig;
+    }
+});
+const _fs = require("fs");
+const _json5 = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/json5"));
+const _core = require("next/dist/compiled/babel/core");
+const _corelibconfig = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/core-lib-config"));
+const _util = require("./util");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../output/log"));
+const _pluginsyntaxjsx = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/plugin-syntax-jsx"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const nextDistPath = /(next[\\/]dist[\\/]shared[\\/]lib)|(next[\\/]dist[\\/]client)|(next[\\/]dist[\\/]pages)/;
+const fileExtensionRegex = /\.([a-z]+)$/;
+function getCacheCharacteristics(loaderOptions, source, filename) {
+    var _fileExtensionRegex_exec;
+    const { isServer, pagesDir } = loaderOptions;
+    const isPageFile = filename.startsWith(pagesDir);
+    const isNextDist = nextDistPath.test(filename);
+    const hasModuleExports = source.indexOf('module.exports') !== -1;
+    const fileExt = ((_fileExtensionRegex_exec = fileExtensionRegex.exec(filename)) == null ? void 0 : _fileExtensionRegex_exec[1]) || 'unknown';
+    return {
+        isServer,
+        isPageFile,
+        isNextDist,
+        hasModuleExports,
+        fileExt
+    };
+}
+/**
+ * Return an array of Babel plugins, conditioned upon loader options and
+ * source file characteristics.
+ */ function getPlugins(loaderOptions, cacheCharacteristics) {
+    const { isServer, isPageFile, isNextDist, hasModuleExports } = cacheCharacteristics;
+    const { development } = loaderOptions;
+    const hasReactRefresh = loaderOptions.transformMode !== 'standalone' ? loaderOptions.hasReactRefresh : false;
+    const applyCommonJsItem = hasModuleExports ? (0, _core.createConfigItem)(require('../plugins/commonjs'), {
+        type: 'plugin'
+    }) : null;
+    const reactRefreshItem = hasReactRefresh ? (0, _core.createConfigItem)([
+        require('next/dist/compiled/react-refresh/babel'),
+        {
+            skipEnvCheck: true
+        }
+    ], {
+        type: 'plugin'
+    }) : null;
+    const pageConfigItem = !isServer && isPageFile ? (0, _core.createConfigItem)([
+        require('../plugins/next-page-config')
+    ], {
+        type: 'plugin'
+    }) : null;
+    const disallowExportAllItem = !isServer && isPageFile ? (0, _core.createConfigItem)([
+        require('../plugins/next-page-disallow-re-export-all-exports')
+    ], {
+        type: 'plugin'
+    }) : null;
+    const transformDefineItem = (0, _core.createConfigItem)([
+        require.resolve('next/dist/compiled/babel/plugin-transform-define'),
+        {
+            'process.env.NODE_ENV': development ? 'development' : 'production',
+            'typeof window': isServer ? 'undefined' : 'object',
+            'process.browser': isServer ? false : true
+        },
+        'next-js-transform-define-instance'
+    ], {
+        type: 'plugin'
+    });
+    const nextSsgItem = !isServer && isPageFile ? (0, _core.createConfigItem)([
+        require.resolve('../plugins/next-ssg-transform')
+    ], {
+        type: 'plugin'
+    }) : null;
+    const commonJsItem = isNextDist ? (0, _core.createConfigItem)(require('next/dist/compiled/babel/plugin-transform-modules-commonjs'), {
+        type: 'plugin'
+    }) : null;
+    const nextFontUnsupported = (0, _core.createConfigItem)([
+        require('../plugins/next-font-unsupported')
+    ], {
+        type: 'plugin'
+    });
+    return [
+        reactRefreshItem,
+        pageConfigItem,
+        disallowExportAllItem,
+        applyCommonJsItem,
+        transformDefineItem,
+        nextSsgItem,
+        commonJsItem,
+        nextFontUnsupported
+    ].filter(Boolean);
+}
+const isJsonFile = /\.(json|babelrc)$/;
+const isJsFile = /\.js$/;
+/**
+ * While this function does block execution while reading from disk, it
+ * should not introduce any issues.  The function is only invoked when
+ * generating a fresh config, and only a small handful of configs should
+ * be generated during compilation.
+ */ function getCustomBabelConfig(configFilePath) {
+    if (isJsonFile.exec(configFilePath)) {
+        const babelConfigRaw = (0, _fs.readFileSync)(configFilePath, 'utf8');
+        return _json5.default.parse(babelConfigRaw);
+    } else if (isJsFile.exec(configFilePath)) {
+        return require(configFilePath);
+    }
+    throw Object.defineProperty(new Error('The Next.js Babel loader does not support .mjs or .cjs config files.'), "__NEXT_ERROR_CODE", {
+        value: "E477",
+        enumerable: false,
+        configurable: true
+    });
+}
+let babelConfigWarned = false;
+/**
+ * Check if custom babel configuration from user only contains options that
+ * can be migrated into latest Next.js features supported by SWC.
+ *
+ * This raises soft warning messages only, not making any errors yet.
+ */ function checkCustomBabelConfigDeprecation(config) {
+    if (!config || Object.keys(config).length === 0) {
+        return;
+    }
+    const { plugins, presets, ...otherOptions } = config;
+    if (Object.keys(otherOptions ?? {}).length > 0) {
+        return;
+    }
+    if (babelConfigWarned) {
+        return;
+    }
+    babelConfigWarned = true;
+    const isPresetReadyToDeprecate = !presets || presets.length === 0 || presets.length === 1 && presets[0] === 'next/babel';
+    const pluginReasons = [];
+    const unsupportedPlugins = [];
+    if (Array.isArray(plugins)) {
+        for (const plugin of plugins){
+            const pluginName = Array.isArray(plugin) ? plugin[0] : plugin;
+            // [NOTE]: We cannot detect if the user uses babel-plugin-macro based transform plugins,
+            // such as `styled-components/macro` in here.
+            switch(pluginName){
+                case 'styled-components':
+                case 'babel-plugin-styled-components':
+                    pluginReasons.push(`\t- 'styled-components' can be enabled via 'compiler.styledComponents' in 'next.config.js'`);
+                    break;
+                case '@emotion/babel-plugin':
+                    pluginReasons.push(`\t- '@emotion/babel-plugin' can be enabled via 'compiler.emotion' in 'next.config.js'`);
+                    break;
+                case 'babel-plugin-relay':
+                    pluginReasons.push(`\t- 'babel-plugin-relay' can be enabled via 'compiler.relay' in 'next.config.js'`);
+                    break;
+                case 'react-remove-properties':
+                    pluginReasons.push(`\t- 'react-remove-properties' can be enabled via 'compiler.reactRemoveProperties' in 'next.config.js'`);
+                    break;
+                case 'transform-remove-console':
+                    pluginReasons.push(`\t- 'transform-remove-console' can be enabled via 'compiler.removeConsole' in 'next.config.js'`);
+                    break;
+                default:
+                    unsupportedPlugins.push(pluginName);
+                    break;
+            }
+        }
+    }
+    if (isPresetReadyToDeprecate && unsupportedPlugins.length === 0) {
+        _log.warn(`It looks like there is a custom Babel configuration that can be removed${pluginReasons.length > 0 ? ':' : '.'}`);
+        if (pluginReasons.length > 0) {
+            _log.warn(`Next.js supports the following features natively: `);
+            _log.warn(pluginReasons.join(''));
+            _log.warn(`For more details configuration options, please refer https://nextjs.org/docs/architecture/nextjs-compiler#supported-features`);
+        }
+    }
+}
+/**
+ * Generate a new, flat Babel config, ready to be handed to Babel-traverse.
+ * This config should have no unresolved overrides, presets, etc.
+ */ function getFreshConfig(cacheCharacteristics, loaderOptions, target, filename, inputSourceMap) {
+    const hasReactCompiler = (()=>{
+        if (loaderOptions.reactCompilerPlugins && loaderOptions.reactCompilerPlugins.length === 0) {
+            return false;
+        }
+        if (/[/\\]node_modules[/\\]/.test(filename)) {
+            return false;
+        }
+        if (loaderOptions.reactCompilerExclude && loaderOptions.reactCompilerExclude(filename)) {
+            return false;
+        }
+        return true;
+    })();
+    const reactCompilerPluginsIfEnabled = hasReactCompiler ? loaderOptions.reactCompilerPlugins ?? [] : [];
+    let { isServer, pagesDir, srcDir, development } = loaderOptions;
+    let options = {
+        babelrc: false,
+        cloneInputAst: false,
+        filename,
+        inputSourceMap: inputSourceMap || undefined,
+        // 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,
+        sourceMaps: this.sourceMap
+    };
+    const baseCaller = {
+        name: 'next-babel-turbo-loader',
+        supportsStaticESM: true,
+        supportsDynamicImport: true,
+        // Provide plugins with insight into webpack target.
+        // https://github.com/babel/babel-loader/issues/787
+        target: target,
+        // Webpack 5 supports TLA behind a flag. We enable it by default
+        // for Babel, and then webpack will throw an error if the experimental
+        // flag isn't enabled.
+        supportsTopLevelAwait: true,
+        isServer,
+        srcDir,
+        pagesDir,
+        isDev: development,
+        ...loaderOptions.caller
+    };
+    if (loaderOptions.transformMode === 'standalone') {
+        if (!reactCompilerPluginsIfEnabled.length) {
+            return null;
+        }
+        options.plugins = [
+            _pluginsyntaxjsx.default,
+            ...reactCompilerPluginsIfEnabled
+        ];
+        options.presets = [
+            [
+                require('next/dist/compiled/babel/preset-typescript'),
+                {
+                    allowNamespaces: true
+                }
+            ]
+        ];
+        options.caller = baseCaller;
+    } else {
+        let { configFile, hasJsxRuntime } = loaderOptions;
+        let customConfig = configFile ? getCustomBabelConfig(configFile) : undefined;
+        checkCustomBabelConfigDeprecation(customConfig);
+        // Set the default sourcemap behavior based on Webpack's mapping flag,
+        // but allow users to override if they want.
+        options.sourceMaps = loaderOptions.sourceMaps === undefined ? this.sourceMap : loaderOptions.sourceMaps;
+        options.plugins = [
+            ...getPlugins(loaderOptions, cacheCharacteristics),
+            ...reactCompilerPluginsIfEnabled,
+            ...(customConfig == null ? void 0 : customConfig.plugins) || []
+        ];
+        // target can be provided in babelrc
+        options.target = isServer ? undefined : customConfig == null ? void 0 : customConfig.target;
+        // env can be provided in babelrc
+        options.env = customConfig == null ? void 0 : customConfig.env;
+        options.presets = (()=>{
+            // If presets is defined the user will have next/babel in their babelrc
+            if (customConfig == null ? void 0 : customConfig.presets) {
+                return customConfig.presets;
+            }
+            // If presets is not defined the user will likely have "env" in their babelrc
+            if (customConfig) {
+                return undefined;
+            }
+            // If no custom config is provided the default is to use next/babel
+            return [
+                'next/babel'
+            ];
+        })();
+        options.overrides = loaderOptions.overrides;
+        options.caller = {
+            ...baseCaller,
+            hasJsxRuntime
+        };
+    }
+    // Babel does strict checks on the config so undefined is not allowed
+    if (typeof options.target === 'undefined') {
+        delete options.target;
+    }
+    Object.defineProperty(options.caller, 'onWarning', {
+        enumerable: false,
+        writable: false,
+        value: (reason)=>{
+            if (!(reason instanceof Error)) {
+                reason = Object.defineProperty(new Error(reason), "__NEXT_ERROR_CODE", {
+                    value: "E394",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            this.emitWarning(reason);
+        }
+    });
+    const loadedOptions = (0, _core.loadOptions)(options);
+    const config = (0, _util.consumeIterator)((0, _corelibconfig.default)(loadedOptions));
+    return config;
+}
+/**
+ * Each key returned here corresponds with a Babel config that can be shared.
+ * The conditions of permissible sharing between files is dependent on specific
+ * file attributes and Next.js compiler states: `CharacteristicsGermaneToCaching`.
+ */ function getCacheKey(cacheCharacteristics) {
+    const { isServer, isPageFile, isNextDist, hasModuleExports, fileExt } = cacheCharacteristics;
+    const flags = 0 | (isServer ? 1 : 0) | (isPageFile ? 2 : 0) | (isNextDist ? 4 : 0) | (hasModuleExports ? 8 : 0);
+    return fileExt + flags;
+}
+const configCache = new Map();
+const configFiles = new Set();
+function getConfig({ source, target, loaderOptions, filename, inputSourceMap }) {
+    const cacheCharacteristics = getCacheCharacteristics(loaderOptions, source, filename);
+    if (loaderOptions.transformMode === 'default' && loaderOptions.configFile) {
+        // Ensures webpack invalidates the cache for this loader when the config file changes
+        this.addDependency(loaderOptions.configFile);
+    }
+    const cacheKey = getCacheKey(cacheCharacteristics);
+    if (configCache.has(cacheKey)) {
+        const cachedConfig = configCache.get(cacheKey);
+        if (!cachedConfig) {
+            return null;
+        }
+        return {
+            ...cachedConfig,
+            options: {
+                ...cachedConfig.options,
+                cwd: loaderOptions.cwd,
+                root: loaderOptions.cwd,
+                filename,
+                sourceFileName: filename
+            }
+        };
+    }
+    if (loaderOptions.transformMode === 'default' && loaderOptions.configFile && !configFiles.has(loaderOptions.configFile)) {
+        configFiles.add(loaderOptions.configFile);
+        _log.info(`Using external babel configuration from ${loaderOptions.configFile}`);
+    }
+    const freshConfig = getFreshConfig.call(this, cacheCharacteristics, loaderOptions, target, filename, inputSourceMap);
+    configCache.set(cacheKey, freshConfig);
+    return freshConfig;
+}
+
+//# sourceMappingURL=get-config.js.map

node_modules/next/dist/build/babel/loader/index.d.ts

@@ -0,0 +1,3 @@
+import type { NextJsLoaderContext } from './types';
+declare const nextBabelLoaderOuter: (this: NextJsLoaderContext, inputSource: string, inputSourceMap: object | null | undefined) => void;
+export default nextBabelLoaderOuter;

node_modules/next/dist/build/babel/loader/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _transform = /*#__PURE__*/ _interop_require_default(require("./transform"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function nextBabelLoader(parentTrace, inputSource, inputSourceMap) {
+    const filename = this.resourcePath;
+    // Ensure `.d.ts` are not processed.
+    if (filename.endsWith('.d.ts')) {
+        return [
+            inputSource,
+            inputSourceMap
+        ];
+    }
+    const target = this.target;
+    const loaderOptions = parentTrace.traceChild('get-options')// @ts-ignore TODO: remove ignore once webpack 5 types are used
+    .traceFn(()=>this.getOptions());
+    if (loaderOptions.exclude && loaderOptions.exclude(filename)) {
+        return [
+            inputSource,
+            inputSourceMap
+        ];
+    }
+    const loaderSpanInner = parentTrace.traceChild('next-babel-turbo-transform');
+    const { code: transformedSource, map: outputSourceMap } = loaderSpanInner.traceFn(()=>_transform.default.call(this, inputSource, inputSourceMap, loaderOptions, filename, target, loaderSpanInner));
+    return [
+        transformedSource,
+        outputSourceMap
+    ];
+}
+const nextBabelLoaderOuter = function nextBabelLoaderOuter(inputSource, inputSourceMap) {
+    const callback = this.async();
+    const loaderSpan = this.currentTraceSpan.traceChild('next-babel-turbo-loader');
+    loaderSpan.traceAsyncFn(()=>nextBabelLoader.call(this, loaderSpan, inputSource, inputSourceMap)).then(([transformedSource, outputSourceMap])=>callback == null ? void 0 : callback(null, transformedSource, outputSourceMap || inputSourceMap), (err)=>{
+        callback == null ? void 0 : callback(err);
+    });
+};
+const _default = nextBabelLoaderOuter;
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/build/babel/loader/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/babel/loader/index.ts"],"sourcesContent":["import type { Span } from '../../../trace'\nimport transform from './transform'\nimport type { NextJsLoaderContext } from './types'\n\nasync function nextBabelLoader(\n  this: NextJsLoaderContext,\n  parentTrace: Span,\n  inputSource: string,\n  inputSourceMap: object | null | undefined\n) {\n  const filename = this.resourcePath\n\n  // Ensure `.d.ts` are not processed.\n  if (filename.endsWith('.d.ts')) {\n    return [inputSource, inputSourceMap]\n  }\n\n  const target = this.target\n  const loaderOptions: any = parentTrace\n    .traceChild('get-options')\n    // @ts-ignore TODO: remove ignore once webpack 5 types are used\n    .traceFn(() => this.getOptions())\n\n  if (loaderOptions.exclude && loaderOptions.exclude(filename)) {\n    return [inputSource, inputSourceMap]\n  }\n\n  const loaderSpanInner = parentTrace.traceChild('next-babel-turbo-transform')\n  const { code: transformedSource, map: outputSourceMap } =\n    loaderSpanInner.traceFn(() =>\n      transform.call(\n        this,\n        inputSource,\n        inputSourceMap,\n        loaderOptions,\n        filename,\n        target,\n        loaderSpanInner\n      )\n    )\n\n  return [transformedSource, outputSourceMap]\n}\n\nconst nextBabelLoaderOuter = function nextBabelLoaderOuter(\n  this: NextJsLoaderContext,\n  inputSource: string,\n  inputSourceMap: object | null | undefined\n) {\n  const callback = this.async()\n\n  const loaderSpan = this.currentTraceSpan.traceChild('next-babel-turbo-loader')\n  loaderSpan\n    .traceAsyncFn(() =>\n      nextBabelLoader.call(this, loaderSpan, inputSource, inputSourceMap)\n    )\n    .then(\n      ([transformedSource, outputSourceMap]: any) =>\n        callback?.(null, transformedSource, outputSourceMap || inputSourceMap),\n      (err) => {\n        callback?.(err)\n      }\n    )\n}\n\nexport default nextBabelLoaderOuter\n"],"names":["nextBabelLoader","parentTrace","inputSource","inputSourceMap","filename","resourcePath","endsWith","target","loaderOptions","traceChild","traceFn","getOptions","exclude","loaderSpanInner","code","transformedSource","map","outputSourceMap","transform","call","nextBabelLoaderOuter","callback","async","loaderSpan","currentTraceSpan","traceAsyncFn","then","err"],"mappings":";;;;+BAiEA;;;eAAA;;;kEAhEsB;;;;;;AAGtB,eAAeA,gBAEbC,WAAiB,EACjBC,WAAmB,EACnBC,cAAyC;IAEzC,MAAMC,WAAW,IAAI,CAACC,YAAY;IAElC,oCAAoC;IACpC,IAAID,SAASE,QAAQ,CAAC,UAAU;QAC9B,OAAO;YAACJ;YAAaC;SAAe;IACtC;IAEA,MAAMI,SAAS,IAAI,CAACA,MAAM;IAC1B,MAAMC,gBAAqBP,YACxBQ,UAAU,CAAC,cACZ,+DAA+D;KAC9DC,OAAO,CAAC,IAAM,IAAI,CAACC,UAAU;IAEhC,IAAIH,cAAcI,OAAO,IAAIJ,cAAcI,OAAO,CAACR,WAAW;QAC5D,OAAO;YAACF;YAAaC;SAAe;IACtC;IAEA,MAAMU,kBAAkBZ,YAAYQ,UAAU,CAAC;IAC/C,MAAM,EAAEK,MAAMC,iBAAiB,EAAEC,KAAKC,eAAe,EAAE,GACrDJ,gBAAgBH,OAAO,CAAC,IACtBQ,kBAAS,CAACC,IAAI,CACZ,IAAI,EACJjB,aACAC,gBACAK,eACAJ,UACAG,QACAM;IAIN,OAAO;QAACE;QAAmBE;KAAgB;AAC7C;AAEA,MAAMG,uBAAuB,SAASA,qBAEpClB,WAAmB,EACnBC,cAAyC;IAEzC,MAAMkB,WAAW,IAAI,CAACC,KAAK;IAE3B,MAAMC,aAAa,IAAI,CAACC,gBAAgB,CAACf,UAAU,CAAC;IACpDc,WACGE,YAAY,CAAC,IACZzB,gBAAgBmB,IAAI,CAAC,IAAI,EAAEI,YAAYrB,aAAaC,iBAErDuB,IAAI,CACH,CAAC,CAACX,mBAAmBE,gBAAqB,GACxCI,4BAAAA,SAAW,MAAMN,mBAAmBE,mBAAmBd,iBACzD,CAACwB;QACCN,4BAAAA,SAAWM;IACb;AAEN;MAEA,WAAeP"}

node_modules/next/dist/build/babel/loader/transform.d.ts

@@ -0,0 +1,6 @@
+import type { Span } from '../../../trace';
+import type { NextJsLoaderContext } from './types';
+export default function transform(this: NextJsLoaderContext, source: string, inputSourceMap: object | null | undefined, loaderOptions: any, filename: string, target: string, parentSpan: Span): {
+    code: string;
+    map: object | null | undefined;
+};

node_modules/next/dist/build/babel/loader/transform.js

@@ -0,0 +1,103 @@
+/*
+ * Partially adapted from @babel/core (MIT license).
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return transform;
+    }
+});
+const _traverse = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/traverse"));
+const _generator = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/generator"));
+const _corelibnormalizefile = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/core-lib-normalize-file"));
+const _corelibnormalizeopts = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/core-lib-normalize-opts"));
+const _corelibblockhoistplugin = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/core-lib-block-hoist-plugin"));
+const _corelibpluginpass = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/core-lib-plugin-pass"));
+const _getconfig = /*#__PURE__*/ _interop_require_default(require("./get-config"));
+const _util = require("./util");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getTraversalParams(file, pluginPairs) {
+    const passPairs = [];
+    const passes = [];
+    const visitors = [];
+    for (const plugin of pluginPairs.concat((0, _corelibblockhoistplugin.default)())){
+        const pass = new _corelibpluginpass.default(file, plugin.key, plugin.options);
+        passPairs.push([
+            plugin,
+            pass
+        ]);
+        passes.push(pass);
+        visitors.push(plugin.visitor);
+    }
+    return {
+        passPairs,
+        passes,
+        visitors
+    };
+}
+function invokePluginPre(file, passPairs) {
+    for (const [{ pre }, pass] of passPairs){
+        if (pre) {
+            pre.call(pass, file);
+        }
+    }
+}
+function invokePluginPost(file, passPairs) {
+    for (const [{ post }, pass] of passPairs){
+        if (post) {
+            post.call(pass, file);
+        }
+    }
+}
+function transformAstPass(file, pluginPairs, parentSpan) {
+    const { passPairs, passes, visitors } = getTraversalParams(file, pluginPairs);
+    invokePluginPre(file, passPairs);
+    const visitor = _traverse.default.visitors.merge(visitors, passes, // @ts-ignore - the exported types are incorrect here
+    file.opts.wrapPluginVisitorMethod);
+    parentSpan.traceChild('babel-turbo-traverse').traceFn(()=>(0, _traverse.default)(file.ast, visitor, file.scope));
+    invokePluginPost(file, passPairs);
+}
+function transformAst(file, babelConfig, parentSpan) {
+    for (const pluginPairs of babelConfig.passes){
+        transformAstPass(file, pluginPairs, parentSpan);
+    }
+}
+function transform(source, inputSourceMap, loaderOptions, filename, target, parentSpan) {
+    const getConfigSpan = parentSpan.traceChild('babel-turbo-get-config');
+    const babelConfig = _getconfig.default.call(this, {
+        source,
+        loaderOptions,
+        inputSourceMap,
+        target,
+        filename
+    });
+    if (!babelConfig) {
+        return {
+            code: source,
+            map: inputSourceMap
+        };
+    }
+    getConfigSpan.stop();
+    const normalizeSpan = parentSpan.traceChild('babel-turbo-normalize-file');
+    const file = (0, _util.consumeIterator)((0, _corelibnormalizefile.default)(babelConfig.passes, (0, _corelibnormalizeopts.default)(babelConfig), source));
+    normalizeSpan.stop();
+    const transformSpan = parentSpan.traceChild('babel-turbo-transform');
+    transformAst(file, babelConfig, transformSpan);
+    transformSpan.stop();
+    const generateSpan = parentSpan.traceChild('babel-turbo-generate');
+    const { code, map } = (0, _generator.default)(file.ast, file.opts.generatorOpts, file.code);
+    generateSpan.stop();
+    return {
+        code,
+        map
+    };
+}
+
+//# sourceMappingURL=transform.js.map

node_modules/next/dist/build/babel/loader/types.d.ts

@@ -0,0 +1,51 @@
+import type { webpack } from 'next/dist/compiled/webpack/webpack'
+import type { Span } from '../../../trace'
+
+export interface NextJsLoaderContext extends webpack.LoaderContext<{}> {
+  currentTraceSpan: Span
+  target: string
+}
+
+export interface NextBabelLoaderBaseOptions {
+  isServer: boolean
+  distDir: string
+  pagesDir: string
+  cwd: string
+  srcDir: string
+  caller: any
+  development: boolean
+
+  // Custom plugins to be added to the generated babel options.
+  reactCompilerPlugins?: Array<any>
+  reactCompilerExclude?: (excludePath: string) => boolean
+}
+
+/**
+ * Options to create babel loader for the default transformations.
+ *
+ * This is primary usecase of babel-loader configuration for running
+ * all of the necessary transforms for the ecmascript instead of swc loader.
+ */
+export type NextBabelLoaderOptionDefaultPresets = NextBabelLoaderBaseOptions & {
+  transformMode: 'default'
+  hasJsxRuntime: boolean
+  hasReactRefresh: boolean
+  sourceMaps?: any[]
+  overrides: any
+  configFile: string | undefined
+}
+
+/**
+ * Options to create babel loader for 'standalone' transformations.
+ *
+ * This'll create a babel loader does not enable any of the default presets or plugins,
+ * only the ones specified in the options where swc loader is enabled but need to inject
+ * a babel specific plugins like react compiler.
+ */
+export type NextBabelLoaderOptionStandalone = NextBabelLoaderBaseOptions & {
+  transformMode: 'standalone'
+}
+
+export type NextBabelLoaderOptions =
+  | NextBabelLoaderOptionDefaultPresets
+  | NextBabelLoaderOptionStandalone

node_modules/next/dist/build/babel/loader/util.d.ts

@@ -0,0 +1 @@
+export declare function consumeIterator(iter: Iterator<any>): any;

node_modules/next/dist/build/babel/loader/util.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "consumeIterator", {
+    enumerable: true,
+    get: function() {
+        return consumeIterator;
+    }
+});
+function consumeIterator(iter) {
+    while(true){
+        const { value, done } = iter.next();
+        if (done) {
+            return value;
+        }
+    }
+}
+
+//# sourceMappingURL=util.js.map

node_modules/next/dist/build/babel/loader/util.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/babel/loader/util.ts"],"sourcesContent":["export function consumeIterator(iter: Iterator<any>) {\n  while (true) {\n    const { value, done } = iter.next()\n    if (done) {\n      return value\n    }\n  }\n}\n"],"names":["consumeIterator","iter","value","done","next"],"mappings":";;;;+BAAgBA;;;eAAAA;;;AAAT,SAASA,gBAAgBC,IAAmB;IACjD,MAAO,KAAM;QACX,MAAM,EAAEC,KAAK,EAAEC,IAAI,EAAE,GAAGF,KAAKG,IAAI;QACjC,IAAID,MAAM;YACR,OAAOD;QACT;IACF;AACF"}

node_modules/next/dist/build/babel/plugins/amp-attributes.d.ts

@@ -0,0 +1,2 @@
+import type { PluginObj } from 'next/dist/compiled/babel/core';
+export default function AmpAttributePatcher(): PluginObj;

node_modules/next/dist/build/babel/plugins/amp-attributes.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return AmpAttributePatcher;
+    }
+});
+function AmpAttributePatcher() {
+    return {
+        visitor: {
+            JSXOpeningElement (path) {
+                const openingElement = path.node;
+                const { name, attributes } = openingElement;
+                if (!(name && name.type === 'JSXIdentifier')) {
+                    return;
+                }
+                if (!name.name.startsWith('amp-')) {
+                    return;
+                }
+                for (const attribute of attributes){
+                    if (attribute.type !== 'JSXAttribute') {
+                        continue;
+                    }
+                    if (attribute.name.name === 'className') {
+                        attribute.name.name = 'class';
+                    }
+                }
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=amp-attributes.js.map

node_modules/next/dist/build/babel/plugins/amp-attributes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/babel/plugins/amp-attributes.ts"],"sourcesContent":["import type { NodePath, types, PluginObj } from 'next/dist/compiled/babel/core'\n\nexport default function AmpAttributePatcher(): PluginObj {\n  return {\n    visitor: {\n      JSXOpeningElement(path: NodePath<types.JSXOpeningElement>) {\n        const openingElement = path.node\n\n        const { name, attributes } = openingElement\n        if (!(name && name.type === 'JSXIdentifier')) {\n          return\n        }\n\n        if (!name.name.startsWith('amp-')) {\n          return\n        }\n\n        for (const attribute of attributes) {\n          if (attribute.type !== 'JSXAttribute') {\n            continue\n          }\n\n          if (attribute.name.name === 'className') {\n            attribute.name.name = 'class'\n          }\n        }\n      },\n    },\n  }\n}\n"],"names":["AmpAttributePatcher","visitor","JSXOpeningElement","path","openingElement","node","name","attributes","type","startsWith","attribute"],"mappings":";;;;+BAEA;;;eAAwBA;;;AAAT,SAASA;IACtB,OAAO;QACLC,SAAS;YACPC,mBAAkBC,IAAuC;gBACvD,MAAMC,iBAAiBD,KAAKE,IAAI;gBAEhC,MAAM,EAAEC,IAAI,EAAEC,UAAU,EAAE,GAAGH;gBAC7B,IAAI,CAAEE,CAAAA,QAAQA,KAAKE,IAAI,KAAK,eAAc,GAAI;oBAC5C;gBACF;gBAEA,IAAI,CAACF,KAAKA,IAAI,CAACG,UAAU,CAAC,SAAS;oBACjC;gBACF;gBAEA,KAAK,MAAMC,aAAaH,WAAY;oBAClC,IAAIG,UAAUF,IAAI,KAAK,gBAAgB;wBACrC;oBACF;oBAEA,IAAIE,UAAUJ,IAAI,CAACA,IAAI,KAAK,aAAa;wBACvCI,UAAUJ,IAAI,CAACA,IAAI,GAAG;oBACxB;gBACF;YACF;QACF;IACF;AACF"}

node_modules/next/dist/build/babel/plugins/commonjs.d.ts

@@ -0,0 +1,2 @@
+import type { PluginObj } from 'next/dist/compiled/babel/core';
+export default function CommonJSModulePlugin(...args: any): PluginObj;

node_modules/next/dist/build/babel/plugins/commonjs.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, // Handle module.exports in user code
+"default", {
+    enumerable: true,
+    get: function() {
+        return CommonJSModulePlugin;
+    }
+});
+const _plugintransformmodulescommonjs = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/plugin-transform-modules-commonjs"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function CommonJSModulePlugin(...args) {
+    const commonjs = (0, _plugintransformmodulescommonjs.default)(...args);
+    return {
+        visitor: {
+            Program: {
+                exit (path, state) {
+                    let foundModuleExports = false;
+                    path.traverse({
+                        MemberExpression (expressionPath) {
+                            if (expressionPath.node.object.name !== 'module') return;
+                            if (expressionPath.node.property.name !== 'exports') return;
+                            foundModuleExports = true;
+                        }
+                    });
+                    if (!foundModuleExports) {
+                        return;
+                    }
+                    commonjs.visitor.Program.exit.call(this, path, state);
+                }
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=commonjs.js.map

node_modules/next/dist/build/babel/plugins/commonjs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/babel/plugins/commonjs.ts"],"sourcesContent":["import type { NodePath, types } from 'next/dist/compiled/babel/core'\nimport type { PluginObj } from 'next/dist/compiled/babel/core'\nimport commonjsPlugin from 'next/dist/compiled/babel/plugin-transform-modules-commonjs'\n\n// Handle module.exports in user code\nexport default function CommonJSModulePlugin(...args: any): PluginObj {\n  const commonjs = commonjsPlugin(...args)\n  return {\n    visitor: {\n      Program: {\n        exit(path: NodePath<types.Program>, state) {\n          let foundModuleExports = false\n          path.traverse({\n            MemberExpression(expressionPath: any) {\n              if (expressionPath.node.object.name !== 'module') return\n              if (expressionPath.node.property.name !== 'exports') return\n              foundModuleExports = true\n            },\n          })\n\n          if (!foundModuleExports) {\n            return\n          }\n\n          commonjs.visitor.Program.exit.call(this, path, state)\n        },\n      },\n    },\n  }\n}\n"],"names":["CommonJSModulePlugin","args","commonjs","commonjsPlugin","visitor","Program","exit","path","state","foundModuleExports","traverse","MemberExpression","expressionPath","node","object","name","property","call"],"mappings":";;;;+BAIA,qCAAqC;AACrC;;;eAAwBA;;;uFAHG;;;;;;AAGZ,SAASA,qBAAqB,GAAGC,IAAS;IACvD,MAAMC,WAAWC,IAAAA,uCAAc,KAAIF;IACnC,OAAO;QACLG,SAAS;YACPC,SAAS;gBACPC,MAAKC,IAA6B,EAAEC,KAAK;oBACvC,IAAIC,qBAAqB;oBACzBF,KAAKG,QAAQ,CAAC;wBACZC,kBAAiBC,cAAmB;4BAClC,IAAIA,eAAeC,IAAI,CAACC,MAAM,CAACC,IAAI,KAAK,UAAU;4BAClD,IAAIH,eAAeC,IAAI,CAACG,QAAQ,CAACD,IAAI,KAAK,WAAW;4BACrDN,qBAAqB;wBACvB;oBACF;oBAEA,IAAI,CAACA,oBAAoB;wBACvB;oBACF;oBAEAP,SAASE,OAAO,CAACC,OAAO,CAACC,IAAI,CAACW,IAAI,CAAC,IAAI,EAAEV,MAAMC;gBACjD;YACF;QACF;IACF;AACF"}

node_modules/next/dist/build/babel/plugins/jsx-pragma.d.ts

@@ -0,0 +1,5 @@
+import type { types as BabelTypes } from 'next/dist/compiled/babel/core';
+import type { PluginObj } from 'next/dist/compiled/babel/core';
+export default function ({ types: t, }: {
+    types: typeof BabelTypes;
+}): PluginObj<any>;

node_modules/next/dist/build/babel/plugins/jsx-pragma.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _pluginsyntaxjsx = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/plugin-syntax-jsx"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _default({ types: t }) {
+    return {
+        inherits: _pluginsyntaxjsx.default,
+        visitor: {
+            JSXElement (_path, state) {
+                state.set('jsx', true);
+            },
+            // Fragment syntax is still JSX since it compiles to createElement(),
+            // but JSXFragment is not a JSXElement
+            JSXFragment (_path, state) {
+                state.set('jsx', true);
+            },
+            Program: {
+                exit (path, state) {
+                    if (state.get('jsx')) {
+                        const pragma = t.identifier(state.opts.pragma);
+                        let importAs = pragma;
+                        // if there's already a React in scope, use that instead of adding an import
+                        const existingBinding = state.opts.reuseImport !== false && state.opts.importAs && path.scope.getBinding(state.opts.importAs);
+                        // var _jsx = _pragma.createElement;
+                        if (state.opts.property) {
+                            if (state.opts.importAs) {
+                                importAs = t.identifier(state.opts.importAs);
+                            } else {
+                                importAs = path.scope.generateUidIdentifier('pragma');
+                            }
+                            const mapping = t.variableDeclaration('var', [
+                                t.variableDeclarator(pragma, t.memberExpression(importAs, t.identifier(state.opts.property)))
+                            ]);
+                            // if the React binding came from a require('react'),
+                            // make sure that our usage comes after it.
+                            let newPath;
+                            if (existingBinding && t.isVariableDeclarator(existingBinding.path.node) && t.isCallExpression(existingBinding.path.node.init) && t.isIdentifier(existingBinding.path.node.init.callee) && existingBinding.path.node.init.callee.name === 'require') {
+                                ;
+                                [newPath] = existingBinding.path.parentPath.insertAfter(mapping);
+                            } else {
+                                ;
+                                [newPath] = path.unshiftContainer('body', mapping);
+                            }
+                            for (const declar of newPath.get('declarations')){
+                                path.scope.registerBinding(newPath.node.kind, declar);
+                            }
+                        }
+                        if (!existingBinding) {
+                            const importSpecifier = t.importDeclaration([
+                                state.opts.import ? t.importSpecifier(importAs, t.identifier(state.opts.import)) : state.opts.importNamespace ? t.importNamespaceSpecifier(importAs) : t.importDefaultSpecifier(importAs)
+                            ], t.stringLiteral(state.opts.module || 'react'));
+                            const [newPath] = path.unshiftContainer('body', importSpecifier);
+                            for (const specifier of newPath.get('specifiers')){
+                                path.scope.registerBinding('module', specifier);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=jsx-pragma.js.map

node_modules/next/dist/build/babel/plugins/next-font-unsupported.d.ts

@@ -0,0 +1,2 @@
+import type { PluginObj } from 'next/dist/compiled/babel/core';
+export default function NextPageDisallowReExportAllExports(): PluginObj<any>;

node_modules/next/dist/build/babel/plugins/next-font-unsupported.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return NextPageDisallowReExportAllExports;
+    }
+});
+function NextPageDisallowReExportAllExports() {
+    return {
+        visitor: {
+            ImportDeclaration (path) {
+                if ([
+                    '@next/font/local',
+                    '@next/font/google',
+                    'next/font/local',
+                    'next/font/google'
+                ].includes(path.node.source.value)) {
+                    var _path_node_loc, _path_node_loc1;
+                    const err = Object.defineProperty(new SyntaxError(`"next/font" requires SWC although Babel is being used due to a custom babel config being present.\nRead more: https://nextjs.org/docs/messages/babel-font-loader-conflict`), "__NEXT_ERROR_CODE", {
+                        value: "E542",
+                        enumerable: false,
+                        configurable: true
+                    });
+                    err.code = 'BABEL_PARSE_ERROR';
+                    err.loc = ((_path_node_loc = path.node.loc) == null ? void 0 : _path_node_loc.start) ?? ((_path_node_loc1 = path.node.loc) == null ? void 0 : _path_node_loc1.end) ?? path.node.loc;
+                    throw err;
+                }
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=next-font-unsupported.js.map

node_modules/next/dist/build/babel/plugins/next-font-unsupported.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/babel/plugins/next-font-unsupported.ts"],"sourcesContent":["import type { NodePath, types } from 'next/dist/compiled/babel/core'\nimport type { PluginObj } from 'next/dist/compiled/babel/core'\n\nexport default function NextPageDisallowReExportAllExports(): PluginObj<any> {\n  return {\n    visitor: {\n      ImportDeclaration(path: NodePath<types.ImportDeclaration>) {\n        if (\n          [\n            '@next/font/local',\n            '@next/font/google',\n            'next/font/local',\n            'next/font/google',\n          ].includes(path.node.source.value)\n        ) {\n          const err = new SyntaxError(\n            `\"next/font\" requires SWC although Babel is being used due to a custom babel config being present.\\nRead more: https://nextjs.org/docs/messages/babel-font-loader-conflict`\n          )\n          ;(err as any).code = 'BABEL_PARSE_ERROR'\n          ;(err as any).loc =\n            path.node.loc?.start ?? path.node.loc?.end ?? path.node.loc\n          throw err\n        }\n      },\n    },\n  }\n}\n"],"names":["NextPageDisallowReExportAllExports","visitor","ImportDeclaration","path","includes","node","source","value","err","SyntaxError","code","loc","start","end"],"mappings":";;;;+BAGA;;;eAAwBA;;;AAAT,SAASA;IACtB,OAAO;QACLC,SAAS;YACPC,mBAAkBC,IAAuC;gBACvD,IACE;oBACE;oBACA;oBACA;oBACA;iBACD,CAACC,QAAQ,CAACD,KAAKE,IAAI,CAACC,MAAM,CAACC,KAAK,GACjC;wBAMEJ,gBAAwBA;oBAL1B,MAAMK,MAAM,qBAEX,CAFW,IAAIC,YACd,CAAC,yKAAyK,CAAC,GADjK,qBAAA;+BAAA;oCAAA;sCAAA;oBAEZ;oBACED,IAAYE,IAAI,GAAG;oBACnBF,IAAYG,GAAG,GACfR,EAAAA,iBAAAA,KAAKE,IAAI,CAACM,GAAG,qBAAbR,eAAeS,KAAK,OAAIT,kBAAAA,KAAKE,IAAI,CAACM,GAAG,qBAAbR,gBAAeU,GAAG,KAAIV,KAAKE,IAAI,CAACM,GAAG;oBAC7D,MAAMH;gBACR;YACF;QACF;IACF;AACF"}

node_modules/next/dist/build/babel/plugins/next-page-config.d.ts

@@ -0,0 +1,5 @@
+import { types as BabelTypes } from 'next/dist/compiled/babel/core';
+import type { PluginObj } from 'next/dist/compiled/babel/core';
+export default function nextPageConfig({ types: t, }: {
+    types: typeof BabelTypes;
+}): PluginObj;

node_modules/next/dist/build/babel/plugins/next-page-config.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, // config to parsing pageConfig for client bundles
+"default", {
+    enumerable: true,
+    get: function() {
+        return nextPageConfig;
+    }
+});
+const _core = require("next/dist/compiled/babel/core");
+const _constants = require("../../../shared/lib/constants");
+const CONFIG_KEY = 'config';
+// replace program path with just a variable with the drop identifier
+function replaceBundle(path, t) {
+    path.parentPath.replaceWith(t.program([
+        t.variableDeclaration('const', [
+            t.variableDeclarator(t.identifier(_constants.STRING_LITERAL_DROP_BUNDLE), t.stringLiteral(`${_constants.STRING_LITERAL_DROP_BUNDLE} ${Date.now()}`))
+        ])
+    ], []));
+}
+function errorMessage(state, details) {
+    const pageName = (state.filename || '').split(state.cwd || '').pop() || 'unknown';
+    return `Invalid page config export found. ${details} in file ${pageName}. See: https://nextjs.org/docs/messages/invalid-page-config`;
+}
+function nextPageConfig({ types: t }) {
+    return {
+        visitor: {
+            Program: {
+                enter (path, state) {
+                    path.traverse({
+                        ExportDeclaration (exportPath, exportState) {
+                            var _exportPath_node_specifiers;
+                            if (_core.types.isExportNamedDeclaration(exportPath.node) && ((_exportPath_node_specifiers = exportPath.node.specifiers) == null ? void 0 : _exportPath_node_specifiers.some((specifier)=>{
+                                return (t.isIdentifier(specifier.exported) ? specifier.exported.name : specifier.exported.value) === CONFIG_KEY;
+                            })) && _core.types.isStringLiteral(exportPath.node.source)) {
+                                throw Object.defineProperty(new Error(errorMessage(exportState, 'Expected object but got export from')), "__NEXT_ERROR_CODE", {
+                                    value: "E394",
+                                    enumerable: false,
+                                    configurable: true
+                                });
+                            }
+                        },
+                        ExportNamedDeclaration (exportPath, exportState) {
+                            var _exportPath_node_declaration, _exportPath_scope_getBinding;
+                            if (exportState.bundleDropped || !exportPath.node.declaration && exportPath.node.specifiers.length === 0) {
+                                return;
+                            }
+                            const config = {};
+                            const declarations = [
+                                ...((_exportPath_node_declaration = exportPath.node.declaration) == null ? void 0 : _exportPath_node_declaration.declarations) || [],
+                                (_exportPath_scope_getBinding = exportPath.scope.getBinding(CONFIG_KEY)) == null ? void 0 : _exportPath_scope_getBinding.path.node
+                            ].filter(Boolean);
+                            for (const specifier of exportPath.node.specifiers){
+                                if ((t.isIdentifier(specifier.exported) ? specifier.exported.name : specifier.exported.value) === CONFIG_KEY) {
+                                    // export {} from 'somewhere'
+                                    if (_core.types.isStringLiteral(exportPath.node.source)) {
+                                        throw Object.defineProperty(new Error(errorMessage(exportState, `Expected object but got import`)), "__NEXT_ERROR_CODE", {
+                                            value: "E394",
+                                            enumerable: false,
+                                            configurable: true
+                                        });
+                                    // import hello from 'world'
+                                    // export { hello as config }
+                                    } else if (_core.types.isIdentifier(specifier.local)) {
+                                        var _exportPath_scope_getBinding1;
+                                        if (_core.types.isImportSpecifier((_exportPath_scope_getBinding1 = exportPath.scope.getBinding(specifier.local.name)) == null ? void 0 : _exportPath_scope_getBinding1.path.node)) {
+                                            throw Object.defineProperty(new Error(errorMessage(exportState, `Expected object but got import`)), "__NEXT_ERROR_CODE", {
+                                                value: "E394",
+                                                enumerable: false,
+                                                configurable: true
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                            for (const declaration of declarations){
+                                if (!_core.types.isIdentifier(declaration.id, {
+                                    name: CONFIG_KEY
+                                })) {
+                                    continue;
+                                }
+                                let { init } = declaration;
+                                if (_core.types.isTSAsExpression(init)) {
+                                    init = init.expression;
+                                }
+                                if (!_core.types.isObjectExpression(init)) {
+                                    const got = init ? init.type : 'undefined';
+                                    throw Object.defineProperty(new Error(errorMessage(exportState, `Expected object but got ${got}`)), "__NEXT_ERROR_CODE", {
+                                        value: "E394",
+                                        enumerable: false,
+                                        configurable: true
+                                    });
+                                }
+                                for (const prop of init.properties){
+                                    if (_core.types.isSpreadElement(prop)) {
+                                        throw Object.defineProperty(new Error(errorMessage(exportState, `Property spread is not allowed`)), "__NEXT_ERROR_CODE", {
+                                            value: "E394",
+                                            enumerable: false,
+                                            configurable: true
+                                        });
+                                    }
+                                    const { name } = prop.key;
+                                    if (_core.types.isIdentifier(prop.key, {
+                                        name: 'amp'
+                                    })) {
+                                        if (!_core.types.isObjectProperty(prop)) {
+                                            throw Object.defineProperty(new Error(errorMessage(exportState, `Invalid property "${name}"`)), "__NEXT_ERROR_CODE", {
+                                                value: "E394",
+                                                enumerable: false,
+                                                configurable: true
+                                            });
+                                        }
+                                        if (!_core.types.isBooleanLiteral(prop.value) && !_core.types.isStringLiteral(prop.value)) {
+                                            throw Object.defineProperty(new Error(errorMessage(exportState, `Invalid value for "${name}"`)), "__NEXT_ERROR_CODE", {
+                                                value: "E394",
+                                                enumerable: false,
+                                                configurable: true
+                                            });
+                                        }
+                                        config.amp = prop.value.value;
+                                    }
+                                }
+                            }
+                            if (config.amp === true) {
+                                var _exportState_file_opts, _exportState_file;
+                                if (!((_exportState_file = exportState.file) == null ? void 0 : (_exportState_file_opts = _exportState_file.opts) == null ? void 0 : _exportState_file_opts.caller.isDev)) {
+                                    // don't replace bundle in development so HMR can track
+                                    // dependencies and trigger reload when they are changed
+                                    replaceBundle(exportPath, t);
+                                }
+                                exportState.bundleDropped = true;
+                                return;
+                            }
+                        }
+                    }, state);
+                }
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=next-page-config.js.map

node_modules/next/dist/build/babel/plugins/next-page-disallow-re-export-all-exports.d.ts

@@ -0,0 +1,2 @@
+import type { PluginObj } from 'next/dist/compiled/babel/core';
+export default function NextPageDisallowReExportAllExports(): PluginObj<any>;

node_modules/next/dist/build/babel/plugins/next-page-disallow-re-export-all-exports.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return NextPageDisallowReExportAllExports;
+    }
+});
+function NextPageDisallowReExportAllExports() {
+    return {
+        visitor: {
+            ExportAllDeclaration (path) {
+                var _path_node_loc, _path_node_loc1;
+                const err = Object.defineProperty(new SyntaxError(`Using \`export * from '...'\` in a page is disallowed. Please use \`export { default } from '...'\` instead.\n` + `Read more: https://nextjs.org/docs/messages/export-all-in-page`), "__NEXT_ERROR_CODE", {
+                    value: "E555",
+                    enumerable: false,
+                    configurable: true
+                });
+                err.code = 'BABEL_PARSE_ERROR';
+                err.loc = ((_path_node_loc = path.node.loc) == null ? void 0 : _path_node_loc.start) ?? ((_path_node_loc1 = path.node.loc) == null ? void 0 : _path_node_loc1.end) ?? path.node.loc;
+                throw err;
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=next-page-disallow-re-export-all-exports.js.map

node_modules/next/dist/build/babel/plugins/next-page-disallow-re-export-all-exports.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/babel/plugins/next-page-disallow-re-export-all-exports.ts"],"sourcesContent":["import type { NodePath, types } from 'next/dist/compiled/babel/core'\nimport type { PluginObj } from 'next/dist/compiled/babel/core'\n\nexport default function NextPageDisallowReExportAllExports(): PluginObj<any> {\n  return {\n    visitor: {\n      ExportAllDeclaration(path: NodePath<types.ExportAllDeclaration>) {\n        const err = new SyntaxError(\n          `Using \\`export * from '...'\\` in a page is disallowed. Please use \\`export { default } from '...'\\` instead.\\n` +\n            `Read more: https://nextjs.org/docs/messages/export-all-in-page`\n        )\n        ;(err as any).code = 'BABEL_PARSE_ERROR'\n        ;(err as any).loc =\n          path.node.loc?.start ?? path.node.loc?.end ?? path.node.loc\n        throw err\n      },\n    },\n  }\n}\n"],"names":["NextPageDisallowReExportAllExports","visitor","ExportAllDeclaration","path","err","SyntaxError","code","loc","node","start","end"],"mappings":";;;;+BAGA;;;eAAwBA;;;AAAT,SAASA;IACtB,OAAO;QACLC,SAAS;YACPC,sBAAqBC,IAA0C;oBAO3DA,gBAAwBA;gBAN1B,MAAMC,MAAM,qBAGX,CAHW,IAAIC,YACd,CAAC,8GAA8G,CAAC,GAC9G,CAAC,8DAA8D,CAAC,GAFxD,qBAAA;2BAAA;gCAAA;kCAAA;gBAGZ;gBACED,IAAYE,IAAI,GAAG;gBACnBF,IAAYG,GAAG,GACfJ,EAAAA,iBAAAA,KAAKK,IAAI,CAACD,GAAG,qBAAbJ,eAAeM,KAAK,OAAIN,kBAAAA,KAAKK,IAAI,CAACD,GAAG,qBAAbJ,gBAAeO,GAAG,KAAIP,KAAKK,IAAI,CAACD,GAAG;gBAC7D,MAAMH;YACR;QACF;IACF;AACF"}

node_modules/next/dist/build/babel/plugins/next-ssg-transform.d.ts

@@ -0,0 +1,15 @@
+import type { NodePath, types as BabelTypes } from 'next/dist/compiled/babel/core';
+import type { PluginObj } from 'next/dist/compiled/babel/core';
+export declare const EXPORT_NAME_GET_STATIC_PROPS = "getStaticProps";
+export declare const EXPORT_NAME_GET_STATIC_PATHS = "getStaticPaths";
+export declare const EXPORT_NAME_GET_SERVER_PROPS = "getServerSideProps";
+type PluginState = {
+    refs: Set<NodePath<BabelTypes.Identifier>>;
+    isPrerender: boolean;
+    isServerProps: boolean;
+    done: boolean;
+};
+export default function nextTransformSsg({ types: t, }: {
+    types: typeof BabelTypes;
+}): PluginObj<PluginState>;
+export {};

node_modules/next/dist/build/babel/plugins/next-ssg-transform.js

@@ -0,0 +1,345 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    EXPORT_NAME_GET_SERVER_PROPS: null,
+    EXPORT_NAME_GET_STATIC_PATHS: null,
+    EXPORT_NAME_GET_STATIC_PROPS: null,
+    default: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    EXPORT_NAME_GET_SERVER_PROPS: function() {
+        return EXPORT_NAME_GET_SERVER_PROPS;
+    },
+    EXPORT_NAME_GET_STATIC_PATHS: function() {
+        return EXPORT_NAME_GET_STATIC_PATHS;
+    },
+    EXPORT_NAME_GET_STATIC_PROPS: function() {
+        return EXPORT_NAME_GET_STATIC_PROPS;
+    },
+    default: function() {
+        return nextTransformSsg;
+    }
+});
+const _constants = require("../../../lib/constants");
+const _constants1 = require("../../../shared/lib/constants");
+const EXPORT_NAME_GET_STATIC_PROPS = 'getStaticProps';
+const EXPORT_NAME_GET_STATIC_PATHS = 'getStaticPaths';
+const EXPORT_NAME_GET_SERVER_PROPS = 'getServerSideProps';
+const ssgExports = new Set([
+    EXPORT_NAME_GET_STATIC_PROPS,
+    EXPORT_NAME_GET_STATIC_PATHS,
+    EXPORT_NAME_GET_SERVER_PROPS,
+    // legacy methods added so build doesn't fail from importing
+    // server-side only methods
+    `unstable_getStaticProps`,
+    `unstable_getStaticPaths`,
+    `unstable_getServerProps`,
+    `unstable_getServerSideProps`
+]);
+function decorateSsgExport(t, path, state) {
+    const gsspName = state.isPrerender ? _constants1.STATIC_PROPS_ID : _constants1.SERVER_PROPS_ID;
+    const gsspId = t.identifier(gsspName);
+    const addGsspExport = (exportPath)=>{
+        if (state.done) {
+            return;
+        }
+        state.done = true;
+        const [pageCompPath] = exportPath.replaceWithMultiple([
+            t.exportNamedDeclaration(t.variableDeclaration(// We use 'var' instead of 'let' or 'const' for ES5 support. Since
+            // this runs in `Program#exit`, no ES2015 transforms (preset env)
+            // will be ran against this code.
+            'var', [
+                t.variableDeclarator(gsspId, t.booleanLiteral(true))
+            ]), [
+                t.exportSpecifier(gsspId, gsspId)
+            ]),
+            exportPath.node
+        ]);
+        exportPath.scope.registerDeclaration(pageCompPath);
+    };
+    path.traverse({
+        ExportDefaultDeclaration (exportDefaultPath) {
+            addGsspExport(exportDefaultPath);
+        },
+        ExportNamedDeclaration (exportNamedPath) {
+            addGsspExport(exportNamedPath);
+        }
+    });
+}
+const isDataIdentifier = (name, state)=>{
+    if (ssgExports.has(name)) {
+        if (name === EXPORT_NAME_GET_SERVER_PROPS) {
+            if (state.isPrerender) {
+                throw Object.defineProperty(new Error(_constants.SERVER_PROPS_SSG_CONFLICT), "__NEXT_ERROR_CODE", {
+                    value: "E394",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            state.isServerProps = true;
+        } else {
+            if (state.isServerProps) {
+                throw Object.defineProperty(new Error(_constants.SERVER_PROPS_SSG_CONFLICT), "__NEXT_ERROR_CODE", {
+                    value: "E394",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            state.isPrerender = true;
+        }
+        return true;
+    }
+    return false;
+};
+function nextTransformSsg({ types: t }) {
+    function getIdentifier(path) {
+        const parentPath = path.parentPath;
+        if (parentPath.type === 'VariableDeclarator') {
+            const pp = parentPath;
+            const name = pp.get('id');
+            return name.node.type === 'Identifier' ? name : null;
+        }
+        if (parentPath.type === 'AssignmentExpression') {
+            const pp = parentPath;
+            const name = pp.get('left');
+            return name.node.type === 'Identifier' ? name : null;
+        }
+        if (path.node.type === 'ArrowFunctionExpression') {
+            return null;
+        }
+        return path.node.id && path.node.id.type === 'Identifier' ? path.get('id') : null;
+    }
+    function isIdentifierReferenced(ident) {
+        const b = ident.scope.getBinding(ident.node.name);
+        if (b == null ? void 0 : b.referenced) {
+            // Functions can reference themselves, so we need to check if there's a
+            // binding outside the function scope or not.
+            if (b.path.type === 'FunctionDeclaration') {
+                return !b.constantViolations.concat(b.referencePaths)// Check that every reference is contained within the function:
+                .every((ref)=>ref.findParent((p)=>p === b.path));
+            }
+            return true;
+        }
+        return false;
+    }
+    function markFunction(path, state) {
+        const ident = getIdentifier(path);
+        if ((ident == null ? void 0 : ident.node) && isIdentifierReferenced(ident)) {
+            state.refs.add(ident);
+        }
+    }
+    function markImport(path, state) {
+        const local = path.get('local');
+        if (isIdentifierReferenced(local)) {
+            state.refs.add(local);
+        }
+    }
+    return {
+        visitor: {
+            Program: {
+                enter (path, state) {
+                    state.refs = new Set();
+                    state.isPrerender = false;
+                    state.isServerProps = false;
+                    state.done = false;
+                    path.traverse({
+                        VariableDeclarator (variablePath, variableState) {
+                            if (variablePath.node.id.type === 'Identifier') {
+                                const local = variablePath.get('id');
+                                if (isIdentifierReferenced(local)) {
+                                    variableState.refs.add(local);
+                                }
+                            } else if (variablePath.node.id.type === 'ObjectPattern') {
+                                const pattern = variablePath.get('id');
+                                const properties = pattern.get('properties');
+                                properties.forEach((p)=>{
+                                    const local = p.get(p.node.type === 'ObjectProperty' ? 'value' : p.node.type === 'RestElement' ? 'argument' : function() {
+                                        throw Object.defineProperty(new Error('invariant'), "__NEXT_ERROR_CODE", {
+                                            value: "E400",
+                                            enumerable: false,
+                                            configurable: true
+                                        });
+                                    }());
+                                    if (isIdentifierReferenced(local)) {
+                                        variableState.refs.add(local);
+                                    }
+                                });
+                            } else if (variablePath.node.id.type === 'ArrayPattern') {
+                                const pattern = variablePath.get('id');
+                                const elements = pattern.get('elements');
+                                elements.forEach((e)=>{
+                                    var _e_node, _e_node1;
+                                    let local;
+                                    if (((_e_node = e.node) == null ? void 0 : _e_node.type) === 'Identifier') {
+                                        local = e;
+                                    } else if (((_e_node1 = e.node) == null ? void 0 : _e_node1.type) === 'RestElement') {
+                                        local = e.get('argument');
+                                    } else {
+                                        return;
+                                    }
+                                    if (isIdentifierReferenced(local)) {
+                                        variableState.refs.add(local);
+                                    }
+                                });
+                            }
+                        },
+                        FunctionDeclaration: markFunction,
+                        FunctionExpression: markFunction,
+                        ArrowFunctionExpression: markFunction,
+                        ImportSpecifier: markImport,
+                        ImportDefaultSpecifier: markImport,
+                        ImportNamespaceSpecifier: markImport,
+                        ExportNamedDeclaration (exportNamedPath, exportNamedState) {
+                            const specifiers = exportNamedPath.get('specifiers');
+                            if (specifiers.length) {
+                                specifiers.forEach((s)=>{
+                                    if (isDataIdentifier(t.isIdentifier(s.node.exported) ? s.node.exported.name : s.node.exported.value, exportNamedState)) {
+                                        s.remove();
+                                    }
+                                });
+                                if (exportNamedPath.node.specifiers.length < 1) {
+                                    exportNamedPath.remove();
+                                }
+                                return;
+                            }
+                            const decl = exportNamedPath.get('declaration');
+                            if (decl == null || decl.node == null) {
+                                return;
+                            }
+                            switch(decl.node.type){
+                                case 'FunctionDeclaration':
+                                    {
+                                        const name = decl.node.id.name;
+                                        if (isDataIdentifier(name, exportNamedState)) {
+                                            exportNamedPath.remove();
+                                        }
+                                        break;
+                                    }
+                                case 'VariableDeclaration':
+                                    {
+                                        const inner = decl.get('declarations');
+                                        inner.forEach((d)=>{
+                                            if (d.node.id.type !== 'Identifier') {
+                                                return;
+                                            }
+                                            const name = d.node.id.name;
+                                            if (isDataIdentifier(name, exportNamedState)) {
+                                                d.remove();
+                                            }
+                                        });
+                                        break;
+                                    }
+                                default:
+                                    {
+                                        break;
+                                    }
+                            }
+                        }
+                    }, state);
+                    if (!state.isPrerender && !state.isServerProps) {
+                        return;
+                    }
+                    const refs = state.refs;
+                    let count;
+                    function sweepFunction(sweepPath) {
+                        const ident = getIdentifier(sweepPath);
+                        if ((ident == null ? void 0 : ident.node) && refs.has(ident) && !isIdentifierReferenced(ident)) {
+                            ++count;
+                            if (t.isAssignmentExpression(sweepPath.parentPath.node) || t.isVariableDeclarator(sweepPath.parentPath.node)) {
+                                sweepPath.parentPath.remove();
+                            } else {
+                                sweepPath.remove();
+                            }
+                        }
+                    }
+                    function sweepImport(sweepPath) {
+                        const local = sweepPath.get('local');
+                        if (refs.has(local) && !isIdentifierReferenced(local)) {
+                            ++count;
+                            sweepPath.remove();
+                            if (sweepPath.parent.specifiers.length === 0) {
+                                sweepPath.parentPath.remove();
+                            }
+                        }
+                    }
+                    do {
+                        ;
+                        path.scope.crawl();
+                        count = 0;
+                        path.traverse({
+                            // eslint-disable-next-line no-loop-func
+                            VariableDeclarator (variablePath) {
+                                if (variablePath.node.id.type === 'Identifier') {
+                                    const local = variablePath.get('id');
+                                    if (refs.has(local) && !isIdentifierReferenced(local)) {
+                                        ++count;
+                                        variablePath.remove();
+                                    }
+                                } else if (variablePath.node.id.type === 'ObjectPattern') {
+                                    const pattern = variablePath.get('id');
+                                    const beforeCount = count;
+                                    const properties = pattern.get('properties');
+                                    properties.forEach((p)=>{
+                                        const local = p.get(p.node.type === 'ObjectProperty' ? 'value' : p.node.type === 'RestElement' ? 'argument' : function() {
+                                            throw Object.defineProperty(new Error('invariant'), "__NEXT_ERROR_CODE", {
+                                                value: "E400",
+                                                enumerable: false,
+                                                configurable: true
+                                            });
+                                        }());
+                                        if (refs.has(local) && !isIdentifierReferenced(local)) {
+                                            ++count;
+                                            p.remove();
+                                        }
+                                    });
+                                    if (beforeCount !== count && pattern.get('properties').length < 1) {
+                                        variablePath.remove();
+                                    }
+                                } else if (variablePath.node.id.type === 'ArrayPattern') {
+                                    const pattern = variablePath.get('id');
+                                    const beforeCount = count;
+                                    const elements = pattern.get('elements');
+                                    elements.forEach((e)=>{
+                                        var _e_node, _e_node1;
+                                        let local;
+                                        if (((_e_node = e.node) == null ? void 0 : _e_node.type) === 'Identifier') {
+                                            local = e;
+                                        } else if (((_e_node1 = e.node) == null ? void 0 : _e_node1.type) === 'RestElement') {
+                                            local = e.get('argument');
+                                        } else {
+                                            return;
+                                        }
+                                        if (refs.has(local) && !isIdentifierReferenced(local)) {
+                                            ++count;
+                                            e.remove();
+                                        }
+                                    });
+                                    if (beforeCount !== count && pattern.get('elements').length < 1) {
+                                        variablePath.remove();
+                                    }
+                                }
+                            },
+                            FunctionDeclaration: sweepFunction,
+                            FunctionExpression: sweepFunction,
+                            ArrowFunctionExpression: sweepFunction,
+                            ImportSpecifier: sweepImport,
+                            ImportDefaultSpecifier: sweepImport,
+                            ImportNamespaceSpecifier: sweepImport
+                        });
+                    }while (count);
+                    decorateSsgExport(t, path, state);
+                }
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=next-ssg-transform.js.map

node_modules/next/dist/build/babel/plugins/optimize-hook-destructuring.d.ts

@@ -0,0 +1,5 @@
+import type { types as BabelTypes } from 'next/dist/compiled/babel/core';
+import type { PluginObj } from 'next/dist/compiled/babel/core';
+export default function ({ types: t, }: {
+    types: typeof BabelTypes;
+}): PluginObj<any>;

node_modules/next/dist/build/babel/plugins/optimize-hook-destructuring.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+// matches any hook-like (the default)
+const isHook = /^use[A-Z]/;
+// matches only built-in hooks provided by React et al
+const isBuiltInHook = /^use(Callback|Context|DebugValue|Effect|ImperativeHandle|LayoutEffect|Memo|Reducer|Ref|State)$/;
+function _default({ types: t }) {
+    const visitor = {
+        CallExpression (path, state) {
+            const onlyBuiltIns = state.opts.onlyBuiltIns;
+            // if specified, options.lib is a list of libraries that provide hook functions
+            const libs = state.opts.lib && (state.opts.lib === true ? [
+                'react',
+                'preact/hooks'
+            ] : [].concat(state.opts.lib));
+            // skip function calls that are not the init of a variable declaration:
+            if (!t.isVariableDeclarator(path.parent)) return;
+            // skip function calls where the return value is not Array-destructured:
+            if (!t.isArrayPattern(path.parent.id)) return;
+            // name of the (hook) function being called:
+            const hookName = path.node.callee.name;
+            if (libs) {
+                const binding = path.scope.getBinding(hookName);
+                // not an import
+                if (!binding || binding.kind !== 'module') return;
+                const specifier = binding.path.parent.source.value;
+                // not a match
+                if (!libs.some((lib)=>lib === specifier)) return;
+            }
+            // only match function calls with names that look like a hook
+            if (!(onlyBuiltIns ? isBuiltInHook : isHook).test(hookName)) return;
+            path.parent.id = t.objectPattern(path.parent.id.elements.reduce((patterns, element, i)=>{
+                if (element === null) {
+                    return patterns;
+                }
+                return patterns.concat(t.objectProperty(t.numericLiteral(i), // TODO: fix this
+                element));
+            }, []));
+        }
+    };
+    return {
+        name: 'optimize-hook-destructuring',
+        visitor: {
+            // this is a workaround to run before preset-env destroys destructured assignments
+            Program (path, state) {
+                path.traverse(visitor, state);
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=optimize-hook-destructuring.js.map

node_modules/next/dist/build/babel/plugins/optimize-hook-destructuring.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/babel/plugins/optimize-hook-destructuring.ts"],"sourcesContent":["import type {\n  NodePath,\n  types as BabelTypes,\n} from 'next/dist/compiled/babel/core'\nimport type { PluginObj } from 'next/dist/compiled/babel/core'\n// matches any hook-like (the default)\nconst isHook = /^use[A-Z]/\n\n// matches only built-in hooks provided by React et al\nconst isBuiltInHook =\n  /^use(Callback|Context|DebugValue|Effect|ImperativeHandle|LayoutEffect|Memo|Reducer|Ref|State)$/\n\nexport default function ({\n  types: t,\n}: {\n  types: typeof BabelTypes\n}): PluginObj<any> {\n  const visitor = {\n    CallExpression(path: NodePath<BabelTypes.CallExpression>, state: any) {\n      const onlyBuiltIns = state.opts.onlyBuiltIns\n\n      // if specified, options.lib is a list of libraries that provide hook functions\n      const libs =\n        state.opts.lib &&\n        (state.opts.lib === true\n          ? ['react', 'preact/hooks']\n          : [].concat(state.opts.lib))\n\n      // skip function calls that are not the init of a variable declaration:\n      if (!t.isVariableDeclarator(path.parent)) return\n\n      // skip function calls where the return value is not Array-destructured:\n      if (!t.isArrayPattern(path.parent.id)) return\n\n      // name of the (hook) function being called:\n      const hookName = (path.node.callee as BabelTypes.Identifier).name\n\n      if (libs) {\n        const binding = path.scope.getBinding(hookName)\n        // not an import\n        if (!binding || binding.kind !== 'module') return\n\n        const specifier = (binding.path.parent as BabelTypes.ImportDeclaration)\n          .source.value\n        // not a match\n        if (!libs.some((lib: any) => lib === specifier)) return\n      }\n\n      // only match function calls with names that look like a hook\n      if (!(onlyBuiltIns ? isBuiltInHook : isHook).test(hookName)) return\n\n      path.parent.id = t.objectPattern(\n        path.parent.id.elements.reduce<Array<BabelTypes.ObjectProperty>>(\n          (patterns, element, i) => {\n            if (element === null) {\n              return patterns\n            }\n\n            return patterns.concat(\n              t.objectProperty(\n                t.numericLiteral(i),\n                // TODO: fix this\n                element as Exclude<\n                  typeof element,\n                  BabelTypes.MemberExpression | BabelTypes.TSParameterProperty\n                >\n              )\n            )\n          },\n          []\n        )\n      )\n    },\n  }\n\n  return {\n    name: 'optimize-hook-destructuring',\n    visitor: {\n      // this is a workaround to run before preset-env destroys destructured assignments\n      Program(path, state) {\n        path.traverse(visitor, state)\n      },\n    },\n  }\n}\n"],"names":["isHook","isBuiltInHook","types","t","visitor","CallExpression","path","state","onlyBuiltIns","opts","libs","lib","concat","isVariableDeclarator","parent","isArrayPattern","id","hookName","node","callee","name","binding","scope","getBinding","kind","specifier","source","value","some","test","objectPattern","elements","reduce","patterns","element","i","objectProperty","numericLiteral","Program","traverse"],"mappings":";;;;+BAYA;;;eAAA;;;AAPA,sCAAsC;AACtC,MAAMA,SAAS;AAEf,sDAAsD;AACtD,MAAMC,gBACJ;AAEa,SAAf,SAAyB,EACvBC,OAAOC,CAAC,EAGT;IACC,MAAMC,UAAU;QACdC,gBAAeC,IAAyC,EAAEC,KAAU;YAClE,MAAMC,eAAeD,MAAME,IAAI,CAACD,YAAY;YAE5C,+EAA+E;YAC/E,MAAME,OACJH,MAAME,IAAI,CAACE,GAAG,IACbJ,CAAAA,MAAME,IAAI,CAACE,GAAG,KAAK,OAChB;gBAAC;gBAAS;aAAe,GACzB,EAAE,CAACC,MAAM,CAACL,MAAME,IAAI,CAACE,GAAG,CAAA;YAE9B,uEAAuE;YACvE,IAAI,CAACR,EAAEU,oBAAoB,CAACP,KAAKQ,MAAM,GAAG;YAE1C,wEAAwE;YACxE,IAAI,CAACX,EAAEY,cAAc,CAACT,KAAKQ,MAAM,CAACE,EAAE,GAAG;YAEvC,4CAA4C;YAC5C,MAAMC,WAAW,AAACX,KAAKY,IAAI,CAACC,MAAM,CAA2BC,IAAI;YAEjE,IAAIV,MAAM;gBACR,MAAMW,UAAUf,KAAKgB,KAAK,CAACC,UAAU,CAACN;gBACtC,gBAAgB;gBAChB,IAAI,CAACI,WAAWA,QAAQG,IAAI,KAAK,UAAU;gBAE3C,MAAMC,YAAY,AAACJ,QAAQf,IAAI,CAACQ,MAAM,CACnCY,MAAM,CAACC,KAAK;gBACf,cAAc;gBACd,IAAI,CAACjB,KAAKkB,IAAI,CAAC,CAACjB,MAAaA,QAAQc,YAAY;YACnD;YAEA,6DAA6D;YAC7D,IAAI,CAAC,AAACjB,CAAAA,eAAeP,gBAAgBD,MAAK,EAAG6B,IAAI,CAACZ,WAAW;YAE7DX,KAAKQ,MAAM,CAACE,EAAE,GAAGb,EAAE2B,aAAa,CAC9BxB,KAAKQ,MAAM,CAACE,EAAE,CAACe,QAAQ,CAACC,MAAM,CAC5B,CAACC,UAAUC,SAASC;gBAClB,IAAID,YAAY,MAAM;oBACpB,OAAOD;gBACT;gBAEA,OAAOA,SAASrB,MAAM,CACpBT,EAAEiC,cAAc,CACdjC,EAAEkC,cAAc,CAACF,IACjB,iBAAiB;gBACjBD;YAMN,GACA,EAAE;QAGR;IACF;IAEA,OAAO;QACLd,MAAM;QACNhB,SAAS;YACP,kFAAkF;YAClFkC,SAAQhC,IAAI,EAAEC,KAAK;gBACjBD,KAAKiC,QAAQ,CAACnC,SAASG;YACzB;QACF;IACF;AACF"}

node_modules/next/dist/build/babel/plugins/react-loadable-plugin.d.ts

@@ -0,0 +1,25 @@
+/**
+COPYRIGHT (c) 2017-present James Kyle <me@thejameskyle.com>
+ MIT License
+ 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 SOFTWAR
+*/
+import type { types as BabelTypes } from 'next/dist/compiled/babel/core';
+import type { PluginObj } from 'next/dist/compiled/babel/core';
+export default function ({ types: t, }: {
+    types: typeof BabelTypes;
+}): PluginObj;

node_modules/next/dist/build/babel/plugins/react-loadable-plugin.js

@@ -0,0 +1,150 @@
+/**
+COPYRIGHT (c) 2017-present James Kyle <me@thejameskyle.com>
+ MIT License
+ 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 SOFTWAR
+*/ // This file is https://github.com/jamiebuilds/react-loadable/blob/master/src/babel.js
+// Modified to also look for `next/dynamic`
+// Modified to put `webpack` and `modules` under `loadableGenerated` to be backwards compatible with next/dynamic which has a `modules` key
+// Modified to support `dynamic(import('something'))` and `dynamic(import('something'), options)
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _path = require("path");
+function _default({ types: t }) {
+    return {
+        visitor: {
+            ImportDeclaration (path, state) {
+                let source = path.node.source.value;
+                if (source !== 'next/dynamic') return;
+                let defaultSpecifier = path.get('specifiers').find((specifier)=>{
+                    return specifier.isImportDefaultSpecifier();
+                });
+                if (!defaultSpecifier) return;
+                const bindingName = defaultSpecifier.node.local.name;
+                const binding = path.scope.getBinding(bindingName);
+                if (!binding) {
+                    return;
+                }
+                binding.referencePaths.forEach((refPath)=>{
+                    var _state_file_opts_caller, _state_file_opts_caller1;
+                    let callExpression = refPath.parentPath;
+                    if (callExpression.isMemberExpression() && callExpression.node.computed === false) {
+                        const property = callExpression.get('property');
+                        if (!Array.isArray(property) && property.isIdentifier({
+                            name: 'Map'
+                        })) {
+                            callExpression = callExpression.parentPath;
+                        }
+                    }
+                    if (!callExpression.isCallExpression()) return;
+                    const callExpression_ = callExpression;
+                    let args = callExpression_.get('arguments');
+                    if (args.length > 2) {
+                        throw callExpression_.buildCodeFrameError('next/dynamic only accepts 2 arguments');
+                    }
+                    if (!args[0]) {
+                        return;
+                    }
+                    let loader;
+                    let options;
+                    if (args[0].isObjectExpression()) {
+                        options = args[0];
+                    } else {
+                        if (!args[1]) {
+                            callExpression_.node.arguments.push(t.objectExpression([]));
+                        }
+                        // This is needed as the code is modified above
+                        args = callExpression_.get('arguments');
+                        loader = args[0];
+                        options = args[1];
+                    }
+                    if (!options.isObjectExpression()) return;
+                    const options_ = options;
+                    let properties = options_.get('properties');
+                    let propertiesMap = {};
+                    properties.forEach((property)=>{
+                        const key = property.get('key');
+                        propertiesMap[key.node.name] = property;
+                    });
+                    if (propertiesMap.loadableGenerated) {
+                        return;
+                    }
+                    if (propertiesMap.loader) {
+                        loader = propertiesMap.loader.get('value');
+                    }
+                    if (propertiesMap.modules) {
+                        loader = propertiesMap.modules.get('value');
+                    }
+                    if (!loader || Array.isArray(loader)) {
+                        return;
+                    }
+                    const dynamicImports = [];
+                    const dynamicKeys = [];
+                    if (propertiesMap.ssr) {
+                        const ssr = propertiesMap.ssr.get('value');
+                        const nodePath = Array.isArray(ssr) ? undefined : ssr;
+                        if (nodePath) {
+                            var _state_file_opts_caller2;
+                            const nonSSR = nodePath.node.type === 'BooleanLiteral' && nodePath.node.value === false;
+                            // If `ssr` is set to `false`, erase the loader for server side
+                            if (nonSSR && loader && ((_state_file_opts_caller2 = state.file.opts.caller) == null ? void 0 : _state_file_opts_caller2.isServer)) {
+                                loader.replaceWith(t.arrowFunctionExpression([], t.nullLiteral(), true));
+                            }
+                        }
+                    }
+                    loader.traverse({
+                        Import (importPath) {
+                            var _state_file_opts_caller;
+                            const importArguments = importPath.parentPath.get('arguments');
+                            if (!Array.isArray(importArguments)) return;
+                            const node = importArguments[0].node;
+                            dynamicImports.push(node);
+                            dynamicKeys.push(t.binaryExpression('+', t.stringLiteral((((_state_file_opts_caller = state.file.opts.caller) == null ? void 0 : _state_file_opts_caller.srcDir) ? (0, _path.relative)(state.file.opts.caller.srcDir, state.file.opts.filename) : state.file.opts.filename) + ' -> '), node));
+                        }
+                    });
+                    if (!dynamicImports.length) return;
+                    options.node.properties.push(t.objectProperty(t.identifier('loadableGenerated'), t.objectExpression(((_state_file_opts_caller = state.file.opts.caller) == null ? void 0 : _state_file_opts_caller.isDev) || ((_state_file_opts_caller1 = state.file.opts.caller) == null ? void 0 : _state_file_opts_caller1.isServer) ? [
+                        t.objectProperty(t.identifier('modules'), t.arrayExpression(dynamicKeys))
+                    ] : [
+                        t.objectProperty(t.identifier('webpack'), t.arrowFunctionExpression([], t.arrayExpression(dynamicImports.map((dynamicImport)=>{
+                            return t.callExpression(t.memberExpression(t.identifier('require'), t.identifier('resolveWeak')), [
+                                dynamicImport
+                            ]);
+                        }))))
+                    ])));
+                    // Turns `dynamic(import('something'))` into `dynamic(() => import('something'))` for backwards compat.
+                    // This is the replicate the behavior in versions below Next.js 7 where we magically handled not executing the `import()` too.
+                    // We'll deprecate this behavior and provide a codemod for it in 7.1.
+                    if (loader.isCallExpression()) {
+                        const arrowFunction = t.arrowFunctionExpression([], loader.node);
+                        loader.replaceWith(arrowFunction);
+                    }
+                });
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=react-loadable-plugin.js.map

node_modules/next/dist/build/babel/preset.d.ts

@@ -0,0 +1,25 @@
+import type { PluginItem } from 'next/dist/compiled/babel/core';
+type StyledJsxPlugin = [string, any] | string;
+type StyledJsxBabelOptions = {
+    plugins?: StyledJsxPlugin[];
+    styleModule?: string;
+    'babel-test'?: boolean;
+} | undefined;
+type NextBabelPresetOptions = {
+    'preset-env'?: any;
+    'preset-react'?: any;
+    'class-properties'?: any;
+    'transform-runtime'?: any;
+    'styled-jsx'?: StyledJsxBabelOptions;
+    'preset-typescript'?: any;
+};
+type BabelPreset = {
+    presets?: PluginItem[] | null;
+    plugins?: PluginItem[] | null;
+    sourceType?: 'script' | 'module' | 'unambiguous';
+    overrides?: Array<{
+        test: RegExp;
+    } & Omit<BabelPreset, 'overrides'>>;
+};
+declare const _default: (api: any, options?: NextBabelPresetOptions) => BabelPreset;
+export default _default;

node_modules/next/dist/build/babel/preset.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _path = require("path");
+const isLoadIntentTest = process.env.NODE_ENV === 'test';
+const isLoadIntentDevelopment = process.env.NODE_ENV === 'development';
+// Resolve styled-jsx plugins
+function styledJsxOptions(options) {
+    options = options || {};
+    options.styleModule = 'styled-jsx/style';
+    if (!Array.isArray(options.plugins)) {
+        return options;
+    }
+    options.plugins = options.plugins.map((plugin)=>{
+        if (Array.isArray(plugin)) {
+            const [name, pluginOptions] = plugin;
+            return [
+                require.resolve(name),
+                pluginOptions
+            ];
+        }
+        return require.resolve(plugin);
+    });
+    return options;
+}
+// Taken from https://github.com/babel/babel/commit/d60c5e1736543a6eac4b549553e107a9ba967051#diff-b4beead8ad9195361b4537601cc22532R158
+function supportsStaticESM(caller) {
+    return !!(caller == null ? void 0 : caller.supportsStaticESM);
+}
+const _default = (api, options = {})=>{
+    var _options_presetreact, _options_presetreact1;
+    const supportsESM = api.caller(supportsStaticESM);
+    const isServer = api.caller((caller)=>!!caller && caller.isServer);
+    const isCallerDevelopment = api.caller((caller)=>caller == null ? void 0 : caller.isDev);
+    // Look at external intent if used without a caller (e.g. via Jest):
+    const isTest = isCallerDevelopment == null && isLoadIntentTest;
+    // Look at external intent if used without a caller (e.g. Storybook):
+    const isDevelopment = isCallerDevelopment === true || isCallerDevelopment == null && isLoadIntentDevelopment;
+    // Default to production mode if not `test` nor `development`:
+    const isProduction = !(isTest || isDevelopment);
+    const isBabelLoader = api.caller((caller)=>!!caller && (caller.name === 'babel-loader' || caller.name === 'next-babel-turbo-loader'));
+    const useJsxRuntime = ((_options_presetreact = options['preset-react']) == null ? void 0 : _options_presetreact.runtime) === 'automatic' || Boolean(api.caller((caller)=>!!caller && caller.hasJsxRuntime)) && ((_options_presetreact1 = options['preset-react']) == null ? void 0 : _options_presetreact1.runtime) !== 'classic';
+    const presetEnvConfig = {
+        // In the test environment `modules` is often needed to be set to true, babel figures that out by itself using the `'auto'` option
+        // In production/development this option is set to `false` so that webpack can handle import/export with tree-shaking
+        modules: 'auto',
+        exclude: [
+            'transform-typeof-symbol'
+        ],
+        ...options['preset-env']
+    };
+    // When transpiling for the server or tests, target the current Node version
+    // if not explicitly specified:
+    if ((isServer || isTest) && (!presetEnvConfig.targets || !(typeof presetEnvConfig.targets === 'object' && 'node' in presetEnvConfig.targets))) {
+        presetEnvConfig.targets = {
+            // Targets the current process' version of Node. This requires apps be
+            // built and deployed on the same version of Node.
+            // This is the same as using "current" but explicit
+            node: process.versions.node
+        };
+    }
+    return {
+        sourceType: 'unambiguous',
+        presets: [
+            [
+                require('next/dist/compiled/babel/preset-env'),
+                presetEnvConfig
+            ],
+            [
+                require('next/dist/compiled/babel/preset-react'),
+                {
+                    // This adds @babel/plugin-transform-react-jsx-source and
+                    // @babel/plugin-transform-react-jsx-self automatically in development
+                    development: isDevelopment || isTest,
+                    ...useJsxRuntime ? {
+                        runtime: 'automatic'
+                    } : {
+                        pragma: '__jsx'
+                    },
+                    ...options['preset-react']
+                }
+            ],
+            [
+                require('next/dist/compiled/babel/preset-typescript'),
+                {
+                    allowNamespaces: true,
+                    ...options['preset-typescript']
+                }
+            ]
+        ],
+        plugins: [
+            !useJsxRuntime && [
+                require('./plugins/jsx-pragma'),
+                {
+                    // This produces the following injected import for modules containing JSX:
+                    //   import React from 'react';
+                    //   var __jsx = React.createElement;
+                    module: 'react',
+                    importAs: 'React',
+                    pragma: '__jsx',
+                    property: 'createElement'
+                }
+            ],
+            [
+                require('./plugins/optimize-hook-destructuring'),
+                {
+                    // only optimize hook functions imported from React/Preact
+                    lib: true
+                }
+            ],
+            require('next/dist/compiled/babel/plugin-syntax-dynamic-import'),
+            [
+                require('next/dist/compiled/babel/plugin-syntax-import-attributes'),
+                {
+                    deprecatedAssertSyntax: true
+                }
+            ],
+            require('./plugins/react-loadable-plugin'),
+            // only enable this plugin if custom config for it was provided
+            // otherwise we will only enable it if their browserslist triggers
+            // preset-env to pull it in
+            options['class-properties'] && [
+                require('next/dist/compiled/babel/plugin-proposal-class-properties'),
+                options['class-properties'] || {}
+            ],
+            [
+                require('next/dist/compiled/babel/plugin-proposal-object-rest-spread'),
+                {
+                    useBuiltIns: true
+                }
+            ],
+            !isServer && [
+                require('next/dist/compiled/babel/plugin-transform-runtime'),
+                {
+                    corejs: false,
+                    helpers: true,
+                    regenerator: true,
+                    useESModules: supportsESM && presetEnvConfig.modules !== 'commonjs',
+                    absoluteRuntime: isBabelLoader ? (0, _path.dirname)(require.resolve('next/dist/compiled/@babel/runtime/package.json')) : undefined,
+                    ...options['transform-runtime']
+                }
+            ],
+            [
+                isTest && options['styled-jsx'] && options['styled-jsx']['babel-test'] ? require('styled-jsx/babel-test') : require('styled-jsx/babel'),
+                styledJsxOptions(options['styled-jsx'])
+            ],
+            require('./plugins/amp-attributes'),
+            isProduction && [
+                require('next/dist/compiled/babel/plugin-transform-react-remove-prop-types'),
+                {
+                    removeImport: true
+                }
+            ],
+            isServer && require('next/dist/compiled/babel/plugin-syntax-bigint'),
+            // Always compile numeric separator because the resulting number is
+            // smaller.
+            require('next/dist/compiled/babel/plugin-proposal-numeric-separator'),
+            require('next/dist/compiled/babel/plugin-proposal-export-namespace-from')
+        ].filter(Boolean)
+    };
+};
+
+//# sourceMappingURL=preset.js.map

node_modules/next/dist/build/build-context.d.ts

@@ -0,0 +1,53 @@
+import type { LoadedEnvFiles } from '@next/env';
+import type { Rewrite, Redirect } from '../lib/load-custom-routes';
+import type { __ApiPreviewProps } from '../server/api-utils';
+import type { NextConfigComplete } from '../server/config-shared';
+import type { Span } from '../trace';
+import type getBaseWebpackConfig from './webpack-config';
+import type { TelemetryPluginState } from './webpack/plugins/telemetry-plugin/telemetry-plugin';
+import type { Telemetry } from '../telemetry/storage';
+export declare function resumePluginState(resumedState?: Record<string, any>): void;
+export declare function getProxiedPluginState<State extends Record<string, any>>(initialState: State): State;
+export declare function getPluginState(): Record<string, any>;
+export interface MappedPages {
+    [page: string]: string;
+}
+export declare const NextBuildContext: Partial<{
+    compilerIdx?: number;
+    pluginState: Record<string, any>;
+    dir: string;
+    distDir: string;
+    buildId: string;
+    encryptionKey: string;
+    config: NextConfigComplete;
+    appDir: string;
+    pagesDir: string;
+    rewrites: {
+        fallback: Rewrite[];
+        afterFiles: Rewrite[];
+        beforeFiles: Rewrite[];
+    };
+    originalRewrites: {
+        fallback: Rewrite[];
+        afterFiles: Rewrite[];
+        beforeFiles: Rewrite[];
+    };
+    hasRewrites: boolean;
+    originalRedirects: Redirect[];
+    loadedEnvFiles: LoadedEnvFiles;
+    previewProps: __ApiPreviewProps;
+    mappedPages: MappedPages | undefined;
+    mappedAppPages: MappedPages | undefined;
+    mappedRootPaths: MappedPages;
+    hasInstrumentationHook: boolean;
+    telemetry: Telemetry;
+    telemetryState: TelemetryPluginState;
+    nextBuildSpan: Span;
+    reactProductionProfiling: boolean;
+    noMangling: boolean;
+    appDirOnly: boolean;
+    clientRouterFilters: Parameters<typeof getBaseWebpackConfig>[1]['clientRouterFilters'];
+    previewModeId: string;
+    fetchCacheKeyPrefix?: string;
+    allowedRevalidateHeaderKeys?: string[];
+}>;

node_modules/next/dist/build/build-context.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    NextBuildContext: null,
+    getPluginState: null,
+    getProxiedPluginState: null,
+    resumePluginState: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NextBuildContext: function() {
+        return NextBuildContext;
+    },
+    getPluginState: function() {
+        return getPluginState;
+    },
+    getProxiedPluginState: function() {
+        return getProxiedPluginState;
+    },
+    resumePluginState: function() {
+        return resumePluginState;
+    }
+});
+// A layer for storing data that is used by plugins to communicate with each
+// other between different steps of the build process. This is only internal
+// to Next.js and will not be a part of the final build output.
+// These states don't need to be deeply merged.
+let pluginState = {};
+function resumePluginState(resumedState) {
+    Object.assign(pluginState, resumedState);
+}
+function getProxiedPluginState(initialState) {
+    return new Proxy(pluginState, {
+        get (target, key) {
+            if (typeof target[key] === 'undefined') {
+                return target[key] = initialState[key];
+            }
+            return target[key];
+        },
+        set (target, key, value) {
+            target[key] = value;
+            return true;
+        }
+    });
+}
+function getPluginState() {
+    return pluginState;
+}
+const NextBuildContext = {};
+
+//# sourceMappingURL=build-context.js.map

node_modules/next/dist/build/build-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/build/build-context.ts"],"sourcesContent":["import type { LoadedEnvFiles } from '@next/env'\nimport type { Rewrite, Redirect } from '../lib/load-custom-routes'\nimport type { __ApiPreviewProps } from '../server/api-utils'\nimport type { NextConfigComplete } from '../server/config-shared'\nimport type { Span } from '../trace'\nimport type getBaseWebpackConfig from './webpack-config'\nimport type { TelemetryPluginState } from './webpack/plugins/telemetry-plugin/telemetry-plugin'\nimport type { Telemetry } from '../telemetry/storage'\n\n// A layer for storing data that is used by plugins to communicate with each\n// other between different steps of the build process. This is only internal\n// to Next.js and will not be a part of the final build output.\n// These states don't need to be deeply merged.\nlet pluginState: Record<string, any> = {}\nexport function resumePluginState(resumedState?: Record<string, any>) {\n  Object.assign(pluginState, resumedState)\n}\n\n// This method gives you the plugin state with typed and mutable value fields\n// behind a proxy so we can lazily initialize the values **after** resuming the\n// plugin state.\nexport function getProxiedPluginState<State extends Record<string, any>>(\n  initialState: State\n) {\n  return new Proxy(pluginState, {\n    get(target, key: string) {\n      if (typeof target[key] === 'undefined') {\n        return (target[key] = initialState[key])\n      }\n      return target[key]\n    },\n    set(target, key: string, value) {\n      target[key] = value\n      return true\n    },\n  }) as State\n}\n\nexport function getPluginState() {\n  return pluginState\n}\n\nexport interface MappedPages {\n  [page: string]: string\n}\n\n// a global object to store context for the current build\n// this is used to pass data between different steps of the build without having\n// to pass it through function arguments.\n// Not exhaustive, but should be extended to as needed whilst refactoring\nexport const NextBuildContext: Partial<{\n  compilerIdx?: number\n  pluginState: Record<string, any>\n  // core fields\n  dir: string\n  distDir: string\n  buildId: string\n  encryptionKey: string\n  config: NextConfigComplete\n  appDir: string\n  pagesDir: string\n  rewrites: {\n    fallback: Rewrite[]\n    afterFiles: Rewrite[]\n    beforeFiles: Rewrite[]\n  }\n  originalRewrites: {\n    fallback: Rewrite[]\n    afterFiles: Rewrite[]\n    beforeFiles: Rewrite[]\n  }\n  hasRewrites: boolean\n  originalRedirects: Redirect[]\n  loadedEnvFiles: LoadedEnvFiles\n  previewProps: __ApiPreviewProps\n  mappedPages: MappedPages | undefined\n  mappedAppPages: MappedPages | undefined\n  mappedRootPaths: MappedPages\n  hasInstrumentationHook: boolean\n\n  // misc fields\n  telemetry: Telemetry\n  telemetryState: TelemetryPluginState\n  nextBuildSpan: Span\n\n  // cli fields\n  reactProductionProfiling: boolean\n  noMangling: boolean\n  appDirOnly: boolean\n  clientRouterFilters: Parameters<\n    typeof getBaseWebpackConfig\n  >[1]['clientRouterFilters']\n  previewModeId: string\n  fetchCacheKeyPrefix?: string\n  allowedRevalidateHeaderKeys?: string[]\n}> = {}\n"],"names":["NextBuildContext","getPluginState","getProxiedPluginState","resumePluginState","pluginState","resumedState","Object","assign","initialState","Proxy","get","target","key","set","value"],"mappings":";;;;;;;;;;;;;;;;;IAkDaA,gBAAgB;eAAhBA;;IAZGC,cAAc;eAAdA;;IAjBAC,qBAAqB;eAArBA;;IAPAC,iBAAiB;eAAjBA;;;AALhB,4EAA4E;AAC5E,4EAA4E;AAC5E,+DAA+D;AAC/D,+CAA+C;AAC/C,IAAIC,cAAmC,CAAC;AACjC,SAASD,kBAAkBE,YAAkC;IAClEC,OAAOC,MAAM,CAACH,aAAaC;AAC7B;AAKO,SAASH,sBACdM,YAAmB;IAEnB,OAAO,IAAIC,MAAML,aAAa;QAC5BM,KAAIC,MAAM,EAAEC,GAAW;YACrB,IAAI,OAAOD,MAAM,CAACC,IAAI,KAAK,aAAa;gBACtC,OAAQD,MAAM,CAACC,IAAI,GAAGJ,YAAY,CAACI,IAAI;YACzC;YACA,OAAOD,MAAM,CAACC,IAAI;QACpB;QACAC,KAAIF,MAAM,EAAEC,GAAW,EAAEE,KAAK;YAC5BH,MAAM,CAACC,IAAI,GAAGE;YACd,OAAO;QACT;IACF;AACF;AAEO,SAASb;IACd,OAAOG;AACT;AAUO,MAAMJ,mBA6CR,CAAC"}

node_modules/next/dist/build/collect-build-traces.d.ts

@@ -0,0 +1,15 @@
+import { Span } from '../trace';
+import type { NextConfigComplete } from '../server/config-shared';
+import { type BuildTraceContext } from './webpack/plugins/next-trace-entrypoints-plugin';
+import type { RoutesUsingEdgeRuntime } from './utils';
+export declare function collectBuildTraces({ dir, config, distDir, edgeRuntimeRoutes, staticPages, nextBuildSpan, hasSsrAmpPages, buildTraceContext, outputFileTracingRoot, }: {
+    dir: string;
+    distDir: string;
+    staticPages: string[];
+    hasSsrAmpPages: boolean;
+    outputFileTracingRoot: string;
+    edgeRuntimeRoutes: RoutesUsingEdgeRuntime;
+    nextBuildSpan?: Span;
+    config: NextConfigComplete;
+    buildTraceContext?: BuildTraceContext;
+}): Promise<void>;

node_modules/next/dist/build/collect-build-traces.js

@@ -0,0 +1,519 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "collectBuildTraces", {
+    enumerable: true,
+    get: function() {
+        return collectBuildTraces;
+    }
+});
+const _trace = require("../trace");
+const _nexttraceentrypointsplugin = require("./webpack/plugins/next-trace-entrypoints-plugin");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _promises = /*#__PURE__*/ _interop_require_default(require("fs/promises"));
+const _nonnullable = require("../lib/non-nullable");
+const _ciinfo = /*#__PURE__*/ _interop_require_wildcard(require("../server/ci-info"));
+const _debug = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/debug"));
+const _picomatch = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/picomatch"));
+const _requirehook = require("../server/require-hook");
+const _nft = require("next/dist/compiled/@vercel/nft");
+const _normalizepagepath = require("../shared/lib/page-path/normalize-page-path");
+const _apppaths = require("../shared/lib/router/utils/app-paths");
+const _iserror = /*#__PURE__*/ _interop_require_default(require("../lib/is-error"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const debug = (0, _debug.default)('next:build:build-traces');
+function shouldIgnore(file, serverIgnoreFn, reasons, cachedIgnoreFiles, children = new Set()) {
+    if (cachedIgnoreFiles.has(file)) {
+        return cachedIgnoreFiles.get(file);
+    }
+    if (serverIgnoreFn(file)) {
+        cachedIgnoreFiles.set(file, true);
+        return true;
+    }
+    children.add(file);
+    const reason = reasons.get(file);
+    if (!reason || reason.parents.size === 0 || reason.type.includes('initial')) {
+        cachedIgnoreFiles.set(file, false);
+        return false;
+    }
+    // if all parents are ignored the child file
+    // should be ignored as well
+    let allParentsIgnored = true;
+    for (const parent of reason.parents.values()){
+        if (!children.has(parent)) {
+            children.add(parent);
+            if (!shouldIgnore(parent, serverIgnoreFn, reasons, cachedIgnoreFiles, children)) {
+                allParentsIgnored = false;
+                break;
+            }
+        }
+    }
+    cachedIgnoreFiles.set(file, allParentsIgnored);
+    return allParentsIgnored;
+}
+async function collectBuildTraces({ dir, config, distDir, edgeRuntimeRoutes, staticPages, nextBuildSpan = new _trace.Span({
+    name: 'build'
+}), hasSsrAmpPages, buildTraceContext, outputFileTracingRoot }) {
+    const startTime = Date.now();
+    debug('starting build traces');
+    const { outputFileTracingIncludes = {}, outputFileTracingExcludes = {} } = config;
+    const excludeGlobKeys = Object.keys(outputFileTracingExcludes);
+    const includeGlobKeys = Object.keys(outputFileTracingIncludes);
+    await nextBuildSpan.traceChild('node-file-trace-build', {
+        isTurbotrace: 'false'
+    }).traceAsyncFn(async ()=>{
+        const nextServerTraceOutput = _path.default.join(distDir, 'next-server.js.nft.json');
+        const nextMinimalTraceOutput = _path.default.join(distDir, 'next-minimal-server.js.nft.json');
+        const root = outputFileTracingRoot;
+        // Under standalone mode, we need to trace the extra IPC server and
+        // worker files.
+        const isStandalone = config.output === 'standalone';
+        const sharedEntriesSet = Object.keys(_requirehook.defaultOverrides).map((value)=>require.resolve(value, {
+                paths: [
+                    require.resolve('next/dist/server/require-hook')
+                ]
+            }));
+        const { cacheHandler } = config;
+        const { cacheHandlers } = config.experimental;
+        // ensure we trace any dependencies needed for custom
+        // incremental cache handler
+        if (cacheHandler) {
+            sharedEntriesSet.push(require.resolve(_path.default.isAbsolute(cacheHandler) ? cacheHandler : _path.default.join(dir, cacheHandler)));
+        }
+        if (cacheHandlers) {
+            for (const handlerPath of Object.values(cacheHandlers)){
+                if (handlerPath) {
+                    sharedEntriesSet.push(require.resolve(_path.default.isAbsolute(handlerPath) ? handlerPath : _path.default.join(dir, handlerPath)));
+                }
+            }
+        }
+        const serverEntries = [
+            ...sharedEntriesSet,
+            ...isStandalone ? [
+                require.resolve('next/dist/server/lib/start-server'),
+                require.resolve('next/dist/server/next'),
+                require.resolve('next/dist/server/require-hook')
+            ] : [],
+            require.resolve('next/dist/server/next-server')
+        ].filter(Boolean);
+        const minimalServerEntries = [
+            ...sharedEntriesSet,
+            require.resolve('next/dist/compiled/next-server/server.runtime.prod')
+        ].filter(Boolean);
+        const additionalIgnores = new Set();
+        for (const glob of excludeGlobKeys){
+            if ((0, _picomatch.default)(glob)('next-server')) {
+                outputFileTracingExcludes[glob].forEach((exclude)=>{
+                    additionalIgnores.add(exclude);
+                });
+            }
+        }
+        const makeIgnoreFn = (ignores)=>{
+            // pre compile the ignore globs
+            const isMatch = (0, _picomatch.default)(ignores, {
+                contains: true,
+                dot: true
+            });
+            return (pathname)=>{
+                if (_path.default.isAbsolute(pathname) && !pathname.startsWith(root)) {
+                    return true;
+                }
+                return isMatch(pathname);
+            };
+        };
+        const sharedIgnores = [
+            '**/next/dist/compiled/next-server/**/*.dev.js',
+            ...isStandalone ? [] : [
+                '**/next/dist/compiled/jest-worker/**/*'
+            ],
+            '**/next/dist/compiled/webpack/(bundle4|bundle5).js',
+            '**/node_modules/webpack5/**/*',
+            '**/next/dist/server/lib/route-resolver*',
+            'next/dist/compiled/semver/semver/**/*.js',
+            ..._ciinfo.hasNextSupport ? [
+                // only ignore image-optimizer code when
+                // this is being handled outside of next-server
+                '**/next/dist/server/image-optimizer.js'
+            ] : [],
+            ...!hasSsrAmpPages ? [
+                '**/next/dist/compiled/@ampproject/toolbox-optimizer/**/*'
+            ] : [],
+            ...isStandalone ? [] : _nexttraceentrypointsplugin.TRACE_IGNORES,
+            ...additionalIgnores
+        ];
+        const sharedIgnoresFn = makeIgnoreFn(sharedIgnores);
+        const serverIgnores = [
+            ...sharedIgnores,
+            '**/node_modules/react{,-dom,-dom-server-turbopack}/**/*.development.js',
+            '**/*.d.ts',
+            '**/*.map',
+            '**/next/dist/pages/**/*',
+            ..._ciinfo.hasNextSupport ? [
+                '**/node_modules/sharp/**/*',
+                '**/@img/sharp-libvips*/**/*'
+            ] : []
+        ].filter(_nonnullable.nonNullable);
+        const serverIgnoreFn = makeIgnoreFn(serverIgnores);
+        const minimalServerIgnores = [
+            ...serverIgnores,
+            '**/next/dist/compiled/edge-runtime/**/*',
+            '**/next/dist/server/web/sandbox/**/*',
+            '**/next/dist/server/post-process.js'
+        ];
+        const minimalServerIgnoreFn = makeIgnoreFn(minimalServerIgnores);
+        const routesIgnores = [
+            ...sharedIgnores,
+            // server chunks are provided via next-trace-entrypoints-plugin plugin
+            // as otherwise all chunks are traced here and included for all pages
+            // whether they are needed or not
+            '**/.next/server/chunks/**',
+            '**/next/dist/server/optimize-amp.js',
+            '**/next/dist/server/post-process.js'
+        ].filter(_nonnullable.nonNullable);
+        const routeIgnoreFn = makeIgnoreFn(routesIgnores);
+        const serverTracedFiles = new Set();
+        const minimalServerTracedFiles = new Set();
+        function addToTracedFiles(base, file, dest) {
+            dest.add(_path.default.relative(distDir, _path.default.join(base, file)).replace(/\\/g, '/'));
+        }
+        if (isStandalone) {
+            addToTracedFiles('', require.resolve('next/dist/compiled/jest-worker/processChild'), serverTracedFiles);
+            addToTracedFiles('', require.resolve('next/dist/compiled/jest-worker/threadChild'), serverTracedFiles);
+        }
+        {
+            var _buildTraceContext_chunksTrace;
+            const chunksToTrace = [
+                ...(buildTraceContext == null ? void 0 : (_buildTraceContext_chunksTrace = buildTraceContext.chunksTrace) == null ? void 0 : _buildTraceContext_chunksTrace.action.input) || [],
+                ...serverEntries,
+                ...minimalServerEntries
+            ];
+            const result = await (0, _nft.nodeFileTrace)(chunksToTrace, {
+                base: outputFileTracingRoot,
+                processCwd: dir,
+                mixedModules: true,
+                async readFile (p) {
+                    try {
+                        return await _promises.default.readFile(p, 'utf8');
+                    } catch (e) {
+                        if ((0, _iserror.default)(e) && (e.code === 'ENOENT' || e.code === 'EISDIR')) {
+                            // since tracing runs in parallel with static generation server
+                            // files might be removed from that step so tolerate ENOENT
+                            // errors gracefully
+                            return '';
+                        }
+                        throw e;
+                    }
+                },
+                async readlink (p) {
+                    try {
+                        return await _promises.default.readlink(p);
+                    } catch (e) {
+                        if ((0, _iserror.default)(e) && (e.code === 'EINVAL' || e.code === 'ENOENT' || e.code === 'UNKNOWN')) {
+                            return null;
+                        }
+                        throw e;
+                    }
+                },
+                async stat (p) {
+                    try {
+                        return await _promises.default.stat(p);
+                    } catch (e) {
+                        if ((0, _iserror.default)(e) && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) {
+                            return null;
+                        }
+                        throw e;
+                    }
+                },
+                // handle shared ignores at top-level as it
+                // avoids over-tracing when we don't need to
+                // and speeds up total trace time
+                ignore (p) {
+                    if (sharedIgnoresFn(p)) {
+                        return true;
+                    }
+                    // if a chunk is attempting to be traced that isn't
+                    // in our initial list we need to ignore it to prevent
+                    // over tracing as webpack needs to be the source of
+                    // truth for which chunks should be included for each entry
+                    if (p.includes('.next/server/chunks') && !chunksToTrace.includes(_path.default.join(outputFileTracingRoot, p))) {
+                        return true;
+                    }
+                    return false;
+                }
+            });
+            const reasons = result.reasons;
+            const fileList = result.fileList;
+            for (const file of result.esmFileList){
+                fileList.add(file);
+            }
+            const parentFilesMap = (0, _nexttraceentrypointsplugin.getFilesMapFromReasons)(fileList, reasons);
+            const cachedLookupIgnore = new Map();
+            const cachedLookupIgnoreMinimal = new Map();
+            for (const [entries, tracedFiles] of [
+                [
+                    serverEntries,
+                    serverTracedFiles
+                ],
+                [
+                    minimalServerEntries,
+                    minimalServerTracedFiles
+                ]
+            ]){
+                for (const file of entries){
+                    var _parentFilesMap_get;
+                    const curFiles = [
+                        ...((_parentFilesMap_get = parentFilesMap.get(_path.default.relative(outputFileTracingRoot, file))) == null ? void 0 : _parentFilesMap_get.keys()) || []
+                    ];
+                    tracedFiles.add(_path.default.relative(distDir, file).replace(/\\/g, '/'));
+                    for (const curFile of curFiles || []){
+                        const filePath = _path.default.join(outputFileTracingRoot, curFile);
+                        if (!shouldIgnore(curFile, tracedFiles === minimalServerTracedFiles ? minimalServerIgnoreFn : serverIgnoreFn, reasons, tracedFiles === minimalServerTracedFiles ? cachedLookupIgnoreMinimal : cachedLookupIgnore)) {
+                            tracedFiles.add(_path.default.relative(distDir, filePath).replace(/\\/g, '/'));
+                        }
+                    }
+                }
+            }
+            const { entryNameFilesMap } = (buildTraceContext == null ? void 0 : buildTraceContext.chunksTrace) || {};
+            const cachedLookupIgnoreRoutes = new Map();
+            await Promise.all([
+                ...entryNameFilesMap ? Object.entries(entryNameFilesMap) : new Map()
+            ].map(async ([entryName, entryNameFiles])=>{
+                const isApp = entryName.startsWith('app/');
+                const isPages = entryName.startsWith('pages/');
+                let route = entryName;
+                if (isApp) {
+                    route = (0, _apppaths.normalizeAppPath)(route.substring('app'.length));
+                }
+                if (isPages) {
+                    route = (0, _normalizepagepath.normalizePagePath)(route.substring('pages'.length));
+                }
+                // we don't need to trace for automatically statically optimized
+                // pages as they don't have server bundles, note there is
+                // the caveat with flying shuttle mode as it needs this for
+                // detecting changed entries
+                if (staticPages.includes(route)) {
+                    return;
+                }
+                const entryOutputPath = _path.default.join(distDir, 'server', `${entryName}.js`);
+                const traceOutputPath = `${entryOutputPath}.nft.json`;
+                const existingTrace = JSON.parse(await _promises.default.readFile(traceOutputPath, 'utf8'));
+                const traceOutputDir = _path.default.dirname(traceOutputPath);
+                const curTracedFiles = new Set();
+                for (const file of [
+                    ...entryNameFiles,
+                    entryOutputPath
+                ]){
+                    var _parentFilesMap_get;
+                    const curFiles = [
+                        ...((_parentFilesMap_get = parentFilesMap.get(_path.default.relative(outputFileTracingRoot, file))) == null ? void 0 : _parentFilesMap_get.keys()) || []
+                    ];
+                    for (const curFile of curFiles || []){
+                        if (!shouldIgnore(curFile, routeIgnoreFn, reasons, cachedLookupIgnoreRoutes)) {
+                            const filePath = _path.default.join(outputFileTracingRoot, curFile);
+                            const outputFile = _path.default.relative(traceOutputDir, filePath).replace(/\\/g, '/');
+                            curTracedFiles.add(outputFile);
+                        }
+                    }
+                }
+                for (const file of existingTrace.files || []){
+                    curTracedFiles.add(file);
+                }
+                await _promises.default.writeFile(traceOutputPath, JSON.stringify({
+                    ...existingTrace,
+                    files: [
+                        ...curTracedFiles
+                    ].sort()
+                }));
+            }));
+        }
+        const moduleTypes = [
+            'app-page',
+            'pages'
+        ];
+        for (const type of moduleTypes){
+            const modulePath = require.resolve(`next/dist/server/route-modules/${type}/module.compiled`);
+            const relativeModulePath = _path.default.relative(root, modulePath);
+            const contextDir = _path.default.join(_path.default.dirname(modulePath), 'vendored', 'contexts');
+            for (const item of (await _promises.default.readdir(contextDir))){
+                const itemPath = _path.default.relative(root, _path.default.join(contextDir, item));
+                if (!serverIgnoreFn(itemPath)) {
+                    addToTracedFiles(root, itemPath, serverTracedFiles);
+                    addToTracedFiles(root, itemPath, minimalServerTracedFiles);
+                }
+            }
+            addToTracedFiles(root, relativeModulePath, serverTracedFiles);
+            addToTracedFiles(root, relativeModulePath, minimalServerTracedFiles);
+        }
+        await Promise.all([
+            _promises.default.writeFile(nextServerTraceOutput, JSON.stringify({
+                version: 1,
+                files: Array.from(serverTracedFiles)
+            })),
+            _promises.default.writeFile(nextMinimalTraceOutput, JSON.stringify({
+                version: 1,
+                files: Array.from(minimalServerTracedFiles)
+            }))
+        ]);
+    });
+    // apply outputFileTracingIncludes/outputFileTracingExcludes after runTurbotrace
+    const includeExcludeSpan = nextBuildSpan.traceChild('apply-include-excludes');
+    await includeExcludeSpan.traceAsyncFn(async ()=>{
+        const globOrig = require('next/dist/compiled/glob');
+        const glob = (pattern)=>{
+            return new Promise((resolve, reject)=>{
+                globOrig(pattern, {
+                    cwd: dir,
+                    nodir: true,
+                    dot: true
+                }, (err, files)=>{
+                    if (err) {
+                        return reject(err);
+                    }
+                    resolve(files);
+                });
+            });
+        };
+        const { entryNameFilesMap } = (buildTraceContext == null ? void 0 : buildTraceContext.chunksTrace) || {};
+        await Promise.all([
+            ...entryNameFilesMap ? Object.entries(entryNameFilesMap) : new Map()
+        ].map(async ([entryName])=>{
+            const isApp = entryName.startsWith('app/');
+            const isPages = entryName.startsWith('pages/');
+            let route = entryName;
+            if (isApp) {
+                route = (0, _apppaths.normalizeAppPath)(entryName);
+            }
+            if (isPages) {
+                route = (0, _normalizepagepath.normalizePagePath)(entryName);
+            }
+            if (staticPages.includes(route)) {
+                return;
+            }
+            // edge routes have no trace files
+            if (edgeRuntimeRoutes.hasOwnProperty(route)) {
+                return;
+            }
+            const combinedIncludes = new Set();
+            const combinedExcludes = new Set();
+            for (const curGlob of includeGlobKeys){
+                const isMatch = (0, _picomatch.default)(curGlob, {
+                    dot: true,
+                    contains: true
+                });
+                if (isMatch(route)) {
+                    for (const include of outputFileTracingIncludes[curGlob]){
+                        combinedIncludes.add(include.replace(/\\/g, '/'));
+                    }
+                }
+            }
+            for (const curGlob of excludeGlobKeys){
+                const isMatch = (0, _picomatch.default)(curGlob, {
+                    dot: true,
+                    contains: true
+                });
+                if (isMatch(route)) {
+                    for (const exclude of outputFileTracingExcludes[curGlob]){
+                        combinedExcludes.add(exclude);
+                    }
+                }
+            }
+            if (!(combinedIncludes == null ? void 0 : combinedIncludes.size) && !(combinedExcludes == null ? void 0 : combinedExcludes.size)) {
+                return;
+            }
+            const traceFile = _path.default.join(distDir, `server`, `${entryName}.js.nft.json`);
+            const pageDir = _path.default.dirname(traceFile);
+            const traceContent = JSON.parse(await _promises.default.readFile(traceFile, 'utf8'));
+            const includes = [];
+            const resolvedTraceIncludes = new Map();
+            if (combinedIncludes == null ? void 0 : combinedIncludes.size) {
+                await Promise.all([
+                    ...combinedIncludes
+                ].map(async (includeGlob)=>{
+                    const results = await glob(includeGlob);
+                    const resolvedInclude = resolvedTraceIncludes.get(includeGlob) || [
+                        ...results.map((file)=>{
+                            return _path.default.relative(pageDir, _path.default.join(dir, file));
+                        })
+                    ];
+                    includes.push(...resolvedInclude);
+                    resolvedTraceIncludes.set(includeGlob, resolvedInclude);
+                }));
+            }
+            const combined = new Set([
+                ...traceContent.files,
+                ...includes
+            ]);
+            if (combinedExcludes == null ? void 0 : combinedExcludes.size) {
+                const resolvedGlobs = [
+                    ...combinedExcludes
+                ].map((exclude)=>_path.default.join(dir, exclude));
+                // pre compile before forEach
+                const isMatch = (0, _picomatch.default)(resolvedGlobs, {
+                    dot: true,
+                    contains: true
+                });
+                combined.forEach((file)=>{
+                    if (isMatch(_path.default.join(pageDir, file))) {
+                        combined.delete(file);
+                    }
+                });
+            }
+            // overwrite trace file with custom includes/excludes
+            await _promises.default.writeFile(traceFile, JSON.stringify({
+                version: traceContent.version,
+                files: [
+                    ...combined
+                ]
+            }));
+        }));
+    });
+    debug(`finished build tracing ${Date.now() - startTime}ms`);
+}
+
+//# sourceMappingURL=collect-build-traces.js.map

node_modules/next/dist/build/compiler.d.ts

@@ -0,0 +1,14 @@
+import { webpack } from 'next/dist/compiled/webpack/webpack';
+import type { Span } from '../trace';
+export type CompilerResult = {
+    errors: webpack.StatsError[];
+    warnings: webpack.StatsError[];
+    stats: webpack.Stats | undefined;
+};
+export declare function runCompiler(config: webpack.Configuration, { runWebpackSpan, inputFileSystem, }: {
+    runWebpackSpan: Span;
+    inputFileSystem?: webpack.Compiler['inputFileSystem'];
+}): Promise<[
+    result: CompilerResult,
+    inputFileSystem?: webpack.Compiler['inputFileSystem']
+]>;

node_modules/next/dist/build/compiler.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "runCompiler", {
+    enumerable: true,
+    get: function() {
+        return runCompiler;
+    }
+});
+const _webpack = require("next/dist/compiled/webpack/webpack");
+function generateStats(result, stat) {
+    const { errors, warnings } = stat.toJson({
+        preset: 'errors-warnings',
+        moduleTrace: true
+    });
+    if (errors && errors.length > 0) {
+        result.errors.push(...errors);
+    }
+    if (warnings && warnings.length > 0) {
+        result.warnings.push(...warnings);
+    }
+    return result;
+}
+// Webpack 5 requires the compiler to be closed (to save caches)
+// Webpack 4 does not have this close method so in order to be backwards compatible we check if it exists
+function closeCompiler(compiler) {
+    return new Promise((resolve, reject)=>{
+        // @ts-ignore Close only exists on the compiler in webpack 5
+        return compiler.close((err)=>err ? reject(err) : resolve());
+    });
+}
+function runCompiler(config, { runWebpackSpan, inputFileSystem }) {
+    return new Promise((resolve, reject)=>{
+        const compiler = (0, _webpack.webpack)(config);
+        // Ensure we use the previous inputFileSystem
+        if (inputFileSystem) {
+            compiler.inputFileSystem = inputFileSystem;
+        }
+        compiler.fsStartTime = Date.now();
+        compiler.run((err, stats)=>{
+            const webpackCloseSpan = runWebpackSpan.traceChild('webpack-close', {
+                name: config.name || 'unknown'
+            });
+            webpackCloseSpan.traceAsyncFn(()=>closeCompiler(compiler)).then(()=>{
+                if (err) {
+                    const reason = err.stack ?? err.toString();
+                    if (reason) {
+                        return resolve([
+                            {
+                                errors: [
+                                    {
+                                        message: reason,
+                                        details: err.details
+                                    }
+                                ],
+                                warnings: [],
+                                stats
+                            },
+                            compiler.inputFileSystem
+                        ]);
+                    }
+                    return reject(err);
+                } else if (!stats) throw Object.defineProperty(new Error('No Stats from webpack'), "__NEXT_ERROR_CODE", {
+                    value: "E370",
+                    enumerable: false,
+                    configurable: true
+                });
+                const result = webpackCloseSpan.traceChild('webpack-generate-error-stats').traceFn(()=>generateStats({
+                        errors: [],
+                        warnings: [],
+                        stats
+                    }, stats));
+                return resolve([
+                    result,
+                    compiler.inputFileSystem
+                ]);
+            });
+        });
+    });
+}
+
+//# sourceMappingURL=compiler.js.map

node_modules/next/dist/build/compiler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/build/compiler.ts"],"sourcesContent":["import { webpack } from 'next/dist/compiled/webpack/webpack'\nimport type { Span } from '../trace'\n\nexport type CompilerResult = {\n  errors: webpack.StatsError[]\n  warnings: webpack.StatsError[]\n  stats: webpack.Stats | undefined\n}\n\nfunction generateStats(\n  result: CompilerResult,\n  stat: webpack.Stats\n): CompilerResult {\n  const { errors, warnings } = stat.toJson({\n    preset: 'errors-warnings',\n    moduleTrace: true,\n  })\n  if (errors && errors.length > 0) {\n    result.errors.push(...errors)\n  }\n\n  if (warnings && warnings.length > 0) {\n    result.warnings.push(...warnings)\n  }\n\n  return result\n}\n\n// Webpack 5 requires the compiler to be closed (to save caches)\n// Webpack 4 does not have this close method so in order to be backwards compatible we check if it exists\nfunction closeCompiler(compiler: webpack.Compiler | webpack.MultiCompiler) {\n  return new Promise<void>((resolve, reject) => {\n    // @ts-ignore Close only exists on the compiler in webpack 5\n    return compiler.close((err: any) => (err ? reject(err) : resolve()))\n  })\n}\n\nexport function runCompiler(\n  config: webpack.Configuration,\n  {\n    runWebpackSpan,\n    inputFileSystem,\n  }: {\n    runWebpackSpan: Span\n    inputFileSystem?: webpack.Compiler['inputFileSystem']\n  }\n): Promise<\n  [\n    result: CompilerResult,\n    inputFileSystem?: webpack.Compiler['inputFileSystem'],\n  ]\n> {\n  return new Promise((resolve, reject) => {\n    const compiler = webpack(config)\n    // Ensure we use the previous inputFileSystem\n    if (inputFileSystem) {\n      compiler.inputFileSystem = inputFileSystem\n    }\n    compiler.fsStartTime = Date.now()\n    compiler.run((err, stats) => {\n      const webpackCloseSpan = runWebpackSpan.traceChild('webpack-close', {\n        name: config.name || 'unknown',\n      })\n      webpackCloseSpan\n        .traceAsyncFn(() => closeCompiler(compiler))\n        .then(() => {\n          if (err) {\n            const reason = err.stack ?? err.toString()\n            if (reason) {\n              return resolve([\n                {\n                  errors: [{ message: reason, details: (err as any).details }],\n                  warnings: [],\n                  stats,\n                },\n                compiler.inputFileSystem,\n              ])\n            }\n            return reject(err)\n          } else if (!stats) throw new Error('No Stats from webpack')\n\n          const result = webpackCloseSpan\n            .traceChild('webpack-generate-error-stats')\n            .traceFn(() =>\n              generateStats({ errors: [], warnings: [], stats }, stats)\n            )\n          return resolve([result, compiler.inputFileSystem])\n        })\n    })\n  })\n}\n"],"names":["runCompiler","generateStats","result","stat","errors","warnings","toJson","preset","moduleTrace","length","push","closeCompiler","compiler","Promise","resolve","reject","close","err","config","runWebpackSpan","inputFileSystem","webpack","fsStartTime","Date","now","run","stats","webpackCloseSpan","traceChild","name","traceAsyncFn","then","reason","stack","toString","message","details","Error","traceFn"],"mappings":";;;;+BAqCgBA;;;eAAAA;;;yBArCQ;AASxB,SAASC,cACPC,MAAsB,EACtBC,IAAmB;IAEnB,MAAM,EAAEC,MAAM,EAAEC,QAAQ,EAAE,GAAGF,KAAKG,MAAM,CAAC;QACvCC,QAAQ;QACRC,aAAa;IACf;IACA,IAAIJ,UAAUA,OAAOK,MAAM,GAAG,GAAG;QAC/BP,OAAOE,MAAM,CAACM,IAAI,IAAIN;IACxB;IAEA,IAAIC,YAAYA,SAASI,MAAM,GAAG,GAAG;QACnCP,OAAOG,QAAQ,CAACK,IAAI,IAAIL;IAC1B;IAEA,OAAOH;AACT;AAEA,gEAAgE;AAChE,yGAAyG;AACzG,SAASS,cAAcC,QAAkD;IACvE,OAAO,IAAIC,QAAc,CAACC,SAASC;QACjC,4DAA4D;QAC5D,OAAOH,SAASI,KAAK,CAAC,CAACC,MAAcA,MAAMF,OAAOE,OAAOH;IAC3D;AACF;AAEO,SAASd,YACdkB,MAA6B,EAC7B,EACEC,cAAc,EACdC,eAAe,EAIhB;IAOD,OAAO,IAAIP,QAAQ,CAACC,SAASC;QAC3B,MAAMH,WAAWS,IAAAA,gBAAO,EAACH;QACzB,6CAA6C;QAC7C,IAAIE,iBAAiB;YACnBR,SAASQ,eAAe,GAAGA;QAC7B;QACAR,SAASU,WAAW,GAAGC,KAAKC,GAAG;QAC/BZ,SAASa,GAAG,CAAC,CAACR,KAAKS;YACjB,MAAMC,mBAAmBR,eAAeS,UAAU,CAAC,iBAAiB;gBAClEC,MAAMX,OAAOW,IAAI,IAAI;YACvB;YACAF,iBACGG,YAAY,CAAC,IAAMnB,cAAcC,WACjCmB,IAAI,CAAC;gBACJ,IAAId,KAAK;oBACP,MAAMe,SAASf,IAAIgB,KAAK,IAAIhB,IAAIiB,QAAQ;oBACxC,IAAIF,QAAQ;wBACV,OAAOlB,QAAQ;4BACb;gCACEV,QAAQ;oCAAC;wCAAE+B,SAASH;wCAAQI,SAAS,AAACnB,IAAYmB,OAAO;oCAAC;iCAAE;gCAC5D/B,UAAU,EAAE;gCACZqB;4BACF;4BACAd,SAASQ,eAAe;yBACzB;oBACH;oBACA,OAAOL,OAAOE;gBAChB,OAAO,IAAI,CAACS,OAAO,MAAM,qBAAkC,CAAlC,IAAIW,MAAM,0BAAV,qBAAA;2BAAA;gCAAA;kCAAA;gBAAiC;gBAE1D,MAAMnC,SAASyB,iBACZC,UAAU,CAAC,gCACXU,OAAO,CAAC,IACPrC,cAAc;wBAAEG,QAAQ,EAAE;wBAAEC,UAAU,EAAE;wBAAEqB;oBAAM,GAAGA;gBAEvD,OAAOZ,QAAQ;oBAACZ;oBAAQU,SAASQ,eAAe;iBAAC;YACnD;QACJ;IACF;AACF"}

node_modules/next/dist/build/create-compiler-aliases.d.ts

@@ -0,0 +1,28 @@
+import { type WebpackLayerName } from '../lib/constants';
+import type { NextConfigComplete } from '../server/config-shared';
+interface CompilerAliases {
+    [alias: string]: string | string[];
+}
+export declare function createWebpackAliases({ distDir, isClient, isEdgeServer, isNodeServer, dev, config, pagesDir, appDir, dir, reactProductionProfiling, hasRewrites, }: {
+    distDir: string;
+    isClient: boolean;
+    isEdgeServer: boolean;
+    isNodeServer: boolean;
+    dev: boolean;
+    config: NextConfigComplete;
+    pagesDir: string | undefined;
+    appDir: string | undefined;
+    dir: string;
+    reactProductionProfiling: boolean;
+    hasRewrites: boolean;
+}): CompilerAliases;
+export declare function createServerOnlyClientOnlyAliases(isServer: boolean): CompilerAliases;
+export declare function createNextApiEsmAliases(): Record<string, string>;
+export declare function createAppRouterApiAliases(isServerOnlyLayer: boolean): Record<string, string>;
+export declare function createRSCAliases(bundledReactChannel: string, { layer, isEdgeServer, reactProductionProfiling, }: {
+    layer: WebpackLayerName;
+    isEdgeServer: boolean;
+    reactProductionProfiling: boolean;
+}): CompilerAliases;
+export declare function getOptimizedModuleAliases(): CompilerAliases;
+export {};

node_modules/next/dist/build/create-compiler-aliases.js

@@ -0,0 +1,354 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createAppRouterApiAliases: null,
+    createNextApiEsmAliases: null,
+    createRSCAliases: null,
+    createServerOnlyClientOnlyAliases: null,
+    createWebpackAliases: null,
+    getOptimizedModuleAliases: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createAppRouterApiAliases: function() {
+        return createAppRouterApiAliases;
+    },
+    createNextApiEsmAliases: function() {
+        return createNextApiEsmAliases;
+    },
+    createRSCAliases: function() {
+        return createRSCAliases;
+    },
+    createServerOnlyClientOnlyAliases: function() {
+        return createServerOnlyClientOnlyAliases;
+    },
+    createWebpackAliases: function() {
+        return createWebpackAliases;
+    },
+    getOptimizedModuleAliases: function() {
+        return getOptimizedModuleAliases;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _constants = require("../lib/constants");
+const _requirehook = require("../server/require-hook");
+const _webpackconfig = require("./webpack-config");
+const _nextdirpaths = require("./next-dir-paths");
+const _utils = require("./utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const isReact19 = typeof _react.use === 'function';
+function createWebpackAliases({ distDir, isClient, isEdgeServer, isNodeServer, dev, config, pagesDir, appDir, dir, reactProductionProfiling, hasRewrites }) {
+    const pageExtensions = config.pageExtensions;
+    const clientResolveRewrites = require.resolve('../shared/lib/router/utils/resolve-rewrites');
+    const customAppAliases = {};
+    const customDocumentAliases = {};
+    // tell webpack where to look for _app and _document
+    // using aliases to allow falling back to the default
+    // version when removed or not present
+    if (dev) {
+        const nextDistPath = 'next/dist/' + (isEdgeServer ? 'esm/' : '');
+        customAppAliases[`${_constants.PAGES_DIR_ALIAS}/_app`] = [
+            ...pagesDir ? pageExtensions.reduce((prev, ext)=>{
+                prev.push(_path.default.join(pagesDir, `_app.${ext}`));
+                return prev;
+            }, []) : [],
+            `${nextDistPath}pages/_app.js`
+        ];
+        customAppAliases[`${_constants.PAGES_DIR_ALIAS}/_error`] = [
+            ...pagesDir ? pageExtensions.reduce((prev, ext)=>{
+                prev.push(_path.default.join(pagesDir, `_error.${ext}`));
+                return prev;
+            }, []) : [],
+            `${nextDistPath}pages/_error.js`
+        ];
+        customDocumentAliases[`${_constants.PAGES_DIR_ALIAS}/_document`] = [
+            ...pagesDir ? pageExtensions.reduce((prev, ext)=>{
+                prev.push(_path.default.join(pagesDir, `_document.${ext}`));
+                return prev;
+            }, []) : [],
+            `${nextDistPath}pages/_document.js`
+        ];
+    }
+    return {
+        '@vercel/og$': 'next/dist/server/og/image-response',
+        // Avoid bundling both entrypoints in React 19 when we just need one.
+        // Also avoids bundler warnings in React 18 where react-dom/server.edge doesn't exist.
+        'next/dist/server/ReactDOMServerPages': isReact19 ? 'react-dom/server.edge' : 'react-dom/server.browser',
+        // Alias next/dist imports to next/dist/esm assets,
+        // let this alias hit before `next` alias.
+        ...isEdgeServer ? {
+            'next/dist/api': 'next/dist/esm/api',
+            'next/dist/build': 'next/dist/esm/build',
+            'next/dist/client': 'next/dist/esm/client',
+            'next/dist/shared': 'next/dist/esm/shared',
+            'next/dist/pages': 'next/dist/esm/pages',
+            'next/dist/lib': 'next/dist/esm/lib',
+            'next/dist/server': 'next/dist/esm/server',
+            ...createNextApiEsmAliases()
+        } : undefined,
+        // For RSC server bundle
+        ...!(0, _webpackconfig.hasExternalOtelApiPackage)() && {
+            '@opentelemetry/api': 'next/dist/compiled/@opentelemetry/api'
+        },
+        ...config.images.loaderFile ? {
+            'next/dist/shared/lib/image-loader': config.images.loaderFile,
+            ...isEdgeServer && {
+                'next/dist/esm/shared/lib/image-loader': config.images.loaderFile
+            }
+        } : undefined,
+        'styled-jsx/style$': _requirehook.defaultOverrides['styled-jsx/style'],
+        'styled-jsx$': _requirehook.defaultOverrides['styled-jsx'],
+        ...customAppAliases,
+        ...customDocumentAliases,
+        ...pagesDir ? {
+            [_constants.PAGES_DIR_ALIAS]: pagesDir
+        } : {},
+        ...appDir ? {
+            [_constants.APP_DIR_ALIAS]: appDir
+        } : {},
+        [_constants.ROOT_DIR_ALIAS]: dir,
+        [_constants.DOT_NEXT_ALIAS]: distDir,
+        ...isClient || isEdgeServer ? getOptimizedModuleAliases() : {},
+        ...reactProductionProfiling ? getReactProfilingInProduction() : {},
+        // For Node server, we need to re-alias the package imports to prefer to
+        // resolve to the ESM export.
+        ...isNodeServer ? getBarrelOptimizationAliases(config.experimental.optimizePackageImports || []) : {},
+        [_constants.RSC_ACTION_VALIDATE_ALIAS]: 'next/dist/build/webpack/loaders/next-flight-loader/action-validate',
+        [_constants.RSC_ACTION_CLIENT_WRAPPER_ALIAS]: 'next/dist/build/webpack/loaders/next-flight-loader/action-client-wrapper',
+        [_constants.RSC_ACTION_PROXY_ALIAS]: 'next/dist/build/webpack/loaders/next-flight-loader/server-reference',
+        [_constants.RSC_ACTION_ENCRYPTION_ALIAS]: 'next/dist/server/app-render/encryption',
+        [_constants.RSC_CACHE_WRAPPER_ALIAS]: 'next/dist/build/webpack/loaders/next-flight-loader/cache-wrapper',
+        ...isClient || isEdgeServer ? {
+            [clientResolveRewrites]: hasRewrites ? clientResolveRewrites : false
+        } : {},
+        '@swc/helpers/_': _path.default.join(_path.default.dirname(require.resolve('@swc/helpers/package.json')), '_'),
+        setimmediate: 'next/dist/compiled/setimmediate'
+    };
+}
+function createServerOnlyClientOnlyAliases(isServer) {
+    return isServer ? {
+        'server-only$': 'next/dist/compiled/server-only/empty',
+        'client-only$': 'next/dist/compiled/client-only/error',
+        'next/dist/compiled/server-only$': 'next/dist/compiled/server-only/empty',
+        'next/dist/compiled/client-only$': 'next/dist/compiled/client-only/error'
+    } : {
+        'server-only$': 'next/dist/compiled/server-only/index',
+        'client-only$': 'next/dist/compiled/client-only/index',
+        'next/dist/compiled/client-only$': 'next/dist/compiled/client-only/index',
+        'next/dist/compiled/server-only': 'next/dist/compiled/server-only/index'
+    };
+}
+function createNextApiEsmAliases() {
+    const mapping = {
+        head: 'next/dist/api/head',
+        image: 'next/dist/api/image',
+        constants: 'next/dist/api/constants',
+        router: 'next/dist/api/router',
+        dynamic: 'next/dist/api/dynamic',
+        script: 'next/dist/api/script',
+        link: 'next/dist/api/link',
+        form: 'next/dist/api/form',
+        navigation: 'next/dist/api/navigation',
+        headers: 'next/dist/api/headers',
+        og: 'next/dist/api/og',
+        server: 'next/dist/api/server',
+        // pages api
+        document: 'next/dist/api/document',
+        app: 'next/dist/api/app'
+    };
+    const aliasMap = {};
+    // Handle fully specified imports like `next/image.js`
+    for (const [key, value] of Object.entries(mapping)){
+        const nextApiFilePath = _path.default.join(_nextdirpaths.NEXT_PROJECT_ROOT, key);
+        aliasMap[nextApiFilePath + '.js'] = value;
+    }
+    return aliasMap;
+}
+function createAppRouterApiAliases(isServerOnlyLayer) {
+    const mapping = {
+        head: 'next/dist/client/components/noop-head',
+        dynamic: 'next/dist/api/app-dynamic',
+        link: 'next/dist/client/app-dir/link',
+        form: 'next/dist/client/app-dir/form'
+    };
+    if (isServerOnlyLayer) {
+        mapping['navigation'] = 'next/dist/api/navigation.react-server';
+    }
+    const aliasMap = {};
+    for (const [key, value] of Object.entries(mapping)){
+        const nextApiFilePath = _path.default.join(_nextdirpaths.NEXT_PROJECT_ROOT, key);
+        aliasMap[nextApiFilePath + '.js'] = value;
+    }
+    return aliasMap;
+}
+function createRSCAliases(bundledReactChannel, { layer, isEdgeServer, reactProductionProfiling }) {
+    const isServerOnlyLayer = (0, _utils.isWebpackServerOnlyLayer)(layer);
+    // For middleware, instrumentation layers, treat them as rsc layer.
+    // Since we only built the runtime package for rsc, convert everything to rsc
+    // to ensure the runtime modules path existed.
+    if (isServerOnlyLayer) {
+        layer = _constants.WEBPACK_LAYERS.reactServerComponents;
+    }
+    let alias = {
+        react$: `next/dist/compiled/react${bundledReactChannel}`,
+        'react-dom$': `next/dist/compiled/react-dom${bundledReactChannel}`,
+        'react/jsx-runtime$': `next/dist/compiled/react${bundledReactChannel}/jsx-runtime`,
+        'react/jsx-dev-runtime$': `next/dist/compiled/react${bundledReactChannel}/jsx-dev-runtime`,
+        'react/compiler-runtime$': `next/dist/compiled/react${bundledReactChannel}/compiler-runtime`,
+        'react-dom/client$': `next/dist/compiled/react-dom${bundledReactChannel}/client`,
+        'react-dom/server$': `next/dist/compiled/react-dom${bundledReactChannel}/server`,
+        'react-dom/server.browser$': `next/dist/compiled/react-dom${bundledReactChannel}/server.browser`,
+        'react-dom/static$': `next/dist/compiled/react-dom${bundledReactChannel}/static`,
+        'react-dom/static.edge$': `next/dist/compiled/react-dom${bundledReactChannel}/static.edge`,
+        'react-dom/static.browser$': `next/dist/compiled/react-dom${bundledReactChannel}/static.browser`,
+        // optimizations to ignore the legacy build of react-dom/server in `server.edge` build
+        'react-dom/server.edge$': `next/dist/build/webpack/alias/react-dom-server-edge${bundledReactChannel}.js`,
+        // react-server-dom-webpack alias
+        'react-server-dom-webpack/client$': `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/client`,
+        'react-server-dom-webpack/client.edge$': `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/client.edge`,
+        'react-server-dom-webpack/server.edge$': `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/server.edge`,
+        'react-server-dom-webpack/server.node$': `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/server.node`,
+        'react-server-dom-webpack/static.edge$': `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/static.edge`
+    };
+    if (!isEdgeServer) {
+        if (layer === _constants.WEBPACK_LAYERS.serverSideRendering) {
+            alias = Object.assign(alias, {
+                'react/jsx-runtime$': `next/dist/server/route-modules/app-page/vendored/${layer}/react-jsx-runtime`,
+                'react/jsx-dev-runtime$': `next/dist/server/route-modules/app-page/vendored/${layer}/react-jsx-dev-runtime`,
+                'react/compiler-runtime$': `next/dist/server/route-modules/app-page/vendored/${layer}/react-compiler-runtime`,
+                react$: `next/dist/server/route-modules/app-page/vendored/${layer}/react`,
+                'react-dom$': `next/dist/server/route-modules/app-page/vendored/${layer}/react-dom`,
+                'react-server-dom-webpack/client.edge$': `next/dist/server/route-modules/app-page/vendored/${layer}/react-server-dom-webpack-client-edge`
+            });
+        } else if (layer === _constants.WEBPACK_LAYERS.reactServerComponents) {
+            alias = Object.assign(alias, {
+                'react/jsx-runtime$': `next/dist/server/route-modules/app-page/vendored/${layer}/react-jsx-runtime`,
+                'react/jsx-dev-runtime$': `next/dist/server/route-modules/app-page/vendored/${layer}/react-jsx-dev-runtime`,
+                'react/compiler-runtime$': `next/dist/server/route-modules/app-page/vendored/${layer}/react-compiler-runtime`,
+                react$: `next/dist/server/route-modules/app-page/vendored/${layer}/react`,
+                'react-dom$': `next/dist/server/route-modules/app-page/vendored/${layer}/react-dom`,
+                'react-server-dom-webpack/server.edge$': `next/dist/server/route-modules/app-page/vendored/${layer}/react-server-dom-webpack-server-edge`,
+                'react-server-dom-webpack/server.node$': `next/dist/server/route-modules/app-page/vendored/${layer}/react-server-dom-webpack-server-node`,
+                'react-server-dom-webpack/static.edge$': `next/dist/server/route-modules/app-page/vendored/${layer}/react-server-dom-webpack-static-edge`
+            });
+        }
+    }
+    if (isEdgeServer) {
+        if (layer === _constants.WEBPACK_LAYERS.reactServerComponents) {
+            alias = Object.assign(alias, {
+                react$: `next/dist/compiled/react${bundledReactChannel}/react.react-server`,
+                'next/dist/compiled/react$': `next/dist/compiled/react${bundledReactChannel}/react.react-server`,
+                'next/dist/compiled/react-experimental$': `next/dist/compiled/react-experimental/react.react-server`,
+                'react/jsx-runtime$': `next/dist/compiled/react${bundledReactChannel}/jsx-runtime.react-server`,
+                'react/compiler-runtime$': `next/dist/compiled/react${bundledReactChannel}/compiler-runtime`,
+                'next/dist/compiled/react/jsx-runtime$': `next/dist/compiled/react${bundledReactChannel}/jsx-runtime.react-server`,
+                'next/dist/compiled/react-experimental/jsx-runtime$': `next/dist/compiled/react-experimental/jsx-runtime.react-server`,
+                'react/jsx-dev-runtime$': `next/dist/compiled/react${bundledReactChannel}/jsx-dev-runtime.react-server`,
+                'next/dist/compiled/react/jsx-dev-runtime$': `next/dist/compiled/react${bundledReactChannel}/jsx-dev-runtime.react-server`,
+                'next/dist/compiled/react-experimental/jsx-dev-runtime$': `next/dist/compiled/react-experimental/jsx-dev-runtime.react-server`,
+                'react-dom$': `next/dist/compiled/react-dom${bundledReactChannel}/react-dom.react-server`,
+                'next/dist/compiled/react-dom$': `next/dist/compiled/react-dom${bundledReactChannel}/react-dom.react-server`,
+                'next/dist/compiled/react-dom-experimental$': `next/dist/compiled/react-dom-experimental/react-dom.react-server`
+            });
+        }
+    }
+    if (reactProductionProfiling) {
+        alias['react-dom/client$'] = `next/dist/compiled/react-dom${bundledReactChannel}/profiling`;
+    }
+    alias['@vercel/turbopack-ecmascript-runtime/browser/dev/hmr-client/hmr-client.ts'] = `next/dist/client/dev/noop-turbopack-hmr`;
+    return alias;
+}
+function getOptimizedModuleAliases() {
+    return {
+        unfetch: require.resolve('next/dist/build/polyfills/fetch/index.js'),
+        'isomorphic-unfetch': require.resolve('next/dist/build/polyfills/fetch/index.js'),
+        'whatwg-fetch': require.resolve('next/dist/build/polyfills/fetch/whatwg-fetch.js'),
+        'object-assign': require.resolve('next/dist/build/polyfills/object-assign.js'),
+        'object.assign/auto': require.resolve('next/dist/build/polyfills/object.assign/auto.js'),
+        'object.assign/implementation': require.resolve('next/dist/build/polyfills/object.assign/implementation.js'),
+        'object.assign/polyfill': require.resolve('next/dist/build/polyfills/object.assign/polyfill.js'),
+        'object.assign/shim': require.resolve('next/dist/build/polyfills/object.assign/shim.js'),
+        url: require.resolve('next/dist/compiled/native-url')
+    };
+}
+// Alias these modules to be resolved with "module" if possible.
+function getBarrelOptimizationAliases(packages) {
+    const aliases = {};
+    const mainFields = [
+        'module',
+        'main'
+    ];
+    for (const pkg of packages){
+        try {
+            const descriptionFileData = require(`${pkg}/package.json`);
+            const descriptionFilePath = require.resolve(`${pkg}/package.json`);
+            for (const field of mainFields){
+                if (descriptionFileData.hasOwnProperty(field)) {
+                    aliases[pkg + '$'] = _path.default.join(_path.default.dirname(descriptionFilePath), descriptionFileData[field]);
+                    break;
+                }
+            }
+        } catch  {}
+    }
+    return aliases;
+}
+function getReactProfilingInProduction() {
+    return {
+        'react-dom/client$': 'react-dom/profiling'
+    };
+}
+
+//# sourceMappingURL=create-compiler-aliases.js.map

node_modules/next/dist/build/deployment-id.d.ts

@@ -0,0 +1 @@
+export declare function getDeploymentIdQueryOrEmptyString(): string;

node_modules/next/dist/build/deployment-id.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getDeploymentIdQueryOrEmptyString", {
+    enumerable: true,
+    get: function() {
+        return getDeploymentIdQueryOrEmptyString;
+    }
+});
+function getDeploymentIdQueryOrEmptyString() {
+    if (process.env.NEXT_DEPLOYMENT_ID) {
+        return `?dpl=${process.env.NEXT_DEPLOYMENT_ID}`;
+    }
+    return '';
+}
+
+//# sourceMappingURL=deployment-id.js.map

node_modules/next/dist/build/deployment-id.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/build/deployment-id.ts"],"sourcesContent":["export function getDeploymentIdQueryOrEmptyString(): string {\n  if (process.env.NEXT_DEPLOYMENT_ID) {\n    return `?dpl=${process.env.NEXT_DEPLOYMENT_ID}`\n  }\n  return ''\n}\n"],"names":["getDeploymentIdQueryOrEmptyString","process","env","NEXT_DEPLOYMENT_ID"],"mappings":";;;;+BAAgBA;;;eAAAA;;;AAAT,SAASA;IACd,IAAIC,QAAQC,GAAG,CAACC,kBAAkB,EAAE;QAClC,OAAO,CAAC,KAAK,EAAEF,QAAQC,GAAG,CAACC,kBAAkB,EAAE;IACjD;IACA,OAAO;AACT"}

node_modules/next/dist/build/entries.d.ts

@@ -0,0 +1,130 @@
+import type { NextConfigComplete } from '../server/config-shared';
+import type { webpack } from 'next/dist/compiled/webpack/webpack';
+import type { MiddlewareConfig, PageStaticInfo } from './analysis/get-page-static-info';
+import type { LoadedEnvFiles } from '@next/env';
+import type { AppLoaderOptions } from './webpack/loaders/next-app-loader';
+import type { CompilerNameValues } from '../shared/lib/constants';
+import type { __ApiPreviewProps } from '../server/api-utils';
+import type { ServerRuntime } from '../types';
+import type { PageExtensions } from './page-extensions-type';
+import type { MappedPages } from './build-context';
+import { PAGE_TYPES } from '../lib/page-types';
+export declare function sortByPageExts(pageExtensions: PageExtensions): (a: string, b: string) => number;
+export declare function getStaticInfoIncludingLayouts({ isInsideAppDir, pageExtensions, pageFilePath, appDir, config: nextConfig, isDev, page, }: {
+    isInsideAppDir: boolean;
+    pageExtensions: PageExtensions;
+    pageFilePath: string;
+    appDir: string | undefined;
+    config: NextConfigComplete;
+    isDev: boolean | undefined;
+    page: string;
+}): Promise<PageStaticInfo>;
+type ObjectValue<T> = T extends {
+    [key: string]: infer V;
+} ? V : never;
+/**
+ * For a given page path removes the provided extensions.
+ */
+export declare function getPageFromPath(pagePath: string, pageExtensions: PageExtensions): string;
+export declare function getPageFilePath({ absolutePagePath, pagesDir, appDir, rootDir, }: {
+    absolutePagePath: string;
+    pagesDir: string | undefined;
+    appDir: string | undefined;
+    rootDir: string;
+}): string;
+/**
+ * Creates a mapping of route to page file path for a given list of page paths.
+ * For example ['/middleware.ts'] is turned into  { '/middleware': `${ROOT_DIR_ALIAS}/middleware.ts` }
+ */
+export declare function createPagesMapping({ isDev, pageExtensions, pagePaths, pagesType, pagesDir, appDir, }: {
+    isDev: boolean;
+    pageExtensions: PageExtensions;
+    pagePaths: string[];
+    pagesType: PAGE_TYPES;
+    pagesDir: string | undefined;
+    appDir: string | undefined;
+}): Promise<MappedPages>;
+export interface CreateEntrypointsParams {
+    buildId: string;
+    config: NextConfigComplete;
+    envFiles: LoadedEnvFiles;
+    isDev?: boolean;
+    pages: MappedPages;
+    pagesDir?: string;
+    previewMode: __ApiPreviewProps;
+    rootDir: string;
+    rootPaths?: MappedPages;
+    appDir?: string;
+    appPaths?: MappedPages;
+    pageExtensions: PageExtensions;
+    hasInstrumentationHook?: boolean;
+}
+export declare function getEdgeServerEntry(opts: {
+    rootDir: string;
+    absolutePagePath: string;
+    buildId: string;
+    bundlePath: string;
+    config: NextConfigComplete;
+    isDev: boolean;
+    isServerComponent: boolean;
+    page: string;
+    pages: MappedPages;
+    middleware?: Partial<MiddlewareConfig>;
+    pagesType: PAGE_TYPES;
+    appDirLoader?: string;
+    hasInstrumentationHook?: boolean;
+    preferredRegion: string | string[] | undefined;
+    middlewareConfig?: MiddlewareConfig;
+}): {
+    import: string;
+    layer: "rsc";
+} | {
+    import: string;
+    layer: "middleware";
+} | {
+    import: string;
+    layer: "api-edge";
+} | {
+    import: string;
+    layer: "ssr" | undefined;
+};
+export declare function getInstrumentationEntry(opts: {
+    absolutePagePath: string;
+    isEdgeServer: boolean;
+    isDev: boolean;
+}): {
+    import: string;
+    filename: string;
+    layer: "instrument";
+};
+export declare function getAppLoader(): "builtin:next-app-loader" | "next-app-loader";
+export declare function getAppEntry(opts: Readonly<AppLoaderOptions>): {
+    import: string;
+    layer: "rsc";
+};
+export declare function getClientEntry(opts: {
+    absolutePagePath: string;
+    page: string;
+}): string | string[];
+export declare function runDependingOnPageType<T>(params: {
+    onClient: () => T;
+    onEdgeServer: () => T;
+    onServer: () => T;
+    page: string;
+    pageRuntime: ServerRuntime;
+    pageType?: PAGE_TYPES;
+}): void;
+export declare function createEntrypoints(params: CreateEntrypointsParams): Promise<{
+    client: webpack.EntryObject;
+    server: webpack.EntryObject;
+    edgeServer: webpack.EntryObject;
+    middlewareMatchers: undefined;
+}>;
+export declare function finalizeEntrypoint({ name, compilerType, value, isServerComponent, hasAppDir, }: {
+    compilerType?: CompilerNameValues;
+    name: string;
+    value: ObjectValue<webpack.EntryObject>;
+    isServerComponent?: boolean;
+    hasAppDir?: boolean;
+}): ObjectValue<webpack.EntryObject>;
+export {};

node_modules/next/dist/build/entries.js

@@ -0,0 +1,729 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createEntrypoints: null,
+    createPagesMapping: null,
+    finalizeEntrypoint: null,
+    getAppEntry: null,
+    getAppLoader: null,
+    getClientEntry: null,
+    getEdgeServerEntry: null,
+    getInstrumentationEntry: null,
+    getPageFilePath: null,
+    getPageFromPath: null,
+    getStaticInfoIncludingLayouts: null,
+    runDependingOnPageType: null,
+    sortByPageExts: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createEntrypoints: function() {
+        return createEntrypoints;
+    },
+    createPagesMapping: function() {
+        return createPagesMapping;
+    },
+    finalizeEntrypoint: function() {
+        return finalizeEntrypoint;
+    },
+    getAppEntry: function() {
+        return getAppEntry;
+    },
+    getAppLoader: function() {
+        return getAppLoader;
+    },
+    getClientEntry: function() {
+        return getClientEntry;
+    },
+    getEdgeServerEntry: function() {
+        return getEdgeServerEntry;
+    },
+    getInstrumentationEntry: function() {
+        return getInstrumentationEntry;
+    },
+    getPageFilePath: function() {
+        return getPageFilePath;
+    },
+    getPageFromPath: function() {
+        return getPageFromPath;
+    },
+    getStaticInfoIncludingLayouts: function() {
+        return getStaticInfoIncludingLayouts;
+    },
+    runDependingOnPageType: function() {
+        return runDependingOnPageType;
+    },
+    sortByPageExts: function() {
+        return sortByPageExts;
+    }
+});
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("./output/log"));
+const _path = require("path");
+const _querystring = require("querystring");
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _constants = require("../lib/constants");
+const _isapiroute = require("../lib/is-api-route");
+const _isedgeruntime = require("../lib/is-edge-runtime");
+const _constants1 = require("../shared/lib/constants");
+const _utils = require("./utils");
+const _getpagestaticinfo = require("./analysis/get-page-static-info");
+const _normalizepathsep = require("../shared/lib/page-path/normalize-path-sep");
+const _normalizepagepath = require("../shared/lib/page-path/normalize-page-path");
+const _apppaths = require("../shared/lib/router/utils/app-paths");
+const _nextmiddlewareloader = require("./webpack/loaders/next-middleware-loader");
+const _isapprouteroute = require("../lib/is-app-route-route");
+const _getmetadataroute = require("../lib/metadata/get-metadata-route");
+const _nextrouteloader = require("./webpack/loaders/next-route-loader");
+const _isinternalcomponent = require("../lib/is-internal-component");
+const _ismetadataroute = require("../lib/metadata/is-metadata-route");
+const _routekind = require("../server/route-kind");
+const _utils1 = require("./webpack/loaders/utils");
+const _normalizecatchallroutes = require("./normalize-catchall-routes");
+const _pagetypes = require("../lib/page-types");
+const _isapppageroute = require("../lib/is-app-page-route");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function sortByPageExts(pageExtensions) {
+    return (a, b)=>{
+        // prioritize entries according to pageExtensions order
+        // for consistency as fs order can differ across systems
+        // NOTE: this is reversed so preferred comes last and
+        // overrides prior
+        const aExt = (0, _path.extname)(a);
+        const bExt = (0, _path.extname)(b);
+        const aNoExt = a.substring(0, a.length - aExt.length);
+        const bNoExt = a.substring(0, b.length - bExt.length);
+        if (aNoExt !== bNoExt) return 0;
+        // find extension index (skip '.' as pageExtensions doesn't have it)
+        const aExtIndex = pageExtensions.indexOf(aExt.substring(1));
+        const bExtIndex = pageExtensions.indexOf(bExt.substring(1));
+        return bExtIndex - aExtIndex;
+    };
+}
+async function getStaticInfoIncludingLayouts({ isInsideAppDir, pageExtensions, pageFilePath, appDir, config: nextConfig, isDev, page }) {
+    // TODO: sync types for pages: PAGE_TYPES, ROUTER_TYPE, 'app' | 'pages', etc.
+    const pageType = isInsideAppDir ? _pagetypes.PAGE_TYPES.APP : _pagetypes.PAGE_TYPES.PAGES;
+    const pageStaticInfo = await (0, _getpagestaticinfo.getPageStaticInfo)({
+        nextConfig,
+        pageFilePath,
+        isDev,
+        page,
+        pageType
+    });
+    if (pageStaticInfo.type === _pagetypes.PAGE_TYPES.PAGES || !appDir) {
+        return pageStaticInfo;
+    }
+    const segments = [
+        pageStaticInfo
+    ];
+    // inherit from layout files only if it's a page route
+    if ((0, _isapppageroute.isAppPageRoute)(page)) {
+        const layoutFiles = [];
+        const potentialLayoutFiles = pageExtensions.map((ext)=>'layout.' + ext);
+        let dir = (0, _path.dirname)(pageFilePath);
+        // Uses startsWith to not include directories further up.
+        while(dir.startsWith(appDir)){
+            for (const potentialLayoutFile of potentialLayoutFiles){
+                const layoutFile = (0, _path.join)(dir, potentialLayoutFile);
+                if (!_fs.default.existsSync(layoutFile)) {
+                    continue;
+                }
+                layoutFiles.push(layoutFile);
+            }
+            // Walk up the directory tree
+            dir = (0, _path.join)(dir, '..');
+        }
+        for (const layoutFile of layoutFiles){
+            const layoutStaticInfo = await (0, _getpagestaticinfo.getAppPageStaticInfo)({
+                nextConfig,
+                pageFilePath: layoutFile,
+                isDev,
+                page,
+                pageType: isInsideAppDir ? _pagetypes.PAGE_TYPES.APP : _pagetypes.PAGE_TYPES.PAGES
+            });
+            segments.unshift(layoutStaticInfo);
+        }
+    }
+    const config = (0, _utils.reduceAppConfig)(segments);
+    return {
+        ...pageStaticInfo,
+        config,
+        runtime: config.runtime,
+        preferredRegion: config.preferredRegion,
+        maxDuration: config.maxDuration
+    };
+}
+function getPageFromPath(pagePath, pageExtensions) {
+    let page = (0, _normalizepathsep.normalizePathSep)(pagePath.replace(new RegExp(`\\.+(${pageExtensions.join('|')})$`), ''));
+    page = page.replace(/\/index$/, '');
+    return page === '' ? '/' : page;
+}
+function getPageFilePath({ absolutePagePath, pagesDir, appDir, rootDir }) {
+    if (absolutePagePath.startsWith(_constants.PAGES_DIR_ALIAS) && pagesDir) {
+        return absolutePagePath.replace(_constants.PAGES_DIR_ALIAS, pagesDir);
+    }
+    if (absolutePagePath.startsWith(_constants.APP_DIR_ALIAS) && appDir) {
+        return absolutePagePath.replace(_constants.APP_DIR_ALIAS, appDir);
+    }
+    if (absolutePagePath.startsWith(_constants.ROOT_DIR_ALIAS)) {
+        return absolutePagePath.replace(_constants.ROOT_DIR_ALIAS, rootDir);
+    }
+    return require.resolve(absolutePagePath);
+}
+async function createPagesMapping({ isDev, pageExtensions, pagePaths, pagesType, pagesDir, appDir }) {
+    const isAppRoute = pagesType === 'app';
+    const pages = {};
+    const promises = pagePaths.map(async (pagePath)=>{
+        // Do not process .d.ts files as routes
+        if (pagePath.endsWith('.d.ts') && pageExtensions.includes('ts')) {
+            return;
+        }
+        let pageKey = getPageFromPath(pagePath, pageExtensions);
+        if (isAppRoute) {
+            pageKey = pageKey.replace(/%5F/g, '_');
+            if (pageKey === '/not-found') {
+                pageKey = _constants1.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY;
+            }
+        }
+        const normalizedPath = (0, _normalizepathsep.normalizePathSep)((0, _path.join)(pagesType === 'pages' ? _constants.PAGES_DIR_ALIAS : pagesType === 'app' ? _constants.APP_DIR_ALIAS : _constants.ROOT_DIR_ALIAS, pagePath));
+        let route = pagesType === 'app' ? (0, _getmetadataroute.normalizeMetadataRoute)(pageKey) : pageKey;
+        if (pagesType === 'app' && (0, _ismetadataroute.isMetadataRouteFile)(pagePath, pageExtensions, true)) {
+            const filePath = (0, _path.join)(appDir, pagePath);
+            const staticInfo = await (0, _getpagestaticinfo.getPageStaticInfo)({
+                nextConfig: {},
+                pageFilePath: filePath,
+                isDev,
+                page: pageKey,
+                pageType: pagesType
+            });
+            route = (0, _getmetadataroute.normalizeMetadataPageToRoute)(route, !!(staticInfo.generateImageMetadata || staticInfo.generateSitemaps));
+        }
+        pages[route] = normalizedPath;
+    });
+    await Promise.all(promises);
+    switch(pagesType){
+        case _pagetypes.PAGE_TYPES.ROOT:
+            {
+                return pages;
+            }
+        case _pagetypes.PAGE_TYPES.APP:
+            {
+                const hasAppPages = Object.keys(pages).some((page)=>page.endsWith('/page'));
+                return {
+                    // If there's any app pages existed, add a default not-found page.
+                    // If there's any custom not-found page existed, it will override the default one.
+                    ...hasAppPages && {
+                        [_constants1.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY]: 'next/dist/client/components/not-found-error'
+                    },
+                    ...pages
+                };
+            }
+        case _pagetypes.PAGE_TYPES.PAGES:
+            {
+                if (isDev) {
+                    delete pages['/_app'];
+                    delete pages['/_error'];
+                    delete pages['/_document'];
+                }
+                // In development we always alias these to allow Webpack to fallback to
+                // the correct source file so that HMR can work properly when a file is
+                // added or removed.
+                const root = isDev && pagesDir ? _constants.PAGES_DIR_ALIAS : 'next/dist/pages';
+                return {
+                    '/_app': `${root}/_app`,
+                    '/_error': `${root}/_error`,
+                    '/_document': `${root}/_document`,
+                    ...pages
+                };
+            }
+        default:
+            {
+                return {};
+            }
+    }
+}
+function getEdgeServerEntry(opts) {
+    var _opts_config_experimental_sri;
+    if (opts.pagesType === 'app' && (0, _isapprouteroute.isAppRouteRoute)(opts.page) && opts.appDirLoader) {
+        const loaderParams = {
+            absolutePagePath: opts.absolutePagePath,
+            page: opts.page,
+            appDirLoader: Buffer.from(opts.appDirLoader || '').toString('base64'),
+            nextConfig: Buffer.from(JSON.stringify(opts.config)).toString('base64'),
+            preferredRegion: opts.preferredRegion,
+            middlewareConfig: Buffer.from(JSON.stringify(opts.middlewareConfig || {})).toString('base64'),
+            cacheHandlers: JSON.stringify(opts.config.experimental.cacheHandlers || {})
+        };
+        return {
+            import: `next-edge-app-route-loader?${(0, _querystring.stringify)(loaderParams)}!`,
+            layer: _constants.WEBPACK_LAYERS.reactServerComponents
+        };
+    }
+    if ((0, _utils.isMiddlewareFile)(opts.page)) {
+        var _opts_middleware;
+        const loaderParams = {
+            absolutePagePath: opts.absolutePagePath,
+            page: opts.page,
+            rootDir: opts.rootDir,
+            matchers: ((_opts_middleware = opts.middleware) == null ? void 0 : _opts_middleware.matchers) ? (0, _nextmiddlewareloader.encodeMatchers)(opts.middleware.matchers) : '',
+            preferredRegion: opts.preferredRegion,
+            middlewareConfig: Buffer.from(JSON.stringify(opts.middlewareConfig || {})).toString('base64')
+        };
+        return {
+            import: `next-middleware-loader?${(0, _querystring.stringify)(loaderParams)}!`,
+            layer: _constants.WEBPACK_LAYERS.middleware
+        };
+    }
+    if ((0, _isapiroute.isAPIRoute)(opts.page)) {
+        const loaderParams = {
+            absolutePagePath: opts.absolutePagePath,
+            page: opts.page,
+            rootDir: opts.rootDir,
+            preferredRegion: opts.preferredRegion,
+            middlewareConfig: Buffer.from(JSON.stringify(opts.middlewareConfig || {})).toString('base64')
+        };
+        return {
+            import: `next-edge-function-loader?${(0, _querystring.stringify)(loaderParams)}!`,
+            layer: _constants.WEBPACK_LAYERS.apiEdge
+        };
+    }
+    const loaderParams = {
+        absolute500Path: opts.pages['/500'] || '',
+        absoluteAppPath: opts.pages['/_app'],
+        absoluteDocumentPath: opts.pages['/_document'],
+        absoluteErrorPath: opts.pages['/_error'],
+        absolutePagePath: opts.absolutePagePath,
+        dev: opts.isDev,
+        isServerComponent: opts.isServerComponent,
+        page: opts.page,
+        stringifiedConfig: Buffer.from(JSON.stringify(opts.config)).toString('base64'),
+        pagesType: opts.pagesType,
+        appDirLoader: Buffer.from(opts.appDirLoader || '').toString('base64'),
+        sriEnabled: !opts.isDev && !!((_opts_config_experimental_sri = opts.config.experimental.sri) == null ? void 0 : _opts_config_experimental_sri.algorithm),
+        cacheHandler: opts.config.cacheHandler,
+        preferredRegion: opts.preferredRegion,
+        middlewareConfig: Buffer.from(JSON.stringify(opts.middlewareConfig || {})).toString('base64'),
+        serverActions: opts.config.experimental.serverActions,
+        cacheHandlers: JSON.stringify(opts.config.experimental.cacheHandlers || {})
+    };
+    return {
+        import: `next-edge-ssr-loader?${JSON.stringify(loaderParams)}!`,
+        // The Edge bundle includes the server in its entrypoint, so it has to
+        // be in the SSR layer — we later convert the page request to the RSC layer
+        // via a webpack rule.
+        layer: opts.appDirLoader ? _constants.WEBPACK_LAYERS.serverSideRendering : undefined
+    };
+}
+function getInstrumentationEntry(opts) {
+    // the '../' is needed to make sure the file is not chunked
+    const filename = `${opts.isEdgeServer ? 'edge-' : opts.isDev ? '' : '../'}${_constants.INSTRUMENTATION_HOOK_FILENAME}.js`;
+    return {
+        import: opts.absolutePagePath,
+        filename,
+        layer: _constants.WEBPACK_LAYERS.instrument
+    };
+}
+function getAppLoader() {
+    return process.env.BUILTIN_APP_LOADER ? `builtin:next-app-loader` : 'next-app-loader';
+}
+function getAppEntry(opts) {
+    if (process.env.NEXT_RSPACK && process.env.BUILTIN_APP_LOADER) {
+        ;
+        opts.projectRoot = (0, _path.normalize)((0, _path.join)(__dirname, '../../..'));
+    }
+    return {
+        import: `${getAppLoader()}?${(0, _querystring.stringify)(opts)}!`,
+        layer: _constants.WEBPACK_LAYERS.reactServerComponents
+    };
+}
+function getClientEntry(opts) {
+    const loaderOptions = {
+        absolutePagePath: opts.absolutePagePath,
+        page: opts.page
+    };
+    const pageLoader = `next-client-pages-loader?${(0, _querystring.stringify)(loaderOptions)}!`;
+    // Make sure next/router is a dependency of _app or else chunk splitting
+    // might cause the router to not be able to load causing hydration
+    // to fail
+    return opts.page === '/_app' ? [
+        pageLoader,
+        require.resolve('../client/router')
+    ] : pageLoader;
+}
+function runDependingOnPageType(params) {
+    if (params.pageType === _pagetypes.PAGE_TYPES.ROOT && (0, _utils.isInstrumentationHookFile)(params.page)) {
+        params.onServer();
+        params.onEdgeServer();
+        return;
+    }
+    if ((0, _utils.isMiddlewareFile)(params.page)) {
+        if (params.pageRuntime === 'nodejs') {
+            params.onServer();
+            return;
+        } else {
+            params.onEdgeServer();
+            return;
+        }
+    }
+    if ((0, _isapiroute.isAPIRoute)(params.page)) {
+        if ((0, _isedgeruntime.isEdgeRuntime)(params.pageRuntime)) {
+            params.onEdgeServer();
+            return;
+        }
+        params.onServer();
+        return;
+    }
+    if (params.page === '/_document') {
+        params.onServer();
+        return;
+    }
+    if (params.page === '/_app' || params.page === '/_error' || params.page === '/404' || params.page === '/500') {
+        params.onClient();
+        params.onServer();
+        return;
+    }
+    if ((0, _isedgeruntime.isEdgeRuntime)(params.pageRuntime)) {
+        params.onClient();
+        params.onEdgeServer();
+        return;
+    }
+    params.onClient();
+    params.onServer();
+    return;
+}
+async function createEntrypoints(params) {
+    const { config, pages, pagesDir, isDev, rootDir, rootPaths, appDir, appPaths, pageExtensions } = params;
+    const edgeServer = {};
+    const server = {};
+    const client = {};
+    let middlewareMatchers = undefined;
+    let appPathsPerRoute = {};
+    if (appDir && appPaths) {
+        for(const pathname in appPaths){
+            const normalizedPath = (0, _apppaths.normalizeAppPath)(pathname);
+            const actualPath = appPaths[pathname];
+            if (!appPathsPerRoute[normalizedPath]) {
+                appPathsPerRoute[normalizedPath] = [];
+            }
+            appPathsPerRoute[normalizedPath].push(// TODO-APP: refactor to pass the page path from createPagesMapping instead.
+            getPageFromPath(actualPath, pageExtensions).replace(_constants.APP_DIR_ALIAS, ''));
+        }
+        // TODO: find a better place to do this
+        (0, _normalizecatchallroutes.normalizeCatchAllRoutes)(appPathsPerRoute);
+        // Make sure to sort parallel routes to make the result deterministic.
+        appPathsPerRoute = Object.fromEntries(Object.entries(appPathsPerRoute).map(([k, v])=>[
+                k,
+                v.sort()
+            ]));
+    }
+    const getEntryHandler = (mappings, pagesType)=>async (page)=>{
+            const bundleFile = (0, _normalizepagepath.normalizePagePath)(page);
+            const clientBundlePath = _path.posix.join(pagesType, bundleFile);
+            const serverBundlePath = pagesType === _pagetypes.PAGE_TYPES.PAGES ? _path.posix.join('pages', bundleFile) : pagesType === _pagetypes.PAGE_TYPES.APP ? _path.posix.join('app', bundleFile) : bundleFile.slice(1);
+            const absolutePagePath = mappings[page];
+            // Handle paths that have aliases
+            const pageFilePath = getPageFilePath({
+                absolutePagePath,
+                pagesDir,
+                appDir,
+                rootDir
+            });
+            const isInsideAppDir = !!appDir && (absolutePagePath.startsWith(_constants.APP_DIR_ALIAS) || absolutePagePath.startsWith(appDir));
+            const staticInfo = await getStaticInfoIncludingLayouts({
+                isInsideAppDir,
+                pageExtensions,
+                pageFilePath,
+                appDir,
+                config,
+                isDev,
+                page
+            });
+            // TODO(timneutkens): remove this
+            const isServerComponent = isInsideAppDir && staticInfo.rsc !== _constants1.RSC_MODULE_TYPES.client;
+            if ((0, _utils.isMiddlewareFile)(page)) {
+                var _staticInfo_middleware;
+                middlewareMatchers = ((_staticInfo_middleware = staticInfo.middleware) == null ? void 0 : _staticInfo_middleware.matchers) ?? [
+                    {
+                        regexp: '.*',
+                        originalSource: '/:path*'
+                    }
+                ];
+            }
+            const isInstrumentation = (0, _utils.isInstrumentationHookFile)(page) && pagesType === _pagetypes.PAGE_TYPES.ROOT;
+            let pageRuntime = staticInfo == null ? void 0 : staticInfo.runtime;
+            if ((0, _utils.isMiddlewareFile)(page) && !config.experimental.nodeMiddleware && pageRuntime === 'nodejs') {
+                _log.warn('nodejs runtime support for middleware requires experimental.nodeMiddleware be enabled in your next.config');
+                pageRuntime = 'edge';
+            }
+            runDependingOnPageType({
+                page,
+                pageRuntime: staticInfo.runtime,
+                pageType: pagesType,
+                onClient: ()=>{
+                    if (isServerComponent || isInsideAppDir) {
+                    // We skip the initial entries for server component pages and let the
+                    // server compiler inject them instead.
+                    } else {
+                        client[clientBundlePath] = getClientEntry({
+                            absolutePagePath,
+                            page
+                        });
+                    }
+                },
+                onServer: ()=>{
+                    if (pagesType === 'app' && appDir) {
+                        const matchedAppPaths = appPathsPerRoute[(0, _apppaths.normalizeAppPath)(page)];
+                        server[serverBundlePath] = getAppEntry({
+                            page,
+                            name: serverBundlePath,
+                            pagePath: absolutePagePath,
+                            appDir,
+                            appPaths: matchedAppPaths,
+                            pageExtensions,
+                            basePath: config.basePath,
+                            assetPrefix: config.assetPrefix,
+                            nextConfigOutput: config.output,
+                            nextConfigExperimentalUseEarlyImport: config.experimental.useEarlyImport ? true : undefined,
+                            preferredRegion: staticInfo.preferredRegion,
+                            middlewareConfig: (0, _utils1.encodeToBase64)(staticInfo.middleware || {})
+                        });
+                    } else if (isInstrumentation) {
+                        server[serverBundlePath.replace('src/', '')] = getInstrumentationEntry({
+                            absolutePagePath,
+                            isEdgeServer: false,
+                            isDev: false
+                        });
+                    } else if ((0, _utils.isMiddlewareFile)(page)) {
+                        server[serverBundlePath.replace('src/', '')] = getEdgeServerEntry({
+                            ...params,
+                            rootDir,
+                            absolutePagePath: absolutePagePath,
+                            bundlePath: clientBundlePath,
+                            isDev: false,
+                            isServerComponent,
+                            page,
+                            middleware: staticInfo == null ? void 0 : staticInfo.middleware,
+                            pagesType,
+                            preferredRegion: staticInfo.preferredRegion,
+                            middlewareConfig: staticInfo.middleware
+                        });
+                    } else if ((0, _isapiroute.isAPIRoute)(page)) {
+                        server[serverBundlePath] = [
+                            (0, _nextrouteloader.getRouteLoaderEntry)({
+                                kind: _routekind.RouteKind.PAGES_API,
+                                page,
+                                absolutePagePath,
+                                preferredRegion: staticInfo.preferredRegion,
+                                middlewareConfig: staticInfo.middleware || {}
+                            })
+                        ];
+                    } else if (!(0, _utils.isMiddlewareFile)(page) && !(0, _isinternalcomponent.isInternalComponent)(absolutePagePath) && !(0, _isinternalcomponent.isNonRoutePagesPage)(page)) {
+                        server[serverBundlePath] = [
+                            (0, _nextrouteloader.getRouteLoaderEntry)({
+                                kind: _routekind.RouteKind.PAGES,
+                                page,
+                                pages,
+                                absolutePagePath,
+                                preferredRegion: staticInfo.preferredRegion,
+                                middlewareConfig: staticInfo.middleware ?? {}
+                            })
+                        ];
+                    } else {
+                        server[serverBundlePath] = [
+                            absolutePagePath
+                        ];
+                    }
+                },
+                onEdgeServer: ()=>{
+                    let appDirLoader = '';
+                    if (isInstrumentation) {
+                        edgeServer[serverBundlePath.replace('src/', '')] = getInstrumentationEntry({
+                            absolutePagePath,
+                            isEdgeServer: true,
+                            isDev: false
+                        });
+                    } else {
+                        if (pagesType === 'app') {
+                            const matchedAppPaths = appPathsPerRoute[(0, _apppaths.normalizeAppPath)(page)];
+                            appDirLoader = getAppEntry({
+                                name: serverBundlePath,
+                                page,
+                                pagePath: absolutePagePath,
+                                appDir: appDir,
+                                appPaths: matchedAppPaths,
+                                pageExtensions,
+                                basePath: config.basePath,
+                                assetPrefix: config.assetPrefix,
+                                nextConfigOutput: config.output,
+                                // This isn't used with edge as it needs to be set on the entry module, which will be the `edgeServerEntry` instead.
+                                // Still passing it here for consistency.
+                                preferredRegion: staticInfo.preferredRegion,
+                                middlewareConfig: Buffer.from(JSON.stringify(staticInfo.middleware || {})).toString('base64')
+                            }).import;
+                        }
+                        edgeServer[serverBundlePath] = getEdgeServerEntry({
+                            ...params,
+                            rootDir,
+                            absolutePagePath: absolutePagePath,
+                            bundlePath: clientBundlePath,
+                            isDev: false,
+                            isServerComponent,
+                            page,
+                            middleware: staticInfo == null ? void 0 : staticInfo.middleware,
+                            pagesType,
+                            appDirLoader,
+                            preferredRegion: staticInfo.preferredRegion,
+                            middlewareConfig: staticInfo.middleware
+                        });
+                    }
+                }
+            });
+        };
+    const promises = [];
+    if (appPaths) {
+        const entryHandler = getEntryHandler(appPaths, _pagetypes.PAGE_TYPES.APP);
+        promises.push(Promise.all(Object.keys(appPaths).map(entryHandler)));
+    }
+    if (rootPaths) {
+        promises.push(Promise.all(Object.keys(rootPaths).map(getEntryHandler(rootPaths, _pagetypes.PAGE_TYPES.ROOT))));
+    }
+    promises.push(Promise.all(Object.keys(pages).map(getEntryHandler(pages, _pagetypes.PAGE_TYPES.PAGES))));
+    await Promise.all(promises);
+    // Optimization: If there's only one instrumentation hook in edge compiler, which means there's no edge server entry.
+    // We remove the edge instrumentation entry from edge compiler as it can be pure server side.
+    if (edgeServer.instrumentation && Object.keys(edgeServer).length === 1) {
+        delete edgeServer.instrumentation;
+    }
+    return {
+        client,
+        server,
+        edgeServer,
+        middlewareMatchers
+    };
+}
+function finalizeEntrypoint({ name, compilerType, value, isServerComponent, hasAppDir }) {
+    const entry = typeof value !== 'object' || Array.isArray(value) ? {
+        import: value
+    } : value;
+    const isApi = name.startsWith('pages/api/');
+    const isInstrumentation = (0, _utils.isInstrumentationHookFilename)(name);
+    switch(compilerType){
+        case _constants1.COMPILER_NAMES.server:
+            {
+                const layer = isApi ? _constants.WEBPACK_LAYERS.apiNode : isInstrumentation ? _constants.WEBPACK_LAYERS.instrument : isServerComponent ? _constants.WEBPACK_LAYERS.reactServerComponents : name.startsWith('pages/') ? _constants.WEBPACK_LAYERS.pagesDirNode : undefined;
+                return {
+                    publicPath: isApi ? '' : undefined,
+                    runtime: isApi ? 'webpack-api-runtime' : 'webpack-runtime',
+                    layer,
+                    ...entry
+                };
+            }
+        case _constants1.COMPILER_NAMES.edgeServer:
+            {
+                return {
+                    layer: isApi ? _constants.WEBPACK_LAYERS.apiEdge : (0, _utils.isMiddlewareFilename)(name) || isInstrumentation ? _constants.WEBPACK_LAYERS.middleware : name.startsWith('pages/') ? _constants.WEBPACK_LAYERS.pagesDirEdge : undefined,
+                    library: {
+                        name: [
+                            '_ENTRIES',
+                            `middleware_[name]`
+                        ],
+                        type: 'assign'
+                    },
+                    runtime: _constants1.EDGE_RUNTIME_WEBPACK,
+                    asyncChunks: false,
+                    ...entry
+                };
+            }
+        case _constants1.COMPILER_NAMES.client:
+            {
+                const isAppLayer = hasAppDir && (name === _constants1.CLIENT_STATIC_FILES_RUNTIME_MAIN_APP || name === _constants1.APP_CLIENT_INTERNALS || name.startsWith('app/'));
+                if (// Client special cases
+                name !== _constants1.CLIENT_STATIC_FILES_RUNTIME_POLYFILLS && name !== _constants1.CLIENT_STATIC_FILES_RUNTIME_MAIN && name !== _constants1.CLIENT_STATIC_FILES_RUNTIME_MAIN_APP && name !== _constants1.CLIENT_STATIC_FILES_RUNTIME_AMP && name !== _constants1.CLIENT_STATIC_FILES_RUNTIME_REACT_REFRESH) {
+                    if (isAppLayer) {
+                        return {
+                            dependOn: _constants1.CLIENT_STATIC_FILES_RUNTIME_MAIN_APP,
+                            layer: _constants.WEBPACK_LAYERS.appPagesBrowser,
+                            ...entry
+                        };
+                    }
+                    return {
+                        dependOn: name.startsWith('pages/') && name !== 'pages/_app' ? 'pages/_app' : _constants1.CLIENT_STATIC_FILES_RUNTIME_MAIN,
+                        layer: _constants.WEBPACK_LAYERS.pagesDirBrowser,
+                        ...entry
+                    };
+                }
+                if (isAppLayer) {
+                    return {
+                        layer: _constants.WEBPACK_LAYERS.appPagesBrowser,
+                        ...entry
+                    };
+                }
+                return {
+                    layer: _constants.WEBPACK_LAYERS.pagesDirBrowser,
+                    ...entry
+                };
+            }
+        default:
+            {
+                // Should never happen.
+                throw Object.defineProperty(new Error('Invalid compiler type'), "__NEXT_ERROR_CODE", {
+                    value: "E498",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+    }
+}
+
+//# sourceMappingURL=entries.js.map

node_modules/next/dist/build/generate-build-id.d.ts

@@ -0,0 +1 @@
+export declare function generateBuildId(generate: () => string | null | Promise<string | null>, fallback: () => string): Promise<string>;

node_modules/next/dist/build/generate-build-id.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "generateBuildId", {
+    enumerable: true,
+    get: function() {
+        return generateBuildId;
+    }
+});
+async function generateBuildId(generate, fallback) {
+    let buildId = await generate();
+    // If there's no buildId defined we'll fall back
+    if (buildId === null) {
+        // We also create a new buildId if it contains the word `ad` to avoid false
+        // positives with ad blockers
+        while(!buildId || /ad/i.test(buildId)){
+            buildId = fallback();
+        }
+    }
+    if (typeof buildId !== 'string') {
+        throw Object.defineProperty(new Error('generateBuildId did not return a string. https://nextjs.org/docs/messages/generatebuildid-not-a-string'), "__NEXT_ERROR_CODE", {
+            value: "E455",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return buildId.trim();
+}
+
+//# sourceMappingURL=generate-build-id.js.map

node_modules/next/dist/build/generate-build-id.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/build/generate-build-id.ts"],"sourcesContent":["export async function generateBuildId(\n  generate: () => string | null | Promise<string | null>,\n  fallback: () => string\n): Promise<string> {\n  let buildId = await generate()\n  // If there's no buildId defined we'll fall back\n  if (buildId === null) {\n    // We also create a new buildId if it contains the word `ad` to avoid false\n    // positives with ad blockers\n    while (!buildId || /ad/i.test(buildId)) {\n      buildId = fallback()\n    }\n  }\n\n  if (typeof buildId !== 'string') {\n    throw new Error(\n      'generateBuildId did not return a string. https://nextjs.org/docs/messages/generatebuildid-not-a-string'\n    )\n  }\n\n  return buildId.trim()\n}\n"],"names":["generateBuildId","generate","fallback","buildId","test","Error","trim"],"mappings":";;;;+BAAsBA;;;eAAAA;;;AAAf,eAAeA,gBACpBC,QAAsD,EACtDC,QAAsB;IAEtB,IAAIC,UAAU,MAAMF;IACpB,gDAAgD;IAChD,IAAIE,YAAY,MAAM;QACpB,2EAA2E;QAC3E,6BAA6B;QAC7B,MAAO,CAACA,WAAW,MAAMC,IAAI,CAACD,SAAU;YACtCA,UAAUD;QACZ;IACF;IAEA,IAAI,OAAOC,YAAY,UAAU;QAC/B,MAAM,qBAEL,CAFK,IAAIE,MACR,2GADI,qBAAA;mBAAA;wBAAA;0BAAA;QAEN;IACF;IAEA,OAAOF,QAAQG,IAAI;AACrB"}

node_modules/next/dist/build/get-babel-config-file.d.ts

@@ -0,0 +1 @@
+export declare function getBabelConfigFile(dir: string): string | undefined;

node_modules/next/dist/build/get-babel-config-file.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getBabelConfigFile", {
+    enumerable: true,
+    get: function() {
+        return getBabelConfigFile;
+    }
+});
+const _path = require("path");
+const _fs = require("fs");
+const BABEL_CONFIG_FILES = [
+    '.babelrc',
+    '.babelrc.json',
+    '.babelrc.js',
+    '.babelrc.mjs',
+    '.babelrc.cjs',
+    'babel.config.js',
+    'babel.config.json',
+    'babel.config.mjs',
+    'babel.config.cjs'
+];
+function getBabelConfigFile(dir) {
+    for (const filename of BABEL_CONFIG_FILES){
+        const configFilePath = (0, _path.join)(dir, filename);
+        const exists = (0, _fs.existsSync)(configFilePath);
+        if (!exists) {
+            continue;
+        }
+        return configFilePath;
+    }
+}
+
+//# sourceMappingURL=get-babel-config-file.js.map

node_modules/next/dist/build/get-babel-config-file.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/build/get-babel-config-file.ts"],"sourcesContent":["import { join } from 'path'\nimport { existsSync } from 'fs'\n\nconst BABEL_CONFIG_FILES = [\n  '.babelrc',\n  '.babelrc.json',\n  '.babelrc.js',\n  '.babelrc.mjs',\n  '.babelrc.cjs',\n  'babel.config.js',\n  'babel.config.json',\n  'babel.config.mjs',\n  'babel.config.cjs',\n]\n\nexport function getBabelConfigFile(dir: string): string | undefined {\n  for (const filename of BABEL_CONFIG_FILES) {\n    const configFilePath = join(dir, filename)\n    const exists = existsSync(configFilePath)\n    if (!exists) {\n      continue\n    }\n    return configFilePath\n  }\n}\n"],"names":["getBabelConfigFile","BABEL_CONFIG_FILES","dir","filename","configFilePath","join","exists","existsSync"],"mappings":";;;;+BAegBA;;;eAAAA;;;sBAfK;oBACM;AAE3B,MAAMC,qBAAqB;IACzB;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD;AAEM,SAASD,mBAAmBE,GAAW;IAC5C,KAAK,MAAMC,YAAYF,mBAAoB;QACzC,MAAMG,iBAAiBC,IAAAA,UAAI,EAACH,KAAKC;QACjC,MAAMG,SAASC,IAAAA,cAAU,EAACH;QAC1B,IAAI,CAACE,QAAQ;YACX;QACF;QACA,OAAOF;IACT;AACF"}

node_modules/next/dist/build/get-babel-loader-config.d.ts

@@ -0,0 +1,29 @@
+import type { ReactCompilerOptions } from '../server/config-shared';
+declare const getBabelLoader: (useSWCLoader: boolean | undefined, babelConfigFile: string | undefined, isServer: boolean, distDir: string, pagesDir: string | undefined, cwd: string, srcDir: string, dev: boolean, isClient: boolean, reactCompilerOptions: boolean | ReactCompilerOptions | undefined, reactCompilerExclude: ((excludePath: string) => boolean) | undefined) => {
+    loader: string;
+    options: {
+        transformMode: string;
+        configFile: string | undefined;
+        isServer: boolean;
+        distDir: string;
+        pagesDir: string | undefined;
+        cwd: string;
+        srcDir: string;
+        development: boolean;
+        hasReactRefresh: boolean;
+        hasJsxRuntime: boolean;
+        reactCompilerPlugins: (string | {
+            compilationMode?: "infer" | "annotation" | "all";
+            panicThreshold: string | undefined;
+        })[][] | undefined;
+        reactCompilerExclude: ((excludePath: string) => boolean) | undefined;
+    };
+} | undefined;
+/**
+ * Get a separate babel loader for the react compiler, only used if Babel is not
+ * configured through e.g. .babelrc. If user have babel config, this should be configured in the babel loader itself.
+ * Note from react compiler:
+ * > For best results, compiler must run as the first plugin in your Babel pipeline so it receives input as close to the original source as possible.
+ */
+declare const getReactCompilerLoader: (options: boolean | ReactCompilerOptions | undefined, cwd: string, isDev: boolean, isServer: boolean, reactCompilerExclude: ((excludePath: string) => boolean) | undefined) => any;
+export { getBabelLoader, getReactCompilerLoader };

node_modules/next/dist/build/get-babel-loader-config.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getBabelLoader: null,
+    getReactCompilerLoader: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getBabelLoader: function() {
+        return getBabelLoader;
+    },
+    getReactCompilerLoader: function() {
+        return getReactCompilerLoader;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getReactCompiler() {
+    try {
+        // It's in peerDependencies, so it should be available
+        // eslint-disable-next-line import/no-extraneous-dependencies
+        return require.resolve('babel-plugin-react-compiler');
+    } catch  {
+        throw Object.defineProperty(new Error('Failed to load the `babel-plugin-react-compiler`. It is required to use the React Compiler. Please install it.'), "__NEXT_ERROR_CODE", {
+            value: "E78",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+const getReactCompilerPlugins = (options, isDev, isServer)=>{
+    if (!options || isServer) {
+        return undefined;
+    }
+    const compilerOptions = typeof options === 'boolean' ? {} : options;
+    if (options) {
+        return [
+            [
+                getReactCompiler(),
+                {
+                    panicThreshold: isDev ? undefined : 'NONE',
+                    ...compilerOptions
+                }
+            ]
+        ];
+    }
+    return undefined;
+};
+const getBabelLoader = (useSWCLoader, babelConfigFile, isServer, distDir, pagesDir, cwd, srcDir, dev, isClient, reactCompilerOptions, reactCompilerExclude)=>{
+    if (!useSWCLoader) {
+        return {
+            loader: require.resolve('./babel/loader/index'),
+            options: {
+                transformMode: 'default',
+                configFile: babelConfigFile,
+                isServer,
+                distDir,
+                pagesDir,
+                cwd,
+                srcDir: _path.default.dirname(srcDir),
+                development: dev,
+                hasReactRefresh: dev && isClient,
+                hasJsxRuntime: true,
+                reactCompilerPlugins: getReactCompilerPlugins(reactCompilerOptions, dev, isServer),
+                reactCompilerExclude
+            }
+        };
+    }
+    return undefined;
+};
+/**
+ * Get a separate babel loader for the react compiler, only used if Babel is not
+ * configured through e.g. .babelrc. If user have babel config, this should be configured in the babel loader itself.
+ * Note from react compiler:
+ * > For best results, compiler must run as the first plugin in your Babel pipeline so it receives input as close to the original source as possible.
+ */ const getReactCompilerLoader = (options, cwd, isDev, isServer, reactCompilerExclude)=>{
+    const reactCompilerPlugins = getReactCompilerPlugins(options, isDev, isServer);
+    if (!reactCompilerPlugins) {
+        return undefined;
+    }
+    const config = {
+        loader: require.resolve('./babel/loader/index'),
+        options: {
+            transformMode: 'standalone',
+            cwd,
+            reactCompilerPlugins
+        }
+    };
+    if (reactCompilerExclude) {
+        config.options.reactCompilerExclude = reactCompilerExclude;
+    }
+    return config;
+};
+
+//# sourceMappingURL=get-babel-loader-config.js.map

node_modules/next/dist/build/get-babel-loader-config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/build/get-babel-loader-config.ts"],"sourcesContent":["import path from 'path'\nimport type { ReactCompilerOptions } from '../server/config-shared'\n\nfunction getReactCompiler() {\n  try {\n    // It's in peerDependencies, so it should be available\n    // eslint-disable-next-line import/no-extraneous-dependencies\n    return require.resolve('babel-plugin-react-compiler')\n  } catch {\n    throw new Error(\n      'Failed to load the `babel-plugin-react-compiler`. It is required to use the React Compiler. Please install it.'\n    )\n  }\n}\n\nconst getReactCompilerPlugins = (\n  options: boolean | ReactCompilerOptions | undefined,\n  isDev: boolean,\n  isServer: boolean\n) => {\n  if (!options || isServer) {\n    return undefined\n  }\n\n  const compilerOptions = typeof options === 'boolean' ? {} : options\n  if (options) {\n    return [\n      [\n        getReactCompiler(),\n        {\n          panicThreshold: isDev ? undefined : 'NONE',\n          ...compilerOptions,\n        },\n      ],\n    ]\n  }\n  return undefined\n}\n\nconst getBabelLoader = (\n  useSWCLoader: boolean | undefined,\n  babelConfigFile: string | undefined,\n  isServer: boolean,\n  distDir: string,\n  pagesDir: string | undefined,\n  cwd: string,\n  srcDir: string,\n  dev: boolean,\n  isClient: boolean,\n  reactCompilerOptions: boolean | ReactCompilerOptions | undefined,\n  reactCompilerExclude: ((excludePath: string) => boolean) | undefined\n) => {\n  if (!useSWCLoader) {\n    return {\n      loader: require.resolve('./babel/loader/index'),\n      options: {\n        transformMode: 'default',\n        configFile: babelConfigFile,\n        isServer,\n        distDir,\n        pagesDir,\n        cwd,\n        srcDir: path.dirname(srcDir),\n        development: dev,\n        hasReactRefresh: dev && isClient,\n        hasJsxRuntime: true,\n        reactCompilerPlugins: getReactCompilerPlugins(\n          reactCompilerOptions,\n          dev,\n          isServer\n        ),\n        reactCompilerExclude,\n      },\n    }\n  }\n\n  return undefined\n}\n\n/**\n * Get a separate babel loader for the react compiler, only used if Babel is not\n * configured through e.g. .babelrc. If user have babel config, this should be configured in the babel loader itself.\n * Note from react compiler:\n * > For best results, compiler must run as the first plugin in your Babel pipeline so it receives input as close to the original source as possible.\n */\nconst getReactCompilerLoader = (\n  options: boolean | ReactCompilerOptions | undefined,\n  cwd: string,\n  isDev: boolean,\n  isServer: boolean,\n  reactCompilerExclude: ((excludePath: string) => boolean) | undefined\n) => {\n  const reactCompilerPlugins = getReactCompilerPlugins(options, isDev, isServer)\n  if (!reactCompilerPlugins) {\n    return undefined\n  }\n\n  const config: any = {\n    loader: require.resolve('./babel/loader/index'),\n    options: {\n      transformMode: 'standalone',\n      cwd,\n      reactCompilerPlugins,\n    },\n  }\n\n  if (reactCompilerExclude) {\n    config.options.reactCompilerExclude = reactCompilerExclude\n  }\n\n  return config\n}\n\nexport { getBabelLoader, getReactCompilerLoader }\n"],"names":["getBabelLoader","getReactCompilerLoader","getReactCompiler","require","resolve","Error","getReactCompilerPlugins","options","isDev","isServer","undefined","compilerOptions","panicThreshold","useSWCLoader","babelConfigFile","distDir","pagesDir","cwd","srcDir","dev","isClient","reactCompilerOptions","reactCompilerExclude","loader","transformMode","configFile","path","dirname","development","hasReactRefresh","hasJsxRuntime","reactCompilerPlugins","config"],"mappings":";;;;;;;;;;;;;;;IAiHSA,cAAc;eAAdA;;IAAgBC,sBAAsB;eAAtBA;;;6DAjHR;;;;;;AAGjB,SAASC;IACP,IAAI;QACF,sDAAsD;QACtD,6DAA6D;QAC7D,OAAOC,QAAQC,OAAO,CAAC;IACzB,EAAE,OAAM;QACN,MAAM,qBAEL,CAFK,IAAIC,MACR,mHADI,qBAAA;mBAAA;wBAAA;0BAAA;QAEN;IACF;AACF;AAEA,MAAMC,0BAA0B,CAC9BC,SACAC,OACAC;IAEA,IAAI,CAACF,WAAWE,UAAU;QACxB,OAAOC;IACT;IAEA,MAAMC,kBAAkB,OAAOJ,YAAY,YAAY,CAAC,IAAIA;IAC5D,IAAIA,SAAS;QACX,OAAO;YACL;gBACEL;gBACA;oBACEU,gBAAgBJ,QAAQE,YAAY;oBACpC,GAAGC,eAAe;gBACpB;aACD;SACF;IACH;IACA,OAAOD;AACT;AAEA,MAAMV,iBAAiB,CACrBa,cACAC,iBACAL,UACAM,SACAC,UACAC,KACAC,QACAC,KACAC,UACAC,sBACAC;IAEA,IAAI,CAACT,cAAc;QACjB,OAAO;YACLU,QAAQpB,QAAQC,OAAO,CAAC;YACxBG,SAAS;gBACPiB,eAAe;gBACfC,YAAYX;gBACZL;gBACAM;gBACAC;gBACAC;gBACAC,QAAQQ,aAAI,CAACC,OAAO,CAACT;gBACrBU,aAAaT;gBACbU,iBAAiBV,OAAOC;gBACxBU,eAAe;gBACfC,sBAAsBzB,wBACpBe,sBACAF,KACAV;gBAEFa;YACF;QACF;IACF;IAEA,OAAOZ;AACT;AAEA;;;;;CAKC,GACD,MAAMT,yBAAyB,CAC7BM,SACAU,KACAT,OACAC,UACAa;IAEA,MAAMS,uBAAuBzB,wBAAwBC,SAASC,OAAOC;IACrE,IAAI,CAACsB,sBAAsB;QACzB,OAAOrB;IACT;IAEA,MAAMsB,SAAc;QAClBT,QAAQpB,QAAQC,OAAO,CAAC;QACxBG,SAAS;YACPiB,eAAe;YACfP;YACAc;QACF;IACF;IAEA,IAAIT,sBAAsB;QACxBU,OAAOzB,OAAO,CAACe,oBAAoB,GAAGA;IACxC;IAEA,OAAOU;AACT"}

node_modules/next/dist/build/handle-entrypoints.d.ts

@@ -0,0 +1,28 @@
+import type { CustomRoutes } from '../lib/load-custom-routes';
+import type { TurbopackManifestLoader } from '../shared/lib/turbopack/manifest-loader';
+import type { TurbopackResult, RawEntrypoints, Entrypoints, PageRoute, AppRoute } from './swc/types';
+import { type EntryIssuesMap } from '../shared/lib/turbopack/utils';
+export declare function handleEntrypoints({ entrypoints, currentEntrypoints, currentEntryIssues, manifestLoader, productionRewrites, logErrors, }: {
+    entrypoints: TurbopackResult<RawEntrypoints>;
+    currentEntrypoints: Entrypoints;
+    currentEntryIssues: EntryIssuesMap;
+    manifestLoader: TurbopackManifestLoader;
+    productionRewrites: CustomRoutes['rewrites'] | undefined;
+    logErrors: boolean;
+}): Promise<void>;
+export declare function handlePagesErrorRoute({ currentEntryIssues, entrypoints, manifestLoader, productionRewrites, logErrors, }: {
+    currentEntryIssues: EntryIssuesMap;
+    entrypoints: Entrypoints;
+    manifestLoader: TurbopackManifestLoader;
+    productionRewrites: CustomRoutes['rewrites'] | undefined;
+    logErrors: boolean;
+}): Promise<void>;
+export declare function handleRouteType({ page, route, currentEntryIssues, entrypoints, manifestLoader, productionRewrites, logErrors, }: {
+    page: string;
+    route: PageRoute | AppRoute;
+    currentEntryIssues: EntryIssuesMap;
+    entrypoints: Entrypoints;
+    manifestLoader: TurbopackManifestLoader;
+    productionRewrites: CustomRoutes['rewrites'] | undefined;
+    logErrors: boolean;
+}): Promise<void>;

node_modules/next/dist/build/handle-entrypoints.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    handleEntrypoints: null,
+    handlePagesErrorRoute: null,
+    handleRouteType: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    handleEntrypoints: function() {
+        return handleEntrypoints;
+    },
+    handlePagesErrorRoute: function() {
+        return handlePagesErrorRoute;
+    },
+    handleRouteType: function() {
+        return handleRouteType;
+    }
+});
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("./output/log"));
+const _entrykey = require("../shared/lib/turbopack/entry-key");
+const _utils = require("../shared/lib/turbopack/utils");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+async function handleEntrypoints({ entrypoints, currentEntrypoints, currentEntryIssues, manifestLoader, productionRewrites, logErrors }) {
+    currentEntrypoints.global.app = entrypoints.pagesAppEndpoint;
+    currentEntrypoints.global.document = entrypoints.pagesDocumentEndpoint;
+    currentEntrypoints.global.error = entrypoints.pagesErrorEndpoint;
+    currentEntrypoints.global.instrumentation = entrypoints.instrumentation;
+    currentEntrypoints.page.clear();
+    currentEntrypoints.app.clear();
+    for (const [pathname, route] of entrypoints.routes){
+        switch(route.type){
+            case 'page':
+            case 'page-api':
+                currentEntrypoints.page.set(pathname, route);
+                break;
+            case 'app-page':
+                {
+                    route.pages.forEach((page)=>{
+                        currentEntrypoints.app.set(page.originalName, {
+                            type: 'app-page',
+                            ...page
+                        });
+                    });
+                    break;
+                }
+            case 'app-route':
+                {
+                    currentEntrypoints.app.set(route.originalName, route);
+                    break;
+                }
+            default:
+                _log.info(`skipping ${pathname} (${route.type})`);
+                break;
+        }
+    }
+    const { middleware, instrumentation } = entrypoints;
+    // We check for explicit true/false, since it's initialized to
+    // undefined during the first loop (middlewareChanges event is
+    // unnecessary during the first serve)
+    if (currentEntrypoints.global.middleware && !middleware) {
+        const key = (0, _entrykey.getEntryKey)('root', 'server', 'middleware');
+        // Went from middleware to no middleware
+        currentEntryIssues.delete(key);
+    }
+    currentEntrypoints.global.middleware = middleware;
+    if (instrumentation) {
+        const processInstrumentation = async (name, prop)=>{
+            const key = (0, _entrykey.getEntryKey)('root', 'server', name);
+            const writtenEndpoint = await instrumentation[prop].writeToDisk();
+            (0, _utils.processIssues)(currentEntryIssues, key, writtenEndpoint, false, logErrors);
+        };
+        await processInstrumentation('instrumentation.nodeJs', 'nodeJs');
+        await processInstrumentation('instrumentation.edge', 'edge');
+        await manifestLoader.loadMiddlewareManifest('instrumentation', 'instrumentation');
+        await manifestLoader.writeManifests({
+            devRewrites: undefined,
+            productionRewrites,
+            entrypoints: currentEntrypoints
+        });
+    }
+    if (middleware) {
+        const key = (0, _entrykey.getEntryKey)('root', 'server', 'middleware');
+        const endpoint = middleware.endpoint;
+        async function processMiddleware() {
+            const writtenEndpoint = await endpoint.writeToDisk();
+            (0, _utils.processIssues)(currentEntryIssues, key, writtenEndpoint, false, logErrors);
+            await manifestLoader.loadMiddlewareManifest('middleware', 'middleware');
+        }
+        await processMiddleware();
+    } else {
+        manifestLoader.deleteMiddlewareManifest((0, _entrykey.getEntryKey)('root', 'server', 'middleware'));
+    }
+}
+async function handlePagesErrorRoute({ currentEntryIssues, entrypoints, manifestLoader, productionRewrites, logErrors }) {
+    if (entrypoints.global.app) {
+        const key = (0, _entrykey.getEntryKey)('pages', 'server', '_app');
+        const writtenEndpoint = await entrypoints.global.app.writeToDisk();
+        (0, _utils.processIssues)(currentEntryIssues, key, writtenEndpoint, false, logErrors);
+    }
+    await manifestLoader.loadBuildManifest('_app');
+    await manifestLoader.loadPagesManifest('_app');
+    await manifestLoader.loadFontManifest('_app');
+    if (entrypoints.global.document) {
+        const key = (0, _entrykey.getEntryKey)('pages', 'server', '_document');
+        const writtenEndpoint = await entrypoints.global.document.writeToDisk();
+        (0, _utils.processIssues)(currentEntryIssues, key, writtenEndpoint, false, logErrors);
+    }
+    await manifestLoader.loadPagesManifest('_document');
+    if (entrypoints.global.error) {
+        const key = (0, _entrykey.getEntryKey)('pages', 'server', '_error');
+        const writtenEndpoint = await entrypoints.global.error.writeToDisk();
+        (0, _utils.processIssues)(currentEntryIssues, key, writtenEndpoint, false, logErrors);
+    }
+    await manifestLoader.loadBuildManifest('_error');
+    await manifestLoader.loadPagesManifest('_error');
+    await manifestLoader.loadFontManifest('_error');
+    await manifestLoader.writeManifests({
+        devRewrites: undefined,
+        productionRewrites,
+        entrypoints
+    });
+}
+async function handleRouteType({ page, route, currentEntryIssues, entrypoints, manifestLoader, productionRewrites, logErrors }) {
+    const shouldCreateWebpackStats = process.env.TURBOPACK_STATS != null;
+    switch(route.type){
+        case 'page':
+            {
+                const serverKey = (0, _entrykey.getEntryKey)('pages', 'server', page);
+                if (entrypoints.global.app) {
+                    const key = (0, _entrykey.getEntryKey)('pages', 'server', '_app');
+                    const writtenEndpoint = await entrypoints.global.app.writeToDisk();
+                    (0, _utils.processIssues)(currentEntryIssues, key, writtenEndpoint, false, logErrors);
+                }
+                await manifestLoader.loadBuildManifest('_app');
+                await manifestLoader.loadPagesManifest('_app');
+                if (entrypoints.global.document) {
+                    const key = (0, _entrykey.getEntryKey)('pages', 'server', '_document');
+                    const writtenEndpoint = await entrypoints.global.document.writeToDisk();
+                    (0, _utils.processIssues)(currentEntryIssues, key, writtenEndpoint, false, logErrors);
+                }
+                await manifestLoader.loadPagesManifest('_document');
+                const writtenEndpoint = await route.htmlEndpoint.writeToDisk();
+                const type = writtenEndpoint == null ? void 0 : writtenEndpoint.type;
+                await manifestLoader.loadBuildManifest(page);
+                await manifestLoader.loadPagesManifest(page);
+                if (type === 'edge') {
+                    await manifestLoader.loadMiddlewareManifest(page, 'pages');
+                } else {
+                    manifestLoader.deleteMiddlewareManifest(serverKey);
+                }
+                await manifestLoader.loadFontManifest('/_app', 'pages');
+                await manifestLoader.loadFontManifest(page, 'pages');
+                if (shouldCreateWebpackStats) {
+                    await manifestLoader.loadWebpackStats(page, 'pages');
+                }
+                await manifestLoader.writeManifests({
+                    devRewrites: undefined,
+                    productionRewrites,
+                    entrypoints
+                });
+                (0, _utils.processIssues)(currentEntryIssues, serverKey, writtenEndpoint, false, logErrors);
+                break;
+            }
+        case 'page-api':
+            {
+                const key = (0, _entrykey.getEntryKey)('pages', 'server', page);
+                const writtenEndpoint = await route.endpoint.writeToDisk();
+                const type = writtenEndpoint.type;
+                await manifestLoader.loadPagesManifest(page);
+                if (type === 'edge') {
+                    await manifestLoader.loadMiddlewareManifest(page, 'pages');
+                } else {
+                    manifestLoader.deleteMiddlewareManifest(key);
+                }
+                await manifestLoader.writeManifests({
+                    devRewrites: undefined,
+                    productionRewrites,
+                    entrypoints
+                });
+                (0, _utils.processIssues)(currentEntryIssues, key, writtenEndpoint, true, logErrors);
+                break;
+            }
+        case 'app-page':
+            {
+                const key = (0, _entrykey.getEntryKey)('app', 'server', page);
+                const writtenEndpoint = await route.htmlEndpoint.writeToDisk();
+                const type = writtenEndpoint.type;
+                if (type === 'edge') {
+                    await manifestLoader.loadMiddlewareManifest(page, 'app');
+                } else {
+                    manifestLoader.deleteMiddlewareManifest(key);
+                }
+                await manifestLoader.loadAppBuildManifest(page);
+                await manifestLoader.loadBuildManifest(page, 'app');
+                await manifestLoader.loadAppPathsManifest(page);
+                await manifestLoader.loadActionManifest(page);
+                await manifestLoader.loadFontManifest(page, 'app');
+                if (shouldCreateWebpackStats) {
+                    await manifestLoader.loadWebpackStats(page, 'app');
+                }
+                await manifestLoader.writeManifests({
+                    devRewrites: undefined,
+                    productionRewrites,
+                    entrypoints
+                });
+                (0, _utils.processIssues)(currentEntryIssues, key, writtenEndpoint, false, logErrors);
+                break;
+            }
+        case 'app-route':
+            {
+                const key = (0, _entrykey.getEntryKey)('app', 'server', page);
+                const writtenEndpoint = await route.endpoint.writeToDisk();
+                const type = writtenEndpoint.type;
+                await manifestLoader.loadAppPathsManifest(page);
+                if (type === 'edge') {
+                    await manifestLoader.loadMiddlewareManifest(page, 'app');
+                } else {
+                    manifestLoader.deleteMiddlewareManifest(key);
+                }
+                await manifestLoader.writeManifests({
+                    devRewrites: undefined,
+                    productionRewrites,
+                    entrypoints
+                });
+                (0, _utils.processIssues)(currentEntryIssues, key, writtenEndpoint, true, logErrors);
+                break;
+            }
+        default:
+            {
+                throw Object.defineProperty(new Error(`unknown route type ${route.type} for ${page}`), "__NEXT_ERROR_CODE", {
+                    value: "E316",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+    }
+}
+
+//# sourceMappingURL=handle-entrypoints.js.map

node_modules/next/dist/build/handle-externals.d.ts

@@ -0,0 +1,19 @@
+import type { WebpackLayerName } from '../lib/constants';
+import type { NextConfigComplete } from '../server/config-shared';
+import type { ResolveOptions } from 'webpack';
+export declare function isResourceInPackages(resource: string, packageNames?: string[], packageDirMapping?: Map<string, string>): boolean;
+export declare function resolveExternal(dir: string, esmExternalsConfig: NextConfigComplete['experimental']['esmExternals'], context: string, request: string, isEsmRequested: boolean, getResolve: (options: ResolveOptions) => (resolveContext: string, resolveRequest: string) => Promise<[string | null, boolean]>, isLocalCallback?: (res: string) => any, baseResolveCheck?: boolean, esmResolveOptions?: any, nodeResolveOptions?: any, baseEsmResolveOptions?: any, baseResolveOptions?: any): Promise<{
+    localRes: any;
+    res?: undefined;
+    isEsm?: undefined;
+} | {
+    res: string | null;
+    isEsm: boolean;
+    localRes?: undefined;
+}>;
+export declare function makeExternalHandler({ config, optOutBundlingPackageRegex, transpiledPackages, dir, }: {
+    config: NextConfigComplete;
+    optOutBundlingPackageRegex: RegExp;
+    transpiledPackages: string[];
+    dir: string;
+}): (context: string, request: string, dependencyType: string, layer: WebpackLayerName | null, getResolve: (options: any) => (resolveContext: string, resolveRequest: string) => Promise<[string | null, boolean]>) => Promise<any>;

node_modules/next/dist/build/handle-externals.js

@@ -0,0 +1,286 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    isResourceInPackages: null,
+    makeExternalHandler: null,
+    resolveExternal: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isResourceInPackages: function() {
+        return isResourceInPackages;
+    },
+    makeExternalHandler: function() {
+        return makeExternalHandler;
+    },
+    resolveExternal: function() {
+        return resolveExternal;
+    }
+});
+const _requirehook = require("../server/require-hook");
+const _constants = require("../shared/lib/constants");
+const _path = /*#__PURE__*/ _interop_require_default(require("../shared/lib/isomorphic/path"));
+const _webpackconfig = require("./webpack-config");
+const _utils = require("./utils");
+const _normalizepathsep = require("../shared/lib/page-path/normalize-path-sep");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const reactPackagesRegex = /^(react|react-dom|react-server-dom-webpack)($|\/)/;
+const pathSeparators = '[/\\\\]';
+const optionalEsmPart = `((${pathSeparators}esm)?${pathSeparators})`;
+const externalFileEnd = '(\\.external(\\.js)?)$';
+const nextDist = `next${pathSeparators}dist`;
+const externalPattern = new RegExp(`${nextDist}${optionalEsmPart}.*${externalFileEnd}`);
+const nodeModulesRegex = /node_modules[/\\].*\.[mc]?js$/;
+function isResourceInPackages(resource, packageNames, packageDirMapping) {
+    if (!packageNames) return false;
+    return packageNames.some((p)=>packageDirMapping && packageDirMapping.has(p) ? resource.startsWith(packageDirMapping.get(p) + _path.default.sep) : resource.includes(_path.default.sep + _path.default.join('node_modules', p.replace(/\//g, _path.default.sep)) + _path.default.sep));
+}
+async function resolveExternal(dir, esmExternalsConfig, context, request, isEsmRequested, getResolve, isLocalCallback, baseResolveCheck = true, esmResolveOptions = _webpackconfig.NODE_ESM_RESOLVE_OPTIONS, nodeResolveOptions = _webpackconfig.NODE_RESOLVE_OPTIONS, baseEsmResolveOptions = _webpackconfig.NODE_BASE_ESM_RESOLVE_OPTIONS, baseResolveOptions = _webpackconfig.NODE_BASE_RESOLVE_OPTIONS) {
+    const esmExternals = !!esmExternalsConfig;
+    const looseEsmExternals = esmExternalsConfig === 'loose';
+    let res = null;
+    let isEsm = false;
+    const preferEsmOptions = esmExternals && isEsmRequested ? [
+        true,
+        false
+    ] : [
+        false
+    ];
+    for (const preferEsm of preferEsmOptions){
+        const resolveOptions = preferEsm ? esmResolveOptions : nodeResolveOptions;
+        const resolve = getResolve(resolveOptions);
+        // Resolve the import with the webpack provided context, this
+        // ensures we're resolving the correct version when multiple
+        // exist.
+        try {
+            ;
+            [res, isEsm] = await resolve(context, request);
+        } catch (err) {
+            res = null;
+        }
+        if (!res) {
+            continue;
+        }
+        // ESM externals can only be imported (and not required).
+        // Make an exception in loose mode.
+        if (!isEsmRequested && isEsm && !looseEsmExternals) {
+            continue;
+        }
+        if (isLocalCallback) {
+            return {
+                localRes: isLocalCallback(res)
+            };
+        }
+        // Bundled Node.js code is relocated without its node_modules tree.
+        // This means we need to make sure its request resolves to the same
+        // package that'll be available at runtime. If it's not identical,
+        // we need to bundle the code (even if it _should_ be external).
+        if (baseResolveCheck) {
+            let baseRes;
+            let baseIsEsm;
+            try {
+                const baseResolve = getResolve(isEsm ? baseEsmResolveOptions : baseResolveOptions);
+                [baseRes, baseIsEsm] = await baseResolve(dir, request);
+            } catch (err) {
+                baseRes = null;
+                baseIsEsm = false;
+            }
+            // Same as above: if the package, when required from the root,
+            // would be different from what the real resolution would use, we
+            // cannot externalize it.
+            // if request is pointing to a symlink it could point to the same file,
+            // the resolver will resolve symlinks so this is handled
+            if (baseRes !== res || isEsm !== baseIsEsm) {
+                res = null;
+                continue;
+            }
+        }
+        break;
+    }
+    return {
+        res,
+        isEsm
+    };
+}
+function makeExternalHandler({ config, optOutBundlingPackageRegex, transpiledPackages, dir }) {
+    var _config_experimental;
+    let resolvedExternalPackageDirs;
+    const looseEsmExternals = ((_config_experimental = config.experimental) == null ? void 0 : _config_experimental.esmExternals) === 'loose';
+    return async function handleExternals(context, request, dependencyType, layer, getResolve) {
+        // We need to externalize internal requests for files intended to
+        // not be bundled.
+        const isLocal = request.startsWith('.') || // Always check for unix-style path, as webpack sometimes
+        // normalizes as posix.
+        _path.default.posix.isAbsolute(request) || // When on Windows, we also want to check for Windows-specific
+        // absolute paths.
+        process.platform === 'win32' && _path.default.win32.isAbsolute(request);
+        // make sure import "next" shows a warning when imported
+        // in pages/components
+        if (request === 'next') {
+            return `commonjs next/dist/lib/import-next-warning`;
+        }
+        const isAppLayer = (0, _utils.isWebpackBundledLayer)(layer);
+        // Relative requires don't need custom resolution, because they
+        // are relative to requests we've already resolved here.
+        // Absolute requires (require('/foo')) are extremely uncommon, but
+        // also have no need for customization as they're already resolved.
+        if (!isLocal) {
+            if (/^next$/.test(request)) {
+                return `commonjs ${request}`;
+            }
+            if (reactPackagesRegex.test(request) && !isAppLayer) {
+                return `commonjs ${request}`;
+            }
+            const notExternalModules = /^(?:private-next-pages\/|next\/(?:dist\/pages\/|(?:app|document|link|form|image|legacy\/image|constants|dynamic|script|navigation|headers|router)$)|string-hash|private-next-rsc-action-validate|private-next-rsc-action-client-wrapper|private-next-rsc-server-reference|private-next-rsc-cache-wrapper$)/;
+            if (notExternalModules.test(request)) {
+                return;
+            }
+        }
+        // @swc/helpers should not be external as it would
+        // require hoisting the package which we can't rely on
+        if (request.includes('@swc/helpers')) {
+            return;
+        }
+        // BARREL_OPTIMIZATION_PREFIX is a special marker that tells Next.js to
+        // optimize the import by removing unused exports. This has to be compiled.
+        if (request.startsWith(_constants.BARREL_OPTIMIZATION_PREFIX)) {
+            return;
+        }
+        // When in esm externals mode, and using import, we resolve with
+        // ESM resolving options.
+        // Also disable esm request when appDir is enabled
+        const isEsmRequested = dependencyType === 'esm';
+        // Don't bundle @vercel/og nodejs bundle for nodejs runtime.
+        // TODO-APP: bundle route.js with different layer that externals common node_module deps.
+        // Make sure @vercel/og is loaded as ESM for Node.js runtime
+        if ((0, _utils.isWebpackServerOnlyLayer)(layer) && request === 'next/dist/compiled/@vercel/og/index.node.js') {
+            return `module ${request}`;
+        }
+        // Specific Next.js imports that should remain external
+        // TODO-APP: Investigate if we can remove this.
+        if (request.startsWith('next/dist/')) {
+            // Non external that needs to be transpiled
+            // Image loader needs to be transpiled
+            if (/^next[\\/]dist[\\/]shared[\\/]lib[\\/]image-loader/.test(request)) {
+                return;
+            }
+            if (/^next[\\/]dist[\\/]compiled[\\/]next-server/.test(request)) {
+                return `commonjs ${request}`;
+            }
+            if (/^next[\\/]dist[\\/]shared[\\/](?!lib[\\/]router[\\/]router)/.test(request) || /^next[\\/]dist[\\/]compiled[\\/].*\.c?js$/.test(request)) {
+                return `commonjs ${request}`;
+            }
+            if (/^next[\\/]dist[\\/]esm[\\/]shared[\\/](?!lib[\\/]router[\\/]router)/.test(request) || /^next[\\/]dist[\\/]compiled[\\/].*\.mjs$/.test(request)) {
+                return `module ${request}`;
+            }
+            return resolveNextExternal(request);
+        }
+        // TODO-APP: Let's avoid this resolve call as much as possible, and eventually get rid of it.
+        const resolveResult = await resolveExternal(dir, config.experimental.esmExternals, context, request, isEsmRequested, getResolve, isLocal ? resolveNextExternal : undefined);
+        if ('localRes' in resolveResult) {
+            return resolveResult.localRes;
+        }
+        // Forcedly resolve the styled-jsx installed by next.js,
+        // since `resolveExternal` cannot find the styled-jsx dep with pnpm
+        if (request === 'styled-jsx/style') {
+            resolveResult.res = _requirehook.defaultOverrides['styled-jsx/style'];
+        }
+        const { res, isEsm } = resolveResult;
+        // If the request cannot be resolved we need to have
+        // webpack "bundle" it so it surfaces the not found error.
+        if (!res) {
+            return;
+        }
+        const isOptOutBundling = optOutBundlingPackageRegex.test(res);
+        // Apply bundling rules to all app layers.
+        // Since handleExternals only handle the server layers, we don't need to exclude client here
+        if (!isOptOutBundling && isAppLayer) {
+            return;
+        }
+        // ESM externals can only be imported (and not required).
+        // Make an exception in loose mode.
+        if (!isEsmRequested && isEsm && !looseEsmExternals && !isLocal) {
+            throw Object.defineProperty(new Error(`ESM packages (${request}) need to be imported. Use 'import' to reference the package instead. https://nextjs.org/docs/messages/import-esm-externals`), "__NEXT_ERROR_CODE", {
+                value: "E310",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        const externalType = isEsm ? 'module' : 'commonjs';
+        // Default pages have to be transpiled
+        if (// This is the @babel/plugin-transform-runtime "helpers: true" option
+        /node_modules[/\\]@babel[/\\]runtime[/\\]/.test(res)) {
+            return;
+        }
+        // Webpack itself has to be compiled because it doesn't always use module relative paths
+        if (/node_modules[/\\]webpack/.test(res) || /node_modules[/\\]css-loader/.test(res)) {
+            return;
+        }
+        // If a package should be transpiled by Next.js, we skip making it external.
+        // It doesn't matter what the extension is, as we'll transpile it anyway.
+        if (transpiledPackages && !resolvedExternalPackageDirs) {
+            resolvedExternalPackageDirs = new Map();
+            // We need to resolve all the external package dirs initially.
+            for (const pkg of transpiledPackages){
+                const pkgRes = await resolveExternal(dir, config.experimental.esmExternals, context, pkg + '/package.json', isEsmRequested, getResolve, isLocal ? resolveNextExternal : undefined);
+                if (pkgRes.res) {
+                    resolvedExternalPackageDirs.set(pkg, _path.default.dirname(pkgRes.res));
+                }
+            }
+        }
+        const resolvedBundlingOptOutRes = resolveBundlingOptOutPackages({
+            resolvedRes: res,
+            config,
+            resolvedExternalPackageDirs,
+            isAppLayer,
+            externalType,
+            isOptOutBundling,
+            request,
+            transpiledPackages
+        });
+        if (resolvedBundlingOptOutRes) {
+            return resolvedBundlingOptOutRes;
+        }
+        // if here, we default to bundling the file
+        return;
+    };
+}
+function resolveBundlingOptOutPackages({ resolvedRes, config, resolvedExternalPackageDirs, isAppLayer, externalType, isOptOutBundling, request, transpiledPackages }) {
+    if (nodeModulesRegex.test(resolvedRes)) {
+        const shouldBundlePages = !isAppLayer && config.bundlePagesRouterDependencies && !isOptOutBundling;
+        const shouldBeBundled = shouldBundlePages || isResourceInPackages(resolvedRes, transpiledPackages, resolvedExternalPackageDirs);
+        if (!shouldBeBundled) {
+            return `${externalType} ${request}` // Externalize if not bundled or opted out
+            ;
+        }
+    }
+}
+/**
+ * @param localRes the full path to the file
+ * @returns the externalized path
+ * @description returns an externalized path if the file is a Next.js file and ends with either `.shared-runtime.js` or `.external.js`
+ * This is used to ensure that files used across the rendering runtime(s) and the user code are one and the same. The logic in this function
+ * will rewrite the require to the correct bundle location depending on the layer at which the file is being used.
+ */ function resolveNextExternal(localRes) {
+    const isExternal = externalPattern.test(localRes);
+    // if the file ends with .external, we need to make it a commonjs require in all cases
+    // this is used mainly to share the async local storage across the routing, rendering and user layers.
+    if (isExternal) {
+        // it's important we return the path that starts with `next/dist/` here instead of the absolute path
+        // otherwise NFT will get tripped up
+        return `commonjs ${(0, _normalizepathsep.normalizePathSep)(localRes.replace(/.*?next[/\\]dist/, 'next/dist'))}`;
+    }
+}
+
+//# sourceMappingURL=handle-externals.js.map

node_modules/next/dist/build/index.d.ts

@@ -0,0 +1,224 @@
+import type { NextConfigComplete } from '../server/config-shared';
+import type { Revalidate } from '../server/lib/cache-control';
+import '../lib/setup-exception-listeners';
+import { Worker } from '../lib/worker';
+import { RSC_PREFETCH_SUFFIX, RSC_SUFFIX, RSC_SEGMENTS_DIR_SUFFIX, RSC_SEGMENT_SUFFIX } from '../lib/constants';
+import type { Header, Redirect, Rewrite, RouteHas } from '../lib/load-custom-routes';
+import type { __ApiPreviewProps } from '../server/api-utils';
+import { NEXT_ROUTER_PREFETCH_HEADER, RSC_HEADER, RSC_CONTENT_TYPE_HEADER, NEXT_DID_POSTPONE_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_REWRITTEN_PATH_HEADER, NEXT_REWRITTEN_QUERY_HEADER } from '../client/components/app-router-headers';
+import { RenderingMode } from './rendering-mode';
+import { type PrefetchSegmentDataRoute } from '../server/lib/router-utils/build-prefetch-segment-data-route';
+type Fallback = null | boolean | string;
+export interface PrerenderManifestRoute {
+    dataRoute: string | null;
+    experimentalBypassFor?: RouteHas[];
+    /**
+     * The headers that should be served along side this prerendered route.
+     */
+    initialHeaders?: Record<string, string>;
+    /**
+     * The status code that should be served along side this prerendered route.
+     */
+    initialStatus?: number;
+    /**
+     * The revalidate value for this route. This might be inferred from:
+     * - route segment configs
+     * - fetch calls
+     * - unstable_cache
+     * - "use cache"
+     */
+    initialRevalidateSeconds: Revalidate;
+    /**
+     * The expire value for this route, which is inferred from the "use cache"
+     * functions that are used by the route, or the expireTime config.
+     */
+    initialExpireSeconds: number | undefined;
+    /**
+     * The prefetch data route associated with this page. If not defined, this
+     * page does not support prefetching.
+     */
+    prefetchDataRoute: string | null | undefined;
+    /**
+     * The dynamic route that this statically prerendered route is based on. If
+     * this is null, then the route was not based on a dynamic route.
+     */
+    srcRoute: string | null;
+    /**
+     * @deprecated use `renderingMode` instead
+     */
+    experimentalPPR: boolean | undefined;
+    /**
+     * The rendering mode for this route. Only `undefined` when not an app router
+     * route.
+     */
+    renderingMode: RenderingMode | undefined;
+    /**
+     * The headers that are allowed to be used when revalidating this route. These
+     * are used internally by Next.js to revalidate routes.
+     */
+    allowHeader: string[];
+}
+export interface DynamicPrerenderManifestRoute {
+    dataRoute: string | null;
+    dataRouteRegex: string | null;
+    experimentalBypassFor?: RouteHas[];
+    fallback: Fallback;
+    /**
+     * When defined, it describes the revalidation configuration for the fallback
+     * route.
+     */
+    fallbackRevalidate: Revalidate | undefined;
+    /**
+     * When defined, it describes the expire configuration for the fallback route.
+     */
+    fallbackExpire: number | undefined;
+    /**
+     * The headers that should used when serving the fallback.
+     */
+    fallbackHeaders?: Record<string, string>;
+    /**
+     * The status code that should be used when serving the fallback.
+     */
+    fallbackStatus?: number;
+    /**
+     * The root params that are unknown for this fallback route.
+     */
+    fallbackRootParams: readonly string[] | undefined;
+    /**
+     * The source route that this fallback route is based on. This is a reference
+     * so that we can associate this dynamic route with the correct source.
+     */
+    fallbackSourceRoute: string | undefined;
+    prefetchDataRoute: string | null | undefined;
+    prefetchDataRouteRegex: string | null | undefined;
+    routeRegex: string;
+    /**
+     * @deprecated use `renderingMode` instead
+     */
+    experimentalPPR: boolean | undefined;
+    /**
+     * The rendering mode for this route. Only `undefined` when not an app router
+     * route.
+     */
+    renderingMode: RenderingMode | undefined;
+    /**
+     * The headers that are allowed to be used when revalidating this route. These
+     * are used internally by Next.js to revalidate routes.
+     */
+    allowHeader: string[];
+}
+export type PrerenderManifest = {
+    version: 4;
+    routes: {
+        [route: string]: PrerenderManifestRoute;
+    };
+    dynamicRoutes: {
+        [route: string]: DynamicPrerenderManifestRoute;
+    };
+    notFoundRoutes: string[];
+    preview: __ApiPreviewProps;
+};
+type ManifestBuiltRoute = {
+    /**
+     * The route pattern used to match requests for this route.
+     */
+    regex: string;
+};
+export type ManifestRewriteRoute = ManifestBuiltRoute & Rewrite;
+export type ManifestRedirectRoute = ManifestBuiltRoute & Redirect;
+export type ManifestHeaderRoute = ManifestBuiltRoute & Header;
+export type ManifestRoute = ManifestBuiltRoute & {
+    page: string;
+    namedRegex?: string;
+    routeKeys?: {
+        [key: string]: string;
+    };
+    prefetchSegmentDataRoutes?: PrefetchSegmentDataRoute[];
+};
+type ManifestDataRoute = {
+    page: string;
+    routeKeys?: {
+        [key: string]: string;
+    };
+    dataRouteRegex: string;
+    namedDataRouteRegex?: string;
+};
+export type RoutesManifest = {
+    version: number;
+    pages404: boolean;
+    basePath: string;
+    redirects: Array<Redirect>;
+    rewrites?: Array<ManifestRewriteRoute> | {
+        beforeFiles: Array<ManifestRewriteRoute>;
+        afterFiles: Array<ManifestRewriteRoute>;
+        fallback: Array<ManifestRewriteRoute>;
+    };
+    headers: Array<ManifestHeaderRoute>;
+    staticRoutes: Array<ManifestRoute>;
+    dynamicRoutes: Array<ManifestRoute>;
+    dataRoutes: Array<ManifestDataRoute>;
+    i18n?: {
+        domains?: ReadonlyArray<{
+            http?: true;
+            domain: string;
+            locales?: readonly string[];
+            defaultLocale: string;
+        }>;
+        locales: readonly string[];
+        defaultLocale: string;
+        localeDetection?: false;
+    };
+    rsc: {
+        header: typeof RSC_HEADER;
+        didPostponeHeader: typeof NEXT_DID_POSTPONE_HEADER;
+        contentTypeHeader: typeof RSC_CONTENT_TYPE_HEADER;
+        varyHeader: string;
+        prefetchHeader: typeof NEXT_ROUTER_PREFETCH_HEADER;
+        suffix: typeof RSC_SUFFIX;
+        prefetchSuffix: typeof RSC_PREFETCH_SUFFIX;
+        prefetchSegmentHeader: typeof NEXT_ROUTER_SEGMENT_PREFETCH_HEADER;
+        prefetchSegmentDirSuffix: typeof RSC_SEGMENTS_DIR_SUFFIX;
+        prefetchSegmentSuffix: typeof RSC_SEGMENT_SUFFIX;
+    };
+    rewriteHeaders: {
+        pathHeader: typeof NEXT_REWRITTEN_PATH_HEADER;
+        queryHeader: typeof NEXT_REWRITTEN_QUERY_HEADER;
+    };
+    skipMiddlewareUrlNormalize?: boolean;
+    caseSensitive?: boolean;
+    /**
+     * Configuration related to Partial Prerendering.
+     */
+    ppr?: {
+        /**
+         * The chained response for the PPR resume.
+         */
+        chain: {
+            /**
+             * The headers that will indicate to Next.js that the request is for a PPR
+             * resume.
+             */
+            headers: Record<string, string>;
+        };
+    };
+};
+export interface FunctionsConfigManifest {
+    version: number;
+    functions: Record<string, {
+        maxDuration?: number | undefined;
+        runtime?: 'nodejs';
+        matchers?: Array<{
+            regexp: string;
+            originalSource: string;
+            has?: Rewrite['has'];
+            missing?: Rewrite['has'];
+        }>;
+    }>;
+}
+type StaticWorker = typeof import('./worker') & Worker;
+export declare function createStaticWorker(config: NextConfigComplete, progress?: {
+    run: () => void;
+    clear: () => void;
+}): StaticWorker;
+export default function build(dir: string, reactProductionProfiling: boolean | undefined, debugOutput: boolean | undefined, runLint: boolean | undefined, noMangling: boolean | undefined, appDirOnly: boolean | undefined, turboNextBuild: boolean | undefined, experimentalBuildMode: 'default' | 'compile' | 'generate', traceUploadUrl: string | undefined): Promise<void>;
+export {};

node_modules/next/dist/build/is-writeable.d.ts

@@ -0,0 +1 @@
+export declare function isWriteable(directory: string): Promise<boolean>;

node_modules/next/dist/build/is-writeable.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isWriteable", {
+    enumerable: true,
+    get: function() {
+        return isWriteable;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function isWriteable(directory) {
+    try {
+        await _fs.default.promises.access(directory, (_fs.default.constants || _fs.default).W_OK);
+        return true;
+    } catch (err) {
+        return false;
+    }
+}
+
+//# sourceMappingURL=is-writeable.js.map

node_modules/next/dist/build/is-writeable.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/build/is-writeable.ts"],"sourcesContent":["import fs from 'fs'\n\nexport async function isWriteable(directory: string): Promise<boolean> {\n  try {\n    await fs.promises.access(directory, (fs.constants || fs).W_OK)\n    return true\n  } catch (err) {\n    return false\n  }\n}\n"],"names":["isWriteable","directory","fs","promises","access","constants","W_OK","err"],"mappings":";;;;+BAEsBA;;;eAAAA;;;2DAFP;;;;;;AAER,eAAeA,YAAYC,SAAiB;IACjD,IAAI;QACF,MAAMC,WAAE,CAACC,QAAQ,CAACC,MAAM,CAACH,WAAW,AAACC,CAAAA,WAAE,CAACG,SAAS,IAAIH,WAAE,AAAD,EAAGI,IAAI;QAC7D,OAAO;IACT,EAAE,OAAOC,KAAK;QACZ,OAAO;IACT;AACF"}

node_modules/next/dist/build/jest/__mocks__/empty.js

@@ -0,0 +1,10 @@
+// this empty files is only here to mock server-only imports
+"use strict";
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=empty.js.map

node_modules/next/dist/build/jest/__mocks__/empty.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/jest/__mocks__/empty.ts"],"sourcesContent":["// this empty files is only here to mock server-only imports\n"],"names":[],"mappings":"AAAA,4DAA4D"}

node_modules/next/dist/build/jest/__mocks__/fileMock.js

@@ -0,0 +1,15 @@
+"use strict";
+module.exports = {
+    src: '/img.jpg',
+    height: 40,
+    width: 40,
+    blurDataURL: 'data:image/png;base64,imagedata'
+};
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=fileMock.js.map

node_modules/next/dist/build/jest/__mocks__/fileMock.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/jest/__mocks__/fileMock.ts"],"sourcesContent":["module.exports = {\n  src: '/img.jpg',\n  height: 40,\n  width: 40,\n  blurDataURL: 'data:image/png;base64,imagedata',\n}\n"],"names":["module","exports","src","height","width","blurDataURL"],"mappings":";AAAAA,OAAOC,OAAO,GAAG;IACfC,KAAK;IACLC,QAAQ;IACRC,OAAO;IACPC,aAAa;AACf"}

node_modules/next/dist/build/jest/__mocks__/nextFontMock.js

@@ -0,0 +1,20 @@
+"use strict";
+module.exports = new Proxy({}, {
+    get: function getter() {
+        return ()=>({
+                className: 'className',
+                variable: 'variable',
+                style: {
+                    fontFamily: 'fontFamily'
+                }
+            });
+    }
+});
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=nextFontMock.js.map

node_modules/next/dist/build/jest/__mocks__/nextFontMock.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/build/jest/__mocks__/nextFontMock.ts"],"sourcesContent":["module.exports = new Proxy(\n  {},\n  {\n    get: function getter() {\n      return () => ({\n        className: 'className',\n        variable: 'variable',\n        style: { fontFamily: 'fontFamily' },\n      })\n    },\n  }\n)\n"],"names":["module","exports","Proxy","get","getter","className","variable","style","fontFamily"],"mappings":";AAAAA,OAAOC,OAAO,GAAG,IAAIC,MACnB,CAAC,GACD;IACEC,KAAK,SAASC;QACZ,OAAO,IAAO,CAAA;gBACZC,WAAW;gBACXC,UAAU;gBACVC,OAAO;oBAAEC,YAAY;gBAAa;YACpC,CAAA;IACF;AACF"}