Initial boiler plate project

node_modules/next/dist/server/future/route-modules/app-route/helpers/auto-implement-methods.d.ts

@@ -0,0 +1,3 @@
+import type { AppRouteHandlerFn, AppRouteHandlers } from '../module';
+import { type HTTP_METHOD } from '../../../../web/http';
+export declare function autoImplementMethods(handlers: AppRouteHandlers): Record<HTTP_METHOD, AppRouteHandlerFn>;

node_modules/next/dist/server/future/route-modules/app-route/helpers/auto-implement-methods.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "autoImplementMethods", {
+    enumerable: true,
+    get: function() {
+        return autoImplementMethods;
+    }
+});
+const _http = require("../../../../web/http");
+const _responsehandlers = require("../../helpers/response-handlers");
+const AUTOMATIC_ROUTE_METHODS = [
+    "HEAD",
+    "OPTIONS"
+];
+function autoImplementMethods(handlers) {
+    // Loop through all the HTTP methods to create the initial methods object.
+    // Each of the methods will be set to the the 405 response handler.
+    const methods = _http.HTTP_METHODS.reduce((acc, method)=>({
+            ...acc,
+            // If the userland module implements the method, then use it. Otherwise,
+            // use the 405 response handler.
+            [method]: handlers[method] ?? _responsehandlers.handleMethodNotAllowedResponse
+        }), {});
+    // Get all the methods that could be automatically implemented that were not
+    // implemented by the userland module.
+    const implemented = new Set(_http.HTTP_METHODS.filter((method)=>handlers[method]));
+    const missing = AUTOMATIC_ROUTE_METHODS.filter((method)=>!implemented.has(method));
+    // Loop over the missing methods to automatically implement them if we can.
+    for (const method of missing){
+        // If the userland module doesn't implement the HEAD method, then
+        // we'll automatically implement it by calling the GET method (if it
+        // exists).
+        if (method === "HEAD") {
+            if (handlers.GET) {
+                // Implement the HEAD method by calling the GET method.
+                methods.HEAD = handlers.GET;
+                // Mark it as implemented.
+                implemented.add("HEAD");
+            }
+            continue;
+        }
+        // If OPTIONS is not provided then implement it.
+        if (method === "OPTIONS") {
+            // TODO: check if HEAD is implemented, if so, use it to add more headers
+            // Get all the methods that were implemented by the userland module.
+            const allow = [
+                "OPTIONS",
+                ...implemented
+            ];
+            // If the list of methods doesn't include HEAD, but it includes GET, then
+            // add HEAD as it's automatically implemented.
+            if (!implemented.has("HEAD") && implemented.has("GET")) {
+                allow.push("HEAD");
+            }
+            // Sort and join the list with commas to create the `Allow` header. See:
+            // https://httpwg.org/specs/rfc9110.html#field.allow
+            const headers = {
+                Allow: allow.sort().join(", ")
+            };
+            // Implement the OPTIONS method by returning a 204 response with the
+            // `Allow` header.
+            methods.OPTIONS = ()=>new Response(null, {
+                    status: 204,
+                    headers
+                });
+            // Mark this method as implemented.
+            implemented.add("OPTIONS");
+            continue;
+        }
+        throw new Error(`Invariant: should handle all automatic implementable methods, got method: ${method}`);
+    }
+    return methods;
+}
+
+//# sourceMappingURL=auto-implement-methods.js.map

node_modules/next/dist/server/future/route-modules/app-route/helpers/auto-implement-methods.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/future/route-modules/app-route/helpers/auto-implement-methods.ts"],"names":["autoImplementMethods","AUTOMATIC_ROUTE_METHODS","handlers","methods","HTTP_METHODS","reduce","acc","method","handleMethodNotAllowedResponse","implemented","Set","filter","missing","has","GET","HEAD","add","allow","push","headers","Allow","sort","join","OPTIONS","Response","status","Error"],"mappings":";;;;+BAOgBA;;;eAAAA;;;sBAL+B;kCACA;AAE/C,MAAMC,0BAA0B;IAAC;IAAQ;CAAU;AAE5C,SAASD,qBACdE,QAA0B;IAE1B,0EAA0E;IAC1E,mEAAmE;IACnE,MAAMC,UAAkDC,kBAAY,CAACC,MAAM,CACzE,CAACC,KAAKC,SAAY,CAAA;YAChB,GAAGD,GAAG;YACN,wEAAwE;YACxE,gCAAgC;YAChC,CAACC,OAAO,EAAEL,QAAQ,CAACK,OAAO,IAAIC,gDAA8B;QAC9D,CAAA,GACA,CAAC;IAGH,4EAA4E;IAC5E,sCAAsC;IACtC,MAAMC,cAAc,IAAIC,IAAIN,kBAAY,CAACO,MAAM,CAAC,CAACJ,SAAWL,QAAQ,CAACK,OAAO;IAC5E,MAAMK,UAAUX,wBAAwBU,MAAM,CAC5C,CAACJ,SAAW,CAACE,YAAYI,GAAG,CAACN;IAG/B,2EAA2E;IAC3E,KAAK,MAAMA,UAAUK,QAAS;QAC5B,iEAAiE;QACjE,oEAAoE;QACpE,WAAW;QACX,IAAIL,WAAW,QAAQ;YACrB,IAAIL,SAASY,GAAG,EAAE;gBAChB,uDAAuD;gBACvDX,QAAQY,IAAI,GAAGb,SAASY,GAAG;gBAE3B,0BAA0B;gBAC1BL,YAAYO,GAAG,CAAC;YAClB;YACA;QACF;QAEA,gDAAgD;QAChD,IAAIT,WAAW,WAAW;YACxB,wEAAwE;YAExE,oEAAoE;YACpE,MAAMU,QAAuB;gBAAC;mBAAcR;aAAY;YAExD,yEAAyE;YACzE,8CAA8C;YAC9C,IAAI,CAACA,YAAYI,GAAG,CAAC,WAAWJ,YAAYI,GAAG,CAAC,QAAQ;gBACtDI,MAAMC,IAAI,CAAC;YACb;YAEA,wEAAwE;YACxE,oDAAoD;YACpD,MAAMC,UAAU;gBAAEC,OAAOH,MAAMI,IAAI,GAAGC,IAAI,CAAC;YAAM;YAEjD,oEAAoE;YACpE,kBAAkB;YAClBnB,QAAQoB,OAAO,GAAG,IAAM,IAAIC,SAAS,MAAM;oBAAEC,QAAQ;oBAAKN;gBAAQ;YAElE,mCAAmC;YACnCV,YAAYO,GAAG,CAAC;YAEhB;QACF;QAEA,MAAM,IAAIU,MACR,CAAC,0EAA0E,EAAEnB,OAAO,CAAC;IAEzF;IAEA,OAAOJ;AACT"}

