Initial boiler plate project

node_modules/next/dist/server/lib/router-utils/build-data-route.d.ts

@@ -0,0 +1,8 @@
+export declare function buildDataRoute(page: string, buildId: string): {
+    page: string;
+    routeKeys: {
+        [named: string]: string;
+    } | undefined;
+    dataRouteRegex: string;
+    namedDataRouteRegex: string | undefined;
+};

node_modules/next/dist/server/lib/router-utils/build-data-route.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "buildDataRoute", {
+    enumerable: true,
+    get: function() {
+        return buildDataRoute;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("../../../shared/lib/isomorphic/path"));
+const _normalizepagepath = require("../../../shared/lib/page-path/normalize-page-path");
+const _isdynamic = require("../../../shared/lib/router/utils/is-dynamic");
+const _routeregex = require("../../../shared/lib/router/utils/route-regex");
+const _loadcustomroutes = require("../../../lib/load-custom-routes");
+const _escaperegexp = require("../../../shared/lib/escape-regexp");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function buildDataRoute(page, buildId) {
+    const pagePath = (0, _normalizepagepath.normalizePagePath)(page);
+    const dataRoute = _path.default.posix.join("/_next/data", buildId, `${pagePath}.json`);
+    let dataRouteRegex;
+    let namedDataRouteRegex;
+    let routeKeys;
+    if ((0, _isdynamic.isDynamicRoute)(page)) {
+        const routeRegex = (0, _routeregex.getNamedRouteRegex)(dataRoute.replace(/\.json$/, ""), true);
+        dataRouteRegex = (0, _loadcustomroutes.normalizeRouteRegex)(routeRegex.re.source.replace(/\(\?:\\\/\)\?\$$/, `\\.json$`));
+        namedDataRouteRegex = routeRegex.namedRegex.replace(/\(\?:\/\)\?\$$/, `\\.json$`);
+        routeKeys = routeRegex.routeKeys;
+    } else {
+        dataRouteRegex = (0, _loadcustomroutes.normalizeRouteRegex)(new RegExp(`^${_path.default.posix.join("/_next/data", (0, _escaperegexp.escapeStringRegexp)(buildId), `${pagePath}.json`)}$`).source);
+    }
+    return {
+        page,
+        routeKeys,
+        dataRouteRegex,
+        namedDataRouteRegex
+    };
+}
+
+//# sourceMappingURL=build-data-route.js.map

node_modules/next/dist/server/lib/router-utils/build-data-route.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/lib/router-utils/build-data-route.ts"],"names":["buildDataRoute","page","buildId","pagePath","normalizePagePath","dataRoute","path","posix","join","dataRouteRegex","namedDataRouteRegex","routeKeys","isDynamicRoute","routeRegex","getNamedRouteRegex","replace","normalizeRouteRegex","re","source","namedRegex","RegExp","escapeStringRegexp"],"mappings":";;;;+BAOgBA;;;eAAAA;;;6DAPC;mCACiB;2BACH;4BACI;kCACC;8BACD;;;;;;AAE5B,SAASA,eAAeC,IAAY,EAAEC,OAAe;IAC1D,MAAMC,WAAWC,IAAAA,oCAAiB,EAACH;IACnC,MAAMI,YAAYC,aAAI,CAACC,KAAK,CAACC,IAAI,CAAC,eAAeN,SAAS,CAAC,EAAEC,SAAS,KAAK,CAAC;IAE5E,IAAIM;IACJ,IAAIC;IACJ,IAAIC;IAEJ,IAAIC,IAAAA,yBAAc,EAACX,OAAO;QACxB,MAAMY,aAAaC,IAAAA,8BAAkB,EACnCT,UAAUU,OAAO,CAAC,WAAW,KAC7B;QAGFN,iBAAiBO,IAAAA,qCAAmB,EAClCH,WAAWI,EAAE,CAACC,MAAM,CAACH,OAAO,CAAC,oBAAoB,CAAC,QAAQ,CAAC;QAE7DL,sBAAsBG,WAAWM,UAAU,CAAEJ,OAAO,CAClD,kBACA,CAAC,QAAQ,CAAC;QAEZJ,YAAYE,WAAWF,SAAS;IAClC,OAAO;QACLF,iBAAiBO,IAAAA,qCAAmB,EAClC,IAAII,OACF,CAAC,CAAC,EAAEd,aAAI,CAACC,KAAK,CAACC,IAAI,CACjB,eACAa,IAAAA,gCAAkB,EAACnB,UACnB,CAAC,EAAEC,SAAS,KAAK,CAAC,EAClB,CAAC,CAAC,EACJe,MAAM;IAEZ;IAEA,OAAO;QACLjB;QACAU;QACAF;QACAC;IACF;AACF"}

node_modules/next/dist/server/lib/router-utils/filesystem.d.ts

@@ -0,0 +1,76 @@
+import type { ManifestRoute, PrerenderManifest } from '../../../build';
+import type { NextConfigComplete } from '../../config-shared';
+import type { PatchMatcher } from '../../../shared/lib/router/utils/path-match';
+import type { MiddlewareRouteMatch } from '../../../shared/lib/router/utils/middleware-route-matcher';
+import { type Rewrite } from '../../../lib/load-custom-routes';
+export type FsOutput = {
+    type: 'appFile' | 'pageFile' | 'nextImage' | 'publicFolder' | 'nextStaticFolder' | 'legacyStaticFolder' | 'devVirtualFsItem';
+    itemPath: string;
+    fsPath?: string;
+    itemsRoot?: string;
+    locale?: string;
+};
+export type FilesystemDynamicRoute = ManifestRoute & {
+    /**
+     * The path matcher that can be used to match paths against this route.
+     */
+    match: PatchMatcher;
+};
+export declare const buildCustomRoute: <T>(type: 'redirect' | 'header' | 'rewrite' | 'before_files_rewrite', item: T & {
+    source: string;
+}, basePath?: string, caseSensitive?: boolean) => T & {
+    match: PatchMatcher;
+    check?: boolean | undefined;
+};
+export declare function setupFsCheck(opts: {
+    dir: string;
+    dev: boolean;
+    minimalMode?: boolean;
+    config: NextConfigComplete;
+    addDevWatcherCallback?: (arg: (files: Map<string, {
+        timestamp: number;
+    }>) => void) => void;
+}): Promise<{
+    headers: (import("../../../lib/load-custom-routes").Header & {
+        match: PatchMatcher;
+        check?: boolean | undefined;
+    })[];
+    rewrites: {
+        beforeFiles: (Rewrite & {
+            match: PatchMatcher;
+            check?: boolean | undefined;
+        })[];
+        afterFiles: (Rewrite & {
+            match: PatchMatcher;
+            check?: boolean | undefined;
+        })[];
+        fallback: (Rewrite & {
+            match: PatchMatcher;
+            check?: boolean | undefined;
+        })[];
+    };
+    redirects: (import("../../../lib/load-custom-routes").Redirect & {
+        match: PatchMatcher;
+        check?: boolean | undefined;
+    })[];
+    buildId: string;
+    handleLocale: (pathname: string, locales?: string[]) => {
+        locale: string | undefined;
+        pathname: string;
+    };
+    appFiles: Set<string>;
+    pageFiles: Set<string>;
+    dynamicRoutes: FilesystemDynamicRoute[];
+    nextDataRoutes: Set<string>;
+    exportPathMapRoutes: (Rewrite & {
+        match: PatchMatcher;
+        check?: boolean | undefined;
+    })[] | undefined;
+    devVirtualFsItems: Set<string>;
+    prerenderManifest: PrerenderManifest;
+    middlewareMatcher: MiddlewareRouteMatch | undefined;
+    ensureCallback(fn: (item: FsOutput) => Promise<void> | undefined): void;
+    getItem(itemPath: string): Promise<FsOutput | null>;
+    getDynamicRoutes(): FilesystemDynamicRoute[];
+    getMiddlewareMatchers(): MiddlewareRouteMatch | undefined;
+}>;

node_modules/next/dist/server/lib/router-utils/filesystem.js

@@ -0,0 +1,536 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    buildCustomRoute: null,
+    setupFsCheck: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    buildCustomRoute: function() {
+        return buildCustomRoute;
+    },
+    setupFsCheck: function() {
+        return setupFsCheck;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _promises = /*#__PURE__*/ _interop_require_default(require("fs/promises"));
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../build/output/log"));
+const _debug = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/debug"));
+const _lrucache = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/lru-cache"));
+const _loadcustomroutes = /*#__PURE__*/ _interop_require_default(require("../../../lib/load-custom-routes"));
+const _redirectstatus = require("../../../lib/redirect-status");
+const _fileexists = require("../../../lib/file-exists");
+const _recursivereaddir = require("../../../lib/recursive-readdir");
+const _utils = require("../../../shared/lib/router/utils");
+const _escaperegexp = require("../../../shared/lib/escape-regexp");
+const _pathmatch = require("../../../shared/lib/router/utils/path-match");
+const _routeregex = require("../../../shared/lib/router/utils/route-regex");
+const _routematcher = require("../../../shared/lib/router/utils/route-matcher");
+const _pathhasprefix = require("../../../shared/lib/router/utils/path-has-prefix");
+const _normalizelocalepath = require("../../../shared/lib/i18n/normalize-locale-path");
+const _removepathprefix = require("../../../shared/lib/router/utils/remove-path-prefix");
+const _middlewareroutematcher = require("../../../shared/lib/router/utils/middleware-route-matcher");
+const _constants = require("../../../shared/lib/constants");
+const _normalizepathsep = require("../../../shared/lib/page-path/normalize-path-sep");
+const _getmetadataroute = require("../../../lib/metadata/get-metadata-route");
+const _rsc = require("../../future/normalizers/request/rsc");
+const _postponed = require("../../future/normalizers/request/postponed");
+const _prefetchrsc = require("../../future/normalizers/request/prefetch-rsc");
+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:router-server:filesystem");
+const buildCustomRoute = (type, item, basePath, caseSensitive)=>{
+    const restrictedRedirectPaths = [
+        "/_next"
+    ].map((p)=>basePath ? `${basePath}${p}` : p);
+    const match = (0, _pathmatch.getPathMatch)(item.source, {
+        strict: true,
+        removeUnnamedParams: true,
+        regexModifier: !item.internal ? (regex)=>(0, _redirectstatus.modifyRouteRegex)(regex, type === "redirect" ? restrictedRedirectPaths : undefined) : undefined,
+        sensitive: caseSensitive
+    });
+    return {
+        ...item,
+        ...type === "rewrite" ? {
+            check: true
+        } : {},
+        match
+    };
+};
+async function setupFsCheck(opts) {
+    const getItemsLru = !opts.dev ? new _lrucache.default({
+        max: 1024 * 1024,
+        length (value, key) {
+            if (!value) return (key == null ? void 0 : key.length) || 0;
+            return (key || "").length + (value.fsPath || "").length + value.itemPath.length + value.type.length;
+        }
+    }) : undefined;
+    // routes that have _next/data endpoints (SSG/SSP)
+    const nextDataRoutes = new Set();
+    const publicFolderItems = new Set();
+    const nextStaticFolderItems = new Set();
+    const legacyStaticFolderItems = new Set();
+    const appFiles = new Set();
+    const pageFiles = new Set();
+    let dynamicRoutes = [];
+    let middlewareMatcher = ()=>false;
+    const distDir = _path.default.join(opts.dir, opts.config.distDir);
+    const publicFolderPath = _path.default.join(opts.dir, "public");
+    const nextStaticFolderPath = _path.default.join(distDir, "static");
+    const legacyStaticFolderPath = _path.default.join(opts.dir, "static");
+    let customRoutes = {
+        redirects: [],
+        rewrites: {
+            beforeFiles: [],
+            afterFiles: [],
+            fallback: []
+        },
+        headers: []
+    };
+    let buildId = "development";
+    let prerenderManifest;
+    if (!opts.dev) {
+        var _middlewareManifest_middleware_, _middlewareManifest_middleware;
+        const buildIdPath = _path.default.join(opts.dir, opts.config.distDir, _constants.BUILD_ID_FILE);
+        try {
+            buildId = await _promises.default.readFile(buildIdPath, "utf8");
+        } catch (err) {
+            if (err.code !== "ENOENT") throw err;
+            throw new Error(`Could not find a production build in the '${opts.config.distDir}' directory. Try building your app with 'next build' before starting the production server. https://nextjs.org/docs/messages/production-start-no-build-id`);
+        }
+        try {
+            for (const file of (await (0, _recursivereaddir.recursiveReadDir)(publicFolderPath))){
+                // Ensure filename is encoded and normalized.
+                publicFolderItems.add(encodeURI((0, _normalizepathsep.normalizePathSep)(file)));
+            }
+        } catch (err) {
+            if (err.code !== "ENOENT") {
+                throw err;
+            }
+        }
+        try {
+            for (const file of (await (0, _recursivereaddir.recursiveReadDir)(legacyStaticFolderPath))){
+                // Ensure filename is encoded and normalized.
+                legacyStaticFolderItems.add(encodeURI((0, _normalizepathsep.normalizePathSep)(file)));
+            }
+            _log.warn(`The static directory has been deprecated in favor of the public directory. https://nextjs.org/docs/messages/static-dir-deprecated`);
+        } catch (err) {
+            if (err.code !== "ENOENT") {
+                throw err;
+            }
+        }
+        try {
+            for (const file of (await (0, _recursivereaddir.recursiveReadDir)(nextStaticFolderPath))){
+                // Ensure filename is encoded and normalized.
+                nextStaticFolderItems.add(_path.default.posix.join("/_next/static", encodeURI((0, _normalizepathsep.normalizePathSep)(file))));
+            }
+        } catch (err) {
+            if (opts.config.output !== "standalone") throw err;
+        }
+        const routesManifestPath = _path.default.join(distDir, _constants.ROUTES_MANIFEST);
+        const prerenderManifestPath = _path.default.join(distDir, _constants.PRERENDER_MANIFEST);
+        const middlewareManifestPath = _path.default.join(distDir, "server", _constants.MIDDLEWARE_MANIFEST);
+        const pagesManifestPath = _path.default.join(distDir, "server", _constants.PAGES_MANIFEST);
+        const appRoutesManifestPath = _path.default.join(distDir, _constants.APP_PATH_ROUTES_MANIFEST);
+        const routesManifest = JSON.parse(await _promises.default.readFile(routesManifestPath, "utf8"));
+        prerenderManifest = JSON.parse(await _promises.default.readFile(prerenderManifestPath, "utf8"));
+        const middlewareManifest = JSON.parse(await _promises.default.readFile(middlewareManifestPath, "utf8").catch(()=>"{}"));
+        const pagesManifest = JSON.parse(await _promises.default.readFile(pagesManifestPath, "utf8"));
+        const appRoutesManifest = JSON.parse(await _promises.default.readFile(appRoutesManifestPath, "utf8").catch(()=>"{}"));
+        for (const key of Object.keys(pagesManifest)){
+            // ensure the non-locale version is in the set
+            if (opts.config.i18n) {
+                pageFiles.add((0, _normalizelocalepath.normalizeLocalePath)(key, opts.config.i18n.locales).pathname);
+            } else {
+                pageFiles.add(key);
+            }
+        }
+        for (const key of Object.keys(appRoutesManifest)){
+            appFiles.add(appRoutesManifest[key]);
+        }
+        const escapedBuildId = (0, _escaperegexp.escapeStringRegexp)(buildId);
+        for (const route of routesManifest.dataRoutes){
+            if ((0, _utils.isDynamicRoute)(route.page)) {
+                const routeRegex = (0, _routeregex.getRouteRegex)(route.page);
+                dynamicRoutes.push({
+                    ...route,
+                    regex: routeRegex.re.toString(),
+                    match: (0, _routematcher.getRouteMatcher)({
+                        // TODO: fix this in the manifest itself, must also be fixed in
+                        // upstream builder that relies on this
+                        re: opts.config.i18n ? new RegExp(route.dataRouteRegex.replace(`/${escapedBuildId}/`, `/${escapedBuildId}/(?<nextLocale>[^/]+?)/`)) : new RegExp(route.dataRouteRegex),
+                        groups: routeRegex.groups
+                    })
+                });
+            }
+            nextDataRoutes.add(route.page);
+        }
+        for (const route of routesManifest.dynamicRoutes){
+            dynamicRoutes.push({
+                ...route,
+                match: (0, _routematcher.getRouteMatcher)((0, _routeregex.getRouteRegex)(route.page))
+            });
+        }
+        if ((_middlewareManifest_middleware = middlewareManifest.middleware) == null ? void 0 : (_middlewareManifest_middleware_ = _middlewareManifest_middleware["/"]) == null ? void 0 : _middlewareManifest_middleware_.matchers) {
+            var _middlewareManifest_middleware_1, _middlewareManifest_middleware1;
+            middlewareMatcher = (0, _middlewareroutematcher.getMiddlewareRouteMatcher)((_middlewareManifest_middleware1 = middlewareManifest.middleware) == null ? void 0 : (_middlewareManifest_middleware_1 = _middlewareManifest_middleware1["/"]) == null ? void 0 : _middlewareManifest_middleware_1.matchers);
+        }
+        customRoutes = {
+            redirects: routesManifest.redirects,
+            rewrites: routesManifest.rewrites ? Array.isArray(routesManifest.rewrites) ? {
+                beforeFiles: [],
+                afterFiles: routesManifest.rewrites,
+                fallback: []
+            } : routesManifest.rewrites : {
+                beforeFiles: [],
+                afterFiles: [],
+                fallback: []
+            },
+            headers: routesManifest.headers
+        };
+    } else {
+        // dev handling
+        customRoutes = await (0, _loadcustomroutes.default)(opts.config);
+        prerenderManifest = {
+            version: 4,
+            routes: {},
+            dynamicRoutes: {},
+            notFoundRoutes: [],
+            preview: {
+                previewModeId: require("crypto").randomBytes(16).toString("hex"),
+                previewModeSigningKey: require("crypto").randomBytes(32).toString("hex"),
+                previewModeEncryptionKey: require("crypto").randomBytes(32).toString("hex")
+            }
+        };
+    }
+    const headers = customRoutes.headers.map((item)=>buildCustomRoute("header", item, opts.config.basePath, opts.config.experimental.caseSensitiveRoutes));
+    const redirects = customRoutes.redirects.map((item)=>buildCustomRoute("redirect", item, opts.config.basePath, opts.config.experimental.caseSensitiveRoutes));
+    const rewrites = {
+        beforeFiles: customRoutes.rewrites.beforeFiles.map((item)=>buildCustomRoute("before_files_rewrite", item)),
+        afterFiles: customRoutes.rewrites.afterFiles.map((item)=>buildCustomRoute("rewrite", item, opts.config.basePath, opts.config.experimental.caseSensitiveRoutes)),
+        fallback: customRoutes.rewrites.fallback.map((item)=>buildCustomRoute("rewrite", item, opts.config.basePath, opts.config.experimental.caseSensitiveRoutes))
+    };
+    const { i18n } = opts.config;
+    const handleLocale = (pathname, locales)=>{
+        let locale;
+        if (i18n) {
+            const i18nResult = (0, _normalizelocalepath.normalizeLocalePath)(pathname, locales || i18n.locales);
+            pathname = i18nResult.pathname;
+            locale = i18nResult.detectedLocale;
+        }
+        return {
+            locale,
+            pathname
+        };
+    };
+    debug("nextDataRoutes", nextDataRoutes);
+    debug("dynamicRoutes", dynamicRoutes);
+    debug("pageFiles", pageFiles);
+    debug("appFiles", appFiles);
+    let ensureFn;
+    const normalizers = {
+        // Because we can't know if the app directory is enabled or not at this
+        // stage, we assume that it is.
+        rsc: new _rsc.RSCPathnameNormalizer(),
+        prefetchRSC: opts.config.experimental.ppr ? new _prefetchrsc.PrefetchRSCPathnameNormalizer() : undefined,
+        postponed: opts.config.experimental.ppr ? new _postponed.PostponedPathnameNormalizer() : undefined
+    };
+    return {
+        headers,
+        rewrites,
+        redirects,
+        buildId,
+        handleLocale,
+        appFiles,
+        pageFiles,
+        dynamicRoutes,
+        nextDataRoutes,
+        exportPathMapRoutes: undefined,
+        devVirtualFsItems: new Set(),
+        prerenderManifest,
+        middlewareMatcher: middlewareMatcher,
+        ensureCallback (fn) {
+            ensureFn = fn;
+        },
+        async getItem (itemPath) {
+            const originalItemPath = itemPath;
+            const itemKey = originalItemPath;
+            const lruResult = getItemsLru == null ? void 0 : getItemsLru.get(itemKey);
+            if (lruResult) {
+                return lruResult;
+            }
+            const { basePath, assetPrefix } = opts.config;
+            const hasBasePath = (0, _pathhasprefix.pathHasPrefix)(itemPath, basePath);
+            const hasAssetPrefix = (0, _pathhasprefix.pathHasPrefix)(itemPath, assetPrefix);
+            // Return null if either path doesn't start with basePath or assetPrefix
+            if ((basePath || assetPrefix) && !hasBasePath && !hasAssetPrefix) {
+                return null;
+            }
+            // Either remove basePath or assetPrefix, not both (due to routes with same name as basePath)
+            if (basePath && hasBasePath) {
+                itemPath = (0, _removepathprefix.removePathPrefix)(itemPath, basePath) || "/";
+            } else if (assetPrefix && hasAssetPrefix) {
+                itemPath = (0, _removepathprefix.removePathPrefix)(itemPath, assetPrefix) || "/";
+            }
+            // Simulate minimal mode requests by normalizing RSC and postponed
+            // requests.
+            if (opts.minimalMode) {
+                var _normalizers_prefetchRSC, _normalizers_postponed;
+                if ((_normalizers_prefetchRSC = normalizers.prefetchRSC) == null ? void 0 : _normalizers_prefetchRSC.match(itemPath)) {
+                    itemPath = normalizers.prefetchRSC.normalize(itemPath, true);
+                } else if (normalizers.rsc.match(itemPath)) {
+                    itemPath = normalizers.rsc.normalize(itemPath, true);
+                } else if ((_normalizers_postponed = normalizers.postponed) == null ? void 0 : _normalizers_postponed.match(itemPath)) {
+                    itemPath = normalizers.postponed.normalize(itemPath, true);
+                }
+            }
+            if (itemPath !== "/" && itemPath.endsWith("/")) {
+                itemPath = itemPath.substring(0, itemPath.length - 1);
+            }
+            let decodedItemPath = itemPath;
+            try {
+                decodedItemPath = decodeURIComponent(itemPath);
+            } catch  {}
+            if (itemPath === "/_next/image") {
+                return {
+                    itemPath,
+                    type: "nextImage"
+                };
+            }
+            const itemsToCheck = [
+                [
+                    this.devVirtualFsItems,
+                    "devVirtualFsItem"
+                ],
+                [
+                    nextStaticFolderItems,
+                    "nextStaticFolder"
+                ],
+                [
+                    legacyStaticFolderItems,
+                    "legacyStaticFolder"
+                ],
+                [
+                    publicFolderItems,
+                    "publicFolder"
+                ],
+                [
+                    appFiles,
+                    "appFile"
+                ],
+                [
+                    pageFiles,
+                    "pageFile"
+                ]
+            ];
+            for (let [items, type] of itemsToCheck){
+                let locale;
+                let curItemPath = itemPath;
+                let curDecodedItemPath = decodedItemPath;
+                const isDynamicOutput = type === "pageFile" || type === "appFile";
+                if (i18n) {
+                    var _i18n_domains;
+                    const localeResult = handleLocale(itemPath, // legacy behavior allows visiting static assets under
+                    // default locale but no other locale
+                    isDynamicOutput ? undefined : [
+                        i18n == null ? void 0 : i18n.defaultLocale,
+                        // default locales from domains need to be matched too
+                        ...((_i18n_domains = i18n.domains) == null ? void 0 : _i18n_domains.map((item)=>item.defaultLocale)) || []
+                    ]);
+                    if (localeResult.pathname !== curItemPath) {
+                        curItemPath = localeResult.pathname;
+                        locale = localeResult.locale;
+                        try {
+                            curDecodedItemPath = decodeURIComponent(curItemPath);
+                        } catch  {}
+                    }
+                }
+                if (type === "legacyStaticFolder") {
+                    if (!(0, _pathhasprefix.pathHasPrefix)(curItemPath, "/static")) {
+                        continue;
+                    }
+                    curItemPath = curItemPath.substring("/static".length);
+                    try {
+                        curDecodedItemPath = decodeURIComponent(curItemPath);
+                    } catch  {}
+                }
+                if (type === "nextStaticFolder" && !(0, _pathhasprefix.pathHasPrefix)(curItemPath, "/_next/static")) {
+                    continue;
+                }
+                const nextDataPrefix = `/_next/data/${buildId}/`;
+                if (type === "pageFile" && curItemPath.startsWith(nextDataPrefix) && curItemPath.endsWith(".json")) {
+                    items = nextDataRoutes;
+                    // remove _next/data/<build-id> prefix
+                    curItemPath = curItemPath.substring(nextDataPrefix.length - 1);
+                    // remove .json postfix
+                    curItemPath = curItemPath.substring(0, curItemPath.length - ".json".length);
+                    const curLocaleResult = handleLocale(curItemPath);
+                    curItemPath = curLocaleResult.pathname === "/index" ? "/" : curLocaleResult.pathname;
+                    locale = curLocaleResult.locale;
+                    try {
+                        curDecodedItemPath = decodeURIComponent(curItemPath);
+                    } catch  {}
+                }
+                let matchedItem = items.has(curItemPath);
+                // check decoded variant as well
+                if (!matchedItem && !opts.dev) {
+                    matchedItem = items.has(curDecodedItemPath);
+                    if (matchedItem) curItemPath = curDecodedItemPath;
+                    else {
+                        // x-ref: https://github.com/vercel/next.js/issues/54008
+                        // There're cases that urls get decoded before requests, we should support both encoded and decoded ones.
+                        // e.g. nginx could decode the proxy urls, the below ones should be treated as the same:
+                        // decoded version: `/_next/static/chunks/pages/blog/[slug]-d4858831b91b69f6.js`
+                        // encoded version: `/_next/static/chunks/pages/blog/%5Bslug%5D-d4858831b91b69f6.js`
+                        try {
+                            // encode the special characters in the path and retrieve again to determine if path exists.
+                            const encodedCurItemPath = encodeURI(curItemPath);
+                            matchedItem = items.has(encodedCurItemPath);
+                        } catch  {}
+                    }
+                }
+                if (matchedItem || opts.dev) {
+                    let fsPath;
+                    let itemsRoot;
+                    switch(type){
+                        case "nextStaticFolder":
+                            {
+                                itemsRoot = nextStaticFolderPath;
+                                curItemPath = curItemPath.substring("/_next/static".length);
+                                break;
+                            }
+                        case "legacyStaticFolder":
+                            {
+                                itemsRoot = legacyStaticFolderPath;
+                                break;
+                            }
+                        case "publicFolder":
+                            {
+                                itemsRoot = publicFolderPath;
+                                break;
+                            }
+                        default:
+                            {
+                                break;
+                            }
+                    }
+                    if (itemsRoot && curItemPath) {
+                        fsPath = _path.default.posix.join(itemsRoot, curItemPath);
+                    }
+                    // dynamically check fs in development so we don't
+                    // have to wait on the watcher
+                    if (!matchedItem && opts.dev) {
+                        const isStaticAsset = [
+                            "nextStaticFolder",
+                            "publicFolder",
+                            "legacyStaticFolder"
+                        ].includes(type);
+                        if (isStaticAsset && itemsRoot) {
+                            let found = fsPath && await (0, _fileexists.fileExists)(fsPath, _fileexists.FileType.File);
+                            if (!found) {
+                                try {
+                                    // In dev, we ensure encoded paths match
+                                    // decoded paths on the filesystem so check
+                                    // that variation as well
+                                    const tempItemPath = decodeURIComponent(curItemPath);
+                                    fsPath = _path.default.posix.join(itemsRoot, tempItemPath);
+                                    found = await (0, _fileexists.fileExists)(fsPath, _fileexists.FileType.File);
+                                } catch  {}
+                                if (!found) {
+                                    continue;
+                                }
+                            }
+                        } else if (type === "pageFile" || type === "appFile") {
+                            var _ensureFn;
+                            const isAppFile = type === "appFile";
+                            if (ensureFn && await ((_ensureFn = ensureFn({
+                                type,
+                                itemPath: isAppFile ? (0, _getmetadataroute.normalizeMetadataRoute)(curItemPath) : curItemPath
+                            })) == null ? void 0 : _ensureFn.catch(()=>"ENSURE_FAILED")) === "ENSURE_FAILED") {
+                                continue;
+                            }
+                        } else {
+                            continue;
+                        }
+                    }
+                    // i18n locales aren't matched for app dir
+                    if (type === "appFile" && locale && locale !== (i18n == null ? void 0 : i18n.defaultLocale)) {
+                        continue;
+                    }
+                    const itemResult = {
+                        type,
+                        fsPath,
+                        locale,
+                        itemsRoot,
+                        itemPath: curItemPath
+                    };
+                    getItemsLru == null ? void 0 : getItemsLru.set(itemKey, itemResult);
+                    return itemResult;
+                }
+            }
+            getItemsLru == null ? void 0 : getItemsLru.set(itemKey, null);
+            return null;
+        },
+        getDynamicRoutes () {
+            // this should include data routes
+            return this.dynamicRoutes;
+        },
+        getMiddlewareMatchers () {
+            return this.middlewareMatcher;
+        }
+    };
+}
+
+//# sourceMappingURL=filesystem.js.map

node_modules/next/dist/server/lib/router-utils/is-postpone.d.ts

@@ -0,0 +1 @@
+export declare function isPostpone(error: any): boolean;

node_modules/next/dist/server/lib/router-utils/is-postpone.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isPostpone", {
+    enumerable: true,
+    get: function() {
+        return isPostpone;
+    }
+});
+const REACT_POSTPONE_TYPE = Symbol.for("react.postpone");
+function isPostpone(error) {
+    return typeof error === "object" && error !== null && error.$$typeof === REACT_POSTPONE_TYPE;
+}
+
+//# sourceMappingURL=is-postpone.js.map

