Initial boiler plate project

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

@@ -0,0 +1,187 @@
+export 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";
+}
+export 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 {
+        throw new UnsupportedValueError(`Unsupported node type "${node.type}"`, path);
+    }
+}
+/**
+ * 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 function extractExportedConstValue(module, exportedName) {
+    for (const moduleItem of module.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/esm/build/analysis/extract-const-value.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/build/analysis/extract-const-value.ts"],"names":["NoSuchDeclarationError","Error","isExportDeclaration","node","type","isVariableDeclaration","isIdentifier","isBooleanLiteral","isNullLiteral","isStringLiteral","isNumericLiteral","isArrayExpression","isObjectExpression","isKeyValueProperty","isRegExpLiteral","isTemplateLiteral","UnsupportedValueError","constructor","message","paths","codePath","path","extractValue","value","RegExp","pattern","flags","undefined","arr","i","len","elements","length","elem","spread","push","expression","obj","prop","properties","key","expressions","cooked","raw","quasis","extractExportedConstValue","module","exportedName","moduleItem","body","declaration","kind","decl","declarations","id","init"],"mappings":"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"}

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

@@ -0,0 +1,426 @@
+import { promises as fs } from "fs";
+import LRUCache from "next/dist/compiled/lru-cache";
+import picomatch from "next/dist/compiled/picomatch";
+import { extractExportedConstValue, UnsupportedValueError } from "./extract-const-value";
+import { parseModule } from "./parse-module";
+import * as Log from "../output/log";
+import { SERVER_RUNTIME } from "../../lib/constants";
+import { checkCustomRoutes } from "../../lib/load-custom-routes";
+import { tryToParsePath } from "../../lib/try-to-parse-path";
+import { isAPIRoute } from "../../lib/is-api-route";
+import { isEdgeRuntime } from "../../lib/is-edge-runtime";
+import { RSC_MODULE_TYPES } from "../../shared/lib/constants";
+import { PAGE_TYPES } from "../../lib/page-types";
+// TODO: migrate preferredRegion here
+// Don't forget to update the next-types-plugin file as well
+const AUTHORIZED_EXTRA_ROUTER_PROPS = [
+    "maxDuration"
+];
+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";
+export function getRSCModuleInformation(source, isReactServerLayer) {
+    var _clientInfoMatch_;
+    const actionsJson = source.match(ACTION_MODULE_LABEL);
+    const actions = actionsJson ? Object.values(JSON.parse(actionsJson[1])) : undefined;
+    const clientInfoMatch = source.match(CLIENT_MODULE_LABEL);
+    const isClientRef = !!clientInfoMatch;
+    if (!isReactServerLayer) {
+        return {
+            type: RSC_MODULE_TYPES.client,
+            actions,
+            isClientRef
+        };
+    }
+    const clientRefs = clientInfoMatch == null ? void 0 : (_clientInfoMatch_ = clientInfoMatch[1]) == null ? void 0 : _clientInfoMatch_.split(",");
+    const clientEntryType = clientInfoMatch == null ? void 0 : clientInfoMatch[2];
+    const type = clientRefs ? RSC_MODULE_TYPES.client : RSC_MODULE_TYPES.server;
+    return {
+        type,
+        actions,
+        clientRefs,
+        clientEntryType,
+        isClientRef
+    };
+}
+const warnedInvalidValueMap = {
+    runtime: new Map(),
+    preferredRegion: new Map()
+};
+function warnInvalidValue(pageFilePath, key, message) {
+    if (warnedInvalidValueMap[key].has(pageFilePath)) return;
+    Log.warn(`Next.js can't recognize the exported \`${key}\` field in "${pageFilePath}" as ${message}.` + "\n" + "The default runtime will be used instead.");
+    warnedInvalidValueMap[key].set(pageFilePath, true);
+}
+/**
+ * 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(swcAST, pageFilePath) {
+    const exportsSet = new Set([
+        "getStaticProps",
+        "getServerSideProps",
+        "generateImageMetadata",
+        "generateSitemaps",
+        "generateStaticParams"
+    ]);
+    if (Array.isArray(swcAST == null ? void 0 : swcAST.body)) {
+        try {
+            let runtime;
+            let preferredRegion;
+            let ssr = false;
+            let ssg = false;
+            let generateImageMetadata = false;
+            let generateSitemaps = false;
+            let generateStaticParams = false;
+            let extraProperties = new Set();
+            let directives = new Set();
+            let hasLeadingNonDirectiveNode = false;
+            for (const node of swcAST.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 (declaration.id.value === "runtime") {
+                            runtime = declaration.init.value;
+                        } else if (declaration.id.value === "preferredRegion") {
+                            if (declaration.init.type === "ArrayExpression") {
+                                const elements = [];
+                                for (const element of declaration.init.elements){
+                                    const { expression } = element;
+                                    if (expression.type !== "StringLiteral") {
+                                        continue;
+                                    }
+                                    elements.push(expression.value);
+                                }
+                                preferredRegion = elements;
+                            } else {
+                                preferredRegion = declaration.init.value;
+                            }
+                        } else {
+                            extraProperties.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;
+                    ssg = id === "getStaticProps";
+                    ssr = id === "getServerSideProps";
+                    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)) {
+                        ssg = id === "getStaticProps";
+                        ssr = id === "getServerSideProps";
+                        generateImageMetadata = id === "generateImageMetadata";
+                        generateSitemaps = id === "generateSitemaps";
+                        generateStaticParams = id === "generateStaticParams";
+                    }
+                }
+                if (node.type === "ExportNamedDeclaration") {
+                    const values = node.specifiers.map((specifier)=>{
+                        var _specifier_orig, _specifier_orig1;
+                        return specifier.type === "ExportSpecifier" && ((_specifier_orig = specifier.orig) == null ? void 0 : _specifier_orig.type) === "Identifier" && ((_specifier_orig1 = specifier.orig) == null ? void 0 : _specifier_orig1.value);
+                    });
+                    for (const value of values){
+                        if (!ssg && value === "getStaticProps") ssg = true;
+                        if (!ssr && value === "getServerSideProps") ssr = true;
+                        if (!generateImageMetadata && value === "generateImageMetadata") generateImageMetadata = true;
+                        if (!generateSitemaps && value === "generateSitemaps") generateSitemaps = true;
+                        if (!generateStaticParams && value === "generateStaticParams") generateStaticParams = true;
+                        if (!runtime && value === "runtime") warnInvalidValue(pageFilePath, "runtime", "it was not assigned to a string literal");
+                        if (!preferredRegion && value === "preferredRegion") warnInvalidValue(pageFilePath, "preferredRegion", "it was not assigned to a string literal or an array of string literals");
+                    }
+                }
+            }
+            return {
+                ssr,
+                ssg,
+                runtime,
+                preferredRegion,
+                generateImageMetadata,
+                generateSitemaps,
+                generateStaticParams,
+                extraProperties,
+                directives
+            };
+        } catch (err) {}
+    }
+    return {
+        ssg: false,
+        ssr: false,
+        runtime: undefined,
+        preferredRegion: undefined,
+        generateImageMetadata: false,
+        generateSitemaps: false,
+        generateStaticParams: false,
+        extraProperties: undefined,
+        directives: undefined
+    };
+}
+async function tryToReadFile(filePath, shouldThrow) {
+    try {
+        return await fs.readFile(filePath, {
+            encoding: "utf8"
+        });
+    } catch (error) {
+        if (shouldThrow) {
+            error.message = `Next.js ERROR: Failed to read file ${filePath}:\n${error.message}`;
+            throw error;
+        }
+    }
+}
+export function getMiddlewareMatchers(matcherOrMatchers, nextConfig) {
+    let matchers = [];
+    if (Array.isArray(matcherOrMatchers)) {
+        matchers = matcherOrMatchers;
+    } else {
+        matchers.push(matcherOrMatchers);
+    }
+    const { i18n } = nextConfig;
+    const originalSourceMap = new Map();
+    let routes = matchers.map((m)=>{
+        let middleware = typeof m === "string" ? {
+            source: m
+        } : m;
+        if (middleware) {
+            originalSourceMap.set(middleware, middleware.source);
+        }
+        return middleware;
+    });
+    // check before we process the routes and after to ensure
+    // they are still valid
+    checkCustomRoutes(routes, "middleware");
+    routes = routes.map((r)=>{
+        let { source } = r;
+        const isRoot = source === "/";
+        if ((i18n == null ? void 0 : i18n.locales) && r.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}`;
+        }
+        r.source = source;
+        return r;
+    });
+    checkCustomRoutes(routes, "middleware");
+    return routes.map((r)=>{
+        const { source, ...rest } = r;
+        const parsedPage = tryToParsePath(source);
+        if (parsedPage.error || !parsedPage.regexStr) {
+            throw new Error(`Invalid source: ${source}`);
+        }
+        const originalSource = originalSourceMap.get(r);
+        return {
+            ...rest,
+            regexp: parsedPage.regexStr,
+            originalSource: originalSource || source
+        };
+    });
+}
+function getMiddlewareConfig(pageFilePath, config, nextConfig) {
+    const result = {};
+    if (config.matcher) {
+        result.matchers = getMiddlewareMatchers(config.matcher, nextConfig);
+    }
+    if (typeof config.regions === "string" || Array.isArray(config.regions)) {
+        result.regions = config.regions;
+    } else if (typeof config.regions !== "undefined") {
+        Log.warn(`The \`regions\` config was ignored: config must be empty, a string or an array of strings. (${pageFilePath})`);
+    }
+    if (config.unstable_allowDynamic) {
+        result.unstable_allowDynamicGlobs = Array.isArray(config.unstable_allowDynamic) ? config.unstable_allowDynamic : [
+            config.unstable_allowDynamic
+        ];
+        for (const glob of result.unstable_allowDynamicGlobs ?? []){
+            try {
+                picomatch(glob);
+            } catch (err) {
+                throw new Error(`${pageFilePath} exported 'config.unstable_allowDynamic' contains invalid pattern '${glob}': ${err.message}`);
+            }
+        }
+    }
+    return result;
+}
+const apiRouteWarnings = new LRUCache({
+    max: 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);
+}
+const warnedUnsupportedValueMap = new LRUCache({
+    max: 250
+});
+function warnAboutUnsupportedValue(pageFilePath, page, error) {
+    if (warnedUnsupportedValueMap.has(pageFilePath)) {
+        return;
+    }
+    Log.warn(`Next.js can't recognize the exported \`config\` field in ` + (page ? `route "${page}"` : `"${pageFilePath}"`) + ":\n" + error.message + (error.path ? ` at "${error.path}"` : "") + ".\n" + "The default config will be used instead.\n" + "Read More - https://nextjs.org/docs/messages/invalid-page-config");
+    warnedUnsupportedValueMap.set(pageFilePath, true);
+}
+// Detect if metadata routes is a dynamic route, which containing
+// generateImageMetadata or generateSitemaps as export
+export async function isDynamicMetadataRoute(pageFilePath) {
+    const fileContent = await tryToReadFile(pageFilePath, true) || "";
+    if (/generateImageMetadata|generateSitemaps/.test(fileContent)) {
+        const swcAST = await parseModule(pageFilePath, fileContent);
+        const exportsInfo = checkExports(swcAST, pageFilePath);
+        return !!(exportsInfo.generateImageMetadata || exportsInfo.generateSitemaps);
+    }
+    return false;
+}
+/**
+ * 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 async function getPageStaticInfo(params) {
+    const { isDev, pageFilePath, nextConfig, page, pageType } = params;
+    const fileContent = await tryToReadFile(pageFilePath, !isDev) || "";
+    if (/(?<!(_jsx|jsx-))runtime|preferredRegion|getStaticProps|getServerSideProps|generateStaticParams|export const/.test(fileContent)) {
+        const swcAST = await parseModule(pageFilePath, fileContent);
+        const { ssg, ssr, runtime, preferredRegion, generateStaticParams, extraProperties, directives } = checkExports(swcAST, pageFilePath);
+        const rscInfo = getRSCModuleInformation(fileContent, true);
+        const rsc = rscInfo.type;
+        // default / failsafe value for config
+        let config// TODO: type this as unknown
+        ;
+        try {
+            config = extractExportedConstValue(swcAST, "config");
+        } catch (e) {
+            if (e instanceof UnsupportedValueError) {
+                warnAboutUnsupportedValue(pageFilePath, page, e);
+            }
+        // `export config` doesn't exist, or other unknown error thrown by swc, silence them
+        }
+        const extraConfig = {};
+        if (extraProperties && pageType === PAGE_TYPES.APP) {
+            for (const prop of extraProperties){
+                if (!AUTHORIZED_EXTRA_ROUTER_PROPS.includes(prop)) continue;
+                try {
+                    extraConfig[prop] = extractExportedConstValue(swcAST, prop);
+                } catch (e) {
+                    if (e instanceof UnsupportedValueError) {
+                        warnAboutUnsupportedValue(pageFilePath, page, e);
+                    }
+                }
+            }
+        } else if (pageType === PAGE_TYPES.PAGES) {
+            for(const key in config){
+                if (!AUTHORIZED_EXTRA_ROUTER_PROPS.includes(key)) continue;
+                extraConfig[key] = config[key];
+            }
+        }
+        if (pageType === PAGE_TYPES.APP) {
+            if (config) {
+                let message = `Page config in ${pageFilePath} is deprecated. Replace \`export const config=…\` with the following:`;
+                if (config.runtime) {
+                    message += `\n  - \`export const runtime = ${JSON.stringify(config.runtime)}\``;
+                }
+                if (config.regions) {
+                    message += `\n  - \`export const preferredRegion = ${JSON.stringify(config.regions)}\``;
+                }
+                message += `\nVisit https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config for more information.`;
+                if (isDev) {
+                    Log.warnOnce(message);
+                } else {
+                    throw new Error(message);
+                }
+                config = {};
+            }
+        }
+        if (!config) config = {};
+        // We use `export const config = { runtime: '...' }` to specify the page runtime for pages/.
+        // In the new app directory, we prefer to use `export const runtime = '...'`
+        // and deprecate the old way. To prevent breaking changes for `pages`, we use the exported config
+        // as the fallback value.
+        let resolvedRuntime;
+        if (pageType === PAGE_TYPES.APP) {
+            resolvedRuntime = runtime;
+        } else {
+            resolvedRuntime = runtime || config.runtime;
+        }
+        if (typeof resolvedRuntime !== "undefined" && resolvedRuntime !== SERVER_RUNTIME.nodejs && !isEdgeRuntime(resolvedRuntime)) {
+            const options = Object.values(SERVER_RUNTIME).join(", ");
+            const message = typeof resolvedRuntime !== "string" ? `The \`runtime\` config must be a string. Please leave it empty or choose one of: ${options}` : `Provided runtime "${resolvedRuntime}" is not supported. Please leave it empty or choose one of: ${options}`;
+            if (isDev) {
+                Log.error(message);
+            } else {
+                throw new Error(message);
+            }
+        }
+        const requiresServerRuntime = ssr || ssg || pageType === PAGE_TYPES.APP;
+        const isAnAPIRoute = isAPIRoute(page == null ? void 0 : page.replace(/^(?:\/src)?\/pages\//, "/"));
+        resolvedRuntime = isEdgeRuntime(resolvedRuntime) || requiresServerRuntime ? resolvedRuntime : undefined;
+        if (resolvedRuntime === SERVER_RUNTIME.experimentalEdge) {
+            warnAboutExperimentalEdge(isAnAPIRoute ? page : null);
+        }
+        if (resolvedRuntime === SERVER_RUNTIME.edge && pageType === PAGE_TYPES.PAGES && 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 new Error(message);
+            }
+        }
+        const middlewareConfig = getMiddlewareConfig(page ?? "middleware/edge API route", config, nextConfig);
+        if (pageType === PAGE_TYPES.APP && (directives == null ? void 0 : directives.has("client")) && generateStaticParams) {
+            throw new Error(`Page "${page}" cannot use both "use client" and export function "generateStaticParams()".`);
+        }
+        return {
+            ssr,
+            ssg,
+            rsc,
+            generateStaticParams,
+            amp: config.amp || false,
+            ...middlewareConfig && {
+                middleware: middlewareConfig
+            },
+            ...resolvedRuntime && {
+                runtime: resolvedRuntime
+            },
+            preferredRegion,
+            extraConfig
+        };
+    }
+    return {
+        ssr: false,
+        ssg: false,
+        rsc: RSC_MODULE_TYPES.server,
+        generateStaticParams: false,
+        amp: false,
+        runtime: undefined
+    };
+}
+
+//# sourceMappingURL=get-page-static-info.js.map

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

@@ -0,0 +1,15 @@
+import LRUCache from "next/dist/compiled/lru-cache";
+import { withPromiseCache } from "../../lib/with-promise-cache";
+import { createHash } from "crypto";
+import { parse } from "../swc";
+/**
+ * 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 const parseModule = withPromiseCache(new LRUCache({
+    max: 500
+}), async (filename, content)=>parse(content, {
+        isModule: "unknown",
+        filename
+    }).catch(()=>null), (_, content)=>createHash("sha1").update(content).digest("hex"));
+
+//# sourceMappingURL=parse-module.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/build/analysis/parse-module.ts"],"names":["LRUCache","withPromiseCache","createHash","parse","parseModule","max","filename","content","isModule","catch","_","update","digest"],"mappings":"AAAA,OAAOA,cAAc,+BAA8B;AACnD,SAASC,gBAAgB,QAAQ,+BAA8B;AAC/D,SAASC,UAAU,QAAQ,SAAQ;AACnC,SAASC,KAAK,QAAQ,SAAQ;AAE9B;;;CAGC,GACD,OAAO,MAAMC,cAAcH,iBACzB,IAAID,SAAsB;IAAEK,KAAK;AAAI,IACrC,OAAOC,UAAkBC,UACvBJ,MAAMI,SAAS;QAAEC,UAAU;QAAWF;IAAS,GAAGG,KAAK,CAAC,IAAM,OAChE,CAACC,GAAGH,UAAYL,WAAW,QAAQS,MAAM,CAACJ,SAASK,MAAM,CAAC,QAC3D"}