node_modules/next/dist/server/future/route-modules/app-route/helpers/clean-url.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Cleans a URL by stripping the protocol, host, and search params.
+ *
+ * @param urlString the url to clean
+ * @returns the cleaned url
+ */
+export declare function cleanURL(url: string | URL): URL;

node_modules/next/dist/server/future/route-modules/app-route/helpers/clean-url.js

@@ -0,0 +1,24 @@
+/**
+ * Cleans a URL by stripping the protocol, host, and search params.
+ *
+ * @param urlString the url to clean
+ * @returns the cleaned url
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "cleanURL", {
+    enumerable: true,
+    get: function() {
+        return cleanURL;
+    }
+});
+function cleanURL(url) {
+    const u = new URL(url);
+    u.host = "localhost:3000";
+    u.search = "";
+    u.protocol = "http";
+    return u;
+}
+
+//# sourceMappingURL=clean-url.js.map

node_modules/next/dist/server/future/route-modules/app-route/helpers/clean-url.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/future/route-modules/app-route/helpers/clean-url.ts"],"names":["cleanURL","url","u","URL","host","search","protocol"],"mappings":"AAAA;;;;;CAKC;;;;+BAEeA;;;eAAAA;;;AAAT,SAASA,SAASC,GAAiB;IACxC,MAAMC,IAAI,IAAIC,IAAIF;IAClBC,EAAEE,IAAI,GAAG;IACTF,EAAEG,MAAM,GAAG;IACXH,EAAEI,QAAQ,GAAG;IACb,OAAOJ;AACT"}

node_modules/next/dist/server/future/route-modules/app-route/helpers/get-pathname-from-absolute-path.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Get pathname from absolute path.
+ *
+ * @param absolutePath the absolute path
+ * @returns the pathname
+ */
+export declare function getPathnameFromAbsolutePath(absolutePath: string): string;

node_modules/next/dist/server/future/route-modules/app-route/helpers/get-pathname-from-absolute-path.js

@@ -0,0 +1,29 @@
+/**
+ * Get pathname from absolute path.
+ *
+ * @param absolutePath the absolute path
+ * @returns the pathname
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getPathnameFromAbsolutePath", {
+    enumerable: true,
+    get: function() {
+        return getPathnameFromAbsolutePath;
+    }
+});
+function getPathnameFromAbsolutePath(absolutePath) {
+    // Remove prefix including app dir
+    let appDir = "/app/";
+    if (!absolutePath.includes(appDir)) {
+        appDir = "\\app\\";
+    }
+    const [, ...parts] = absolutePath.split(appDir);
+    const relativePath = appDir[0] + parts.join(appDir);
+    // remove extension
+    const pathname = relativePath.split(".").slice(0, -1).join(".");
+    return pathname;
+}
+
+//# sourceMappingURL=get-pathname-from-absolute-path.js.map

node_modules/next/dist/server/future/route-modules/app-route/helpers/get-pathname-from-absolute-path.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/future/route-modules/app-route/helpers/get-pathname-from-absolute-path.ts"],"names":["getPathnameFromAbsolutePath","absolutePath","appDir","includes","parts","split","relativePath","join","pathname","slice"],"mappings":"AAAA;;;;;CAKC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA,4BAA4BC,YAAoB;IAC9D,kCAAkC;IAClC,IAAIC,SAAS;IACb,IAAI,CAACD,aAAaE,QAAQ,CAACD,SAAS;QAClCA,SAAS;IACX;IACA,MAAM,GAAG,GAAGE,MAAM,GAAGH,aAAaI,KAAK,CAACH;IACxC,MAAMI,eAAeJ,MAAM,CAAC,EAAE,GAAGE,MAAMG,IAAI,CAACL;IAE5C,mBAAmB;IACnB,MAAMM,WAAWF,aAAaD,KAAK,CAAC,KAAKI,KAAK,CAAC,GAAG,CAAC,GAAGF,IAAI,CAAC;IAC3D,OAAOC;AACT"}

node_modules/next/dist/server/future/route-modules/app-route/helpers/parsed-url-query-to-params.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import type { ParsedUrlQuery } from 'querystring';
+/**
+ * Converts the query into params.
+ *
+ * @param query the query to convert to params
+ * @returns the params
+ */
+export declare function parsedUrlQueryToParams(query: ParsedUrlQuery): Record<string, string | string[]>;

node_modules/next/dist/server/future/route-modules/app-route/helpers/parsed-url-query-to-params.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parsedUrlQueryToParams", {
+    enumerable: true,
+    get: function() {
+        return parsedUrlQueryToParams;
+    }
+});
+function parsedUrlQueryToParams(query) {
+    const params = {};
+    for (const [key, value] of Object.entries(query)){
+        if (typeof value === "undefined") continue;
+        params[key] = value;
+    }
+    return params;
+}
+
+//# sourceMappingURL=parsed-url-query-to-params.js.map