node_modules/next/dist/server/lib/router-utils/is-postpone.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/lib/router-utils/is-postpone.ts"],"names":["isPostpone","REACT_POSTPONE_TYPE","Symbol","for","error","$$typeof"],"mappings":";;;;+BAEgBA;;;eAAAA;;;AAFhB,MAAMC,sBAA8BC,OAAOC,GAAG,CAAC;AAExC,SAASH,WAAWI,KAAU;IACnC,OACE,OAAOA,UAAU,YACjBA,UAAU,QACVA,MAAMC,QAAQ,KAAKJ;AAEvB"}

node_modules/next/dist/server/lib/router-utils/proxy-request.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { NextUrlWithParsedQuery } from '../../request-meta';
+export declare function proxyRequest(req: IncomingMessage, res: ServerResponse, parsedUrl: NextUrlWithParsedQuery, upgradeHead?: any, reqBody?: any, proxyTimeout?: number | null): Promise<void>;

node_modules/next/dist/server/lib/router-utils/proxy-request.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "proxyRequest", {
+    enumerable: true,
+    get: function() {
+        return proxyRequest;
+    }
+});
+const _url = /*#__PURE__*/ _interop_require_default(require("url"));
+const _serverrouteutils = require("../../server-route-utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function proxyRequest(req, res, parsedUrl, upgradeHead, reqBody, proxyTimeout) {
+    const { query } = parsedUrl;
+    delete parsedUrl.query;
+    parsedUrl.search = (0, _serverrouteutils.stringifyQuery)(req, query);
+    const target = _url.default.format(parsedUrl);
+    const HttpProxy = require("next/dist/compiled/http-proxy");
+    const proxy = new HttpProxy({
+        target,
+        changeOrigin: true,
+        ignorePath: true,
+        ws: true,
+        // we limit proxy requests to 30s by default, in development
+        // we don't time out WebSocket requests to allow proxying
+        proxyTimeout: proxyTimeout === null ? undefined : proxyTimeout || 30000,
+        headers: {
+            "x-forwarded-host": req.headers.host || ""
+        }
+    });
+    await new Promise((proxyResolve, proxyReject)=>{
+        let finished = false;
+        // http-proxy does not properly detect a client disconnect in newer
+        // versions of Node.js. This is caused because it only listens for the
+        // `aborted` event on the our request object, but it also fully reads
+        // and closes the request object. Node **will not** fire `aborted` when
+        // the request is already closed. Listening for `close` on our response
+        // object will detect the disconnect, and we can abort the proxy's
+        // connection.
+        proxy.on("proxyReq", (proxyReq)=>{
+            res.on("close", ()=>proxyReq.destroy());
+        });
+        proxy.on("proxyRes", (proxyRes)=>{
+            if (res.destroyed) {
+                proxyRes.destroy();
+            } else {
+                res.on("close", ()=>proxyRes.destroy());
+            }
+        });
+        proxy.on("proxyRes", (proxyRes, innerReq, innerRes)=>{
+            const cleanup = (err)=>{
+                // cleanup event listeners to allow clean garbage collection
+                proxyRes.removeListener("error", cleanup);
+                proxyRes.removeListener("close", cleanup);
+                innerRes.removeListener("error", cleanup);
+                innerRes.removeListener("close", cleanup);
+                // destroy all source streams to propagate the caught event backward
+                innerReq.destroy(err);
+                proxyRes.destroy(err);
+            };
+            proxyRes.once("error", cleanup);
+            proxyRes.once("close", cleanup);
+            innerRes.once("error", cleanup);
+            innerRes.once("close", cleanup);
+        });
+        proxy.on("error", (err)=>{
+            console.error(`Failed to proxy ${target}`, err);
+            if (!finished) {
+                finished = true;
+                proxyReject(err);
+                if (!res.destroyed) {
+                    res.statusCode = 500;
+                    res.end("Internal Server Error");
+                }
+            }
+        });
+        // if upgrade head is present treat as WebSocket request
+        if (upgradeHead) {
+            proxy.on("proxyReqWs", (proxyReq)=>{
+                proxyReq.on("close", ()=>{
+                    if (!finished) {
+                        finished = true;
+                        proxyResolve(true);
+                    }
+                });
+            });
+            proxy.ws(req, res, upgradeHead);
+            proxyResolve(true);
+        } else {
+            proxy.on("proxyReq", (proxyReq)=>{
+                proxyReq.on("close", ()=>{
+                    if (!finished) {
+                        finished = true;
+                        proxyResolve(true);
+                    }
+                });
+            });
+            proxy.web(req, res, {
+                buffer: reqBody
+            });
+        }
+    });
+}
+
+//# sourceMappingURL=proxy-request.js.map