node_modules/next/dist/server/future/route-modules/app-route/helpers/parsed-url-query-to-params.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/future/route-modules/app-route/helpers/parsed-url-query-to-params.ts"],"names":["parsedUrlQueryToParams","query","params","key","value","Object","entries"],"mappings":";;;;+BAQgBA;;;eAAAA;;;AAAT,SAASA,uBACdC,KAAqB;IAErB,MAAMC,SAA4C,CAAC;IAEnD,KAAK,MAAM,CAACC,KAAKC,MAAM,IAAIC,OAAOC,OAAO,CAACL,OAAQ;QAChD,IAAI,OAAOG,UAAU,aAAa;QAClCF,MAAM,CAACC,IAAI,GAAGC;IAChB;IAEA,OAAOF;AACT"}

node_modules/next/dist/server/future/route-modules/app-route/helpers/resolve-handler-error.d.ts

@@ -0,0 +1 @@
+export declare function resolveHandlerError(err: any): Response | false;

node_modules/next/dist/server/future/route-modules/app-route/helpers/resolve-handler-error.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveHandlerError", {
+    enumerable: true,
+    get: function() {
+        return resolveHandlerError;
+    }
+});
+const _notfound = require("../../../../../client/components/not-found");
+const _redirect = require("../../../../../client/components/redirect");
+const _responsehandlers = require("../../helpers/response-handlers");
+function resolveHandlerError(err) {
+    if ((0, _redirect.isRedirectError)(err)) {
+        const redirect = (0, _redirect.getURLFromRedirectError)(err);
+        if (!redirect) {
+            throw new Error("Invariant: Unexpected redirect url format");
+        }
+        const status = (0, _redirect.getRedirectStatusCodeFromError)(err);
+        // This is a redirect error! Send the redirect response.
+        return (0, _responsehandlers.handleRedirectResponse)(redirect, err.mutableCookies, status);
+    }
+    if ((0, _notfound.isNotFoundError)(err)) {
+        // This is a not found error! Send the not found response.
+        return (0, _responsehandlers.handleNotFoundResponse)();
+    }
+    // Return false to indicate that this is not a handled error.
+    return false;
+}
+
+//# sourceMappingURL=resolve-handler-error.js.map

node_modules/next/dist/server/future/route-modules/app-route/helpers/resolve-handler-error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/future/route-modules/app-route/helpers/resolve-handler-error.ts"],"names":["resolveHandlerError","err","isRedirectError","redirect","getURLFromRedirectError","Error","status","getRedirectStatusCodeFromError","handleRedirectResponse","mutableCookies","isNotFoundError","handleNotFoundResponse"],"mappings":";;;;+BAWgBA;;;eAAAA;;;0BAXgB;0BAKzB;kCAIA;AAEA,SAASA,oBAAoBC,GAAQ;IAC1C,IAAIC,IAAAA,yBAAe,EAACD,MAAM;QACxB,MAAME,WAAWC,IAAAA,iCAAuB,EAACH;QACzC,IAAI,CAACE,UAAU;YACb,MAAM,IAAIE,MAAM;QAClB;QAEA,MAAMC,SAASC,IAAAA,wCAA8B,EAACN;QAE9C,wDAAwD;QACxD,OAAOO,IAAAA,wCAAsB,EAACL,UAAUF,IAAIQ,cAAc,EAAEH;IAC9D;IAEA,IAAII,IAAAA,yBAAe,EAACT,MAAM;QACxB,0DAA0D;QAC1D,OAAOU,IAAAA,wCAAsB;IAC/B;IAEA,6DAA6D;IAC7D,OAAO;AACT"}

node_modules/next/dist/server/future/route-modules/app-route/module.compiled.d.ts

@@ -0,0 +1 @@
+export * from './module'

node_modules/next/dist/server/future/route-modules/app-route/module.compiled.js

@@ -0,0 +1,24 @@
+"use strict";
+if (process.env.NEXT_RUNTIME === "edge") {
+    module.exports = require("next/dist/server/future/route-modules/app-route/module.js");
+} else {
+    if (process.env.__NEXT_EXPERIMENTAL_REACT) {
+        if (process.env.NODE_ENV === "development") {
+            module.exports = require("next/dist/compiled/next-server/app-route-experimental.runtime.dev.js");
+        } else if (process.env.TURBOPACK) {
+            module.exports = require("next/dist/compiled/next-server/app-route-turbo-experimental.runtime.prod.js");
+        } else {
+            module.exports = require("next/dist/compiled/next-server/app-route-experimental.runtime.prod.js");
+        }
+    } else {
+        if (process.env.NODE_ENV === "development") {
+            module.exports = require("next/dist/compiled/next-server/app-route.runtime.dev.js");
+        } else if (process.env.TURBOPACK) {
+            module.exports = require("next/dist/compiled/next-server/app-route-turbo.runtime.prod.js");
+        } else {
+            module.exports = require("next/dist/compiled/next-server/app-route.runtime.prod.js");
+        }
+    }
+}
+
+//# sourceMappingURL=module.compiled.js.map

node_modules/next/dist/server/future/route-modules/app-route/module.compiled.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/future/route-modules/app-route/module.compiled.js"],"names":["process","env","NEXT_RUNTIME","module","exports","require","__NEXT_EXPERIMENTAL_REACT","NODE_ENV","TURBOPACK"],"mappings":";AAAA,IAAIA,QAAQC,GAAG,CAACC,YAAY,KAAK,QAAQ;IACvCC,OAAOC,OAAO,GAAGC,QAAQ;AAC3B,OAAO;IACL,IAAIL,QAAQC,GAAG,CAACK,yBAAyB,EAAE;QACzC,IAAIN,QAAQC,GAAG,CAACM,QAAQ,KAAK,eAAe;YAC1CJ,OAAOC,OAAO,GAAGC,QAAQ;QAC3B,OAAO,IAAIL,QAAQC,GAAG,CAACO,SAAS,EAAE;YAChCL,OAAOC,OAAO,GAAGC,QAAQ;QAC3B,OAAO;YACLF,OAAOC,OAAO,GAAGC,QAAQ;QAC3B;IACF,OAAO;QACL,IAAIL,QAAQC,GAAG,CAACM,QAAQ,KAAK,eAAe;YAC1CJ,OAAOC,OAAO,GAAGC,QAAQ;QAC3B,OAAO,IAAIL,QAAQC,GAAG,CAACO,SAAS,EAAE;YAChCL,OAAOC,OAAO,GAAGC,QAAQ;QAC3B,OAAO;YACLF,OAAOC,OAAO,GAAGC,QAAQ;QAC3B;IACF;AACF"}

node_modules/next/dist/server/future/route-modules/app-route/module.d.ts

@@ -0,0 +1,118 @@
+import type { NextConfig } from '../../../config-shared';
+import type { AppRouteRouteDefinition } from '../../route-definitions/app-route-route-definition';
+import type { AppConfig } from '../../../../build/utils';
+import type { NextRequest } from '../../../web/spec-extension/request';
+import type { PrerenderManifest } from '../../../../build';
+import type { DeepReadonly } from '../../../../shared/lib/deep-readonly';
+import { RouteModule, type RouteModuleHandleContext, type RouteModuleOptions } from '../route-module';
+import { type StaticGenerationContext } from '../../../async-storage/static-generation-async-storage-wrapper';
+import { type HTTP_METHOD } from '../../../web/http';
+import * as serverHooks from '../../../../client/components/hooks-server-context';
+import * as sharedModules from './shared-modules';
+/**
+ * The AppRouteModule is the type of the module exported by the bundled App
+ * Route module.
+ */
+export type AppRouteModule = typeof import('../../../../build/templates/app-route');
+/**
+ * AppRouteRouteHandlerContext is the context that is passed to the route
+ * handler for app routes.
+ */
+export interface AppRouteRouteHandlerContext extends RouteModuleHandleContext {
+    renderOpts: StaticGenerationContext['renderOpts'];
+    prerenderManifest: DeepReadonly<PrerenderManifest>;
+}
+/**
+ * AppRouteHandlerFnContext is the context that is passed to the handler as the
+ * second argument.
+ */
+type AppRouteHandlerFnContext = {
+    params?: Record<string, string | string[]>;
+};
+/**
+ * Handler function for app routes. If a non-Response value is returned, an error
+ * will be thrown.
+ */
+export type AppRouteHandlerFn = (
+/**
+ * Incoming request object.
+ */
+req: NextRequest, 
+/**
+ * Context properties on the request (including the parameters if this was a
+ * dynamic route).
+ */
+ctx: AppRouteHandlerFnContext) => unknown;
+/**
+ * AppRouteHandlers describes the handlers for app routes that is provided by
+ * the userland module.
+ */
+export type AppRouteHandlers = {
+    [method in HTTP_METHOD]?: AppRouteHandlerFn;
+};
+/**
+ * AppRouteUserlandModule is the userland module that is provided for app
+ * routes. This contains all the user generated code.
+ */
+export type AppRouteUserlandModule = AppRouteHandlers & Pick<AppConfig, 'dynamic' | 'revalidate' | 'dynamicParams' | 'fetchCache'> & {
+    generateStaticParams?: any;
+};
+/**
+ * AppRouteRouteModuleOptions is the options that are passed to the app route
+ * module from the bundled code.
+ */
+export interface AppRouteRouteModuleOptions extends RouteModuleOptions<AppRouteRouteDefinition, AppRouteUserlandModule> {
+    readonly resolvedPagePath: string;
+    readonly nextConfigOutput: NextConfig['output'];
+}
+/**
+ * AppRouteRouteHandler is the handler for app routes.
+ */
+export declare class AppRouteRouteModule extends RouteModule<AppRouteRouteDefinition, AppRouteUserlandModule> {
+    /**
+     * A reference to the request async storage.
+     */
+    readonly requestAsyncStorage: import("../../../../client/components/request-async-storage.external").RequestAsyncStorage;
+    /**
+     * A reference to the static generation async storage.
+     */
+    readonly staticGenerationAsyncStorage: import("../../../../client/components/static-generation-async-storage.external").StaticGenerationAsyncStorage;
+    /**
+     * An interface to call server hooks which interact with the underlying
+     * storage.
+     */
+    readonly serverHooks: typeof serverHooks;
+    static readonly sharedModules: typeof sharedModules;
+    /**
+     * A reference to the mutation related async storage, such as mutations of
+     * cookies.
+     */
+    readonly actionAsyncStorage: import("../../../../client/components/action-async-storage.external").ActionAsyncStorage;
+    readonly resolvedPagePath: string;
+    readonly nextConfigOutput: NextConfig['output'] | undefined;
+    private readonly methods;
+    private readonly hasNonStaticMethods;
+    private readonly dynamic;
+    constructor({ userland, definition, resolvedPagePath, nextConfigOutput, }: AppRouteRouteModuleOptions);
+    /**
+     * Resolves the handler function for the given method.
+     *
+     * @param method the requested method
+     * @returns the handler function for the given method
+     */
+    private resolve;
+    /**
+     * Executes the route handler.
+     */
+    private execute;
+    handle(request: NextRequest, context: AppRouteRouteHandlerContext): Promise<Response>;
+}
+export default AppRouteRouteModule;
+/**
+ * Gets all the method names for handlers that are not considered static.
+ *
+ * @param handlers the handlers from the userland module
+ * @returns the method names that are not considered static or false if all
+ *          methods are static
+ */
+export declare function hasNonStaticMethods(handlers: AppRouteHandlers): boolean;

node_modules/next/dist/server/future/route-modules/app-route/module.js