node_modules/next/dist/server/lib/router-utils/proxy-request.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/lib/router-utils/proxy-request.ts"],"names":["proxyRequest","req","res","parsedUrl","upgradeHead","reqBody","proxyTimeout","query","search","stringifyQuery","target","url","format","HttpProxy","require","proxy","changeOrigin","ignorePath","ws","undefined","headers","host","Promise","proxyResolve","proxyReject","finished","on","proxyReq","destroy","proxyRes","destroyed","innerReq","innerRes","cleanup","err","removeListener","once","console","error","statusCode","end","web","buffer"],"mappings":";;;;+BAMsBA;;;eAAAA;;;4DAHN;kCACe;;;;;;AAExB,eAAeA,aACpBC,GAAoB,EACpBC,GAAmB,EACnBC,SAAiC,EACjCC,WAAiB,EACjBC,OAAa,EACbC,YAA4B;IAE5B,MAAM,EAAEC,KAAK,EAAE,GAAGJ;IAClB,OAAO,AAACA,UAAkBI,KAAK;IAC/BJ,UAAUK,MAAM,GAAGC,IAAAA,gCAAc,EAACR,KAAYM;IAE9C,MAAMG,SAASC,YAAG,CAACC,MAAM,CAACT;IAC1B,MAAMU,YACJC,QAAQ;IAEV,MAAMC,QAAQ,IAAIF,UAAU;QAC1BH;QACAM,cAAc;QACdC,YAAY;QACZC,IAAI;QACJ,4DAA4D;QAC5D,yDAAyD;QACzDZ,cAAcA,iBAAiB,OAAOa,YAAYb,gBAAgB;QAClEc,SAAS;YACP,oBAAoBnB,IAAImB,OAAO,CAACC,IAAI,IAAI;QAC1C;IACF;IAEA,MAAM,IAAIC,QAAQ,CAACC,cAAcC;QAC/B,IAAIC,WAAW;QAEf,mEAAmE;QACnE,sEAAsE;QACtE,qEAAqE;QACrE,uEAAuE;QACvE,uEAAuE;QACvE,kEAAkE;QAClE,cAAc;QACdV,MAAMW,EAAE,CAAC,YAAY,CAACC;YACpBzB,IAAIwB,EAAE,CAAC,SAAS,IAAMC,SAASC,OAAO;QACxC;QACAb,MAAMW,EAAE,CAAC,YAAY,CAACG;YACpB,IAAI3B,IAAI4B,SAAS,EAAE;gBACjBD,SAASD,OAAO;YAClB,OAAO;gBACL1B,IAAIwB,EAAE,CAAC,SAAS,IAAMG,SAASD,OAAO;YACxC;QACF;QAEAb,MAAMW,EAAE,CAAC,YAAY,CAACG,UAAUE,UAAUC;YACxC,MAAMC,UAAU,CAACC;gBACf,4DAA4D;gBAC5DL,SAASM,cAAc,CAAC,SAASF;gBACjCJ,SAASM,cAAc,CAAC,SAASF;gBACjCD,SAASG,cAAc,CAAC,SAASF;gBACjCD,SAASG,cAAc,CAAC,SAASF;gBAEjC,oEAAoE;gBACpEF,SAASH,OAAO,CAACM;gBACjBL,SAASD,OAAO,CAACM;YACnB;YAEAL,SAASO,IAAI,CAAC,SAASH;YACvBJ,SAASO,IAAI,CAAC,SAASH;YACvBD,SAASI,IAAI,CAAC,SAASH;YACvBD,SAASI,IAAI,CAAC,SAASH;QACzB;QAEAlB,MAAMW,EAAE,CAAC,SAAS,CAACQ;YACjBG,QAAQC,KAAK,CAAC,CAAC,gBAAgB,EAAE5B,OAAO,CAAC,EAAEwB;YAC3C,IAAI,CAACT,UAAU;gBACbA,WAAW;gBACXD,YAAYU;gBAEZ,IAAI,CAAChC,IAAI4B,SAAS,EAAE;oBAClB5B,IAAIqC,UAAU,GAAG;oBACjBrC,IAAIsC,GAAG,CAAC;gBACV;YACF;QACF;QAEA,wDAAwD;QACxD,IAAIpC,aAAa;YACfW,MAAMW,EAAE,CAAC,cAAc,CAACC;gBACtBA,SAASD,EAAE,CAAC,SAAS;oBACnB,IAAI,CAACD,UAAU;wBACbA,WAAW;wBACXF,aAAa;oBACf;gBACF;YACF;YACAR,MAAMG,EAAE,CAACjB,KAA+BC,KAAKE;YAC7CmB,aAAa;QACf,OAAO;YACLR,MAAMW,EAAE,CAAC,YAAY,CAACC;gBACpBA,SAASD,EAAE,CAAC,SAAS;oBACnB,IAAI,CAACD,UAAU;wBACbA,WAAW;wBACXF,aAAa;oBACf;gBACF;YACF;YACAR,MAAM0B,GAAG,CAACxC,KAAKC,KAAK;gBAClBwC,QAAQrC;YACV;QACF;IACF;AACF"}