@@ -0,0 +1,524 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    AppRouteRouteModule: null,
+    default: null,
+    hasNonStaticMethods: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AppRouteRouteModule: function() {
+        return AppRouteRouteModule;
+    },
+    default: function() {
+        return _default;
+    },
+    hasNonStaticMethods: function() {
+        return hasNonStaticMethods;
+    }
+});
+const _routemodule = require("../route-module");
+const _requestasyncstoragewrapper = require("../../../async-storage/request-async-storage-wrapper");
+const _staticgenerationasyncstoragewrapper = require("../../../async-storage/static-generation-async-storage-wrapper");
+const _responsehandlers = require("../helpers/response-handlers");
+const _http = require("../../../web/http");
+const _patchfetch = require("../../../lib/patch-fetch");
+const _tracer = require("../../../lib/trace/tracer");
+const _constants = require("../../../lib/trace/constants");
+const _getpathnamefromabsolutepath = require("./helpers/get-pathname-from-absolute-path");
+const _resolvehandlererror = require("./helpers/resolve-handler-error");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../../build/output/log"));
+const _autoimplementmethods = require("./helpers/auto-implement-methods");
+const _requestcookies = require("../../../web/spec-extension/adapters/request-cookies");
+const _headers = require("../../../web/spec-extension/adapters/headers");
+const _parsedurlquerytoparams = require("./helpers/parsed-url-query-to-params");
+const _hooksservercontext = /*#__PURE__*/ _interop_require_wildcard(require("../../../../client/components/hooks-server-context"));
+const _requestasyncstorageexternal = require("../../../../client/components/request-async-storage.external");
+const _staticgenerationasyncstorageexternal = require("../../../../client/components/static-generation-async-storage.external");
+const _actionasyncstorageexternal = require("../../../../client/components/action-async-storage.external");
+const _sharedmodules = /*#__PURE__*/ _interop_require_wildcard(require("./shared-modules"));
+const _serveractionrequestmeta = require("../../../lib/server-action-request-meta");
+const _cookies = require("next/dist/compiled/@edge-runtime/cookies");
+const _cleanurl = require("./helpers/clean-url");
+const _staticgenerationbailout = require("../../../../client/components/static-generation-bailout");
+const _dynamicrendering = require("../../../app-render/dynamic-rendering");
+const _reflect = require("../../../web/spec-extension/adapters/reflect");
+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;
+}
+class AppRouteRouteModule extends _routemodule.RouteModule {
+    static #_ = this.sharedModules = _sharedmodules;
+    constructor({ userland, definition, resolvedPagePath, nextConfigOutput }){
+        super({
+            userland,
+            definition
+        });
+        /**
+   * A reference to the request async storage.
+   */ this.requestAsyncStorage = _requestasyncstorageexternal.requestAsyncStorage;
+        /**
+   * A reference to the static generation async storage.
+   */ this.staticGenerationAsyncStorage = _staticgenerationasyncstorageexternal.staticGenerationAsyncStorage;
+        /**
+   * An interface to call server hooks which interact with the underlying
+   * storage.
+   */ this.serverHooks = _hooksservercontext;
+        /**
+   * A reference to the mutation related async storage, such as mutations of
+   * cookies.
+   */ this.actionAsyncStorage = _actionasyncstorageexternal.actionAsyncStorage;
+        this.resolvedPagePath = resolvedPagePath;
+        this.nextConfigOutput = nextConfigOutput;
+        // Automatically implement some methods if they aren't implemented by the
+        // userland module.
+        this.methods = (0, _autoimplementmethods.autoImplementMethods)(userland);
+        // Get the non-static methods for this route.
+        this.hasNonStaticMethods = hasNonStaticMethods(userland);
+        // Get the dynamic property from the userland module.
+        this.dynamic = this.userland.dynamic;
+        if (this.nextConfigOutput === "export") {
+            if (!this.dynamic || this.dynamic === "auto") {
+                this.dynamic = "error";
+            } else if (this.dynamic === "force-dynamic") {
+                throw new Error(`export const dynamic = "force-dynamic" on page "${definition.pathname}" cannot be used with "output: export". See more info here: https://nextjs.org/docs/advanced-features/static-html-export`);
+            }
+        }
+        // We only warn in development after here, so return if we're not in
+        // development.
+        if (process.env.NODE_ENV === "development") {
+            // Print error in development if the exported handlers are in lowercase, only
+            // uppercase handlers are supported.
+            const lowercased = _http.HTTP_METHODS.map((method)=>method.toLowerCase());
+            for (const method of lowercased){
+                if (method in this.userland) {
+                    _log.error(`Detected lowercase method '${method}' in '${this.resolvedPagePath}'. Export the uppercase '${method.toUpperCase()}' method name to fix this error.`);
+                }
+            }
+            // Print error if the module exports a default handler, they must use named
+            // exports for each HTTP method.
+            if ("default" in this.userland) {
+                _log.error(`Detected default export in '${this.resolvedPagePath}'. Export a named export for each HTTP method instead.`);
+            }
+            // If there is no methods exported by this module, then return a not found
+            // response.
+            if (!_http.HTTP_METHODS.some((method)=>method in this.userland)) {
+                _log.error(`No HTTP methods exported in '${this.resolvedPagePath}'. Export a named export for each HTTP method.`);
+            }
+        }
+    }
+    /**
+   * Resolves the handler function for the given method.
+   *
+   * @param method the requested method
+   * @returns the handler function for the given method
+   */ resolve(method) {
+        // Ensure that the requested method is a valid method (to prevent RCE's).
+        if (!(0, _http.isHTTPMethod)(method)) return _responsehandlers.handleBadRequestResponse;
+        // Return the handler.
+        return this.methods[method];
+    }
+    /**
+   * Executes the route handler.
+   */ async execute(rawRequest, context) {
+        // Get the handler function for the given method.
+        const handler = this.resolve(rawRequest.method);
+        // Get the context for the request.
+        const requestContext = {
+            req: rawRequest
+        };
+        requestContext.renderOpts = {
+            previewProps: context.prerenderManifest.preview
+        };
+        // Get the context for the static generation.
+        const staticGenerationContext = {
+            urlPathname: rawRequest.nextUrl.pathname,
+            renderOpts: context.renderOpts
+        };
+        // Add the fetchCache option to the renderOpts.
+        staticGenerationContext.renderOpts.fetchCache = this.userland.fetchCache;
+        // Run the handler with the request AsyncLocalStorage to inject the helper
+        // support. We set this to `unknown` because the type is not known until
+        // runtime when we do a instanceof check below.
+        const response = await this.actionAsyncStorage.run({
+            isAppRoute: true,
+            isAction: (0, _serveractionrequestmeta.getIsServerAction)(rawRequest)
+        }, ()=>_requestasyncstoragewrapper.RequestAsyncStorageWrapper.wrap(this.requestAsyncStorage, requestContext, ()=>_staticgenerationasyncstoragewrapper.StaticGenerationAsyncStorageWrapper.wrap(this.staticGenerationAsyncStorage, staticGenerationContext, (staticGenerationStore)=>{
+                    var _getTracer_getRootSpanAttributes;
+                    // Check to see if we should bail out of static generation based on
+                    // having non-static methods.
+                    const isStaticGeneration = staticGenerationStore.isStaticGeneration;
+                    if (this.hasNonStaticMethods) {
+                        if (isStaticGeneration) {
+                            const err = new _hooksservercontext.DynamicServerError("Route is configured with methods that cannot be statically generated.");
+                            staticGenerationStore.dynamicUsageDescription = err.message;
+                            staticGenerationStore.dynamicUsageStack = err.stack;
+                            throw err;
+                        } else {
+                            // We aren't statically generating but since this route has non-static methods
+                            // we still need to set the default caching to no cache by setting revalidate = 0
+                            // @TODO this type of logic is too indirect. we need to refactor how we set fetch cache
+                            // behavior. Prior to the most recent refactor this logic was buried deep in staticGenerationBailout
+                            // so it is possible it was unintentional and then tests were written to assert the current behavior
+                            staticGenerationStore.revalidate = 0;
+                        }
+                    }
+                    // We assume we can pass the original request through however we may end up
+                    // proxying it in certain circumstances based on execution type and configuration
+                    let request = rawRequest;
+                    // Update the static generation store based on the dynamic property.
+                    switch(this.dynamic){
+                        case "force-dynamic":
+                            {
+                                // Routes of generated paths should be dynamic
+                                staticGenerationStore.forceDynamic = true;
+                                break;
+                            }
+                        case "force-static":
+                            // The dynamic property is set to force-static, so we should
+                            // force the page to be static.
+                            staticGenerationStore.forceStatic = true;
+                            // We also Proxy the request to replace dynamic data on the request
+                            // with empty stubs to allow for safely executing as static
+                            request = new Proxy(rawRequest, forceStaticRequestHandlers);
+                            break;
+                        case "error":
+                            // The dynamic property is set to error, so we should throw an
+                            // error if the page is being statically generated.
+                            staticGenerationStore.dynamicShouldError = true;
+                            if (isStaticGeneration) request = new Proxy(rawRequest, requireStaticRequestHandlers);
+                            break;
+                        default:
+                            // We proxy `NextRequest` to track dynamic access, and potentially bail out of static generation
+                            request = proxyNextRequest(rawRequest, staticGenerationStore);
+                    }
+                    // If the static generation store does not have a revalidate value
+                    // set, then we should set it the revalidate value from the userland
+                    // module or default to false.
+                    staticGenerationStore.revalidate ??= this.userland.revalidate ?? false;
+                    // TODO: propagate this pathname from route matcher
+                    const route = (0, _getpathnamefromabsolutepath.getPathnameFromAbsolutePath)(this.resolvedPagePath);
+                    (_getTracer_getRootSpanAttributes = (0, _tracer.getTracer)().getRootSpanAttributes()) == null ? void 0 : _getTracer_getRootSpanAttributes.set("next.route", route);
+                    return (0, _tracer.getTracer)().trace(_constants.AppRouteRouteHandlersSpan.runHandler, {
+                        spanName: `executing api route (app) ${route}`,
+                        attributes: {
+                            "next.route": route
+                        }
+                    }, async ()=>{
+                        var _staticGenerationStore_incrementalCache, _staticGenerationStore_tags;
+                        // Patch the global fetch.
+                        (0, _patchfetch.patchFetch)({
+                            serverHooks: this.serverHooks,
+                            staticGenerationAsyncStorage: this.staticGenerationAsyncStorage
+                        });
+                        const res = await handler(request, {
+                            params: context.params ? (0, _parsedurlquerytoparams.parsedUrlQueryToParams)(context.params) : undefined
+                        });
+                        if (!(res instanceof Response)) {
+                            throw new Error(`No response is returned from route handler '${this.resolvedPagePath}'. Ensure you return a \`Response\` or a \`NextResponse\` in all branches of your handler.`);
+                        }
+                        context.renderOpts.fetchMetrics = staticGenerationStore.fetchMetrics;
+                        context.renderOpts.waitUntil = Promise.all([
+                            (_staticGenerationStore_incrementalCache = staticGenerationStore.incrementalCache) == null ? void 0 : _staticGenerationStore_incrementalCache.revalidateTag(staticGenerationStore.revalidatedTags || []),
+                            ...Object.values(staticGenerationStore.pendingRevalidates || {})
+                        ]);
+                        (0, _patchfetch.addImplicitTags)(staticGenerationStore);
+                        context.renderOpts.fetchTags = (_staticGenerationStore_tags = staticGenerationStore.tags) == null ? void 0 : _staticGenerationStore_tags.join(",");
+                        // It's possible cookies were set in the handler, so we need
+                        // to merge the modified cookies and the returned response
+                        // here.
+                        const requestStore = this.requestAsyncStorage.getStore();
+                        if (requestStore && requestStore.mutableCookies) {
+                            const headers = new Headers(res.headers);
+                            if ((0, _requestcookies.appendMutableCookies)(headers, requestStore.mutableCookies)) {
+                                return new Response(res.body, {
+                                    status: res.status,
+                                    statusText: res.statusText,
+                                    headers
+                                });
+                            }
+                        }
+                        return res;
+                    });
+                })));
+        // If the handler did't return a valid response, then return the internal
+        // error response.
+        if (!(response instanceof Response)) {
+            // TODO: validate the correct handling behavior, maybe log something?
+            return (0, _responsehandlers.handleInternalServerErrorResponse)();
+        }
+        if (response.headers.has("x-middleware-rewrite")) {
+            // TODO: move this error into the `NextResponse.rewrite()` function.
+            // TODO-APP: re-enable support below when we can proxy these type of requests
+            throw new Error("NextResponse.rewrite() was used in a app route handler, this is not currently supported. Please remove the invocation to continue.");
+        // // This is a rewrite created via `NextResponse.rewrite()`. We need to send
+        // // the response up so it can be handled by the backing server.
+        // // If the server is running in minimal mode, we just want to forward the
+        // // response (including the rewrite headers) upstream so it can perform the
+        // // redirect for us, otherwise return with the special condition so this
+        // // server can perform a rewrite.
+        // if (!minimalMode) {
+        //   return { response, condition: 'rewrite' }
+        // }
+        // // Relativize the url so it's relative to the base url. This is so the
+        // // outgoing headers upstream can be relative.
+        // const rewritePath = response.headers.get('x-middleware-rewrite')!
+        // const initUrl = getRequestMeta(req, 'initURL')!
+        // const { pathname } = parseUrl(relativizeURL(rewritePath, initUrl))
+        // response.headers.set('x-middleware-rewrite', pathname)
+        }
+        if (response.headers.get("x-middleware-next") === "1") {
+            // TODO: move this error into the `NextResponse.next()` function.
+            throw new Error("NextResponse.next() was used in a app route handler, this is not supported. See here for more info: https://nextjs.org/docs/messages/next-response-next-in-app-route-handler");
+        }
+        return response;
+    }
+    async handle(request, context) {
+        try {
+            // Execute the route to get the response.
+            const response = await this.execute(request, context);
+            // The response was handled, return it.
+            return response;
+        } catch (err) {
+            // Try to resolve the error to a response, else throw it again.
+            const response = (0, _resolvehandlererror.resolveHandlerError)(err);
+            if (!response) throw err;
+            // The response was resolved, return it.
+            return response;
+        }
+    }
+}
+const _default = AppRouteRouteModule;
+function hasNonStaticMethods(handlers) {
+    if (// Order these by how common they are to be used
+    handlers.POST || handlers.POST || handlers.DELETE || handlers.PATCH || handlers.OPTIONS) {
+        return true;
+    }
+    return false;
+}
+// These symbols will be used to stash cached values on Proxied requests without requiring
+// additional closures or storage such as WeakMaps.
+const nextURLSymbol = Symbol("nextUrl");
+const requestCloneSymbol = Symbol("clone");
+const urlCloneSymbol = Symbol("clone");
+const searchParamsSymbol = Symbol("searchParams");
+const hrefSymbol = Symbol("href");
+const toStringSymbol = Symbol("toString");
+const headersSymbol = Symbol("headers");
+const cookiesSymbol = Symbol("cookies");
+/**
+ * The general technique with these proxy handlers is to prioritize keeping them static
+ * by stashing computed values on the Proxy itself. This is safe because the Proxy is
+ * inaccessible to the consumer since all operations are forwarded
+ */ const forceStaticRequestHandlers = {
+    get (target, prop, receiver) {
+        switch(prop){
+            case "headers":
+                return target[headersSymbol] || (target[headersSymbol] = _headers.HeadersAdapter.seal(new Headers({})));
+            case "cookies":
+                return target[cookiesSymbol] || (target[cookiesSymbol] = _requestcookies.RequestCookiesAdapter.seal(new _cookies.RequestCookies(new Headers({}))));
+            case "nextUrl":
+                return target[nextURLSymbol] || (target[nextURLSymbol] = new Proxy(target.nextUrl, forceStaticNextUrlHandlers));
+            case "url":
+                // we don't need to separately cache this we can just read the nextUrl
+                // and return the href since we know it will have been stripped of any
+                // dynamic parts. We access via the receiver to trigger the get trap
+                return receiver.nextUrl.href;
+            case "geo":
+            case "ip":
+                return undefined;
+            case "clone":
+                return target[requestCloneSymbol] || (target[requestCloneSymbol] = ()=>new Proxy(// This is vaguely unsafe but it's required since NextRequest does not implement
+                    // clone. The reason we might expect this to work in this context is the Proxy will
+                    // respond with static-amenable values anyway somewhat restoring the interface.
+                    // @TODO we need to rethink NextRequest and NextURL because they are not sufficientlly
+                    // sophisticated to adequately represent themselves in all contexts. A better approach is
+                    // to probably embed the static generation logic into the class itself removing the need
+                    // for any kind of proxying
+                    target.clone(), forceStaticRequestHandlers));
+            default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+        }
+    }
+};
+const forceStaticNextUrlHandlers = {
+    get (target, prop, receiver) {
+        switch(prop){
+            // URL properties
+            case "search":
+                return "";
+            case "searchParams":
+                return target[searchParamsSymbol] || (target[searchParamsSymbol] = new URLSearchParams());
+            case "href":
+                return target[hrefSymbol] || (target[hrefSymbol] = (0, _cleanurl.cleanURL)(target.href).href);
+            case "toJSON":
+            case "toString":
+                return target[toStringSymbol] || (target[toStringSymbol] = ()=>receiver.href);
+            // NextUrl properties
+            case "url":
+                // Currently nextURL does not expose url but our Docs indicate that it is an available property
+                // I am forcing this to undefined here to avoid accidentally exposing a dynamic value later if
+                // the underlying nextURL ends up adding this property
+                return undefined;
+            case "clone":
+                return target[urlCloneSymbol] || (target[urlCloneSymbol] = ()=>new Proxy(target.clone(), forceStaticNextUrlHandlers));
+            default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+        }
+    }
+};
+function proxyNextRequest(request, staticGenerationStore) {
+    const nextUrlHandlers = {
+        get (target, prop, receiver) {
+            switch(prop){
+                case "search":
+                case "searchParams":
+                case "url":
+                case "href":
+                case "toJSON":
+                case "toString":
+                case "origin":
+                    {
+                        (0, _dynamicrendering.trackDynamicDataAccessed)(staticGenerationStore, `nextUrl.${prop}`);
+                        return _reflect.ReflectAdapter.get(target, prop, receiver);
+                    }
+                case "clone":
+                    return target[urlCloneSymbol] || (target[urlCloneSymbol] = ()=>new Proxy(target.clone(), nextUrlHandlers));
+                default:
+                    return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+        }
+    };
+    const nextRequestHandlers = {
+        get (target, prop) {
+            switch(prop){
+                case "nextUrl":
+                    return target[nextURLSymbol] || (target[nextURLSymbol] = new Proxy(target.nextUrl, nextUrlHandlers));
+                case "headers":
+                case "cookies":
+                case "url":
+                case "body":
+                case "blob":
+                case "json":
+                case "text":
+                case "arrayBuffer":
+                case "formData":
+                    {
+                        (0, _dynamicrendering.trackDynamicDataAccessed)(staticGenerationStore, `request.${prop}`);
+                        // The receiver arg is intentionally the same as the target to fix an issue with
+                        // edge runtime, where attempting to access internal slots with the wrong `this` context
+                        // results in an error.
+                        return _reflect.ReflectAdapter.get(target, prop, target);
+                    }
+                case "clone":
+                    return target[requestCloneSymbol] || (target[requestCloneSymbol] = ()=>new Proxy(// This is vaguely unsafe but it's required since NextRequest does not implement
+                        // clone. The reason we might expect this to work in this context is the Proxy will
+                        // respond with static-amenable values anyway somewhat restoring the interface.
+                        // @TODO we need to rethink NextRequest and NextURL because they are not sufficientlly
+                        // sophisticated to adequately represent themselves in all contexts. A better approach is
+                        // to probably embed the static generation logic into the class itself removing the need
+                        // for any kind of proxying
+                        target.clone(), nextRequestHandlers));
+                default:
+                    // The receiver arg is intentionally the same as the target to fix an issue with
+                    // edge runtime, where attempting to access internal slots with the wrong `this` context
+                    // results in an error.
+                    return _reflect.ReflectAdapter.get(target, prop, target);
+            }
+        }
+    };
+    return new Proxy(request, nextRequestHandlers);
+}
+const requireStaticRequestHandlers = {
+    get (target, prop, receiver) {
+        switch(prop){
+            case "nextUrl":
+                return target[nextURLSymbol] || (target[nextURLSymbol] = new Proxy(target.nextUrl, requireStaticNextUrlHandlers));
+            case "headers":
+            case "cookies":
+            case "url":
+            case "body":
+            case "blob":
+            case "json":
+            case "text":
+            case "arrayBuffer":
+            case "formData":
+                throw new _staticgenerationbailout.StaticGenBailoutError(`Route ${target.nextUrl.pathname} with \`dynamic = "error"\` couldn't be rendered statically because it used \`request.${prop}\`.`);
+            case "clone":
+                return target[requestCloneSymbol] || (target[requestCloneSymbol] = ()=>new Proxy(// This is vaguely unsafe but it's required since NextRequest does not implement
+                    // clone. The reason we might expect this to work in this context is the Proxy will
+                    // respond with static-amenable values anyway somewhat restoring the interface.
+                    // @TODO we need to rethink NextRequest and NextURL because they are not sufficientlly
+                    // sophisticated to adequately represent themselves in all contexts. A better approach is
+                    // to probably embed the static generation logic into the class itself removing the need
+                    // for any kind of proxying
+                    target.clone(), requireStaticRequestHandlers));
+            default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+        }
+    }
+};
+const requireStaticNextUrlHandlers = {
+    get (target, prop, receiver) {
+        switch(prop){
+            case "search":
+            case "searchParams":
+            case "url":
+            case "href":
+            case "toJSON":
+            case "toString":
+            case "origin":
+                throw new _staticgenerationbailout.StaticGenBailoutError(`Route ${target.pathname} with \`dynamic = "error"\` couldn't be rendered statically because it used \`nextUrl.${prop}\`.`);
+            case "clone":
+                return target[urlCloneSymbol] || (target[urlCloneSymbol] = ()=>new Proxy(target.clone(), requireStaticNextUrlHandlers));
+            default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+        }
+    }
+};
+
+//# sourceMappingURL=module.js.map

node_modules/next/dist/server/future/route-modules/app-route/shared-modules.d.ts

@@ -0,0 +1 @@
+export * as appRouterContext from '../../../../shared/lib/app-router-context.shared-runtime';

node_modules/next/dist/server/future/route-modules/app-route/shared-modules.js

@@ -0,0 +1,56 @@
+// the name of the export has to be the camelCase version of the file name (without the extension)
+// TODO: remove this. We need it because using notFound from next/navigation imports this file :(
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "appRouterContext", {
+    enumerable: true,
+    get: function() {
+        return _approutercontextsharedruntime;
+    }
+});
+const _approutercontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../shared/lib/app-router-context.shared-runtime"));
+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;
+}
+
+//# sourceMappingURL=shared-modules.js.map

node_modules/next/dist/server/future/route-modules/app-route/shared-modules.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/future/route-modules/app-route/shared-modules.ts"],"names":["appRouterContext"],"mappings":"AAAA,kGAAkG;AAClG,iGAAiG;;;;;+BACrFA;;;;;;uFAAsB"}