node_modules/next/dist/server/lib/router-utils/resolve-routes.d.ts

@@ -0,0 +1,20 @@
+import type { FsOutput } from './filesystem';
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { NextConfigComplete } from '../../config-shared';
+import type { RenderServer, initialize } from '../router-server';
+import type { UnwrapPromise } from '../../../lib/coalesced-function';
+import type { NextUrlWithParsedQuery } from '../../request-meta';
+export declare function getResolveRoutes(fsChecker: UnwrapPromise<ReturnType<typeof import('./filesystem').setupFsCheck>>, config: NextConfigComplete, opts: Parameters<typeof initialize>[0], renderServer: RenderServer, renderServerOpts: Parameters<RenderServer['initialize']>[0], ensureMiddleware?: (url?: string) => Promise<void>): ({ req, res, isUpgradeReq, invokedOutputs, }: {
+    req: IncomingMessage;
+    res: ServerResponse;
+    isUpgradeReq: boolean;
+    signal: AbortSignal;
+    invokedOutputs?: Set<string> | undefined;
+}) => Promise<{
+    finished: boolean;
+    statusCode?: number | undefined;
+    bodyStream?: ReadableStream<any> | null | undefined;
+    resHeaders: Record<string, string | string[]>;
+    parsedUrl: NextUrlWithParsedQuery;
+    matchedOutput?: FsOutput | null | undefined;
+}>;

node_modules/next/dist/server/lib/router-utils/resolve-routes.js

@@ -0,0 +1,540 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getResolveRoutes", {
+    enumerable: true,
+    get: function() {
+        return getResolveRoutes;
+    }
+});
+const _url = /*#__PURE__*/ _interop_require_default(require("url"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _debug = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/debug"));
+const _bodystreams = require("../../body-streams");
+const _utils = require("../server-ipc/utils");
+const _serverrouteutils = require("../../server-route-utils");
+const _formathostname = require("../format-hostname");
+const _utils1 = require("../../web/utils");
+const _pipereadable = require("../../pipe-readable");
+const _gethostname = require("../../../shared/lib/get-hostname");
+const _redirectstatus = require("../../../lib/redirect-status");
+const _utils2 = require("../../../shared/lib/utils");
+const _relativizeurl = require("../../../shared/lib/router/utils/relativize-url");
+const _addpathprefix = require("../../../shared/lib/router/utils/add-path-prefix");
+const _pathhasprefix = require("../../../shared/lib/router/utils/path-has-prefix");
+const _detectdomainlocale = require("../../../shared/lib/i18n/detect-domain-locale");
+const _normalizelocalepath = require("../../../shared/lib/i18n/normalize-locale-path");
+const _removepathprefix = require("../../../shared/lib/router/utils/remove-path-prefix");
+const _nextdata = require("../../future/normalizers/request/next-data");
+const _basepath = require("../../future/normalizers/request/base-path");
+const _postponed = require("../../future/normalizers/request/postponed");
+const _requestmeta = require("../../request-meta");
+const _preparedestination = require("../../../shared/lib/router/utils/prepare-destination");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = (0, _debug.default)("next:router-server:resolve-routes");
+function getResolveRoutes(fsChecker, config, opts, renderServer, renderServerOpts, ensureMiddleware) {
+    const routes = [
+        // _next/data with middleware handling
+        {
+            match: ()=>({}),
+            name: "middleware_next_data"
+        },
+        ...opts.minimalMode ? [] : fsChecker.headers,
+        ...opts.minimalMode ? [] : fsChecker.redirects,
+        // check middleware (using matchers)
+        {
+            match: ()=>({}),
+            name: "middleware"
+        },
+        ...opts.minimalMode ? [] : fsChecker.rewrites.beforeFiles,
+        // check middleware (using matchers)
+        {
+            match: ()=>({}),
+            name: "before_files_end"
+        },
+        // we check exact matches on fs before continuing to
+        // after files rewrites
+        {
+            match: ()=>({}),
+            name: "check_fs"
+        },
+        ...opts.minimalMode ? [] : fsChecker.rewrites.afterFiles,
+        // we always do the check: true handling before continuing to
+        // fallback rewrites
+        {
+            check: true,
+            match: ()=>({}),
+            name: "after files check: true"
+        },
+        ...opts.minimalMode ? [] : fsChecker.rewrites.fallback
+    ];
+    async function resolveRoutes({ req, res, isUpgradeReq, invokedOutputs }) {
+        var _req_socket, _req_headers_xforwardedproto;
+        let finished = false;
+        let resHeaders = {};
+        let matchedOutput = null;
+        let parsedUrl = _url.default.parse(req.url || "", true);
+        let didRewrite = false;
+        const urlParts = (req.url || "").split("?", 1);
+        const urlNoQuery = urlParts[0];
+        // this normalizes repeated slashes in the path e.g. hello//world ->
+        // hello/world or backslashes to forward slashes, this does not
+        // handle trailing slash as that is handled the same as a next.config.js
+        // redirect
+        if (urlNoQuery == null ? void 0 : urlNoQuery.match(/(\\|\/\/)/)) {
+            parsedUrl = _url.default.parse((0, _utils2.normalizeRepeatedSlashes)(req.url), true);
+            return {
+                parsedUrl,
+                resHeaders,
+                finished: true,
+                statusCode: 308
+            };
+        }
+        // TODO: inherit this from higher up
+        const protocol = (req == null ? void 0 : (_req_socket = req.socket) == null ? void 0 : _req_socket.encrypted) || ((_req_headers_xforwardedproto = req.headers["x-forwarded-proto"]) == null ? void 0 : _req_headers_xforwardedproto.includes("https")) ? "https" : "http";
+        // When there are hostname and port we build an absolute URL
+        const initUrl = config.experimental.trustHostHeader ? `https://${req.headers.host || "localhost"}${req.url}` : opts.port ? `${protocol}://${(0, _formathostname.formatHostname)(opts.hostname || "localhost")}:${opts.port}${req.url}` : req.url || "";
+        (0, _requestmeta.addRequestMeta)(req, "initURL", initUrl);
+        (0, _requestmeta.addRequestMeta)(req, "initQuery", {
+            ...parsedUrl.query
+        });
+        (0, _requestmeta.addRequestMeta)(req, "initProtocol", protocol);
+        if (!isUpgradeReq) {
+            (0, _requestmeta.addRequestMeta)(req, "clonableBody", (0, _bodystreams.getCloneableBody)(req));
+        }
+        const maybeAddTrailingSlash = (pathname)=>{
+            if (config.trailingSlash && !config.skipMiddlewareUrlNormalize && !pathname.endsWith("/")) {
+                return `${pathname}/`;
+            }
+            return pathname;
+        };
+        let domainLocale;
+        let defaultLocale;
+        let initialLocaleResult = undefined;
+        if (config.i18n) {
+            var _parsedUrl_pathname;
+            const hadTrailingSlash = (_parsedUrl_pathname = parsedUrl.pathname) == null ? void 0 : _parsedUrl_pathname.endsWith("/");
+            const hadBasePath = (0, _pathhasprefix.pathHasPrefix)(parsedUrl.pathname || "", config.basePath);
+            initialLocaleResult = (0, _normalizelocalepath.normalizeLocalePath)((0, _removepathprefix.removePathPrefix)(parsedUrl.pathname || "/", config.basePath), config.i18n.locales);
+            domainLocale = (0, _detectdomainlocale.detectDomainLocale)(config.i18n.domains, (0, _gethostname.getHostname)(parsedUrl, req.headers));
+            defaultLocale = (domainLocale == null ? void 0 : domainLocale.defaultLocale) || config.i18n.defaultLocale;
+            parsedUrl.query.__nextDefaultLocale = defaultLocale;
+            parsedUrl.query.__nextLocale = initialLocaleResult.detectedLocale || defaultLocale;
+            // ensure locale is present for resolving routes
+            if (!initialLocaleResult.detectedLocale && !initialLocaleResult.pathname.startsWith("/_next/")) {
+                parsedUrl.pathname = (0, _addpathprefix.addPathPrefix)(initialLocaleResult.pathname === "/" ? `/${defaultLocale}` : (0, _addpathprefix.addPathPrefix)(initialLocaleResult.pathname || "", `/${defaultLocale}`), hadBasePath ? config.basePath : "");
+                if (hadTrailingSlash) {
+                    parsedUrl.pathname = maybeAddTrailingSlash(parsedUrl.pathname);
+                }
+            }
+        }
+        const checkLocaleApi = (pathname)=>{
+            if (config.i18n && pathname === urlNoQuery && (initialLocaleResult == null ? void 0 : initialLocaleResult.detectedLocale) && (0, _pathhasprefix.pathHasPrefix)(initialLocaleResult.pathname, "/api")) {
+                return true;
+            }
+        };
+        async function checkTrue() {
+            const pathname = parsedUrl.pathname || "";
+            if (checkLocaleApi(pathname)) {
+                return;
+            }
+            if (!(invokedOutputs == null ? void 0 : invokedOutputs.has(pathname))) {
+                const output = await fsChecker.getItem(pathname);
+                if (output) {
+                    if (config.useFileSystemPublicRoutes || didRewrite || output.type !== "appFile" && output.type !== "pageFile") {
+                        return output;
+                    }
+                }
+            }
+            const dynamicRoutes = fsChecker.getDynamicRoutes();
+            let curPathname = parsedUrl.pathname;
+            if (config.basePath) {
+                if (!(0, _pathhasprefix.pathHasPrefix)(curPathname || "", config.basePath)) {
+                    return;
+                }
+                curPathname = (curPathname == null ? void 0 : curPathname.substring(config.basePath.length)) || "/";
+            }
+            const localeResult = fsChecker.handleLocale(curPathname || "");
+            for (const route of dynamicRoutes){
+                // when resolving fallback: false the
+                // render worker may return a no-fallback response
+                // which signals we need to continue resolving.
+                // TODO: optimize this to collect static paths
+                // to use at the routing layer
+                if (invokedOutputs == null ? void 0 : invokedOutputs.has(route.page)) {
+                    continue;
+                }
+                const params = route.match(localeResult.pathname);
+                if (params) {
+                    const pageOutput = await fsChecker.getItem((0, _addpathprefix.addPathPrefix)(route.page, config.basePath || ""));
+                    // i18n locales aren't matched for app dir
+                    if ((pageOutput == null ? void 0 : pageOutput.type) === "appFile" && (initialLocaleResult == null ? void 0 : initialLocaleResult.detectedLocale)) {
+                        continue;
+                    }
+                    if (pageOutput && (curPathname == null ? void 0 : curPathname.startsWith("/_next/data"))) {
+                        parsedUrl.query.__nextDataReq = "1";
+                    }
+                    if (config.useFileSystemPublicRoutes || didRewrite) {
+                        return pageOutput;
+                    }
+                }
+            }
+        }
+        const normalizers = {
+            basePath: config.basePath && config.basePath !== "/" ? new _basepath.BasePathPathnameNormalizer(config.basePath) : undefined,
+            data: new _nextdata.NextDataPathnameNormalizer(fsChecker.buildId),
+            postponed: config.experimental.ppr ? new _postponed.PostponedPathnameNormalizer() : undefined
+        };
+        async function handleRoute(route) {
+            let curPathname = parsedUrl.pathname || "/";
+            if (config.i18n && route.internal) {
+                const hadTrailingSlash = curPathname.endsWith("/");
+                if (config.basePath) {
+                    curPathname = (0, _removepathprefix.removePathPrefix)(curPathname, config.basePath);
+                }
+                const hadBasePath = curPathname !== parsedUrl.pathname;
+                const localeResult = (0, _normalizelocalepath.normalizeLocalePath)(curPathname, config.i18n.locales);
+                const isDefaultLocale = localeResult.detectedLocale === defaultLocale;
+                if (isDefaultLocale) {
+                    curPathname = localeResult.pathname === "/" && hadBasePath ? config.basePath : (0, _addpathprefix.addPathPrefix)(localeResult.pathname, hadBasePath ? config.basePath : "");
+                } else if (hadBasePath) {
+                    curPathname = curPathname === "/" ? config.basePath : (0, _addpathprefix.addPathPrefix)(curPathname, config.basePath);
+                }
+                if ((isDefaultLocale || hadBasePath) && hadTrailingSlash) {
+                    curPathname = maybeAddTrailingSlash(curPathname);
+                }
+            }
+            let params = route.match(curPathname);
+            if ((route.has || route.missing) && params) {
+                const hasParams = (0, _preparedestination.matchHas)(req, parsedUrl.query, route.has, route.missing);
+                if (hasParams) {
+                    Object.assign(params, hasParams);
+                } else {
+                    params = false;
+                }
+            }
+            if (params) {
+                if (fsChecker.exportPathMapRoutes && route.name === "before_files_end") {
+                    for (const exportPathMapRoute of fsChecker.exportPathMapRoutes){
+                        const result = await handleRoute(exportPathMapRoute);
+                        if (result) {
+                            return result;
+                        }
+                    }
+                }
+                if (route.name === "middleware_next_data" && parsedUrl.pathname) {
+                    var _fsChecker_getMiddlewareMatchers;
+                    if ((_fsChecker_getMiddlewareMatchers = fsChecker.getMiddlewareMatchers()) == null ? void 0 : _fsChecker_getMiddlewareMatchers.length) {
+                        var _normalizers_basePath, _normalizers_postponed;
+                        let normalized = parsedUrl.pathname;
+                        // Remove the base path if it exists.
+                        const hadBasePath = (_normalizers_basePath = normalizers.basePath) == null ? void 0 : _normalizers_basePath.match(parsedUrl.pathname);
+                        if (hadBasePath && normalizers.basePath) {
+                            normalized = normalizers.basePath.normalize(normalized, true);
+                        }
+                        let updated = false;
+                        if (normalizers.data.match(normalized)) {
+                            updated = true;
+                            parsedUrl.query.__nextDataReq = "1";
+                            normalized = normalizers.data.normalize(normalized, true);
+                        } else if ((_normalizers_postponed = normalizers.postponed) == null ? void 0 : _normalizers_postponed.match(normalized)) {
+                            updated = true;
+                            normalized = normalizers.postponed.normalize(normalized, true);
+                        }
+                        if (config.i18n) {
+                            const curLocaleResult = (0, _normalizelocalepath.normalizeLocalePath)(normalized, config.i18n.locales);
+                            if (curLocaleResult.detectedLocale) {
+                                parsedUrl.query.__nextLocale = curLocaleResult.detectedLocale;
+                            }
+                        }
+                        // If we updated the pathname, and it had a base path, re-add the
+                        // base path.
+                        if (updated) {
+                            if (hadBasePath) {
+                                normalized = _nodepath.default.posix.join(config.basePath, normalized);
+                            }
+                            // Re-add the trailing slash (if required).
+                            normalized = maybeAddTrailingSlash(normalized);
+                            parsedUrl.pathname = normalized;
+                        }
+                    }
+                }
+                if (route.name === "check_fs") {
+                    const pathname = parsedUrl.pathname || "";
+                    if ((invokedOutputs == null ? void 0 : invokedOutputs.has(pathname)) || checkLocaleApi(pathname)) {
+                        return;
+                    }
+                    const output = await fsChecker.getItem(pathname);
+                    if (output && !(config.i18n && (initialLocaleResult == null ? void 0 : initialLocaleResult.detectedLocale) && (0, _pathhasprefix.pathHasPrefix)(pathname, "/api"))) {
+                        if (config.useFileSystemPublicRoutes || didRewrite || output.type !== "appFile" && output.type !== "pageFile") {
+                            matchedOutput = output;
+                            if (output.locale) {
+                                parsedUrl.query.__nextLocale = output.locale;
+                            }
+                            return {
+                                parsedUrl,
+                                resHeaders,
+                                finished: true,
+                                matchedOutput
+                            };
+                        }
+                    }
+                }
+                if (!opts.minimalMode && route.name === "middleware") {
+                    const match = fsChecker.getMiddlewareMatchers();
+                    if (// @ts-expect-error BaseNextRequest stuff
+                    match == null ? void 0 : match(parsedUrl.pathname, req, parsedUrl.query)) {
+                        if (ensureMiddleware) {
+                            await ensureMiddleware(req.url);
+                        }
+                        const serverResult = await (renderServer == null ? void 0 : renderServer.initialize(renderServerOpts));
+                        if (!serverResult) {
+                            throw new Error(`Failed to initialize render server "middleware"`);
+                        }
+                        (0, _requestmeta.addRequestMeta)(req, "invokePath", "");
+                        (0, _requestmeta.addRequestMeta)(req, "invokeOutput", "");
+                        (0, _requestmeta.addRequestMeta)(req, "invokeQuery", {});
+                        (0, _requestmeta.addRequestMeta)(req, "middlewareInvoke", true);
+                        debug("invoking middleware", req.url, req.headers);
+                        let middlewareRes = undefined;
+                        let bodyStream = undefined;
+                        try {
+                            try {
+                                await serverResult.requestHandler(req, res, parsedUrl);
+                            } catch (err) {
+                                if (!("result" in err) || !("response" in err.result)) {
+                                    throw err;
+                                }
+                                middlewareRes = err.result.response;
+                                res.statusCode = middlewareRes.status;
+                                if (middlewareRes.body) {
+                                    bodyStream = middlewareRes.body;
+                                } else if (middlewareRes.status) {
+                                    bodyStream = new ReadableStream({
+                                        start (controller) {
+                                            controller.enqueue("");
+                                            controller.close();
+                                        }
+                                    });
+                                }
+                            }
+                        } catch (e) {
+                            // If the client aborts before we can receive a response object
+                            // (when the headers are flushed), then we can early exit without
+                            // further processing.
+                            if ((0, _pipereadable.isAbortError)(e)) {
+                                return {
+                                    parsedUrl,
+                                    resHeaders,
+                                    finished: true
+                                };
+                            }
+                            throw e;
+                        }
+                        if (res.closed || res.finished || !middlewareRes) {
+                            return {
+                                parsedUrl,
+                                resHeaders,
+                                finished: true
+                            };
+                        }
+                        const middlewareHeaders = (0, _utils1.toNodeOutgoingHttpHeaders)(middlewareRes.headers);
+                        debug("middleware res", middlewareRes.status, middlewareHeaders);
+                        if (middlewareHeaders["x-middleware-override-headers"]) {
+                            const overriddenHeaders = new Set();
+                            let overrideHeaders = middlewareHeaders["x-middleware-override-headers"];
+                            if (typeof overrideHeaders === "string") {
+                                overrideHeaders = overrideHeaders.split(",");
+                            }
+                            for (const key of overrideHeaders){
+                                overriddenHeaders.add(key.trim());
+                            }
+                            delete middlewareHeaders["x-middleware-override-headers"];
+                            // Delete headers.
+                            for (const key of Object.keys(req.headers)){
+                                if (!overriddenHeaders.has(key)) {
+                                    delete req.headers[key];
+                                }
+                            }
+                            // Update or add headers.
+                            for (const key of overriddenHeaders.keys()){
+                                const valueKey = "x-middleware-request-" + key;
+                                const newValue = middlewareHeaders[valueKey];
+                                const oldValue = req.headers[key];
+                                if (oldValue !== newValue) {
+                                    req.headers[key] = newValue === null ? undefined : newValue;
+                                }
+                                delete middlewareHeaders[valueKey];
+                            }
+                        }
+                        if (!middlewareHeaders["x-middleware-rewrite"] && !middlewareHeaders["x-middleware-next"] && !middlewareHeaders["location"]) {
+                            middlewareHeaders["x-middleware-refresh"] = "1";
+                        }
+                        delete middlewareHeaders["x-middleware-next"];
+                        for (const [key, value] of Object.entries({
+                            ...(0, _utils.filterReqHeaders)(middlewareHeaders, _utils.ipcForbiddenHeaders)
+                        })){
+                            if ([
+                                "content-length",
+                                "x-middleware-rewrite",
+                                "x-middleware-redirect",
+                                "x-middleware-refresh"
+                            ].includes(key)) {
+                                continue;
+                            }
+                            if (value) {
+                                resHeaders[key] = value;
+                                req.headers[key] = value;
+                            }
+                        }
+                        if (middlewareHeaders["x-middleware-rewrite"]) {
+                            const value = middlewareHeaders["x-middleware-rewrite"];
+                            const rel = (0, _relativizeurl.relativizeURL)(value, initUrl);
+                            resHeaders["x-middleware-rewrite"] = rel;
+                            const query = parsedUrl.query;
+                            parsedUrl = _url.default.parse(rel, true);
+                            if (parsedUrl.protocol) {
+                                return {
+                                    parsedUrl,
+                                    resHeaders,
+                                    finished: true
+                                };
+                            }
+                            // keep internal query state
+                            for (const key of Object.keys(query)){
+                                if (key.startsWith("_next") || key.startsWith("__next")) {
+                                    parsedUrl.query[key] = query[key];
+                                }
+                            }
+                            if (config.i18n) {
+                                const curLocaleResult = (0, _normalizelocalepath.normalizeLocalePath)(parsedUrl.pathname || "", config.i18n.locales);
+                                if (curLocaleResult.detectedLocale) {
+                                    parsedUrl.query.__nextLocale = curLocaleResult.detectedLocale;
+                                }
+                            }
+                        }
+                        if (middlewareHeaders["location"]) {
+                            const value = middlewareHeaders["location"];
+                            const rel = (0, _relativizeurl.relativizeURL)(value, initUrl);
+                            resHeaders["location"] = rel;
+                            parsedUrl = _url.default.parse(rel, true);
+                            return {
+                                parsedUrl,
+                                resHeaders,
+                                finished: true,
+                                statusCode: middlewareRes.status
+                            };
+                        }
+                        if (middlewareHeaders["x-middleware-refresh"]) {
+                            return {
+                                parsedUrl,
+                                resHeaders,
+                                finished: true,
+                                bodyStream,
+                                statusCode: middlewareRes.status
+                            };
+                        }
+                    }
+                }
+                // handle redirect
+                if (("statusCode" in route || "permanent" in route) && route.destination) {
+                    const { parsedDestination } = (0, _preparedestination.prepareDestination)({
+                        appendParamsToQuery: false,
+                        destination: route.destination,
+                        params: params,
+                        query: parsedUrl.query
+                    });
+                    const { query } = parsedDestination;
+                    delete parsedDestination.query;
+                    parsedDestination.search = (0, _serverrouteutils.stringifyQuery)(req, query);
+                    parsedDestination.pathname = (0, _utils2.normalizeRepeatedSlashes)(parsedDestination.pathname);
+                    return {
+                        finished: true,
+                        // @ts-expect-error custom ParsedUrl
+                        parsedUrl: parsedDestination,
+                        statusCode: (0, _redirectstatus.getRedirectStatus)(route)
+                    };
+                }
+                // handle headers
+                if (route.headers) {
+                    const hasParams = Object.keys(params).length > 0;
+                    for (const header of route.headers){
+                        let { key, value } = header;
+                        if (hasParams) {
+                            key = (0, _preparedestination.compileNonPath)(key, params);
+                            value = (0, _preparedestination.compileNonPath)(value, params);
+                        }
+                        if (key.toLowerCase() === "set-cookie") {
+                            if (!Array.isArray(resHeaders[key])) {
+                                const val = resHeaders[key];
+                                resHeaders[key] = typeof val === "string" ? [
+                                    val
+                                ] : [];
+                            }
+                            resHeaders[key].push(value);
+                        } else {
+                            resHeaders[key] = value;
+                        }
+                    }
+                }
+                // handle rewrite
+                if (route.destination) {
+                    const { parsedDestination } = (0, _preparedestination.prepareDestination)({
+                        appendParamsToQuery: true,
+                        destination: route.destination,
+                        params: params,
+                        query: parsedUrl.query
+                    });
+                    if (parsedDestination.protocol) {
+                        return {
+                            // @ts-expect-error custom ParsedUrl
+                            parsedUrl: parsedDestination,
+                            finished: true
+                        };
+                    }
+                    if (config.i18n) {
+                        const curLocaleResult = (0, _normalizelocalepath.normalizeLocalePath)((0, _removepathprefix.removePathPrefix)(parsedDestination.pathname, config.basePath), config.i18n.locales);
+                        if (curLocaleResult.detectedLocale) {
+                            parsedUrl.query.__nextLocale = curLocaleResult.detectedLocale;
+                        }
+                    }
+                    didRewrite = true;
+                    parsedUrl.pathname = parsedDestination.pathname;
+                    Object.assign(parsedUrl.query, parsedDestination.query);
+                }
+                // handle check: true
+                if (route.check) {
+                    const output = await checkTrue();
+                    if (output) {
+                        return {
+                            parsedUrl,
+                            resHeaders,
+                            finished: true,
+                            matchedOutput: output
+                        };
+                    }
+                }
+            }
+        }
+        for (const route of routes){
+            const result = await handleRoute(route);
+            if (result) {
+                return result;
+            }
+        }
+        return {
+            finished,
+            parsedUrl,
+            resHeaders,
+            matchedOutput
+        };
+    }
+    return resolveRoutes;
+}
+
+//# sourceMappingURL=resolve-routes.js.map

node_modules/next/dist/server/lib/router-utils/setup-dev-bundler.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+import type { NextConfigComplete } from '../../config-shared';
+import type { UnwrapPromise } from '../../../lib/coalesced-function';
+import type { MiddlewareMatcher } from '../../../build/analysis/get-page-static-info';
+import type { MiddlewareRouteMatch } from '../../../shared/lib/router/utils/middleware-route-matcher';
+import type { PropagateToWorkersField } from './types';
+import type { NextJsHotReloaderInterface } from '../../dev/hot-reloader-types';
+import type { Telemetry } from '../../../telemetry/storage';
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { LazyRenderServerInstance } from '../router-server';
+export type SetupOpts = {
+    renderServer: LazyRenderServerInstance;
+    dir: string;
+    turbo?: boolean;
+    appDir?: string;
+    pagesDir?: string;
+    telemetry: Telemetry;
+    isCustomServer?: boolean;
+    fsChecker: UnwrapPromise<ReturnType<typeof import('./filesystem').setupFsCheck>>;
+    nextConfig: NextConfigComplete;
+    port: number;
+};
+export type ServerFields = {
+    actualMiddlewareFile?: string | undefined;
+    actualInstrumentationHookFile?: string | undefined;
+    appPathRoutes?: Record<string, string | string[]>;
+    middleware?: {
+        page: string;
+        match: MiddlewareRouteMatch;
+        matchers?: MiddlewareMatcher[];
+    } | undefined;
+    hasAppNotFound?: boolean;
+    interceptionRoutes?: ReturnType<typeof import('./filesystem').buildCustomRoute>[];
+};
+export declare function propagateServerField(opts: SetupOpts, field: PropagateToWorkersField, args: any): Promise<void>;
+export declare function setupDevBundler(opts: SetupOpts): Promise<{
+    serverFields: ServerFields;
+    hotReloader: NextJsHotReloaderInterface;
+    requestHandler: (req: IncomingMessage, res: ServerResponse<IncomingMessage>) => Promise<{
+        finished: boolean;
+    }>;
+    logErrorWithOriginalStack: (err: unknown, type?: "warning" | "uncaughtException" | "unhandledRejection" | "app-dir" | undefined) => Promise<void>;
+    ensureMiddleware(requestUrl?: string | undefined): Promise<void>;
+}>;
+export type DevBundler = Awaited<ReturnType<typeof setupDevBundler>>;

node_modules/next/dist/server/lib/router-utils/setup-dev-bundler.js

@@ -0,0 +1,830 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    propagateServerField: null,
+    setupDevBundler: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    propagateServerField: function() {
+        return propagateServerField;
+    },
+    setupDevBundler: function() {
+        return setupDevBundler;
+    }
+});
+const _swc = require("../../../build/swc");
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _url = /*#__PURE__*/ _interop_require_default(require("url"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _querystring = /*#__PURE__*/ _interop_require_default(require("querystring"));
+const _watchpack = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/watchpack"));
+const _env = require("@next/env");
+const _iserror = /*#__PURE__*/ _interop_require_default(require("../../../lib/is-error"));
+const _findup = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/find-up"));
+const _filesystem = require("./filesystem");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../build/output/log"));
+const _hotreloaderwebpack = /*#__PURE__*/ _interop_require_default(require("../../dev/hot-reloader-webpack"));
+const _shared = require("../../../trace/shared");
+const _loadjsconfig = /*#__PURE__*/ _interop_require_default(require("../../../build/load-jsconfig"));
+const _findpagefile = require("../find-page-file");
+const _events = require("../../../telemetry/events");
+const _defineenvplugin = require("../../../build/webpack/plugins/define-env-plugin");
+const _logappdirerror = require("../../dev/log-app-dir-error");
+const _utils = require("../../../shared/lib/router/utils");
+const _entries = require("../../../build/entries");
+const _verifytypescriptsetup = require("../../../lib/verify-typescript-setup");
+const _verifypartytownsetup = require("../../../lib/verify-partytown-setup");
+const _routeregex = require("../../../shared/lib/router/utils/route-regex");
+const _apppaths = require("../../../shared/lib/router/utils/app-paths");
+const _builddataroute = require("./build-data-route");
+const _routematcher = require("../../../shared/lib/router/utils/route-matcher");
+const _normalizepathsep = require("../../../shared/lib/page-path/normalize-path-sep");
+const _createclientrouterfilter = require("../../../lib/create-client-router-filter");
+const _absolutepathtopage = require("../../../shared/lib/page-path/absolute-path-to-page");
+const _generateinterceptionroutesrewrites = require("../../../lib/generate-interception-routes-rewrites");
+const _constants = require("../../../shared/lib/constants");
+const _middlewareroutematcher = require("../../../shared/lib/router/utils/middleware-route-matcher");
+const _utils1 = require("../../../build/utils");
+const _middleware = require("../../../client/components/react-dev-overlay/server/middleware");
+const _middlewareturbopack = require("../../../client/components/react-dev-overlay/server/middleware-turbopack");
+const _shared1 = require("../../../build/webpack/plugins/next-types-plugin/shared");
+const _hotreloadertypes = require("../../dev/hot-reloader-types");
+const _pagetypes = require("../../../lib/page-types");
+const _hotreloaderturbopack = require("../../dev/hot-reloader-turbopack");
+const _errorsource = require("../../../shared/lib/error-source");
+const _encryptionutils = require("../../app-render/encryption-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;
+}
+async function verifyTypeScript(opts) {
+    let usingTypeScript = false;
+    const verifyResult = await (0, _verifytypescriptsetup.verifyTypeScriptSetup)({
+        dir: opts.dir,
+        distDir: opts.nextConfig.distDir,
+        intentDirs: [
+            opts.pagesDir,
+            opts.appDir
+        ].filter(Boolean),
+        typeCheckPreflight: false,
+        tsconfigPath: opts.nextConfig.typescript.tsconfigPath,
+        disableStaticImages: opts.nextConfig.images.disableStaticImages,
+        hasAppDir: !!opts.appDir,
+        hasPagesDir: !!opts.pagesDir
+    });
+    if (verifyResult.version) {
+        usingTypeScript = true;
+    }
+    return usingTypeScript;
+}
+class ModuleBuildError extends Error {
+}
+async function propagateServerField(opts, field, args) {
+    var _opts_renderServer_instance, _opts_renderServer;
+    await ((_opts_renderServer = opts.renderServer) == null ? void 0 : (_opts_renderServer_instance = _opts_renderServer.instance) == null ? void 0 : _opts_renderServer_instance.propagateServerField(opts.dir, field, args));
+}
+async function startWatcher(opts) {
+    const { nextConfig, appDir, pagesDir, dir } = opts;
+    const { useFileSystemPublicRoutes } = nextConfig;
+    const usingTypeScript = await verifyTypeScript(opts);
+    const distDir = _path.default.join(opts.dir, opts.nextConfig.distDir);
+    (0, _shared.setGlobal)("distDir", distDir);
+    (0, _shared.setGlobal)("phase", _constants.PHASE_DEVELOPMENT_SERVER);
+    const validFileMatcher = (0, _findpagefile.createValidFileMatcher)(nextConfig.pageExtensions, appDir);
+    const serverFields = {};
+    const hotReloader = opts.turbo ? await (0, _hotreloaderturbopack.createHotReloaderTurbopack)(opts, serverFields, distDir) : new _hotreloaderwebpack.default(opts.dir, {
+        appDir,
+        pagesDir,
+        distDir: distDir,
+        config: opts.nextConfig,
+        buildId: "development",
+        encryptionKey: await (0, _encryptionutils.generateEncryptionKeyBase64)(),
+        telemetry: opts.telemetry,
+        rewrites: opts.fsChecker.rewrites,
+        previewProps: opts.fsChecker.prerenderManifest.preview
+    });
+    await hotReloader.start();
+    if (opts.nextConfig.experimental.nextScriptWorkers) {
+        await (0, _verifypartytownsetup.verifyPartytownSetup)(opts.dir, _path.default.join(distDir, _constants.CLIENT_STATIC_FILES_PATH));
+    }
+    opts.fsChecker.ensureCallback(async function ensure(item) {
+        if (item.type === "appFile" || item.type === "pageFile") {
+            await hotReloader.ensurePage({
+                clientOnly: false,
+                page: item.itemPath,
+                isApp: item.type === "appFile",
+                definition: undefined
+            });
+        }
+    });
+    let resolved = false;
+    let prevSortedRoutes = [];
+    await new Promise(async (resolve, reject)=>{
+        if (pagesDir) {
+            // Watchpack doesn't emit an event for an empty directory
+            _fs.default.readdir(pagesDir, (_, files)=>{
+                if (files == null ? void 0 : files.length) {
+                    return;
+                }
+                if (!resolved) {
+                    resolve();
+                    resolved = true;
+                }
+            });
+        }
+        const pages = pagesDir ? [
+            pagesDir
+        ] : [];
+        const app = appDir ? [
+            appDir
+        ] : [];
+        const directories = [
+            ...pages,
+            ...app
+        ];
+        const rootDir = pagesDir || appDir;
+        const files = [
+            ...(0, _utils1.getPossibleMiddlewareFilenames)(_path.default.join(rootDir, ".."), nextConfig.pageExtensions),
+            ...(0, _utils1.getPossibleInstrumentationHookFilenames)(_path.default.join(rootDir, ".."), nextConfig.pageExtensions)
+        ];
+        let nestedMiddleware = [];
+        const envFiles = [
+            ".env.development.local",
+            ".env.local",
+            ".env.development",
+            ".env"
+        ].map((file)=>_path.default.join(dir, file));
+        files.push(...envFiles);
+        // tsconfig/jsconfig paths hot-reloading
+        const tsconfigPaths = [
+            _path.default.join(dir, "tsconfig.json"),
+            _path.default.join(dir, "jsconfig.json")
+        ];
+        files.push(...tsconfigPaths);
+        const wp = new _watchpack.default({
+            ignored: (pathname)=>{
+                return !files.some((file)=>file.startsWith(pathname)) && !directories.some((d)=>pathname.startsWith(d) || d.startsWith(pathname));
+            }
+        });
+        const fileWatchTimes = new Map();
+        let enabledTypeScript = usingTypeScript;
+        let previousClientRouterFilters;
+        let previousConflictingPagePaths = new Set();
+        wp.on("aggregated", async ()=>{
+            var _serverFields_middleware, _serverFields_middleware1;
+            let middlewareMatchers;
+            const routedPages = [];
+            const knownFiles = wp.getTimeInfoEntries();
+            const appPaths = {};
+            const pageNameSet = new Set();
+            const conflictingAppPagePaths = new Set();
+            const appPageFilePaths = new Map();
+            const pagesPageFilePaths = new Map();
+            let envChange = false;
+            let tsconfigChange = false;
+            let conflictingPageChange = 0;
+            let hasRootAppNotFound = false;
+            const { appFiles, pageFiles } = opts.fsChecker;
+            appFiles.clear();
+            pageFiles.clear();
+            _shared1.devPageFiles.clear();
+            const sortedKnownFiles = [
+                ...knownFiles.keys()
+            ].sort((0, _entries.sortByPageExts)(nextConfig.pageExtensions));
+            for (const fileName of sortedKnownFiles){
+                if (!files.includes(fileName) && !directories.some((d)=>fileName.startsWith(d))) {
+                    continue;
+                }
+                const meta = knownFiles.get(fileName);
+                const watchTime = fileWatchTimes.get(fileName);
+                // If the file is showing up for the first time or the meta.timestamp is changed since last time
+                const watchTimeChange = watchTime === undefined || watchTime && watchTime !== (meta == null ? void 0 : meta.timestamp);
+                fileWatchTimes.set(fileName, meta == null ? void 0 : meta.timestamp);
+                if (envFiles.includes(fileName)) {
+                    if (watchTimeChange) {
+                        envChange = true;
+                    }
+                    continue;
+                }
+                if (tsconfigPaths.includes(fileName)) {
+                    if (fileName.endsWith("tsconfig.json")) {
+                        enabledTypeScript = true;
+                    }
+                    if (watchTimeChange) {
+                        tsconfigChange = true;
+                    }
+                    continue;
+                }
+                if ((meta == null ? void 0 : meta.accuracy) === undefined || !validFileMatcher.isPageFile(fileName)) {
+                    continue;
+                }
+                const isAppPath = Boolean(appDir && (0, _normalizepathsep.normalizePathSep)(fileName).startsWith((0, _normalizepathsep.normalizePathSep)(appDir) + "/"));
+                const isPagePath = Boolean(pagesDir && (0, _normalizepathsep.normalizePathSep)(fileName).startsWith((0, _normalizepathsep.normalizePathSep)(pagesDir) + "/"));
+                const rootFile = (0, _absolutepathtopage.absolutePathToPage)(fileName, {
+                    dir: dir,
+                    extensions: nextConfig.pageExtensions,
+                    keepIndex: false,
+                    pagesType: _pagetypes.PAGE_TYPES.ROOT
+                });
+                if ((0, _utils1.isMiddlewareFile)(rootFile)) {
+                    var _staticInfo_middleware;
+                    const staticInfo = await (0, _entries.getStaticInfoIncludingLayouts)({
+                        pageFilePath: fileName,
+                        config: nextConfig,
+                        appDir: appDir,
+                        page: rootFile,
+                        isDev: true,
+                        isInsideAppDir: isAppPath,
+                        pageExtensions: nextConfig.pageExtensions
+                    });
+                    if (nextConfig.output === "export") {
+                        _log.error('Middleware cannot be used with "output: export". See more info here: https://nextjs.org/docs/advanced-features/static-html-export');
+                        continue;
+                    }
+                    serverFields.actualMiddlewareFile = rootFile;
+                    await propagateServerField(opts, "actualMiddlewareFile", serverFields.actualMiddlewareFile);
+                    middlewareMatchers = ((_staticInfo_middleware = staticInfo.middleware) == null ? void 0 : _staticInfo_middleware.matchers) || [
+                        {
+                            regexp: ".*",
+                            originalSource: "/:path*"
+                        }
+                    ];
+                    continue;
+                }
+                if ((0, _utils1.isInstrumentationHookFile)(rootFile) && nextConfig.experimental.instrumentationHook) {
+                    serverFields.actualInstrumentationHookFile = rootFile;
+                    await propagateServerField(opts, "actualInstrumentationHookFile", serverFields.actualInstrumentationHookFile);
+                    continue;
+                }
+                if (fileName.endsWith(".ts") || fileName.endsWith(".tsx")) {
+                    enabledTypeScript = true;
+                }
+                if (!(isAppPath || isPagePath)) {
+                    continue;
+                }
+                // Collect all current filenames for the TS plugin to use
+                _shared1.devPageFiles.add(fileName);
+                let pageName = (0, _absolutepathtopage.absolutePathToPage)(fileName, {
+                    dir: isAppPath ? appDir : pagesDir,
+                    extensions: nextConfig.pageExtensions,
+                    keepIndex: isAppPath,
+                    pagesType: isAppPath ? _pagetypes.PAGE_TYPES.APP : _pagetypes.PAGE_TYPES.PAGES
+                });
+                if (!isAppPath && pageName.startsWith("/api/") && nextConfig.output === "export") {
+                    _log.error('API Routes cannot be used with "output: export". See more info here: https://nextjs.org/docs/advanced-features/static-html-export');
+                    continue;
+                }
+                if (isAppPath) {
+                    const isRootNotFound = validFileMatcher.isRootNotFound(fileName);
+                    hasRootAppNotFound = true;
+                    if (isRootNotFound) {
+                        continue;
+                    }
+                    if (!isRootNotFound && !validFileMatcher.isAppRouterPage(fileName)) {
+                        continue;
+                    }
+                    // Ignore files/directories starting with `_` in the app directory
+                    if ((0, _normalizepathsep.normalizePathSep)(pageName).includes("/_")) {
+                        continue;
+                    }
+                    const originalPageName = pageName;
+                    pageName = (0, _apppaths.normalizeAppPath)(pageName).replace(/%5F/g, "_");
+                    if (!appPaths[pageName]) {
+                        appPaths[pageName] = [];
+                    }
+                    appPaths[pageName].push(originalPageName);
+                    if (useFileSystemPublicRoutes) {
+                        appFiles.add(pageName);
+                    }
+                    if (routedPages.includes(pageName)) {
+                        continue;
+                    }
+                } else {
+                    if (useFileSystemPublicRoutes) {
+                        pageFiles.add(pageName);
+                        // always add to nextDataRoutes for now but in future only add
+                        // entries that actually use getStaticProps/getServerSideProps
+                        opts.fsChecker.nextDataRoutes.add(pageName);
+                    }
+                }
+                (isAppPath ? appPageFilePaths : pagesPageFilePaths).set(pageName, fileName);
+                if (appDir && pageNameSet.has(pageName)) {
+                    conflictingAppPagePaths.add(pageName);
+                } else {
+                    pageNameSet.add(pageName);
+                }
+                /**
+         * If there is a middleware that is not declared in the root we will
+         * warn without adding it so it doesn't make its way into the system.
+         */ if (/[\\\\/]_middleware$/.test(pageName)) {
+                    nestedMiddleware.push(pageName);
+                    continue;
+                }
+                routedPages.push(pageName);
+            }
+            const numConflicting = conflictingAppPagePaths.size;
+            conflictingPageChange = numConflicting - previousConflictingPagePaths.size;
+            if (conflictingPageChange !== 0) {
+                if (numConflicting > 0) {
+                    let errorMessage = `Conflicting app and page file${numConflicting === 1 ? " was" : "s were"} found, please remove the conflicting files to continue:\n`;
+                    for (const p of conflictingAppPagePaths){
+                        const appPath = _path.default.relative(dir, appPageFilePaths.get(p));
+                        const pagesPath = _path.default.relative(dir, pagesPageFilePaths.get(p));
+                        errorMessage += `  "${pagesPath}" - "${appPath}"\n`;
+                    }
+                    hotReloader.setHmrServerError(new Error(errorMessage));
+                } else if (numConflicting === 0) {
+                    hotReloader.clearHmrServerError();
+                    await propagateServerField(opts, "reloadMatchers", undefined);
+                }
+            }
+            previousConflictingPagePaths = conflictingAppPagePaths;
+            let clientRouterFilters;
+            if (nextConfig.experimental.clientRouterFilter) {
+                clientRouterFilters = (0, _createclientrouterfilter.createClientRouterFilter)(Object.keys(appPaths), nextConfig.experimental.clientRouterFilterRedirects ? (nextConfig._originalRedirects || []).filter((r)=>!r.internal) : [], nextConfig.experimental.clientRouterFilterAllowedRate);
+                if (!previousClientRouterFilters || JSON.stringify(previousClientRouterFilters) !== JSON.stringify(clientRouterFilters)) {
+                    envChange = true;
+                    previousClientRouterFilters = clientRouterFilters;
+                }
+            }
+            if (!usingTypeScript && enabledTypeScript) {
+                // we tolerate the error here as this is best effort
+                // and the manual install command will be shown
+                await verifyTypeScript(opts).then(()=>{
+                    tsconfigChange = true;
+                }).catch(()=>{});
+            }
+            if (envChange || tsconfigChange) {
+                var _hotReloader_activeWebpackConfigs;
+                if (envChange) {
+                    // only log changes in router server
+                    (0, _env.loadEnvConfig)(dir, true, _log, true, (envFilePath)=>{
+                        _log.info(`Reload env: ${envFilePath}`);
+                    });
+                    await propagateServerField(opts, "loadEnvConfig", [
+                        {
+                            dev: true,
+                            forceReload: true,
+                            silent: true
+                        }
+                    ]);
+                }
+                let tsconfigResult;
+                if (tsconfigChange) {
+                    try {
+                        tsconfigResult = await (0, _loadjsconfig.default)(dir, nextConfig);
+                    } catch (_) {
+                    /* do we want to log if there are syntax errors in tsconfig  while editing? */ }
+                }
+                if (hotReloader.turbopackProject) {
+                    const hasRewrites = opts.fsChecker.rewrites.afterFiles.length > 0 || opts.fsChecker.rewrites.beforeFiles.length > 0 || opts.fsChecker.rewrites.fallback.length > 0;
+                    await hotReloader.turbopackProject.update({
+                        defineEnv: (0, _swc.createDefineEnv)({
+                            isTurbopack: true,
+                            clientRouterFilters,
+                            config: nextConfig,
+                            dev: true,
+                            distDir,
+                            fetchCacheKeyPrefix: opts.nextConfig.experimental.fetchCacheKeyPrefix,
+                            hasRewrites,
+                            // TODO: Implement
+                            middlewareMatchers: undefined
+                        })
+                    });
+                }
+                (_hotReloader_activeWebpackConfigs = hotReloader.activeWebpackConfigs) == null ? void 0 : _hotReloader_activeWebpackConfigs.forEach((config, idx)=>{
+                    const isClient = idx === 0;
+                    const isNodeServer = idx === 1;
+                    const isEdgeServer = idx === 2;
+                    const hasRewrites = opts.fsChecker.rewrites.afterFiles.length > 0 || opts.fsChecker.rewrites.beforeFiles.length > 0 || opts.fsChecker.rewrites.fallback.length > 0;
+                    if (tsconfigChange) {
+                        var _config_resolve_plugins, _config_resolve;
+                        (_config_resolve = config.resolve) == null ? void 0 : (_config_resolve_plugins = _config_resolve.plugins) == null ? void 0 : _config_resolve_plugins.forEach((plugin)=>{
+                            // look for the JsConfigPathsPlugin and update with
+                            // the latest paths/baseUrl config
+                            if (plugin && plugin.jsConfigPlugin && tsconfigResult) {
+                                var _config_resolve_modules, _config_resolve, _jsConfig_compilerOptions;
+                                const { resolvedBaseUrl, jsConfig } = tsconfigResult;
+                                const currentResolvedBaseUrl = plugin.resolvedBaseUrl;
+                                const resolvedUrlIndex = (_config_resolve = config.resolve) == null ? void 0 : (_config_resolve_modules = _config_resolve.modules) == null ? void 0 : _config_resolve_modules.findIndex((item)=>item === currentResolvedBaseUrl);
+                                if (resolvedBaseUrl) {
+                                    if (resolvedBaseUrl.baseUrl !== currentResolvedBaseUrl.baseUrl) {
+                                        // remove old baseUrl and add new one
+                                        if (resolvedUrlIndex && resolvedUrlIndex > -1) {
+                                            var _config_resolve_modules1, _config_resolve1;
+                                            (_config_resolve1 = config.resolve) == null ? void 0 : (_config_resolve_modules1 = _config_resolve1.modules) == null ? void 0 : _config_resolve_modules1.splice(resolvedUrlIndex, 1);
+                                        }
+                                        // If the resolvedBaseUrl is implicit we only remove the previous value.
+                                        // Only add the baseUrl if it's explicitly set in tsconfig/jsconfig
+                                        if (!resolvedBaseUrl.isImplicit) {
+                                            var _config_resolve_modules2, _config_resolve2;
+                                            (_config_resolve2 = config.resolve) == null ? void 0 : (_config_resolve_modules2 = _config_resolve2.modules) == null ? void 0 : _config_resolve_modules2.push(resolvedBaseUrl.baseUrl);
+                                        }
+                                    }
+                                }
+                                if ((jsConfig == null ? void 0 : (_jsConfig_compilerOptions = jsConfig.compilerOptions) == null ? void 0 : _jsConfig_compilerOptions.paths) && resolvedBaseUrl) {
+                                    Object.keys(plugin.paths).forEach((key)=>{
+                                        delete plugin.paths[key];
+                                    });
+                                    Object.assign(plugin.paths, jsConfig.compilerOptions.paths);
+                                    plugin.resolvedBaseUrl = resolvedBaseUrl;
+                                }
+                            }
+                        });
+                    }
+                    if (envChange) {
+                        var _config_plugins;
+                        (_config_plugins = config.plugins) == null ? void 0 : _config_plugins.forEach((plugin)=>{
+                            // we look for the DefinePlugin definitions so we can
+                            // update them on the active compilers
+                            if (plugin && typeof plugin.definitions === "object" && plugin.definitions.__NEXT_DEFINE_ENV) {
+                                const newDefine = (0, _defineenvplugin.getDefineEnv)({
+                                    isTurbopack: false,
+                                    clientRouterFilters,
+                                    config: nextConfig,
+                                    dev: true,
+                                    distDir,
+                                    fetchCacheKeyPrefix: opts.nextConfig.experimental.fetchCacheKeyPrefix,
+                                    hasRewrites,
+                                    isClient,
+                                    isEdgeServer,
+                                    isNodeOrEdgeCompilation: isNodeServer || isEdgeServer,
+                                    isNodeServer,
+                                    middlewareMatchers: undefined
+                                });
+                                Object.keys(plugin.definitions).forEach((key)=>{
+                                    if (!(key in newDefine)) {
+                                        delete plugin.definitions[key];
+                                    }
+                                });
+                                Object.assign(plugin.definitions, newDefine);
+                            }
+                        });
+                    }
+                });
+                await hotReloader.invalidate({
+                    reloadAfterInvalidation: envChange
+                });
+            }
+            if (nestedMiddleware.length > 0) {
+                _log.error(new _utils1.NestedMiddlewareError(nestedMiddleware, dir, pagesDir || appDir).message);
+                nestedMiddleware = [];
+            }
+            // Make sure to sort parallel routes to make the result deterministic.
+            serverFields.appPathRoutes = Object.fromEntries(Object.entries(appPaths).map(([k, v])=>[
+                    k,
+                    v.sort()
+                ]));
+            await propagateServerField(opts, "appPathRoutes", serverFields.appPathRoutes);
+            // TODO: pass this to fsChecker/next-dev-server?
+            serverFields.middleware = middlewareMatchers ? {
+                match: null,
+                page: "/",
+                matchers: middlewareMatchers
+            } : undefined;
+            await propagateServerField(opts, "middleware", serverFields.middleware);
+            serverFields.hasAppNotFound = hasRootAppNotFound;
+            opts.fsChecker.middlewareMatcher = ((_serverFields_middleware = serverFields.middleware) == null ? void 0 : _serverFields_middleware.matchers) ? (0, _middlewareroutematcher.getMiddlewareRouteMatcher)((_serverFields_middleware1 = serverFields.middleware) == null ? void 0 : _serverFields_middleware1.matchers) : undefined;
+            const interceptionRoutes = (0, _generateinterceptionroutesrewrites.generateInterceptionRoutesRewrites)(Object.keys(appPaths), opts.nextConfig.basePath).map((item)=>(0, _filesystem.buildCustomRoute)("before_files_rewrite", item, opts.nextConfig.basePath, opts.nextConfig.experimental.caseSensitiveRoutes));
+            opts.fsChecker.rewrites.beforeFiles.push(...interceptionRoutes);
+            const exportPathMap = typeof nextConfig.exportPathMap === "function" && await (nextConfig.exportPathMap == null ? void 0 : nextConfig.exportPathMap.call(nextConfig, {}, {
+                dev: true,
+                dir: opts.dir,
+                outDir: null,
+                distDir: distDir,
+                buildId: "development"
+            })) || {};
+            const exportPathMapEntries = Object.entries(exportPathMap || {});
+            if (exportPathMapEntries.length > 0) {
+                opts.fsChecker.exportPathMapRoutes = exportPathMapEntries.map(([key, value])=>(0, _filesystem.buildCustomRoute)("before_files_rewrite", {
+                        source: key,
+                        destination: `${value.page}${value.query ? "?" : ""}${_querystring.default.stringify(value.query)}`
+                    }, opts.nextConfig.basePath, opts.nextConfig.experimental.caseSensitiveRoutes));
+            }
+            try {
+                // we serve a separate manifest with all pages for the client in
+                // dev mode so that we can match a page after a rewrite on the client
+                // before it has been built and is populated in the _buildManifest
+                const sortedRoutes = (0, _utils.getSortedRoutes)(routedPages);
+                opts.fsChecker.dynamicRoutes = sortedRoutes.map((page)=>{
+                    const regex = (0, _routeregex.getRouteRegex)(page);
+                    return {
+                        regex: regex.re.toString(),
+                        match: (0, _routematcher.getRouteMatcher)(regex),
+                        page
+                    };
+                });
+                const dataRoutes = [];
+                for (const page of sortedRoutes){
+                    const route = (0, _builddataroute.buildDataRoute)(page, "development");
+                    const routeRegex = (0, _routeregex.getRouteRegex)(route.page);
+                    dataRoutes.push({
+                        ...route,
+                        regex: routeRegex.re.toString(),
+                        match: (0, _routematcher.getRouteMatcher)({
+                            // TODO: fix this in the manifest itself, must also be fixed in
+                            // upstream builder that relies on this
+                            re: opts.nextConfig.i18n ? new RegExp(route.dataRouteRegex.replace(`/development/`, `/development/(?<nextLocale>[^/]+?)/`)) : new RegExp(route.dataRouteRegex),
+                            groups: routeRegex.groups
+                        })
+                    });
+                }
+                opts.fsChecker.dynamicRoutes.unshift(...dataRoutes);
+                if (!(prevSortedRoutes == null ? void 0 : prevSortedRoutes.every((val, idx)=>val === sortedRoutes[idx]))) {
+                    const addedRoutes = sortedRoutes.filter((route)=>!prevSortedRoutes.includes(route));
+                    const removedRoutes = prevSortedRoutes.filter((route)=>!sortedRoutes.includes(route));
+                    // emit the change so clients fetch the update
+                    hotReloader.send({
+                        action: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.DEV_PAGES_MANIFEST_UPDATE,
+                        data: [
+                            {
+                                devPagesManifest: true
+                            }
+                        ]
+                    });
+                    addedRoutes.forEach((route)=>{
+                        hotReloader.send({
+                            action: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.ADDED_PAGE,
+                            data: [
+                                route
+                            ]
+                        });
+                    });
+                    removedRoutes.forEach((route)=>{
+                        hotReloader.send({
+                            action: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.REMOVED_PAGE,
+                            data: [
+                                route
+                            ]
+                        });
+                    });
+                }
+                prevSortedRoutes = sortedRoutes;
+                if (!resolved) {
+                    resolve();
+                    resolved = true;
+                }
+            } catch (e) {
+                if (!resolved) {
+                    reject(e);
+                    resolved = true;
+                } else {
+                    _log.warn("Failed to reload dynamic routes:", e);
+                }
+            } finally{
+                // Reload the matchers. The filesystem would have been written to,
+                // and the matchers need to re-scan it to update the router.
+                await propagateServerField(opts, "reloadMatchers", undefined);
+            }
+        });
+        wp.watch({
+            directories: [
+                dir
+            ],
+            startTime: 0
+        });
+    });
+    const clientPagesManifestPath = `/_next/${_constants.CLIENT_STATIC_FILES_PATH}/development/${_constants.DEV_CLIENT_PAGES_MANIFEST}`;
+    opts.fsChecker.devVirtualFsItems.add(clientPagesManifestPath);
+    const devMiddlewareManifestPath = `/_next/${_constants.CLIENT_STATIC_FILES_PATH}/development/${_constants.DEV_MIDDLEWARE_MANIFEST}`;
+    opts.fsChecker.devVirtualFsItems.add(devMiddlewareManifestPath);
+    async function requestHandler(req, res) {
+        var _parsedUrl_pathname, _parsedUrl_pathname1;
+        const parsedUrl = _url.default.parse(req.url || "/");
+        if ((_parsedUrl_pathname = parsedUrl.pathname) == null ? void 0 : _parsedUrl_pathname.includes(clientPagesManifestPath)) {
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json; charset=utf-8");
+            res.end(JSON.stringify({
+                pages: prevSortedRoutes.filter((route)=>!opts.fsChecker.appFiles.has(route))
+            }));
+            return {
+                finished: true
+            };
+        }
+        if ((_parsedUrl_pathname1 = parsedUrl.pathname) == null ? void 0 : _parsedUrl_pathname1.includes(devMiddlewareManifestPath)) {
+            var _serverFields_middleware;
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json; charset=utf-8");
+            res.end(JSON.stringify(((_serverFields_middleware = serverFields.middleware) == null ? void 0 : _serverFields_middleware.matchers) || []));
+            return {
+                finished: true
+            };
+        }
+        return {
+            finished: false
+        };
+    }
+    async function logErrorWithOriginalStack(err, type) {
+        let usedOriginalStack = false;
+        if ((0, _iserror.default)(err) && err.stack) {
+            try {
+                const frames = (0, _middleware.parseStack)(err.stack);
+                // Filter out internal edge related runtime stack
+                const frame = frames.find(({ file })=>!(file == null ? void 0 : file.startsWith("eval")) && !(file == null ? void 0 : file.includes("web/adapter")) && !(file == null ? void 0 : file.includes("web/globals")) && !(file == null ? void 0 : file.includes("sandbox/context")) && !(file == null ? void 0 : file.includes("<anonymous>")));
+                let originalFrame, isEdgeCompiler;
+                const frameFile = frame == null ? void 0 : frame.file;
+                if ((frame == null ? void 0 : frame.lineNumber) && frameFile) {
+                    if (hotReloader.turbopackProject) {
+                        try {
+                            originalFrame = await (0, _middlewareturbopack.createOriginalStackFrame)(hotReloader.turbopackProject, {
+                                file: frameFile,
+                                methodName: frame.methodName,
+                                line: frame.lineNumber ?? 0,
+                                column: frame.column,
+                                isServer: true
+                            });
+                        } catch  {}
+                    } else {
+                        var _hotReloader_edgeServerStats, _hotReloader_serverStats, _frame_file, _frame_file1;
+                        const moduleId = frameFile.replace(/^(webpack-internal:\/\/\/|file:\/\/)/, "");
+                        const modulePath = frameFile.replace(/^(webpack-internal:\/\/\/|file:\/\/)(\(.*\)\/)?/, "");
+                        const src = (0, _errorsource.getErrorSource)(err);
+                        isEdgeCompiler = src === _constants.COMPILER_NAMES.edgeServer;
+                        const compilation = isEdgeCompiler ? (_hotReloader_edgeServerStats = hotReloader.edgeServerStats) == null ? void 0 : _hotReloader_edgeServerStats.compilation : (_hotReloader_serverStats = hotReloader.serverStats) == null ? void 0 : _hotReloader_serverStats.compilation;
+                        const source = await (0, _middleware.getSourceById)(!!((_frame_file = frame.file) == null ? void 0 : _frame_file.startsWith(_path.default.sep)) || !!((_frame_file1 = frame.file) == null ? void 0 : _frame_file1.startsWith("file:")), moduleId, compilation);
+                        try {
+                            var _hotReloader_edgeServerStats1, _hotReloader_serverStats1;
+                            originalFrame = await (0, _middleware.createOriginalStackFrame)({
+                                source,
+                                frame,
+                                moduleId,
+                                modulePath,
+                                rootDirectory: opts.dir,
+                                errorMessage: err.message,
+                                compilation: isEdgeCompiler ? (_hotReloader_edgeServerStats1 = hotReloader.edgeServerStats) == null ? void 0 : _hotReloader_edgeServerStats1.compilation : (_hotReloader_serverStats1 = hotReloader.serverStats) == null ? void 0 : _hotReloader_serverStats1.compilation
+                            });
+                        } catch  {}
+                    }
+                    if ((originalFrame == null ? void 0 : originalFrame.originalCodeFrame) && originalFrame.originalStackFrame) {
+                        const { originalCodeFrame, originalStackFrame } = originalFrame;
+                        const { file, lineNumber, column, methodName } = originalStackFrame;
+                        _log[type === "warning" ? "warn" : "error"](`${file} (${lineNumber}:${column}) @ ${methodName}`);
+                        let errorToLog;
+                        if (isEdgeCompiler) {
+                            errorToLog = err.message;
+                        } else if ((0, _iserror.default)(err) && hotReloader.turbopackProject) {
+                            const stack = await traceTurbopackErrorStack(hotReloader.turbopackProject, err, frames);
+                            const error = new Error(err.message);
+                            error.stack = stack;
+                            error.digest = err.digest;
+                            errorToLog = error;
+                        } else {
+                            errorToLog = err;
+                        }
+                        if (type === "warning") {
+                            _log.warn(errorToLog);
+                        } else if (type === "app-dir") {
+                            (0, _logappdirerror.logAppDirError)(errorToLog);
+                        } else if (type) {
+                            _log.error(`${type}:`, errorToLog);
+                        } else {
+                            _log.error(errorToLog);
+                        }
+                        console[type === "warning" ? "warn" : "error"](originalCodeFrame);
+                        usedOriginalStack = true;
+                    }
+                }
+            } catch (_) {
+            // failed to load original stack using source maps
+            // this un-actionable by users so we don't show the
+            // internal error and only show the provided stack
+            }
+        }
+        if (!usedOriginalStack) {
+            if (err instanceof ModuleBuildError) {
+                _log.error(err.message);
+            } else if (type === "warning") {
+                _log.warn(err);
+            } else if (type === "app-dir") {
+                (0, _logappdirerror.logAppDirError)(err);
+            } else if (type) {
+                _log.error(`${type}:`, err);
+            } else {
+                _log.error(err);
+            }
+        }
+    }
+    return {
+        serverFields,
+        hotReloader,
+        requestHandler,
+        logErrorWithOriginalStack,
+        async ensureMiddleware (requestUrl) {
+            if (!serverFields.actualMiddlewareFile) return;
+            return hotReloader.ensurePage({
+                page: serverFields.actualMiddlewareFile,
+                clientOnly: false,
+                definition: undefined,
+                url: requestUrl
+            });
+        }
+    };
+}
+async function setupDevBundler(opts) {
+    const isSrcDir = _path.default.relative(opts.dir, opts.pagesDir || opts.appDir || "").startsWith("src");
+    const result = await startWatcher(opts);
+    opts.telemetry.record((0, _events.eventCliSession)(_path.default.join(opts.dir, opts.nextConfig.distDir), opts.nextConfig, {
+        webpackVersion: 5,
+        isSrcDir,
+        turboFlag: !!opts.turbo,
+        cliCommand: "dev",
+        appDir: !!opts.appDir,
+        pagesDir: !!opts.pagesDir,
+        isCustomServer: !!opts.isCustomServer,
+        hasNowJson: !!await (0, _findup.default)("now.json", {
+            cwd: opts.dir
+        })
+    }));
+    return result;
+}
+// Returns a trace rewritten through Turbopack's sourcemaps
+async function traceTurbopackErrorStack(project, error, frames) {
+    let originalFrames = await Promise.all(frames.map(async (f)=>{
+        try {
+            const traced = await (0, _middlewareturbopack.batchedTraceSource)(project, {
+                file: f.file,
+                methodName: f.methodName,
+                line: f.lineNumber ?? 0,
+                column: f.column,
+                isServer: true
+            });
+            return (traced == null ? void 0 : traced.frame) ?? f;
+        } catch  {
+            return f;
+        }
+    }));
+    return error.name + ": " + error.message + "\n" + originalFrames.map((f)=>{
+        if (f == null) {
+            return null;
+        }
+        let line = "    at";
+        if (f.methodName != null) {
+            line += " " + f.methodName;
+        }
+        if (f.file != null) {
+            const file = f.file.startsWith("/") || // Built-in "filenames" like `<anonymous>` shouldn't be made relative
+            f.file.startsWith("<") || f.file.startsWith("node:") ? f.file : `./${f.file}`;
+            line += ` (${file}`;
+            if (f.lineNumber != null) {
+                line += ":" + f.lineNumber;
+                if (f.column != null) {
+                    line += ":" + f.column;
+                }
+            }
+            line += ")";
+        }
+        return line;
+    }).filter(Boolean).join("\n");
+}
+
+//# sourceMappingURL=setup-dev-bundler.js.map

node_modules/next/dist/server/lib/router-utils/types.d.ts

@@ -0,0 +1 @@
+export type PropagateToWorkersField = 'actualMiddlewareFile' | 'actualInstrumentationHookFile' | 'reloadMatchers' | 'loadEnvConfig' | 'appPathRoutes' | 'middleware';

node_modules/next/dist/server/lib/router-utils/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=types.js.map

node_modules/next/dist/server/lib/router-utils/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}