Initial boiler plate project

node_modules/next/dist/server/web/adapter.d.ts

@@ -0,0 +1,23 @@
+import type { RequestData, FetchEventResult } from './types';
+import type { RequestInit } from './spec-extension/request';
+import { NextFetchEvent } from './spec-extension/fetch-event';
+import { NextRequest } from './spec-extension/request';
+export declare class NextRequestHint extends NextRequest {
+    sourcePage: string;
+    fetchMetrics?: FetchEventResult['fetchMetrics'];
+    constructor(params: {
+        init: RequestInit;
+        input: Request | string;
+        page: string;
+    });
+    get request(): void;
+    respondWith(): void;
+    waitUntil(): void;
+}
+export type AdapterOptions = {
+    handler: (req: NextRequestHint, event: NextFetchEvent) => Promise<Response>;
+    page: string;
+    request: RequestData;
+    IncrementalCache?: typeof import('../lib/incremental-cache').IncrementalCache;
+};
+export declare function adapter(params: AdapterOptions): Promise<FetchEventResult>;

node_modules/next/dist/server/web/adapter.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    NextRequestHint: null,
+    adapter: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NextRequestHint: function() {
+        return NextRequestHint;
+    },
+    adapter: function() {
+        return adapter;
+    }
+});
+const _error = require("./error");
+const _utils = require("./utils");
+const _fetchevent = require("./spec-extension/fetch-event");
+const _request = require("./spec-extension/request");
+const _response = require("./spec-extension/response");
+const _relativizeurl = require("../../shared/lib/router/utils/relativize-url");
+const _nexturl = require("./next-url");
+const _internalutils = require("../internal-utils");
+const _apppaths = require("../../shared/lib/router/utils/app-paths");
+const _approuterheaders = require("../../client/components/app-router-headers");
+const _constants = require("../../lib/constants");
+const _globals = require("./globals");
+const _requestasyncstoragewrapper = require("../async-storage/request-async-storage-wrapper");
+const _requestasyncstorageexternal = require("../../client/components/request-async-storage.external");
+const _tracer = require("../lib/trace/tracer");
+const _constants1 = require("../lib/trace/constants");
+const _getedgepreviewprops = require("./get-edge-preview-props");
+class NextRequestHint extends _request.NextRequest {
+    constructor(params){
+        super(params.input, params.init);
+        this.sourcePage = params.page;
+    }
+    get request() {
+        throw new _error.PageSignatureError({
+            page: this.sourcePage
+        });
+    }
+    respondWith() {
+        throw new _error.PageSignatureError({
+            page: this.sourcePage
+        });
+    }
+    waitUntil() {
+        throw new _error.PageSignatureError({
+            page: this.sourcePage
+        });
+    }
+}
+const headersGetter = {
+    keys: (headers)=>Array.from(headers.keys()),
+    get: (headers, key)=>headers.get(key) ?? undefined
+};
+let propagator = (request, fn)=>{
+    const tracer = (0, _tracer.getTracer)();
+    return tracer.withPropagatedContext(request.headers, fn, headersGetter);
+};
+let testApisIntercepted = false;
+function ensureTestApisIntercepted() {
+    if (!testApisIntercepted) {
+        testApisIntercepted = true;
+        if (process.env.NEXT_PRIVATE_TEST_PROXY === "true") {
+            const { interceptTestApis, wrapRequestHandler } = require("next/dist/experimental/testmode/server-edge");
+            interceptTestApis();
+            propagator = wrapRequestHandler(propagator);
+        }
+    }
+}
+async function adapter(params) {
+    ensureTestApisIntercepted();
+    await (0, _globals.ensureInstrumentationRegistered)();
+    // TODO-APP: use explicit marker for this
+    const isEdgeRendering = typeof self.__BUILD_MANIFEST !== "undefined";
+    params.request.url = (0, _apppaths.normalizeRscURL)(params.request.url);
+    const requestUrl = new _nexturl.NextURL(params.request.url, {
+        headers: params.request.headers,
+        nextConfig: params.request.nextConfig
+    });
+    // Iterator uses an index to keep track of the current iteration. Because of deleting and appending below we can't just use the iterator.
+    // Instead we use the keys before iteration.
+    const keys = [
+        ...requestUrl.searchParams.keys()
+    ];
+    for (const key of keys){
+        const value = requestUrl.searchParams.getAll(key);
+        if (key !== _constants.NEXT_QUERY_PARAM_PREFIX && key.startsWith(_constants.NEXT_QUERY_PARAM_PREFIX)) {
+            const normalizedKey = key.substring(_constants.NEXT_QUERY_PARAM_PREFIX.length);
+            requestUrl.searchParams.delete(normalizedKey);
+            for (const val of value){
+                requestUrl.searchParams.append(normalizedKey, val);
+            }
+            requestUrl.searchParams.delete(key);
+        }
+    }
+    // Ensure users only see page requests, never data requests.
+    const buildId = requestUrl.buildId;
+    requestUrl.buildId = "";
+    const isNextDataRequest = params.request.headers["x-nextjs-data"];
+    if (isNextDataRequest && requestUrl.pathname === "/index") {
+        requestUrl.pathname = "/";
+    }
+    const requestHeaders = (0, _utils.fromNodeOutgoingHttpHeaders)(params.request.headers);
+    const flightHeaders = new Map();
+    // Parameters should only be stripped for middleware
+    if (!isEdgeRendering) {
+        for (const param of _approuterheaders.FLIGHT_PARAMETERS){
+            const key = param.toString().toLowerCase();
+            const value = requestHeaders.get(key);
+            if (value) {
+                flightHeaders.set(key, requestHeaders.get(key));
+                requestHeaders.delete(key);
+            }
+        }
+    }
+    const normalizeUrl = process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE ? new URL(params.request.url) : requestUrl;
+    const request = new NextRequestHint({
+        page: params.page,
+        // Strip internal query parameters off the request.
+        input: (0, _internalutils.stripInternalSearchParams)(normalizeUrl, true).toString(),
+        init: {
+            body: params.request.body,
+            geo: params.request.geo,
+            headers: requestHeaders,
+            ip: params.request.ip,
+            method: params.request.method,
+            nextConfig: params.request.nextConfig,
+            signal: params.request.signal
+        }
+    });
+    /**
+   * This allows to identify the request as a data request. The user doesn't
+   * need to know about this property neither use it. We add it for testing
+   * purposes.
+   */ if (isNextDataRequest) {
+        Object.defineProperty(request, "__isData", {
+            enumerable: false,
+            value: true
+        });
+    }
+    if (!globalThis.__incrementalCache && params.IncrementalCache) {
+        globalThis.__incrementalCache = new params.IncrementalCache({
+            appDir: true,
+            fetchCache: true,
+            minimalMode: process.env.NODE_ENV !== "development",
+            fetchCacheKeyPrefix: process.env.__NEXT_FETCH_CACHE_KEY_PREFIX,
+            dev: process.env.NODE_ENV === "development",
+            requestHeaders: params.request.headers,
+            requestProtocol: "https",
+            getPrerenderManifest: ()=>{
+                return {
+                    version: -1,
+                    routes: {},
+                    dynamicRoutes: {},
+                    notFoundRoutes: [],
+                    preview: (0, _getedgepreviewprops.getEdgePreviewProps)()
+                };
+            }
+        });
+    }
+    const event = new _fetchevent.NextFetchEvent({
+        request,
+        page: params.page
+    });
+    let response;
+    let cookiesFromResponse;
+    response = await propagator(request, ()=>{
+        // we only care to make async storage available for middleware
+        const isMiddleware = params.page === "/middleware" || params.page === "/src/middleware";
+        if (isMiddleware) {
+            return (0, _tracer.getTracer)().trace(_constants1.MiddlewareSpan.execute, {
+                spanName: `middleware ${request.method} ${request.nextUrl.pathname}`,
+                attributes: {
+                    "http.target": request.nextUrl.pathname,
+                    "http.method": request.method
+                }
+            }, ()=>_requestasyncstoragewrapper.RequestAsyncStorageWrapper.wrap(_requestasyncstorageexternal.requestAsyncStorage, {
+                    req: request,
+                    renderOpts: {
+                        onUpdateCookies: (cookies)=>{
+                            cookiesFromResponse = cookies;
+                        },
+                        // @ts-expect-error: TODO: investigate why previewProps isn't on RenderOpts
+                        previewProps: (0, _getedgepreviewprops.getEdgePreviewProps)()
+                    }
+                }, ()=>params.handler(request, event)));
+        }
+        return params.handler(request, event);
+    });
+    // check if response is a Response object
+    if (response && !(response instanceof Response)) {
+        throw new TypeError("Expected an instance of Response to be returned");
+    }
+    if (response && cookiesFromResponse) {
+        response.headers.set("set-cookie", cookiesFromResponse);
+    }
+    /**
+   * For rewrites we must always include the locale in the final pathname
+   * so we re-create the NextURL forcing it to include it when the it is
+   * an internal rewrite. Also we make sure the outgoing rewrite URL is
+   * a data URL if the request was a data request.
+   */ const rewrite = response == null ? void 0 : response.headers.get("x-middleware-rewrite");
+    if (response && rewrite && !isEdgeRendering) {
+        const rewriteUrl = new _nexturl.NextURL(rewrite, {
+            forceLocale: true,
+            headers: params.request.headers,
+            nextConfig: params.request.nextConfig
+        });
+        if (!process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE) {
+            if (rewriteUrl.host === request.nextUrl.host) {
+                rewriteUrl.buildId = buildId || rewriteUrl.buildId;
+                response.headers.set("x-middleware-rewrite", String(rewriteUrl));
+            }
+        }
+        /**
+     * When the request is a data request we must show if there was a rewrite
+     * with an internal header so the client knows which component to load
+     * from the data request.
+     */ const relativizedRewrite = (0, _relativizeurl.relativizeURL)(String(rewriteUrl), String(requestUrl));
+        if (isNextDataRequest && // if the rewrite is external and external rewrite
+        // resolving config is enabled don't add this header
+        // so the upstream app can set it instead
+        !(process.env.__NEXT_EXTERNAL_MIDDLEWARE_REWRITE_RESOLVE && relativizedRewrite.match(/http(s)?:\/\//))) {
+            response.headers.set("x-nextjs-rewrite", relativizedRewrite);
+        }
+    }
+    /**
+   * For redirects we will not include the locale in case when it is the
+   * default and we must also make sure the outgoing URL is a data one if
+   * the incoming request was a data request.
+   */ const redirect = response == null ? void 0 : response.headers.get("Location");
+    if (response && redirect && !isEdgeRendering) {
+        const redirectURL = new _nexturl.NextURL(redirect, {
+            forceLocale: false,
+            headers: params.request.headers,
+            nextConfig: params.request.nextConfig
+        });
+        /**
+     * Responses created from redirects have immutable headers so we have
+     * to clone the response to be able to modify it.
+     */ response = new Response(response.body, response);
+        if (!process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE) {
+            if (redirectURL.host === request.nextUrl.host) {
+                redirectURL.buildId = buildId || redirectURL.buildId;
+                response.headers.set("Location", String(redirectURL));
+            }
+        }
+        /**
+     * When the request is a data request we can't use the location header as
+     * it may end up with CORS error. Instead we map to an internal header so
+     * the client knows the destination.
+     */ if (isNextDataRequest) {
+            response.headers.delete("Location");
+            response.headers.set("x-nextjs-redirect", (0, _relativizeurl.relativizeURL)(String(redirectURL), String(requestUrl)));
+        }
+    }
+    const finalResponse = response ? response : _response.NextResponse.next();
+    // Flight headers are not overridable / removable so they are applied at the end.
+    const middlewareOverrideHeaders = finalResponse.headers.get("x-middleware-override-headers");
+    const overwrittenHeaders = [];
+    if (middlewareOverrideHeaders) {
+        for (const [key, value] of flightHeaders){
+            finalResponse.headers.set(`x-middleware-request-${key}`, value);
+            overwrittenHeaders.push(key);
+        }
+        if (overwrittenHeaders.length > 0) {
+            finalResponse.headers.set("x-middleware-override-headers", middlewareOverrideHeaders + "," + overwrittenHeaders.join(","));
+        }
+    }
+    return {
+        response: finalResponse,
+        waitUntil: Promise.all(event[_fetchevent.waitUntilSymbol]),
+        fetchMetrics: request.fetchMetrics
+    };
+}
+
+//# sourceMappingURL=adapter.js.map

node_modules/next/dist/server/web/edge-route-module-wrapper.d.ts

@@ -0,0 +1,32 @@
+import type { AppRouteRouteModule } from '../future/route-modules/app-route/module';
+import './globals';
+import { type AdapterOptions } from './adapter';
+type WrapOptions = Partial<Pick<AdapterOptions, 'page'>>;
+/**
+ * EdgeRouteModuleWrapper is a wrapper around a route module.
+ *
+ * Note that this class should only be used in the edge runtime.
+ */
+export declare class EdgeRouteModuleWrapper {
+    private readonly routeModule;
+    private readonly matcher;
+    /**
+     * The constructor is wrapped with private to ensure that it can only be
+     * constructed by the static wrap method.
+     *
+     * @param routeModule the route module to wrap
+     */
+    private constructor();
+    /**
+     * This will wrap a module with the EdgeModuleWrapper and return a function
+     * that can be used as a handler for the edge runtime.
+     *
+     * @param module the module to wrap
+     * @param options any options that should be passed to the adapter and
+     *                override the ones passed from the runtime
+     * @returns a function that can be used as a handler for the edge runtime
+     */
+    static wrap(routeModule: AppRouteRouteModule, options?: WrapOptions): (opts: AdapterOptions) => Promise<import("./types").FetchEventResult>;
+    private handler;
+}
+export {};

node_modules/next/dist/server/web/edge-route-module-wrapper.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EdgeRouteModuleWrapper", {
+    enumerable: true,
+    get: function() {
+        return EdgeRouteModuleWrapper;
+    }
+});
+require("./globals");
+const _adapter = require("./adapter");
+const _incrementalcache = require("../lib/incremental-cache");
+const _routematcher = require("../future/route-matchers/route-matcher");
+const _internaledgewaituntil = require("./internal-edge-wait-until");
+const _serverutils = require("../server-utils");
+const _querystring = require("../../shared/lib/router/utils/querystring");
+const _getedgepreviewprops = require("./get-edge-preview-props");
+class EdgeRouteModuleWrapper {
+    /**
+   * The constructor is wrapped with private to ensure that it can only be
+   * constructed by the static wrap method.
+   *
+   * @param routeModule the route module to wrap
+   */ constructor(routeModule){
+        this.routeModule = routeModule;
+        // TODO: (wyattjoh) possibly allow the module to define it's own matcher
+        this.matcher = new _routematcher.RouteMatcher(routeModule.definition);
+    }
+    /**
+   * This will wrap a module with the EdgeModuleWrapper and return a function
+   * that can be used as a handler for the edge runtime.
+   *
+   * @param module the module to wrap
+   * @param options any options that should be passed to the adapter and
+   *                override the ones passed from the runtime
+   * @returns a function that can be used as a handler for the edge runtime
+   */ static wrap(routeModule, options = {}) {
+        // Create the module wrapper.
+        const wrapper = new EdgeRouteModuleWrapper(routeModule);
+        // Return the wrapping function.
+        return (opts)=>{
+            return (0, _adapter.adapter)({
+                ...opts,
+                ...options,
+                IncrementalCache: _incrementalcache.IncrementalCache,
+                // Bind the handler method to the wrapper so it still has context.
+                handler: wrapper.handler.bind(wrapper)
+            });
+        };
+    }
+    async handler(request, evt) {
+        const utils = (0, _serverutils.getUtils)({
+            pageIsDynamic: this.matcher.isDynamic,
+            page: this.matcher.definition.pathname,
+            basePath: request.nextUrl.basePath,
+            // We don't need the `handleRewrite` util, so can just pass an empty object
+            rewrites: {},
+            // only used for rewrites, so setting an arbitrary default value here
+            caseSensitive: false
+        });
+        const { params } = utils.normalizeDynamicRouteParams((0, _querystring.searchParamsToUrlQuery)(request.nextUrl.searchParams));
+        const previewProps = (0, _getedgepreviewprops.getEdgePreviewProps)();
+        // Create the context for the handler. This contains the params from the
+        // match (if any).
+        const context = {
+            params,
+            prerenderManifest: {
+                version: 4,
+                routes: {},
+                dynamicRoutes: {},
+                preview: previewProps,
+                notFoundRoutes: []
+            },
+            renderOpts: {
+                supportsDynamicResponse: true,
+                // App Route's cannot be postponed.
+                experimental: {
+                    ppr: false
+                }
+            }
+        };
+        // Get the response from the handler.
+        const res = await this.routeModule.handle(request, context);
+        const waitUntilPromises = [
+            (0, _internaledgewaituntil.internal_getCurrentFunctionWaitUntil)()
+        ];
+        if (context.renderOpts.waitUntil) {
+            waitUntilPromises.push(context.renderOpts.waitUntil);
+        }
+        evt.waitUntil(Promise.all(waitUntilPromises));
+        return res;
+    }
+}
+
+//# sourceMappingURL=edge-route-module-wrapper.js.map

node_modules/next/dist/server/web/edge-route-module-wrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/web/edge-route-module-wrapper.ts"],"names":["EdgeRouteModuleWrapper","routeModule","matcher","RouteMatcher","definition","wrap","options","wrapper","opts","adapter","IncrementalCache","handler","bind","request","evt","utils","getUtils","pageIsDynamic","isDynamic","page","pathname","basePath","nextUrl","rewrites","caseSensitive","params","normalizeDynamicRouteParams","searchParamsToUrlQuery","searchParams","previewProps","getEdgePreviewProps","context","prerenderManifest","version","routes","dynamicRoutes","preview","notFoundRoutes","renderOpts","supportsDynamicResponse","experimental","ppr","res","handle","waitUntilPromises","internal_getCurrentFunctionWaitUntil","waitUntil","push","Promise","all"],"mappings":";;;;+BAwBaA;;;eAAAA;;;QAlBN;yBAEsC;kCACZ;8BACJ;uCAEwB;6BAC5B;6BACc;qCACH;AAS7B,MAAMA;IAGX;;;;;GAKC,GACD,YAAoB,AAAiBC,WAAgC,CAAE;aAAlCA,cAAAA;QACnC,wEAAwE;QACxE,IAAI,CAACC,OAAO,GAAG,IAAIC,0BAAY,CAACF,YAAYG,UAAU;IACxD;IAEA;;;;;;;;GAQC,GACD,OAAcC,KACZJ,WAAgC,EAChCK,UAAuB,CAAC,CAAC,EACzB;QACA,6BAA6B;QAC7B,MAAMC,UAAU,IAAIP,uBAAuBC;QAE3C,gCAAgC;QAChC,OAAO,CAACO;YACN,OAAOC,IAAAA,gBAAO,EAAC;gBACb,GAAGD,IAAI;gBACP,GAAGF,OAAO;gBACVI,kBAAAA,kCAAgB;gBAChB,kEAAkE;gBAClEC,SAASJ,QAAQI,OAAO,CAACC,IAAI,CAACL;YAChC;QACF;IACF;IAEA,MAAcI,QACZE,OAAoB,EACpBC,GAAmB,EACA;QACnB,MAAMC,QAAQC,IAAAA,qBAAQ,EAAC;YACrBC,eAAe,IAAI,CAACf,OAAO,CAACgB,SAAS;YACrCC,MAAM,IAAI,CAACjB,OAAO,CAACE,UAAU,CAACgB,QAAQ;YACtCC,UAAUR,QAAQS,OAAO,CAACD,QAAQ;YAClC,2EAA2E;YAC3EE,UAAU,CAAC;YACX,qEAAqE;YACrEC,eAAe;QACjB;QAEA,MAAM,EAAEC,MAAM,EAAE,GAAGV,MAAMW,2BAA2B,CAClDC,IAAAA,mCAAsB,EAACd,QAAQS,OAAO,CAACM,YAAY;QAGrD,MAAMC,eAAeC,IAAAA,wCAAmB;QAExC,wEAAwE;QACxE,kBAAkB;QAClB,MAAMC,UAAuC;YAC3CN;YACAO,mBAAmB;gBACjBC,SAAS;gBACTC,QAAQ,CAAC;gBACTC,eAAe,CAAC;gBAChBC,SAASP;gBACTQ,gBAAgB,EAAE;YACpB;YACAC,YAAY;gBACVC,yBAAyB;gBACzB,mCAAmC;gBACnCC,cAAc;oBAAEC,KAAK;gBAAM;YAC7B;QACF;QAEA,qCAAqC;QACrC,MAAMC,MAAM,MAAM,IAAI,CAACzC,WAAW,CAAC0C,MAAM,CAAC9B,SAASkB;QAEnD,MAAMa,oBAAoB;YAACC,IAAAA,2DAAoC;SAAG;QAClE,IAAId,QAAQO,UAAU,CAACQ,SAAS,EAAE;YAChCF,kBAAkBG,IAAI,CAAChB,QAAQO,UAAU,CAACQ,SAAS;QACrD;QACAhC,IAAIgC,SAAS,CAACE,QAAQC,GAAG,CAACL;QAE1B,OAAOF;IACT;AACF"}

node_modules/next/dist/server/web/error.d.ts

@@ -0,0 +1,11 @@
+export declare class PageSignatureError extends Error {
+    constructor({ page }: {
+        page: string;
+    });
+}
+export declare class RemovedPageError extends Error {
+    constructor();
+}
+export declare class RemovedUAError extends Error {
+    constructor();
+}

node_modules/next/dist/server/web/error.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    PageSignatureError: null,
+    RemovedPageError: null,
+    RemovedUAError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    PageSignatureError: function() {
+        return PageSignatureError;
+    },
+    RemovedPageError: function() {
+        return RemovedPageError;
+    },
+    RemovedUAError: function() {
+        return RemovedUAError;
+    }
+});
+class PageSignatureError extends Error {
+    constructor({ page }){
+        super(`The middleware "${page}" accepts an async API directly with the form:
+  
+  export function middleware(request, event) {
+    return NextResponse.redirect('/new-location')
+  }
+  
+  Read more: https://nextjs.org/docs/messages/middleware-new-signature
+  `);
+    }
+}
+class RemovedPageError extends Error {
+    constructor(){
+        super(`The request.page has been deprecated in favour of \`URLPattern\`.
+  Read more: https://nextjs.org/docs/messages/middleware-request-page
+  `);
+    }
+}
+class RemovedUAError extends Error {
+    constructor(){
+        super(`The request.ua has been removed in favour of \`userAgent\` function.
+  Read more: https://nextjs.org/docs/messages/middleware-parse-user-agent
+  `);
+    }
+}
+
+//# sourceMappingURL=error.js.map

node_modules/next/dist/server/web/error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/web/error.ts"],"names":["PageSignatureError","RemovedPageError","RemovedUAError","Error","constructor","page"],"mappings":";;;;;;;;;;;;;;;;IAAaA,kBAAkB;eAAlBA;;IAaAC,gBAAgB;eAAhBA;;IAQAC,cAAc;eAAdA;;;AArBN,MAAMF,2BAA2BG;IACtCC,YAAY,EAAEC,IAAI,EAAoB,CAAE;QACtC,KAAK,CAAC,CAAC,gBAAgB,EAAEA,KAAK;;;;;;;EAOhC,CAAC;IACD;AACF;AAEO,MAAMJ,yBAAyBE;IACpCC,aAAc;QACZ,KAAK,CAAC,CAAC;;EAET,CAAC;IACD;AACF;AAEO,MAAMF,uBAAuBC;IAClCC,aAAc;QACZ,KAAK,CAAC,CAAC;;EAET,CAAC;IACD;AACF"}

node_modules/next/dist/server/web/exports/index.d.ts

@@ -0,0 +1,5 @@
+export { ImageResponse } from '../spec-extension/image-response';
+export { NextRequest } from '../spec-extension/request';
+export { NextResponse } from '../spec-extension/response';
+export { userAgent, userAgentFromString } from '../spec-extension/user-agent';
+export { URLPattern } from '../spec-extension/url-pattern';

node_modules/next/dist/server/web/exports/index.js

@@ -0,0 +1,46 @@
+// Alias index file of next/server for edge runtime for tree-shaking purpose
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ImageResponse: null,
+    NextRequest: null,
+    NextResponse: null,
+    URLPattern: null,
+    userAgent: null,
+    userAgentFromString: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ImageResponse: function() {
+        return _imageresponse.ImageResponse;
+    },
+    NextRequest: function() {
+        return _request.NextRequest;
+    },
+    NextResponse: function() {
+        return _response.NextResponse;
+    },
+    URLPattern: function() {
+        return _urlpattern.URLPattern;
+    },
+    userAgent: function() {
+        return _useragent.userAgent;
+    },
+    userAgentFromString: function() {
+        return _useragent.userAgentFromString;
+    }
+});
+const _imageresponse = require("../spec-extension/image-response");
+const _request = require("../spec-extension/request");
+const _response = require("../spec-extension/response");
+const _useragent = require("../spec-extension/user-agent");
+const _urlpattern = require("../spec-extension/url-pattern");
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/server/web/exports/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/exports/index.ts"],"names":["ImageResponse","NextRequest","NextResponse","URLPattern","userAgent","userAgentFromString"],"mappings":"AAAA,4EAA4E;;;;;;;;;;;;;;;;;;;;IAEnEA,aAAa;eAAbA,4BAAa;;IACbC,WAAW;eAAXA,oBAAW;;IACXC,YAAY;eAAZA,sBAAY;;IAEZC,UAAU;eAAVA,sBAAU;;IADVC,SAAS;eAATA,oBAAS;;IAAEC,mBAAmB;eAAnBA,8BAAmB;;;+BAHT;yBACF;0BACC;2BACkB;4BACpB"}

node_modules/next/dist/server/web/get-edge-preview-props.d.ts

@@ -0,0 +1,10 @@
+/**
+ * In edge runtime, these props directly accessed from environment variables.
+ *   - local: env vars will be injected through edge-runtime as runtime env vars
+ *   - deployment: env vars will be replaced by edge build pipeline
+ */
+export declare function getEdgePreviewProps(): {
+    previewModeId: string;
+    previewModeSigningKey: string;
+    previewModeEncryptionKey: string;
+};

node_modules/next/dist/server/web/get-edge-preview-props.js

@@ -0,0 +1,23 @@
+/**
+ * In edge runtime, these props directly accessed from environment variables.
+ *   - local: env vars will be injected through edge-runtime as runtime env vars
+ *   - deployment: env vars will be replaced by edge build pipeline
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getEdgePreviewProps", {
+    enumerable: true,
+    get: function() {
+        return getEdgePreviewProps;
+    }
+});
+function getEdgePreviewProps() {
+    return {
+        previewModeId: process.env.NODE_ENV === "production" ? process.env.__NEXT_PREVIEW_MODE_ID : "development-id",
+        previewModeSigningKey: process.env.__NEXT_PREVIEW_MODE_SIGNING_KEY || "",
+        previewModeEncryptionKey: process.env.__NEXT_PREVIEW_MODE_ENCRYPTION_KEY || ""
+    };
+}
+
+//# sourceMappingURL=get-edge-preview-props.js.map

node_modules/next/dist/server/web/get-edge-preview-props.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/web/get-edge-preview-props.ts"],"names":["getEdgePreviewProps","previewModeId","process","env","NODE_ENV","__NEXT_PREVIEW_MODE_ID","previewModeSigningKey","__NEXT_PREVIEW_MODE_SIGNING_KEY","previewModeEncryptionKey","__NEXT_PREVIEW_MODE_ENCRYPTION_KEY"],"mappings":"AAAA;;;;CAIC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA;IACd,OAAO;QACLC,eACEC,QAAQC,GAAG,CAACC,QAAQ,KAAK,eACrBF,QAAQC,GAAG,CAACE,sBAAsB,GAClC;QACNC,uBAAuBJ,QAAQC,GAAG,CAACI,+BAA+B,IAAI;QACtEC,0BACEN,QAAQC,GAAG,CAACM,kCAAkC,IAAI;IACtD;AACF"}

node_modules/next/dist/server/web/globals.d.ts

@@ -0,0 +1 @@
+export declare function ensureInstrumentationRegistered(): Promise<void>;

node_modules/next/dist/server/web/globals.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ensureInstrumentationRegistered", {
+    enumerable: true,
+    get: function() {
+        return ensureInstrumentationRegistered;
+    }
+});
+async function registerInstrumentation() {
+    const register = "_ENTRIES" in globalThis && _ENTRIES.middleware_instrumentation && (await _ENTRIES.middleware_instrumentation).register;
+    if (register) {
+        try {
+            await register();
+        } catch (err) {
+            err.message = `An error occurred while loading instrumentation hook: ${err.message}`;
+            throw err;
+        }
+    }
+}
+let registerInstrumentationPromise = null;
+function ensureInstrumentationRegistered() {
+    if (!registerInstrumentationPromise) {
+        registerInstrumentationPromise = registerInstrumentation();
+    }
+    return registerInstrumentationPromise;
+}
+function getUnsupportedModuleErrorMessage(module) {
+    // warning: if you change these messages, you must adjust how react-dev-overlay's middleware detects modules not found
+    return `The edge runtime does not support Node.js '${module}' module.
+Learn More: https://nextjs.org/docs/messages/node-module-in-edge-runtime`;
+}
+function __import_unsupported(moduleName) {
+    const proxy = new Proxy(function() {}, {
+        get (_obj, prop) {
+            if (prop === "then") {
+                return {};
+            }
+            throw new Error(getUnsupportedModuleErrorMessage(moduleName));
+        },
+        construct () {
+            throw new Error(getUnsupportedModuleErrorMessage(moduleName));
+        },
+        apply (_target, _this, args) {
+            if (typeof args[0] === "function") {
+                return args[0](proxy);
+            }
+            throw new Error(getUnsupportedModuleErrorMessage(moduleName));
+        }
+    });
+    return new Proxy({}, {
+        get: ()=>proxy
+    });
+}
+function enhanceGlobals() {
+    // The condition is true when the "process" module is provided
+    if (process !== global.process) {
+        // prefer local process but global.process has correct "env"
+        process.env = global.process.env;
+        global.process = process;
+    }
+    // to allow building code that import but does not use node.js modules,
+    // webpack will expect this function to exist in global scope
+    Object.defineProperty(globalThis, "__import_unsupported", {
+        value: __import_unsupported,
+        enumerable: false,
+        configurable: false
+    });
+    // Eagerly fire instrumentation hook to make the startup faster.
+    void ensureInstrumentationRegistered();
+}
+enhanceGlobals();
+
+//# sourceMappingURL=globals.js.map

node_modules/next/dist/server/web/globals.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/web/globals.ts"],"names":["ensureInstrumentationRegistered","registerInstrumentation","register","globalThis","_ENTRIES","middleware_instrumentation","err","message","registerInstrumentationPromise","getUnsupportedModuleErrorMessage","module","__import_unsupported","moduleName","proxy","Proxy","get","_obj","prop","Error","construct","apply","_target","_this","args","enhanceGlobals","process","global","env","Object","defineProperty","value","enumerable","configurable"],"mappings":";;;;+BAkBgBA;;;eAAAA;;;AAhBhB,eAAeC;IACb,MAAMC,WACJ,cAAcC,cACdC,SAASC,0BAA0B,IACnC,AAAC,CAAA,MAAMD,SAASC,0BAA0B,AAAD,EAAGH,QAAQ;IACtD,IAAIA,UAAU;QACZ,IAAI;YACF,MAAMA;QACR,EAAE,OAAOI,KAAU;YACjBA,IAAIC,OAAO,GAAG,CAAC,sDAAsD,EAAED,IAAIC,OAAO,CAAC,CAAC;YACpF,MAAMD;QACR;IACF;AACF;AAEA,IAAIE,iCAAuD;AACpD,SAASR;IACd,IAAI,CAACQ,gCAAgC;QACnCA,iCAAiCP;IACnC;IACA,OAAOO;AACT;AAEA,SAASC,iCAAiCC,MAAc;IACtD,sHAAsH;IACtH,OAAO,CAAC,2CAA2C,EAAEA,OAAO;wEACU,CAAC;AACzE;AAEA,SAASC,qBAAqBC,UAAkB;IAC9C,MAAMC,QAAa,IAAIC,MAAM,YAAa,GAAG;QAC3CC,KAAIC,IAAI,EAAEC,IAAI;YACZ,IAAIA,SAAS,QAAQ;gBACnB,OAAO,CAAC;YACV;YACA,MAAM,IAAIC,MAAMT,iCAAiCG;QACnD;QACAO;YACE,MAAM,IAAID,MAAMT,iCAAiCG;QACnD;QACAQ,OAAMC,OAAO,EAAEC,KAAK,EAAEC,IAAI;YACxB,IAAI,OAAOA,IAAI,CAAC,EAAE,KAAK,YAAY;gBACjC,OAAOA,IAAI,CAAC,EAAE,CAACV;YACjB;YACA,MAAM,IAAIK,MAAMT,iCAAiCG;QACnD;IACF;IACA,OAAO,IAAIE,MAAM,CAAC,GAAG;QAAEC,KAAK,IAAMF;IAAM;AAC1C;AAEA,SAASW;IACP,8DAA8D;IAC9D,IAAIC,YAAYC,OAAOD,OAAO,EAAE;QAC9B,4DAA4D;QAC5DA,QAAQE,GAAG,GAAGD,OAAOD,OAAO,CAACE,GAAG;QAChCD,OAAOD,OAAO,GAAGA;IACnB;IAEA,uEAAuE;IACvE,6DAA6D;IAC7DG,OAAOC,cAAc,CAAC1B,YAAY,wBAAwB;QACxD2B,OAAOnB;QACPoB,YAAY;QACZC,cAAc;IAChB;IAEA,gEAAgE;IAChE,KAAKhC;AACP;AAEAwB"}

node_modules/next/dist/server/web/http.d.ts

@@ -0,0 +1,18 @@
+/**
+ * List of valid HTTP methods that can be implemented by Next.js's Custom App
+ * Routes.
+ */
+export declare const HTTP_METHODS: readonly ["GET", "HEAD", "OPTIONS", "POST", "PUT", "DELETE", "PATCH"];
+/**
+ * A type representing the valid HTTP methods that can be implemented by
+ * Next.js's Custom App Routes.
+ */
+export type HTTP_METHOD = (typeof HTTP_METHODS)[number];
+/**
+ * Checks to see if the passed string is an HTTP method. Note that this is case
+ * sensitive.
+ *
+ * @param maybeMethod the string that may be an HTTP method
+ * @returns true if the string is an HTTP method
+ */
+export declare function isHTTPMethod(maybeMethod: string): maybeMethod is HTTP_METHOD;

node_modules/next/dist/server/web/http.js

@@ -0,0 +1,39 @@
+/**
+ * List of valid HTTP methods that can be implemented by Next.js's Custom App
+ * Routes.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    HTTP_METHODS: null,
+    isHTTPMethod: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    HTTP_METHODS: function() {
+        return HTTP_METHODS;
+    },
+    isHTTPMethod: function() {
+        return isHTTPMethod;
+    }
+});
+const HTTP_METHODS = [
+    "GET",
+    "HEAD",
+    "OPTIONS",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH"
+];
+function isHTTPMethod(maybeMethod) {
+    return HTTP_METHODS.includes(maybeMethod);
+}
+
+//# sourceMappingURL=http.js.map

node_modules/next/dist/server/web/http.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/web/http.ts"],"names":["HTTP_METHODS","isHTTPMethod","maybeMethod","includes"],"mappings":"AAAA;;;CAGC;;;;;;;;;;;;;;;IACYA,YAAY;eAAZA;;IAuBGC,YAAY;eAAZA;;;AAvBT,MAAMD,eAAe;IAC1B;IACA;IACA;IACA;IACA;IACA;IACA;CACD;AAeM,SAASC,aAAaC,WAAmB;IAC9C,OAAOF,aAAaG,QAAQ,CAACD;AAC/B"}

node_modules/next/dist/server/web/internal-edge-wait-until.d.ts

@@ -0,0 +1,2 @@
+export declare function internal_getCurrentFunctionWaitUntil(): Promise<void> | null;
+export declare function internal_runWithWaitUntil<T>(fn: () => T): T;

node_modules/next/dist/server/web/internal-edge-wait-until.js

@@ -0,0 +1,64 @@
+// An internal module to expose the "waitUntil" API to Edge SSR and Edge Route Handler functions.
+// This is highly experimental and subject to change.
+// We still need a global key to bypass Webpack's layering of modules.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    internal_getCurrentFunctionWaitUntil: null,
+    internal_runWithWaitUntil: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    internal_getCurrentFunctionWaitUntil: function() {
+        return internal_getCurrentFunctionWaitUntil;
+    },
+    internal_runWithWaitUntil: function() {
+        return internal_runWithWaitUntil;
+    }
+});
+const GLOBAL_KEY = Symbol.for("__next_internal_waitUntil__");
+const state = // @ts-ignore
+globalThis[GLOBAL_KEY] || // @ts-ignore
+(globalThis[GLOBAL_KEY] = {
+    waitUntilCounter: 0,
+    waitUntilResolve: undefined,
+    waitUntilPromise: null
+});
+// No matter how many concurrent requests are being handled, we want to make sure
+// that the final promise is only resolved once all of the waitUntil promises have
+// settled.
+function resolveOnePromise() {
+    state.waitUntilCounter--;
+    if (state.waitUntilCounter === 0) {
+        state.waitUntilResolve();
+        state.waitUntilPromise = null;
+    }
+}
+function internal_getCurrentFunctionWaitUntil() {
+    return state.waitUntilPromise;
+}
+function internal_runWithWaitUntil(fn) {
+    const result = fn();
+    if (result && typeof result === "object" && "then" in result && "finally" in result && typeof result.then === "function" && typeof result.finally === "function") {
+        if (!state.waitUntilCounter) {
+            // Create the promise for the next batch of waitUntil calls.
+            state.waitUntilPromise = new Promise((resolve)=>{
+                state.waitUntilResolve = resolve;
+            });
+        }
+        state.waitUntilCounter++;
+        return result.finally(()=>{
+            resolveOnePromise();
+        });
+    }
+    return result;
+}
+
+//# sourceMappingURL=internal-edge-wait-until.js.map

node_modules/next/dist/server/web/internal-edge-wait-until.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/web/internal-edge-wait-until.ts"],"names":["internal_getCurrentFunctionWaitUntil","internal_runWithWaitUntil","GLOBAL_KEY","Symbol","for","state","globalThis","waitUntilCounter","waitUntilResolve","undefined","waitUntilPromise","resolveOnePromise","fn","result","then","finally","Promise","resolve"],"mappings":"AAAA,iGAAiG;AACjG,qDAAqD;AAErD,sEAAsE;;;;;;;;;;;;;;;;IA4BtDA,oCAAoC;eAApCA;;IAIAC,yBAAyB;eAAzBA;;;AA/BhB,MAAMC,aAAaC,OAAOC,GAAG,CAAC;AAE9B,MAAMC,QAKJ,aAAa;AACbC,UAAU,CAACJ,WAAW,IACtB,aAAa;AACZI,CAAAA,UAAU,CAACJ,WAAW,GAAG;IACxBK,kBAAkB;IAClBC,kBAAkBC;IAClBC,kBAAkB;AACpB,CAAA;AAEF,iFAAiF;AACjF,kFAAkF;AAClF,WAAW;AACX,SAASC;IACPN,MAAME,gBAAgB;IACtB,IAAIF,MAAME,gBAAgB,KAAK,GAAG;QAChCF,MAAMG,gBAAgB;QACtBH,MAAMK,gBAAgB,GAAG;IAC3B;AACF;AAEO,SAASV;IACd,OAAOK,MAAMK,gBAAgB;AAC/B;AAEO,SAAST,0BAA6BW,EAAW;IACtD,MAAMC,SAASD;IACf,IACEC,UACA,OAAOA,WAAW,YAClB,UAAUA,UACV,aAAaA,UACb,OAAOA,OAAOC,IAAI,KAAK,cACvB,OAAOD,OAAOE,OAAO,KAAK,YAC1B;QACA,IAAI,CAACV,MAAME,gBAAgB,EAAE;YAC3B,4DAA4D;YAC5DF,MAAMK,gBAAgB,GAAG,IAAIM,QAAc,CAACC;gBAC1CZ,MAAMG,gBAAgB,GAAGS;YAC3B;QACF;QACAZ,MAAME,gBAAgB;QACtB,OAAOM,OAAOE,OAAO,CAAC;YACpBJ;QACF;IACF;IAEA,OAAOE;AACT"}

node_modules/next/dist/server/web/next-url.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="node" />
+import type { OutgoingHttpHeaders } from 'http';
+import type { DomainLocale, I18NConfig } from '../config-shared';
+import type { I18NProvider } from '../future/helpers/i18n-provider';
+interface Options {
+    base?: string | URL;
+    headers?: OutgoingHttpHeaders;
+    forceLocale?: boolean;
+    nextConfig?: {
+        basePath?: string;
+        i18n?: I18NConfig | null;
+        trailingSlash?: boolean;
+    };
+    i18nProvider?: I18NProvider;
+}
+declare const Internal: unique symbol;
+export declare class NextURL {
+    private [Internal];
+    constructor(input: string | URL, base?: string | URL, opts?: Options);
+    constructor(input: string | URL, opts?: Options);
+    private analyze;
+    private formatPathname;
+    private formatSearch;
+    get buildId(): string | undefined;
+    set buildId(buildId: string | undefined);
+    get locale(): string;
+    set locale(locale: string);
+    get defaultLocale(): string | undefined;
+    get domainLocale(): DomainLocale | undefined;
+    get searchParams(): URLSearchParams;
+    get host(): string;
+    set host(value: string);
+    get hostname(): string;
+    set hostname(value: string);
+    get port(): string;
+    set port(value: string);
+    get protocol(): string;
+    set protocol(value: string);
+    get href(): string;
+    set href(url: string);
+    get origin(): string;
+    get pathname(): string;
+    set pathname(value: string);
+    get hash(): string;
+    set hash(value: string);
+    get search(): string;
+    set search(value: string);
+    get password(): string;
+    set password(value: string);
+    get username(): string;
+    set username(value: string);
+    get basePath(): string;
+    set basePath(value: string);
+    toString(): string;
+    toJSON(): string;
+    clone(): NextURL;
+}
+export {};

node_modules/next/dist/server/web/next-url.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NextURL", {
+    enumerable: true,
+    get: function() {
+        return NextURL;
+    }
+});
+const _detectdomainlocale = require("../../shared/lib/i18n/detect-domain-locale");
+const _formatnextpathnameinfo = require("../../shared/lib/router/utils/format-next-pathname-info");
+const _gethostname = require("../../shared/lib/get-hostname");
+const _getnextpathnameinfo = require("../../shared/lib/router/utils/get-next-pathname-info");
+const REGEX_LOCALHOST_HOSTNAME = /(?!^https?:\/\/)(127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}|\[::1\]|localhost)/;
+function parseURL(url, base) {
+    return new URL(String(url).replace(REGEX_LOCALHOST_HOSTNAME, "localhost"), base && String(base).replace(REGEX_LOCALHOST_HOSTNAME, "localhost"));
+}
+const Internal = Symbol("NextURLInternal");
+class NextURL {
+    constructor(input, baseOrOpts, opts){
+        let base;
+        let options;
+        if (typeof baseOrOpts === "object" && "pathname" in baseOrOpts || typeof baseOrOpts === "string") {
+            base = baseOrOpts;
+            options = opts || {};
+        } else {
+            options = opts || baseOrOpts || {};
+        }
+        this[Internal] = {
+            url: parseURL(input, base ?? options.base),
+            options: options,
+            basePath: ""
+        };
+        this.analyze();
+    }
+    analyze() {
+        var _this_Internal_options_nextConfig_i18n, _this_Internal_options_nextConfig, _this_Internal_domainLocale, _this_Internal_options_nextConfig_i18n1, _this_Internal_options_nextConfig1;
+        const info = (0, _getnextpathnameinfo.getNextPathnameInfo)(this[Internal].url.pathname, {
+            nextConfig: this[Internal].options.nextConfig,
+            parseData: !process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE,
+            i18nProvider: this[Internal].options.i18nProvider
+        });
+        const hostname = (0, _gethostname.getHostname)(this[Internal].url, this[Internal].options.headers);
+        this[Internal].domainLocale = this[Internal].options.i18nProvider ? this[Internal].options.i18nProvider.detectDomainLocale(hostname) : (0, _detectdomainlocale.detectDomainLocale)((_this_Internal_options_nextConfig = this[Internal].options.nextConfig) == null ? void 0 : (_this_Internal_options_nextConfig_i18n = _this_Internal_options_nextConfig.i18n) == null ? void 0 : _this_Internal_options_nextConfig_i18n.domains, hostname);
+        const defaultLocale = ((_this_Internal_domainLocale = this[Internal].domainLocale) == null ? void 0 : _this_Internal_domainLocale.defaultLocale) || ((_this_Internal_options_nextConfig1 = this[Internal].options.nextConfig) == null ? void 0 : (_this_Internal_options_nextConfig_i18n1 = _this_Internal_options_nextConfig1.i18n) == null ? void 0 : _this_Internal_options_nextConfig_i18n1.defaultLocale);
+        this[Internal].url.pathname = info.pathname;
+        this[Internal].defaultLocale = defaultLocale;
+        this[Internal].basePath = info.basePath ?? "";
+        this[Internal].buildId = info.buildId;
+        this[Internal].locale = info.locale ?? defaultLocale;
+        this[Internal].trailingSlash = info.trailingSlash;
+    }
+    formatPathname() {
+        return (0, _formatnextpathnameinfo.formatNextPathnameInfo)({
+            basePath: this[Internal].basePath,
+            buildId: this[Internal].buildId,
+            defaultLocale: !this[Internal].options.forceLocale ? this[Internal].defaultLocale : undefined,
+            locale: this[Internal].locale,
+            pathname: this[Internal].url.pathname,
+            trailingSlash: this[Internal].trailingSlash
+        });
+    }
+    formatSearch() {
+        return this[Internal].url.search;
+    }
+    get buildId() {
+        return this[Internal].buildId;
+    }
+    set buildId(buildId) {
+        this[Internal].buildId = buildId;
+    }
+    get locale() {
+        return this[Internal].locale ?? "";
+    }
+    set locale(locale) {
+        var _this_Internal_options_nextConfig_i18n, _this_Internal_options_nextConfig;
+        if (!this[Internal].locale || !((_this_Internal_options_nextConfig = this[Internal].options.nextConfig) == null ? void 0 : (_this_Internal_options_nextConfig_i18n = _this_Internal_options_nextConfig.i18n) == null ? void 0 : _this_Internal_options_nextConfig_i18n.locales.includes(locale))) {
+            throw new TypeError(`The NextURL configuration includes no locale "${locale}"`);
+        }
+        this[Internal].locale = locale;
+    }
+    get defaultLocale() {
+        return this[Internal].defaultLocale;
+    }
+    get domainLocale() {
+        return this[Internal].domainLocale;
+    }
+    get searchParams() {
+        return this[Internal].url.searchParams;
+    }
+    get host() {
+        return this[Internal].url.host;
+    }
+    set host(value) {
+        this[Internal].url.host = value;
+    }
+    get hostname() {
+        return this[Internal].url.hostname;
+    }
+    set hostname(value) {
+        this[Internal].url.hostname = value;
+    }
+    get port() {
+        return this[Internal].url.port;
+    }
+    set port(value) {
+        this[Internal].url.port = value;
+    }
+    get protocol() {
+        return this[Internal].url.protocol;
+    }
+    set protocol(value) {
+        this[Internal].url.protocol = value;
+    }
+    get href() {
+        const pathname = this.formatPathname();
+        const search = this.formatSearch();
+        return `${this.protocol}//${this.host}${pathname}${search}${this.hash}`;
+    }
+    set href(url) {
+        this[Internal].url = parseURL(url);
+        this.analyze();
+    }
+    get origin() {
+        return this[Internal].url.origin;
+    }
+    get pathname() {
+        return this[Internal].url.pathname;
+    }
+    set pathname(value) {
+        this[Internal].url.pathname = value;
+    }
+    get hash() {
+        return this[Internal].url.hash;
+    }
+    set hash(value) {
+        this[Internal].url.hash = value;
+    }
+    get search() {
+        return this[Internal].url.search;
+    }
+    set search(value) {
+        this[Internal].url.search = value;
+    }
+    get password() {
+        return this[Internal].url.password;
+    }
+    set password(value) {
+        this[Internal].url.password = value;
+    }
+    get username() {
+        return this[Internal].url.username;
+    }
+    set username(value) {
+        this[Internal].url.username = value;
+    }
+    get basePath() {
+        return this[Internal].basePath;
+    }
+    set basePath(value) {
+        this[Internal].basePath = value.startsWith("/") ? value : `/${value}`;
+    }
+    toString() {
+        return this.href;
+    }
+    toJSON() {
+        return this.href;
+    }
+    [Symbol.for("edge-runtime.inspect.custom")]() {
+        return {
+            href: this.href,
+            origin: this.origin,
+            protocol: this.protocol,
+            username: this.username,
+            password: this.password,
+            host: this.host,
+            hostname: this.hostname,
+            port: this.port,
+            pathname: this.pathname,
+            search: this.search,
+            searchParams: this.searchParams,
+            hash: this.hash
+        };
+    }
+    clone() {
+        return new NextURL(String(this), this[Internal].options);
+    }
+}
+
+//# sourceMappingURL=next-url.js.map

node_modules/next/dist/server/web/sandbox/context.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+import type { EdgeFunctionDefinition } from '../../../build/webpack/plugins/middleware-plugin';
+import { AsyncLocalStorage } from 'async_hooks';
+import { EdgeRuntime } from 'next/dist/compiled/edge-runtime';
+/**
+ * Same as clearModuleContext but for all module contexts.
+ */
+export declare function clearAllModuleContexts(): Promise<void>;
+/**
+ * For a given path a context, this function checks if there is any module
+ * context that contains the path with an older content and, if that's the
+ * case, removes the context from the cache.
+ *
+ * This function also clears all intervals and timeouts created by the
+ * module context.
+ */
+export declare function clearModuleContext(path: string): Promise<void>;
+export declare const requestStore: AsyncLocalStorage<{
+    headers: Headers;
+}>;
+interface ModuleContextOptions {
+    moduleName: string;
+    onError: (err: unknown) => void;
+    onWarning: (warn: Error) => void;
+    useCache: boolean;
+    distDir: string;
+    edgeFunctionEntry: Pick<EdgeFunctionDefinition, 'assets' | 'wasm' | 'env'>;
+}
+/**
+ * For a given module name this function will get a cached module
+ * context or create it. It will return the module context along
+ * with a function that allows to run some code from a given
+ * filepath within the context.
+ */
+export declare function getModuleContext(options: ModuleContextOptions): Promise<{
+    evaluateInContext: (filepath: string) => void;
+    runtime: EdgeRuntime;
+    paths: Map<string, string>;
+    warnedEvals: Set<string>;
+}>;
+export {};

node_modules/next/dist/server/web/sandbox/context.js

@@ -0,0 +1,425 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    clearAllModuleContexts: null,
+    clearModuleContext: null,
+    getModuleContext: null,
+    requestStore: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    clearAllModuleContexts: function() {
+        return clearAllModuleContexts;
+    },
+    clearModuleContext: function() {
+        return clearModuleContext;
+    },
+    getModuleContext: function() {
+        return getModuleContext;
+    },
+    requestStore: function() {
+        return requestStore;
+    }
+});
+const _async_hooks = require("async_hooks");
+const _constants = require("../../../shared/lib/constants");
+const _edgeruntime = require("next/dist/compiled/edge-runtime");
+const _fs = require("fs");
+const _utils = require("../utils");
+const _pick = require("../../../lib/pick");
+const _fetchinlineassets = require("./fetch-inline-assets");
+const _vm = require("vm");
+const _nodebuffer = /*#__PURE__*/ _interop_require_default(require("node:buffer"));
+const _nodeevents = /*#__PURE__*/ _interop_require_default(require("node:events"));
+const _nodeassert = /*#__PURE__*/ _interop_require_default(require("node:assert"));
+const _nodeutil = /*#__PURE__*/ _interop_require_default(require("node:util"));
+const _nodeasync_hooks = /*#__PURE__*/ _interop_require_default(require("node:async_hooks"));
+const _resourcemanagers = require("./resource-managers");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+let getServerError;
+let decorateServerError;
+if (process.env.NODE_ENV === "development") {
+    const middleware = require("../../../client/components/react-dev-overlay/server/middleware");
+    getServerError = middleware.getServerError;
+    decorateServerError = require("../../../shared/lib/error-source").decorateServerError;
+} else {
+    getServerError = (error, _)=>error;
+    decorateServerError = (_, __)=>{};
+}
+/**
+ * A Map of cached module contexts indexed by the module name. It allows
+ * to have a different cache scoped per module name or depending on the
+ * provided module key on creation.
+ */ const moduleContexts = new Map();
+const pendingModuleCaches = new Map();
+async function clearAllModuleContexts() {
+    _resourcemanagers.intervalsManager.removeAll();
+    _resourcemanagers.timeoutsManager.removeAll();
+    moduleContexts.clear();
+    pendingModuleCaches.clear();
+}
+async function clearModuleContext(path) {
+    _resourcemanagers.intervalsManager.removeAll();
+    _resourcemanagers.timeoutsManager.removeAll();
+    const handleContext = (key, cache, context)=>{
+        if (cache == null ? void 0 : cache.paths.has(path)) {
+            context.delete(key);
+        }
+    };
+    for (const [key, cache] of moduleContexts){
+        handleContext(key, cache, moduleContexts);
+    }
+    for (const [key, cache] of pendingModuleCaches){
+        handleContext(key, await cache, pendingModuleCaches);
+    }
+}
+async function loadWasm(wasm) {
+    const modules = {};
+    await Promise.all(wasm.map(async (binding)=>{
+        const module1 = await WebAssembly.compile(await _fs.promises.readFile(binding.filePath));
+        modules[binding.name] = module1;
+    }));
+    return modules;
+}
+function buildEnvironmentVariablesFrom(injectedEnvironments) {
+    const pairs = Object.keys(process.env).map((key)=>[
+            key,
+            process.env[key]
+        ]);
+    const env = Object.fromEntries(pairs);
+    for (const key of Object.keys(injectedEnvironments)){
+        env[key] = injectedEnvironments[key];
+    }
+    env.NEXT_RUNTIME = "edge";
+    return env;
+}
+function throwUnsupportedAPIError(name) {
+    const error = new Error(`A Node.js API is used (${name}) which is not supported in the Edge Runtime.
+Learn more: https://nextjs.org/docs/api-reference/edge-runtime`);
+    decorateServerError(error, _constants.COMPILER_NAMES.edgeServer);
+    throw error;
+}
+function createProcessPolyfill(env) {
+    const processPolyfill = {
+        env: buildEnvironmentVariablesFrom(env)
+    };
+    const overriddenValue = {};
+    for (const key of Object.keys(process)){
+        if (key === "env") continue;
+        Object.defineProperty(processPolyfill, key, {
+            get () {
+                if (overriddenValue[key] !== undefined) {
+                    return overriddenValue[key];
+                }
+                if (typeof process[key] === "function") {
+                    return ()=>throwUnsupportedAPIError(`process.${key}`);
+                }
+                return undefined;
+            },
+            set (value) {
+                overriddenValue[key] = value;
+            },
+            enumerable: false
+        });
+    }
+    return processPolyfill;
+}
+function addStub(context, name) {
+    Object.defineProperty(context, name, {
+        get () {
+            return function() {
+                throwUnsupportedAPIError(name);
+            };
+        },
+        enumerable: false
+    });
+}
+function getDecorateUnhandledError(runtime) {
+    const EdgeRuntimeError = runtime.evaluate(`Error`);
+    return (error)=>{
+        if (error instanceof EdgeRuntimeError) {
+            decorateServerError(error, _constants.COMPILER_NAMES.edgeServer);
+        }
+    };
+}
+function getDecorateUnhandledRejection(runtime) {
+    const EdgeRuntimeError = runtime.evaluate(`Error`);
+    return (rejected)=>{
+        if (rejected.reason instanceof EdgeRuntimeError) {
+            decorateServerError(rejected.reason, _constants.COMPILER_NAMES.edgeServer);
+        }
+    };
+}
+const NativeModuleMap = (()=>{
+    const mods = {
+        "node:buffer": (0, _pick.pick)(_nodebuffer.default, [
+            "constants",
+            "kMaxLength",
+            "kStringMaxLength",
+            "Buffer",
+            "SlowBuffer"
+        ]),
+        "node:events": (0, _pick.pick)(_nodeevents.default, [
+            "EventEmitter",
+            "captureRejectionSymbol",
+            "defaultMaxListeners",
+            "errorMonitor",
+            "listenerCount",
+            "on",
+            "once"
+        ]),
+        "node:async_hooks": (0, _pick.pick)(_nodeasync_hooks.default, [
+            "AsyncLocalStorage",
+            "AsyncResource"
+        ]),
+        "node:assert": (0, _pick.pick)(_nodeassert.default, [
+            "AssertionError",
+            "deepEqual",
+            "deepStrictEqual",
+            "doesNotMatch",
+            "doesNotReject",
+            "doesNotThrow",
+            "equal",
+            "fail",
+            "ifError",
+            "match",
+            "notDeepEqual",
+            "notDeepStrictEqual",
+            "notEqual",
+            "notStrictEqual",
+            "ok",
+            "rejects",
+            "strict",
+            "strictEqual",
+            "throws"
+        ]),
+        "node:util": (0, _pick.pick)(_nodeutil.default, [
+            "_extend",
+            "callbackify",
+            "format",
+            "inherits",
+            "promisify",
+            "types"
+        ])
+    };
+    return new Map(Object.entries(mods));
+})();
+const requestStore = new _async_hooks.AsyncLocalStorage();
+/**
+ * Create a module cache specific for the provided parameters. It includes
+ * a runtime context, require cache and paths cache.
+ */ async function createModuleContext(options) {
+    const warnedEvals = new Set();
+    const warnedWasmCodegens = new Set();
+    const { edgeFunctionEntry } = options;
+    const wasm = await loadWasm(edgeFunctionEntry.wasm ?? []);
+    const runtime = new _edgeruntime.EdgeRuntime({
+        codeGeneration: process.env.NODE_ENV !== "production" ? {
+            strings: true,
+            wasm: true
+        } : undefined,
+        extend: (context)=>{
+            context.process = createProcessPolyfill(edgeFunctionEntry.env);
+            Object.defineProperty(context, "require", {
+                enumerable: false,
+                value: (id)=>{
+                    const value = NativeModuleMap.get(id);
+                    if (!value) {
+                        throw TypeError("Native module not found: " + id);
+                    }
+                    return value;
+                }
+            });
+            if (process.env.NODE_ENV !== "production") {
+                context.__next_log_error__ = function(err) {
+                    options.onError(err);
+                };
+            }
+            context.__next_eval__ = function __next_eval__(fn) {
+                const key = fn.toString();
+                if (!warnedEvals.has(key)) {
+                    const warning = getServerError(new Error(`Dynamic Code Evaluation (e. g. 'eval', 'new Function') not allowed in Edge Runtime
+Learn More: https://nextjs.org/docs/messages/edge-dynamic-code-evaluation`), _constants.COMPILER_NAMES.edgeServer);
+                    warning.name = "DynamicCodeEvaluationWarning";
+                    Error.captureStackTrace(warning, __next_eval__);
+                    warnedEvals.add(key);
+                    options.onWarning(warning);
+                }
+                return fn();
+            };
+            context.__next_webassembly_compile__ = function __next_webassembly_compile__(fn) {
+                const key = fn.toString();
+                if (!warnedWasmCodegens.has(key)) {
+                    const warning = getServerError(new Error(`Dynamic WASM code generation (e. g. 'WebAssembly.compile') not allowed in Edge Runtime.
+Learn More: https://nextjs.org/docs/messages/edge-dynamic-code-evaluation`), _constants.COMPILER_NAMES.edgeServer);
+                    warning.name = "DynamicWasmCodeGenerationWarning";
+                    Error.captureStackTrace(warning, __next_webassembly_compile__);
+                    warnedWasmCodegens.add(key);
+                    options.onWarning(warning);
+                }
+                return fn();
+            };
+            context.__next_webassembly_instantiate__ = async function __next_webassembly_instantiate__(fn) {
+                const result = await fn();
+                // If a buffer is given, WebAssembly.instantiate returns an object
+                // containing both a module and an instance while it returns only an
+                // instance if a WASM module is given. Utilize the fact to determine
+                // if the WASM code generation happens.
+                //
+                // https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate#primary_overload_%E2%80%94_taking_wasm_binary_code
+                const instantiatedFromBuffer = result.hasOwnProperty("module");
+                const key = fn.toString();
+                if (instantiatedFromBuffer && !warnedWasmCodegens.has(key)) {
+                    const warning = getServerError(new Error(`Dynamic WASM code generation ('WebAssembly.instantiate' with a buffer parameter) not allowed in Edge Runtime.
+Learn More: https://nextjs.org/docs/messages/edge-dynamic-code-evaluation`), _constants.COMPILER_NAMES.edgeServer);
+                    warning.name = "DynamicWasmCodeGenerationWarning";
+                    Error.captureStackTrace(warning, __next_webassembly_instantiate__);
+                    warnedWasmCodegens.add(key);
+                    options.onWarning(warning);
+                }
+                return result;
+            };
+            const __fetch = context.fetch;
+            context.fetch = async (input, init = {})=>{
+                var _init_headers_get;
+                const callingError = new Error("[internal]");
+                const assetResponse = await (0, _fetchinlineassets.fetchInlineAsset)({
+                    input,
+                    assets: options.edgeFunctionEntry.assets,
+                    distDir: options.distDir,
+                    context
+                });
+                if (assetResponse) {
+                    return assetResponse;
+                }
+                init.headers = new Headers(init.headers ?? {});
+                // Forward subrequest header from incoming request to outgoing request
+                const store = requestStore.getStore();
+                if ((store == null ? void 0 : store.headers.has("x-middleware-subrequest")) && !init.headers.has("x-middleware-subrequest")) {
+                    init.headers.set("x-middleware-subrequest", store.headers.get("x-middleware-subrequest") ?? "");
+                }
+                const prevs = ((_init_headers_get = init.headers.get(`x-middleware-subrequest`)) == null ? void 0 : _init_headers_get.split(":")) || [];
+                const value = prevs.concat(options.moduleName).join(":");
+                init.headers.set("x-middleware-subrequest", value);
+                if (!init.headers.has("user-agent")) {
+                    init.headers.set(`user-agent`, `Next.js Middleware`);
+                }
+                const response = typeof input === "object" && "url" in input ? __fetch(input.url, {
+                    ...(0, _pick.pick)(input, [
+                        "method",
+                        "body",
+                        "cache",
+                        "credentials",
+                        "integrity",
+                        "keepalive",
+                        "mode",
+                        "redirect",
+                        "referrer",
+                        "referrerPolicy",
+                        "signal"
+                    ]),
+                    ...init,
+                    headers: {
+                        ...Object.fromEntries(input.headers),
+                        ...Object.fromEntries(init.headers)
+                    }
+                }) : __fetch(String(input), init);
+                return await response.catch((err)=>{
+                    callingError.message = err.message;
+                    err.stack = callingError.stack;
+                    throw err;
+                });
+            };
+            const __Request = context.Request;
+            context.Request = class extends __Request {
+                constructor(input, init){
+                    const url = typeof input !== "string" && "url" in input ? input.url : String(input);
+                    (0, _utils.validateURL)(url);
+                    super(url, init);
+                    this.next = init == null ? void 0 : init.next;
+                }
+            };
+            const __redirect = context.Response.redirect.bind(context.Response);
+            context.Response.redirect = (...args)=>{
+                (0, _utils.validateURL)(args[0]);
+                return __redirect(...args);
+            };
+            for (const name of _constants.EDGE_UNSUPPORTED_NODE_APIS){
+                addStub(context, name);
+            }
+            Object.assign(context, wasm);
+            context.performance = performance;
+            context.AsyncLocalStorage = _async_hooks.AsyncLocalStorage;
+            // @ts-ignore the timeouts have weird types in the edge runtime
+            context.setInterval = (...args)=>_resourcemanagers.intervalsManager.add(args);
+            // @ts-ignore the timeouts have weird types in the edge runtime
+            context.clearInterval = (interval)=>_resourcemanagers.intervalsManager.remove(interval);
+            // @ts-ignore the timeouts have weird types in the edge runtime
+            context.setTimeout = (...args)=>_resourcemanagers.timeoutsManager.add(args);
+            // @ts-ignore the timeouts have weird types in the edge runtime
+            context.clearTimeout = (timeout)=>_resourcemanagers.timeoutsManager.remove(timeout);
+            return context;
+        }
+    });
+    const decorateUnhandledError = getDecorateUnhandledError(runtime);
+    runtime.context.addEventListener("error", decorateUnhandledError);
+    const decorateUnhandledRejection = getDecorateUnhandledRejection(runtime);
+    runtime.context.addEventListener("unhandledrejection", decorateUnhandledRejection);
+    return {
+        runtime,
+        paths: new Map(),
+        warnedEvals: new Set()
+    };
+}
+function getModuleContextShared(options) {
+    let deferredModuleContext = pendingModuleCaches.get(options.moduleName);
+    if (!deferredModuleContext) {
+        deferredModuleContext = createModuleContext(options);
+        pendingModuleCaches.set(options.moduleName, deferredModuleContext);
+    }
+    return deferredModuleContext;
+}
+async function getModuleContext(options) {
+    let lazyModuleContext;
+    if (options.useCache) {
+        lazyModuleContext = moduleContexts.get(options.moduleName) || await getModuleContextShared(options);
+    }
+    if (!lazyModuleContext) {
+        lazyModuleContext = await createModuleContext(options);
+        moduleContexts.set(options.moduleName, lazyModuleContext);
+    }
+    const moduleContext = lazyModuleContext;
+    const evaluateInContext = (filepath)=>{
+        if (!moduleContext.paths.has(filepath)) {
+            const content = (0, _fs.readFileSync)(filepath, "utf-8");
+            try {
+                (0, _vm.runInContext)(content, moduleContext.runtime.context, {
+                    filename: filepath
+                });
+                moduleContext.paths.set(filepath, content);
+            } catch (error) {
+                if (options.useCache) {
+                    moduleContext == null ? void 0 : moduleContext.paths.delete(filepath);
+                }
+                throw error;
+            }
+        }
+    };
+    return {
+        ...moduleContext,
+        evaluateInContext
+    };
+}
+
+//# sourceMappingURL=context.js.map

node_modules/next/dist/server/web/sandbox/fetch-inline-assets.d.ts

@@ -0,0 +1,15 @@
+import type { EdgeFunctionDefinition } from '../../../build/webpack/plugins/middleware-plugin';
+/**
+ * Short-circuits the `fetch` function
+ * to return a stream for a given asset, if a user used `new URL("file", import.meta.url)`.
+ * This allows to embed assets in Edge Runtime.
+ */
+export declare function fetchInlineAsset(options: {
+    input: RequestInfo | URL;
+    distDir: string;
+    assets: EdgeFunctionDefinition['assets'];
+    context: {
+        Response: typeof Response;
+        ReadableStream: typeof ReadableStream;
+    };
+}): Promise<Response | undefined>;

node_modules/next/dist/server/web/sandbox/fetch-inline-assets.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "fetchInlineAsset", {
+    enumerable: true,
+    get: function() {
+        return fetchInlineAsset;
+    }
+});
+const _fs = require("fs");
+const _bodystreams = require("../../body-streams");
+const _path = require("path");
+async function fetchInlineAsset(options) {
+    const inputString = String(options.input);
+    if (!inputString.startsWith("blob:")) {
+        return;
+    }
+    const name = inputString.replace("blob:", "");
+    const asset = options.assets ? options.assets.find((x)=>x.name === name) : {
+        name,
+        filePath: name
+    };
+    if (!asset) {
+        return;
+    }
+    const filePath = (0, _path.resolve)(options.distDir, asset.filePath);
+    const fileIsReadable = await _fs.promises.access(filePath).then(()=>true, ()=>false);
+    if (fileIsReadable) {
+        const readStream = (0, _fs.createReadStream)(filePath);
+        return new options.context.Response((0, _bodystreams.requestToBodyStream)(options.context, Uint8Array, readStream));
+    }
+}
+
+//# sourceMappingURL=fetch-inline-assets.js.map

node_modules/next/dist/server/web/sandbox/fetch-inline-assets.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/sandbox/fetch-inline-assets.ts"],"names":["fetchInlineAsset","options","inputString","String","input","startsWith","name","replace","asset","assets","find","x","filePath","resolve","distDir","fileIsReadable","fs","access","then","readStream","createReadStream","context","Response","requestToBodyStream","Uint8Array"],"mappings":";;;;+BAUsBA;;;eAAAA;;;oBAT2B;6BACb;sBACZ;AAOjB,eAAeA,iBAAiBC,OAKtC;IACC,MAAMC,cAAcC,OAAOF,QAAQG,KAAK;IACxC,IAAI,CAACF,YAAYG,UAAU,CAAC,UAAU;QACpC;IACF;IAEA,MAAMC,OAAOJ,YAAYK,OAAO,CAAC,SAAS;IAC1C,MAAMC,QAAQP,QAAQQ,MAAM,GACxBR,QAAQQ,MAAM,CAACC,IAAI,CAAC,CAACC,IAAMA,EAAEL,IAAI,KAAKA,QACtC;QACEA;QACAM,UAAUN;IACZ;IACJ,IAAI,CAACE,OAAO;QACV;IACF;IAEA,MAAMI,WAAWC,IAAAA,aAAO,EAACZ,QAAQa,OAAO,EAAEN,MAAMI,QAAQ;IACxD,MAAMG,iBAAiB,MAAMC,YAAE,CAACC,MAAM,CAACL,UAAUM,IAAI,CACnD,IAAM,MACN,IAAM;IAGR,IAAIH,gBAAgB;QAClB,MAAMI,aAAaC,IAAAA,oBAAgB,EAACR;QACpC,OAAO,IAAIX,QAAQoB,OAAO,CAACC,QAAQ,CACjCC,IAAAA,gCAAmB,EAACtB,QAAQoB,OAAO,EAAEG,YAAYL;IAErD;AACF"}

node_modules/next/dist/server/web/sandbox/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sandbox';
+export { clearModuleContext } from './context';

node_modules/next/dist/server/web/sandbox/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "clearModuleContext", {
+    enumerable: true,
+    get: function() {
+        return _context.clearModuleContext;
+    }
+});
+0 && __export(require("./sandbox"));
+_export_star(require("./sandbox"), exports);
+const _context = require("./context");
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/server/web/sandbox/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/sandbox/index.ts"],"names":["clearModuleContext"],"mappings":";;;;+BACSA;;;eAAAA,2BAAkB;;;;qBADb;yBACqB"}

node_modules/next/dist/server/web/sandbox/resource-managers.d.ts

@@ -0,0 +1,19 @@
+declare abstract class ResourceManager<T, K> {
+    private resources;
+    abstract create(resourceArgs: K): T;
+    abstract destroy(resource: T): void;
+    add(resourceArgs: K): T;
+    remove(resource: T): void;
+    removeAll(): void;
+}
+declare class IntervalsManager extends ResourceManager<number, Parameters<typeof setInterval>> {
+    create(args: Parameters<typeof setInterval>): number;
+    destroy(interval: number): void;
+}
+declare class TimeoutsManager extends ResourceManager<number, Parameters<typeof setTimeout>> {
+    create(args: Parameters<typeof setTimeout>): number;
+    destroy(timeout: number): void;
+}
+export declare const intervalsManager: IntervalsManager;
+export declare const timeoutsManager: TimeoutsManager;
+export {};

node_modules/next/dist/server/web/sandbox/resource-managers.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    intervalsManager: null,
+    timeoutsManager: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    intervalsManager: function() {
+        return intervalsManager;
+    },
+    timeoutsManager: function() {
+        return timeoutsManager;
+    }
+});
+class ResourceManager {
+    add(resourceArgs) {
+        const resource = this.create(resourceArgs);
+        this.resources.push(resource);
+        return resource;
+    }
+    remove(resource) {
+        this.resources = this.resources.filter((r)=>r !== resource);
+        this.destroy(resource);
+    }
+    removeAll() {
+        this.resources.forEach(this.destroy);
+        this.resources = [];
+    }
+    constructor(){
+        this.resources = [];
+    }
+}
+class IntervalsManager extends ResourceManager {
+    create(args) {
+        // TODO: use the edge runtime provided `setInterval` instead
+        return setInterval(...args)[Symbol.toPrimitive]();
+    }
+    destroy(interval) {
+        clearInterval(interval);
+    }
+}
+class TimeoutsManager extends ResourceManager {
+    create(args) {
+        // TODO: use the edge runtime provided `setTimeout` instead
+        return setTimeout(...args)[Symbol.toPrimitive]();
+    }
+    destroy(timeout) {
+        clearTimeout(timeout);
+    }
+}
+const intervalsManager = new IntervalsManager();
+const timeoutsManager = new TimeoutsManager();
+
+//# sourceMappingURL=resource-managers.js.map

node_modules/next/dist/server/web/sandbox/resource-managers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/sandbox/resource-managers.ts"],"names":["intervalsManager","timeoutsManager","ResourceManager","add","resourceArgs","resource","create","resources","push","remove","filter","r","destroy","removeAll","forEach","IntervalsManager","args","setInterval","Symbol","toPrimitive","interval","clearInterval","TimeoutsManager","setTimeout","timeout","clearTimeout"],"mappings":";;;;;;;;;;;;;;;IAmDaA,gBAAgB;eAAhBA;;IACAC,eAAe;eAAfA;;;AApDb,MAAeC;IAMbC,IAAIC,YAAe,EAAE;QACnB,MAAMC,WAAW,IAAI,CAACC,MAAM,CAACF;QAC7B,IAAI,CAACG,SAAS,CAACC,IAAI,CAACH;QACpB,OAAOA;IACT;IAEAI,OAAOJ,QAAW,EAAE;QAClB,IAAI,CAACE,SAAS,GAAG,IAAI,CAACA,SAAS,CAACG,MAAM,CAAC,CAACC,IAAMA,MAAMN;QACpD,IAAI,CAACO,OAAO,CAACP;IACf;IAEAQ,YAAY;QACV,IAAI,CAACN,SAAS,CAACO,OAAO,CAAC,IAAI,CAACF,OAAO;QACnC,IAAI,CAACL,SAAS,GAAG,EAAE;IACrB;;aAnBQA,YAAiB,EAAE;;AAoB7B;AAEA,MAAMQ,yBAAyBb;IAI7BI,OAAOU,IAAoC,EAAE;QAC3C,4DAA4D;QAC5D,OAAOC,eAAeD,KAAK,CAACE,OAAOC,WAAW,CAAC;IACjD;IAEAP,QAAQQ,QAAgB,EAAE;QACxBC,cAAcD;IAChB;AACF;AAEA,MAAME,wBAAwBpB;IAI5BI,OAAOU,IAAmC,EAAE;QAC1C,2DAA2D;QAC3D,OAAOO,cAAcP,KAAK,CAACE,OAAOC,WAAW,CAAC;IAChD;IAEAP,QAAQY,OAAe,EAAE;QACvBC,aAAaD;IACf;AACF;AAEO,MAAMxB,mBAAmB,IAAIe;AAC7B,MAAMd,kBAAkB,IAAIqB"}

node_modules/next/dist/server/web/sandbox/sandbox.d.ts

@@ -0,0 +1,27 @@
+import type { NodejsRequestData, FetchEventResult } from '../types';
+import type { EdgeFunctionDefinition } from '../../../build/webpack/plugins/middleware-plugin';
+import type { EdgeRuntime } from 'next/dist/compiled/edge-runtime';
+export declare const ErrorSource: unique symbol;
+type RunnerFn = (params: {
+    name: string;
+    onError?: (err: unknown) => void;
+    onWarning?: (warn: Error) => void;
+    paths: string[];
+    request: NodejsRequestData;
+    useCache: boolean;
+    edgeFunctionEntry: Pick<EdgeFunctionDefinition, 'wasm' | 'assets'>;
+    distDir: string;
+    incrementalCache?: any;
+}) => Promise<FetchEventResult>;
+export declare function getRuntimeContext(params: {
+    name: string;
+    onWarning?: any;
+    onError?: (err: unknown) => void;
+    useCache: boolean;
+    edgeFunctionEntry: any;
+    distDir: string;
+    paths: string[];
+    incrementalCache?: any;
+}): Promise<EdgeRuntime<any>>;
+export declare const run: RunnerFn;
+export {};

node_modules/next/dist/server/web/sandbox/sandbox.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ErrorSource: null,
+    getRuntimeContext: null,
+    run: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ErrorSource: function() {
+        return ErrorSource;
+    },
+    getRuntimeContext: function() {
+        return getRuntimeContext;
+    },
+    run: function() {
+        return run;
+    }
+});
+const _context = require("./context");
+const _bodystreams = require("../../body-streams");
+const _approuterheaders = require("../../../client/components/app-router-headers");
+const ErrorSource = Symbol("SandboxError");
+const FORBIDDEN_HEADERS = [
+    "content-length",
+    "content-encoding",
+    "transfer-encoding"
+];
+/**
+ * Decorates the runner function making sure all errors it can produce are
+ * tagged with `edge-server` so they can properly be rendered in dev.
+ */ function withTaggedErrors(fn) {
+    if (process.env.NODE_ENV === "development") {
+        const { getServerError } = require("../../../client/components/react-dev-overlay/server/middleware");
+        return (params)=>fn(params).then((result)=>{
+                var _result_waitUntil;
+                return {
+                    ...result,
+                    waitUntil: result == null ? void 0 : (_result_waitUntil = result.waitUntil) == null ? void 0 : _result_waitUntil.catch((error)=>{
+                        // TODO: used COMPILER_NAMES.edgeServer instead. Verify that it does not increase the runtime size.
+                        throw getServerError(error, "edge-server");
+                    })
+                };
+            }).catch((error)=>{
+                // TODO: used COMPILER_NAMES.edgeServer instead
+                throw getServerError(error, "edge-server");
+            });
+    }
+    return fn;
+}
+async function getRuntimeContext(params) {
+    const { runtime, evaluateInContext } = await (0, _context.getModuleContext)({
+        moduleName: params.name,
+        onWarning: params.onWarning ?? (()=>{}),
+        onError: params.onError ?? (()=>{}),
+        useCache: params.useCache !== false,
+        edgeFunctionEntry: params.edgeFunctionEntry,
+        distDir: params.distDir
+    });
+    if (params.incrementalCache) {
+        runtime.context.globalThis.__incrementalCache = params.incrementalCache;
+    }
+    for (const paramPath of params.paths){
+        evaluateInContext(paramPath);
+    }
+    return runtime;
+}
+const run = withTaggedErrors(async function runWithTaggedErrors(params) {
+    var _params_request_body;
+    const runtime = await getRuntimeContext(params);
+    const subreq = params.request.headers[`x-middleware-subrequest`];
+    const subrequests = typeof subreq === "string" ? subreq.split(":") : [];
+    const MAX_RECURSION_DEPTH = 5;
+    const depth = subrequests.reduce((acc, curr)=>curr === params.name ? acc + 1 : acc, 0);
+    if (depth >= MAX_RECURSION_DEPTH) {
+        return {
+            waitUntil: Promise.resolve(),
+            response: new runtime.context.Response(null, {
+                headers: {
+                    "x-middleware-next": "1"
+                }
+            })
+        };
+    }
+    const edgeFunction = (await runtime.context._ENTRIES[`middleware_${params.name}`]).default;
+    const cloned = ![
+        "HEAD",
+        "GET"
+    ].includes(params.request.method) ? (_params_request_body = params.request.body) == null ? void 0 : _params_request_body.cloneBodyStream() : undefined;
+    const KUint8Array = runtime.evaluate("Uint8Array");
+    const urlInstance = new URL(params.request.url);
+    urlInstance.searchParams.delete(_approuterheaders.NEXT_RSC_UNION_QUERY);
+    params.request.url = urlInstance.toString();
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(params.request.headers)){
+        headers.set(key, (value == null ? void 0 : value.toString()) ?? "");
+    }
+    try {
+        let result = undefined;
+        await _context.requestStore.run({
+            headers
+        }, async ()=>{
+            result = await edgeFunction({
+                request: {
+                    ...params.request,
+                    body: cloned && (0, _bodystreams.requestToBodyStream)(runtime.context, KUint8Array, cloned)
+                }
+            });
+            for (const headerName of FORBIDDEN_HEADERS){
+                result.response.headers.delete(headerName);
+            }
+        });
+        if (!result) throw new Error("Edge function did not return a response");
+        return result;
+    } finally{
+        var _params_request_body1;
+        await ((_params_request_body1 = params.request.body) == null ? void 0 : _params_request_body1.finalize());
+    }
+});
+
+//# sourceMappingURL=sandbox.js.map

node_modules/next/dist/server/web/sandbox/sandbox.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/sandbox/sandbox.ts"],"names":["ErrorSource","getRuntimeContext","run","Symbol","FORBIDDEN_HEADERS","withTaggedErrors","fn","process","env","NODE_ENV","getServerError","require","params","then","result","waitUntil","catch","error","runtime","evaluateInContext","getModuleContext","moduleName","name","onWarning","onError","useCache","edgeFunctionEntry","distDir","incrementalCache","context","globalThis","__incrementalCache","paramPath","paths","runWithTaggedErrors","subreq","request","headers","subrequests","split","MAX_RECURSION_DEPTH","depth","reduce","acc","curr","Promise","resolve","response","Response","edgeFunction","_ENTRIES","default","cloned","includes","method","body","cloneBodyStream","undefined","KUint8Array","evaluate","urlInstance","URL","url","searchParams","delete","NEXT_RSC_UNION_QUERY","toString","Headers","key","value","Object","entries","set","requestStore","requestToBodyStream","headerName","Error","finalize"],"mappings":"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"}

node_modules/next/dist/server/web/spec-extension/adapters/headers.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+import type { IncomingHttpHeaders } from 'http';
+export type ReadonlyHeaders = Headers & {
+    /** @deprecated Method unavailable on `ReadonlyHeaders`. Read more: https://nextjs.org/docs/app/api-reference/functions/headers */
+    append(...args: any[]): void;
+    /** @deprecated Method unavailable on `ReadonlyHeaders`. Read more: https://nextjs.org/docs/app/api-reference/functions/headers */
+    set(...args: any[]): void;
+    /** @deprecated Method unavailable on `ReadonlyHeaders`. Read more: https://nextjs.org/docs/app/api-reference/functions/headers */
+    delete(...args: any[]): void;
+};
+export declare class HeadersAdapter extends Headers {
+    private readonly headers;
+    constructor(headers: IncomingHttpHeaders);
+    /**
+     * Seals a Headers instance to prevent modification by throwing an error when
+     * any mutating method is called.
+     */
+    static seal(headers: Headers): ReadonlyHeaders;
+    /**
+     * Merges a header value into a string. This stores multiple values as an
+     * array, so we need to merge them into a string.
+     *
+     * @param value a header value
+     * @returns a merged header value (a string)
+     */
+    private merge;
+    /**
+     * Creates a Headers instance from a plain object or a Headers instance.
+     *
+     * @param headers a plain object or a Headers instance
+     * @returns a headers instance
+     */
+    static from(headers: IncomingHttpHeaders | Headers): Headers;
+    append(name: string, value: string): void;
+    delete(name: string): void;
+    get(name: string): string | null;
+    has(name: string): boolean;
+    set(name: string, value: string): void;
+    forEach(callbackfn: (value: string, name: string, parent: Headers) => void, thisArg?: any): void;
+    entries(): IterableIterator<[string, string]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+    [Symbol.iterator](): IterableIterator<[string, string]>;
+}

node_modules/next/dist/server/web/spec-extension/adapters/headers.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    HeadersAdapter: null,
+    ReadonlyHeadersError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    HeadersAdapter: function() {
+        return HeadersAdapter;
+    },
+    ReadonlyHeadersError: function() {
+        return ReadonlyHeadersError;
+    }
+});
+const _reflect = require("./reflect");
+class ReadonlyHeadersError extends Error {
+    constructor(){
+        super("Headers cannot be modified. Read more: https://nextjs.org/docs/app/api-reference/functions/headers");
+    }
+    static callable() {
+        throw new ReadonlyHeadersError();
+    }
+}
+class HeadersAdapter extends Headers {
+    constructor(headers){
+        // We've already overridden the methods that would be called, so we're just
+        // calling the super constructor to ensure that the instanceof check works.
+        super();
+        this.headers = new Proxy(headers, {
+            get (target, prop, receiver) {
+                // Because this is just an object, we expect that all "get" operations
+                // are for properties. If it's a "get" for a symbol, we'll just return
+                // the symbol.
+                if (typeof prop === "symbol") {
+                    return _reflect.ReflectAdapter.get(target, prop, receiver);
+                }
+                const lowercased = prop.toLowerCase();
+                // Let's find the original casing of the key. This assumes that there is
+                // no mixed case keys (e.g. "Content-Type" and "content-type") in the
+                // headers object.
+                const original = Object.keys(headers).find((o)=>o.toLowerCase() === lowercased);
+                // If the original casing doesn't exist, return undefined.
+                if (typeof original === "undefined") return;
+                // If the original casing exists, return the value.
+                return _reflect.ReflectAdapter.get(target, original, receiver);
+            },
+            set (target, prop, value, receiver) {
+                if (typeof prop === "symbol") {
+                    return _reflect.ReflectAdapter.set(target, prop, value, receiver);
+                }
+                const lowercased = prop.toLowerCase();
+                // Let's find the original casing of the key. This assumes that there is
+                // no mixed case keys (e.g. "Content-Type" and "content-type") in the
+                // headers object.
+                const original = Object.keys(headers).find((o)=>o.toLowerCase() === lowercased);
+                // If the original casing doesn't exist, use the prop as the key.
+                return _reflect.ReflectAdapter.set(target, original ?? prop, value, receiver);
+            },
+            has (target, prop) {
+                if (typeof prop === "symbol") return _reflect.ReflectAdapter.has(target, prop);
+                const lowercased = prop.toLowerCase();
+                // Let's find the original casing of the key. This assumes that there is
+                // no mixed case keys (e.g. "Content-Type" and "content-type") in the
+                // headers object.
+                const original = Object.keys(headers).find((o)=>o.toLowerCase() === lowercased);
+                // If the original casing doesn't exist, return false.
+                if (typeof original === "undefined") return false;
+                // If the original casing exists, return true.
+                return _reflect.ReflectAdapter.has(target, original);
+            },
+            deleteProperty (target, prop) {
+                if (typeof prop === "symbol") return _reflect.ReflectAdapter.deleteProperty(target, prop);
+                const lowercased = prop.toLowerCase();
+                // Let's find the original casing of the key. This assumes that there is
+                // no mixed case keys (e.g. "Content-Type" and "content-type") in the
+                // headers object.
+                const original = Object.keys(headers).find((o)=>o.toLowerCase() === lowercased);
+                // If the original casing doesn't exist, return true.
+                if (typeof original === "undefined") return true;
+                // If the original casing exists, delete the property.
+                return _reflect.ReflectAdapter.deleteProperty(target, original);
+            }
+        });
+    }
+    /**
+   * Seals a Headers instance to prevent modification by throwing an error when
+   * any mutating method is called.
+   */ static seal(headers) {
+        return new Proxy(headers, {
+            get (target, prop, receiver) {
+                switch(prop){
+                    case "append":
+                    case "delete":
+                    case "set":
+                        return ReadonlyHeadersError.callable;
+                    default:
+                        return _reflect.ReflectAdapter.get(target, prop, receiver);
+                }
+            }
+        });
+    }
+    /**
+   * Merges a header value into a string. This stores multiple values as an
+   * array, so we need to merge them into a string.
+   *
+   * @param value a header value
+   * @returns a merged header value (a string)
+   */ merge(value) {
+        if (Array.isArray(value)) return value.join(", ");
+        return value;
+    }
+    /**
+   * Creates a Headers instance from a plain object or a Headers instance.
+   *
+   * @param headers a plain object or a Headers instance
+   * @returns a headers instance
+   */ static from(headers) {
+        if (headers instanceof Headers) return headers;
+        return new HeadersAdapter(headers);
+    }
+    append(name, value) {
+        const existing = this.headers[name];
+        if (typeof existing === "string") {
+            this.headers[name] = [
+                existing,
+                value
+            ];
+        } else if (Array.isArray(existing)) {
+            existing.push(value);
+        } else {
+            this.headers[name] = value;
+        }
+    }
+    delete(name) {
+        delete this.headers[name];
+    }
+    get(name) {
+        const value = this.headers[name];
+        if (typeof value !== "undefined") return this.merge(value);
+        return null;
+    }
+    has(name) {
+        return typeof this.headers[name] !== "undefined";
+    }
+    set(name, value) {
+        this.headers[name] = value;
+    }
+    forEach(callbackfn, thisArg) {
+        for (const [name, value] of this.entries()){
+            callbackfn.call(thisArg, value, name, this);
+        }
+    }
+    *entries() {
+        for (const key of Object.keys(this.headers)){
+            const name = key.toLowerCase();
+            // We assert here that this is a string because we got it from the
+            // Object.keys() call above.
+            const value = this.get(name);
+            yield [
+                name,
+                value
+            ];
+        }
+    }
+    *keys() {
+        for (const key of Object.keys(this.headers)){
+            const name = key.toLowerCase();
+            yield name;
+        }
+    }
+    *values() {
+        for (const key of Object.keys(this.headers)){
+            // We assert here that this is a string because we got it from the
+            // Object.keys() call above.
+            const value = this.get(key);
+            yield value;
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+}
+
+//# sourceMappingURL=headers.js.map

node_modules/next/dist/server/web/spec-extension/adapters/headers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/web/spec-extension/adapters/headers.ts"],"names":["HeadersAdapter","ReadonlyHeadersError","Error","constructor","callable","Headers","headers","Proxy","get","target","prop","receiver","ReflectAdapter","lowercased","toLowerCase","original","Object","keys","find","o","set","value","has","deleteProperty","seal","merge","Array","isArray","join","from","append","name","existing","push","delete","forEach","callbackfn","thisArg","entries","call","key","values","Symbol","iterator"],"mappings":"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"}

node_modules/next/dist/server/web/spec-extension/adapters/headers.test.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/next/dist/server/web/spec-extension/adapters/next-request.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import type { BaseNextRequest } from '../../../base-http';
+import type { NodeNextRequest } from '../../../base-http/node';
+import type { WebNextRequest } from '../../../base-http/web';
+import type { Writable } from 'node:stream';
+import { NextRequest } from '../request';
+export declare const ResponseAbortedName = "ResponseAborted";
+export declare class ResponseAborted extends Error {
+    readonly name = "ResponseAborted";
+}
+/**
+ * Creates an AbortController tied to the closing of a ServerResponse (or other
+ * appropriate Writable).
+ *
+ * If the `close` event is fired before the `finish` event, then we'll send the
+ * `abort` signal.
+ */
+export declare function createAbortController(response: Writable): AbortController;
+/**
+ * Creates an AbortSignal tied to the closing of a ServerResponse (or other
+ * appropriate Writable).
+ *
+ * This cannot be done with the request (IncomingMessage or Readable) because
+ * the `abort` event will not fire if to data has been fully read (because that
+ * will "close" the readable stream and nothing fires after that).
+ */
+export declare function signalFromNodeResponse(response: Writable): AbortSignal;
+export declare class NextRequestAdapter {
+    static fromBaseNextRequest(request: BaseNextRequest, signal: AbortSignal): NextRequest;
+    static fromNodeNextRequest(request: NodeNextRequest, signal: AbortSignal): NextRequest;
+    static fromWebNextRequest(request: WebNextRequest): NextRequest;
+}

node_modules/next/dist/server/web/spec-extension/adapters/next-request.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    NextRequestAdapter: null,
+    ResponseAborted: null,
+    ResponseAbortedName: null,
+    createAbortController: null,
+    signalFromNodeResponse: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NextRequestAdapter: function() {
+        return NextRequestAdapter;
+    },
+    ResponseAborted: function() {
+        return ResponseAborted;
+    },
+    ResponseAbortedName: function() {
+        return ResponseAbortedName;
+    },
+    createAbortController: function() {
+        return createAbortController;
+    },
+    signalFromNodeResponse: function() {
+        return signalFromNodeResponse;
+    }
+});
+const _requestmeta = require("../../../request-meta");
+const _utils = require("../../utils");
+const _request = require("../request");
+const ResponseAbortedName = "ResponseAborted";
+class ResponseAborted extends Error {
+    constructor(...args){
+        super(...args);
+        this.name = ResponseAbortedName;
+    }
+}
+function createAbortController(response) {
+    const controller = new AbortController();
+    // If `finish` fires first, then `res.end()` has been called and the close is
+    // just us finishing the stream on our side. If `close` fires first, then we
+    // know the client disconnected before we finished.
+    response.once("close", ()=>{
+        if (response.writableFinished) return;
+        controller.abort(new ResponseAborted());
+    });
+    return controller;
+}
+function signalFromNodeResponse(response) {
+    const { errored, destroyed } = response;
+    if (errored || destroyed) {
+        return AbortSignal.abort(errored ?? new ResponseAborted());
+    }
+    const { signal } = createAbortController(response);
+    return signal;
+}
+class NextRequestAdapter {
+    static fromBaseNextRequest(request, signal) {
+        // TODO: look at refining this check
+        if ("request" in request && request.request) {
+            return NextRequestAdapter.fromWebNextRequest(request);
+        }
+        return NextRequestAdapter.fromNodeNextRequest(request, signal);
+    }
+    static fromNodeNextRequest(request, signal) {
+        // HEAD and GET requests can not have a body.
+        let body = null;
+        if (request.method !== "GET" && request.method !== "HEAD" && request.body) {
+            // @ts-expect-error - this is handled by undici, when streams/web land use it instead
+            body = request.body;
+        }
+        let url;
+        if (request.url.startsWith("http")) {
+            url = new URL(request.url);
+        } else {
+            // Grab the full URL from the request metadata.
+            const base = (0, _requestmeta.getRequestMeta)(request, "initURL");
+            if (!base || !base.startsWith("http")) {
+                // Because the URL construction relies on the fact that the URL provided
+                // is absolute, we need to provide a base URL. We can't use the request
+                // URL because it's relative, so we use a dummy URL instead.
+                url = new URL(request.url, "http://n");
+            } else {
+                url = new URL(request.url, base);
+            }
+        }
+        return new _request.NextRequest(url, {
+            method: request.method,
+            headers: (0, _utils.fromNodeOutgoingHttpHeaders)(request.headers),
+            // @ts-expect-error - see https://github.com/whatwg/fetch/pull/1457
+            duplex: "half",
+            signal,
+            // geo
+            // ip
+            // nextConfig
+            // body can not be passed if request was aborted
+            // or we get a Request body was disturbed error
+            ...signal.aborted ? {} : {
+                body
+            }
+        });
+    }
+    static fromWebNextRequest(request) {
+        // HEAD and GET requests can not have a body.
+        let body = null;
+        if (request.method !== "GET" && request.method !== "HEAD") {
+            body = request.body;
+        }
+        return new _request.NextRequest(request.url, {
+            method: request.method,
+            headers: (0, _utils.fromNodeOutgoingHttpHeaders)(request.headers),
+            // @ts-expect-error - see https://github.com/whatwg/fetch/pull/1457
+            duplex: "half",
+            signal: request.request.signal,
+            // geo
+            // ip
+            // nextConfig
+            // body can not be passed if request was aborted
+            // or we get a Request body was disturbed error
+            ...request.request.signal.aborted ? {} : {
+                body
+            }
+        });
+    }
+}
+
+//# sourceMappingURL=next-request.js.map

node_modules/next/dist/server/web/spec-extension/adapters/next-request.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/web/spec-extension/adapters/next-request.ts"],"names":["NextRequestAdapter","ResponseAborted","ResponseAbortedName","createAbortController","signalFromNodeResponse","Error","name","response","controller","AbortController","once","writableFinished","abort","errored","destroyed","AbortSignal","signal","fromBaseNextRequest","request","fromWebNextRequest","fromNodeNextRequest","body","method","url","startsWith","URL","base","getRequestMeta","NextRequest","headers","fromNodeOutgoingHttpHeaders","duplex","aborted"],"mappings":"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"}

node_modules/next/dist/server/web/spec-extension/adapters/reflect.d.ts

@@ -0,0 +1,6 @@
+export declare class ReflectAdapter {
+    static get<T extends object>(target: T, prop: string | symbol, receiver: unknown): any;
+    static set<T extends object>(target: T, prop: string | symbol, value: any, receiver: any): boolean;
+    static has<T extends object>(target: T, prop: string | symbol): boolean;
+    static deleteProperty<T extends object>(target: T, prop: string | symbol): boolean;
+}

node_modules/next/dist/server/web/spec-extension/adapters/reflect.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ReflectAdapter", {
+    enumerable: true,
+    get: function() {
+        return ReflectAdapter;
+    }
+});
+class ReflectAdapter {
+    static get(target, prop, receiver) {
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "function") {
+            return value.bind(target);
+        }
+        return value;
+    }
+    static set(target, prop, value, receiver) {
+        return Reflect.set(target, prop, value, receiver);
+    }
+    static has(target, prop) {
+        return Reflect.has(target, prop);
+    }
+    static deleteProperty(target, prop) {
+        return Reflect.deleteProperty(target, prop);
+    }
+}
+
+//# sourceMappingURL=reflect.js.map

node_modules/next/dist/server/web/spec-extension/adapters/reflect.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/web/spec-extension/adapters/reflect.ts"],"names":["ReflectAdapter","get","target","prop","receiver","value","Reflect","bind","set","has","deleteProperty"],"mappings":";;;;+BAAaA;;;eAAAA;;;AAAN,MAAMA;IACX,OAAOC,IACLC,MAAS,EACTC,IAAqB,EACrBC,QAAiB,EACZ;QACL,MAAMC,QAAQC,QAAQL,GAAG,CAACC,QAAQC,MAAMC;QACxC,IAAI,OAAOC,UAAU,YAAY;YAC/B,OAAOA,MAAME,IAAI,CAACL;QACpB;QAEA,OAAOG;IACT;IAEA,OAAOG,IACLN,MAAS,EACTC,IAAqB,EACrBE,KAAU,EACVD,QAAa,EACJ;QACT,OAAOE,QAAQE,GAAG,CAACN,QAAQC,MAAME,OAAOD;IAC1C;IAEA,OAAOK,IAAsBP,MAAS,EAAEC,IAAqB,EAAW;QACtE,OAAOG,QAAQG,GAAG,CAACP,QAAQC;IAC7B;IAEA,OAAOO,eACLR,MAAS,EACTC,IAAqB,EACZ;QACT,OAAOG,QAAQI,cAAc,CAACR,QAAQC;IACxC;AACF"}

node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.d.ts

@@ -0,0 +1,13 @@
+import type { RequestCookies } from '../cookies';
+import { ResponseCookies } from '../cookies';
+export type ReadonlyRequestCookies = Omit<RequestCookies, 'set' | 'clear' | 'delete'> & Pick<ResponseCookies, 'set' | 'delete'>;
+export declare class RequestCookiesAdapter {
+    static seal(cookies: RequestCookies): ReadonlyRequestCookies;
+}
+export declare function getModifiedCookieValues(cookies: ResponseCookies): ResponseCookie[];
+export declare function appendMutableCookies(headers: Headers, mutableCookies: ResponseCookies): boolean;
+type ResponseCookie = NonNullable<ReturnType<InstanceType<typeof ResponseCookies>['get']>>;
+export declare class MutableRequestCookiesAdapter {
+    static wrap(cookies: RequestCookies, onUpdateCookies?: (cookies: string[]) => void): ResponseCookies;
+}
+export {};

node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    MutableRequestCookiesAdapter: null,
+    ReadonlyRequestCookiesError: null,
+    RequestCookiesAdapter: null,
+    appendMutableCookies: null,
+    getModifiedCookieValues: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    MutableRequestCookiesAdapter: function() {
+        return MutableRequestCookiesAdapter;
+    },
+    ReadonlyRequestCookiesError: function() {
+        return ReadonlyRequestCookiesError;
+    },
+    RequestCookiesAdapter: function() {
+        return RequestCookiesAdapter;
+    },
+    appendMutableCookies: function() {
+        return appendMutableCookies;
+    },
+    getModifiedCookieValues: function() {
+        return getModifiedCookieValues;
+    }
+});
+const _cookies = require("../cookies");
+const _reflect = require("./reflect");
+const _staticgenerationasyncstorageexternal = require("../../../../client/components/static-generation-async-storage.external");
+class ReadonlyRequestCookiesError extends Error {
+    constructor(){
+        super("Cookies can only be modified in a Server Action or Route Handler. Read more: https://nextjs.org/docs/app/api-reference/functions/cookies#cookiessetname-value-options");
+    }
+    static callable() {
+        throw new ReadonlyRequestCookiesError();
+    }
+}
+class RequestCookiesAdapter {
+    static seal(cookies) {
+        return new Proxy(cookies, {
+            get (target, prop, receiver) {
+                switch(prop){
+                    case "clear":
+                    case "delete":
+                    case "set":
+                        return ReadonlyRequestCookiesError.callable;
+                    default:
+                        return _reflect.ReflectAdapter.get(target, prop, receiver);
+                }
+            }
+        });
+    }
+}
+const SYMBOL_MODIFY_COOKIE_VALUES = Symbol.for("next.mutated.cookies");
+function getModifiedCookieValues(cookies) {
+    const modified = cookies[SYMBOL_MODIFY_COOKIE_VALUES];
+    if (!modified || !Array.isArray(modified) || modified.length === 0) {
+        return [];
+    }
+    return modified;
+}
+function appendMutableCookies(headers, mutableCookies) {
+    const modifiedCookieValues = getModifiedCookieValues(mutableCookies);
+    if (modifiedCookieValues.length === 0) {
+        return false;
+    }
+    // Return a new response that extends the response with
+    // the modified cookies as fallbacks. `res` cookies
+    // will still take precedence.
+    const resCookies = new _cookies.ResponseCookies(headers);
+    const returnedCookies = resCookies.getAll();
+    // Set the modified cookies as fallbacks.
+    for (const cookie of modifiedCookieValues){
+        resCookies.set(cookie);
+    }
+    // Set the original cookies as the final values.
+    for (const cookie of returnedCookies){
+        resCookies.set(cookie);
+    }
+    return true;
+}
+class MutableRequestCookiesAdapter {
+    static wrap(cookies, onUpdateCookies) {
+        const responseCookies = new _cookies.ResponseCookies(new Headers());
+        for (const cookie of cookies.getAll()){
+            responseCookies.set(cookie);
+        }
+        let modifiedValues = [];
+        const modifiedCookies = new Set();
+        const updateResponseCookies = ()=>{
+            // TODO-APP: change method of getting staticGenerationAsyncStore
+            const staticGenerationAsyncStore = _staticgenerationasyncstorageexternal.staticGenerationAsyncStorage.getStore();
+            if (staticGenerationAsyncStore) {
+                staticGenerationAsyncStore.pathWasRevalidated = true;
+            }
+            const allCookies = responseCookies.getAll();
+            modifiedValues = allCookies.filter((c)=>modifiedCookies.has(c.name));
+            if (onUpdateCookies) {
+                const serializedCookies = [];
+                for (const cookie of modifiedValues){
+                    const tempCookies = new _cookies.ResponseCookies(new Headers());
+                    tempCookies.set(cookie);
+                    serializedCookies.push(tempCookies.toString());
+                }
+                onUpdateCookies(serializedCookies);
+            }
+        };
+        return new Proxy(responseCookies, {
+            get (target, prop, receiver) {
+                switch(prop){
+                    // A special symbol to get the modified cookie values
+                    case SYMBOL_MODIFY_COOKIE_VALUES:
+                        return modifiedValues;
+                    // TODO: Throw error if trying to set a cookie after the response
+                    // headers have been set.
+                    case "delete":
+                        return function(...args) {
+                            modifiedCookies.add(typeof args[0] === "string" ? args[0] : args[0].name);
+                            try {
+                                target.delete(...args);
+                            } finally{
+                                updateResponseCookies();
+                            }
+                        };
+                    case "set":
+                        return function(...args) {
+                            modifiedCookies.add(typeof args[0] === "string" ? args[0] : args[0].name);
+                            try {
+                                return target.set(...args);
+                            } finally{
+                                updateResponseCookies();
+                            }
+                        };
+                    default:
+                        return _reflect.ReflectAdapter.get(target, prop, receiver);
+                }
+            }
+        });
+    }
+}
+
+//# sourceMappingURL=request-cookies.js.map

node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/web/spec-extension/adapters/request-cookies.ts"],"names":["MutableRequestCookiesAdapter","ReadonlyRequestCookiesError","RequestCookiesAdapter","appendMutableCookies","getModifiedCookieValues","Error","constructor","callable","seal","cookies","Proxy","get","target","prop","receiver","ReflectAdapter","SYMBOL_MODIFY_COOKIE_VALUES","Symbol","for","modified","Array","isArray","length","headers","mutableCookies","modifiedCookieValues","resCookies","ResponseCookies","returnedCookies","getAll","cookie","set","wrap","onUpdateCookies","responseCookies","Headers","modifiedValues","modifiedCookies","Set","updateResponseCookies","staticGenerationAsyncStore","staticGenerationAsyncStorage","getStore","pathWasRevalidated","allCookies","filter","c","has","name","serializedCookies","tempCookies","push","toString","args","add","delete"],"mappings":"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"}

node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.test.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/next/dist/server/web/spec-extension/cookies.d.ts

@@ -0,0 +1 @@
+export { RequestCookies, ResponseCookies, stringifyCookie, } from 'next/dist/compiled/@edge-runtime/cookies';

node_modules/next/dist/server/web/spec-extension/cookies.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    RequestCookies: null,
+    ResponseCookies: null,
+    stringifyCookie: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    RequestCookies: function() {
+        return _cookies.RequestCookies;
+    },
+    ResponseCookies: function() {
+        return _cookies.ResponseCookies;
+    },
+    stringifyCookie: function() {
+        return _cookies.stringifyCookie;
+    }
+});
+const _cookies = require("next/dist/compiled/@edge-runtime/cookies");
+
+//# sourceMappingURL=cookies.js.map

node_modules/next/dist/server/web/spec-extension/cookies.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/spec-extension/cookies.ts"],"names":["RequestCookies","ResponseCookies","stringifyCookie"],"mappings":";;;;;;;;;;;;;;;;IACEA,cAAc;eAAdA,uBAAc;;IACdC,eAAe;eAAfA,wBAAe;;IACfC,eAAe;eAAfA,wBAAe;;;yBACV"}

node_modules/next/dist/server/web/spec-extension/fetch-event.d.ts

@@ -0,0 +1,33 @@
+import type { NextRequest } from './request';
+declare const responseSymbol: unique symbol;
+declare const passThroughSymbol: unique symbol;
+export declare const waitUntilSymbol: unique symbol;
+declare class FetchEvent {
+    readonly [waitUntilSymbol]: Promise<any>[];
+    [responseSymbol]?: Promise<Response>;
+    [passThroughSymbol]: boolean;
+    constructor(_request: Request);
+    respondWith(response: Response | Promise<Response>): void;
+    passThroughOnException(): void;
+    waitUntil(promise: Promise<any>): void;
+}
+export declare class NextFetchEvent extends FetchEvent {
+    sourcePage: string;
+    constructor(params: {
+        request: NextRequest;
+        page: string;
+    });
+    /**
+     * @deprecated The `request` is now the first parameter and the API is now async.
+     *
+     * Read more: https://nextjs.org/docs/messages/middleware-new-signature
+     */
+    get request(): void;
+    /**
+     * @deprecated Using `respondWith` is no longer needed.
+     *
+     * Read more: https://nextjs.org/docs/messages/middleware-new-signature
+     */
+    respondWith(): void;
+}
+export {};

node_modules/next/dist/server/web/spec-extension/fetch-event.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    NextFetchEvent: null,
+    waitUntilSymbol: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NextFetchEvent: function() {
+        return NextFetchEvent;
+    },
+    waitUntilSymbol: function() {
+        return waitUntilSymbol;
+    }
+});
+const _error = require("../error");
+const responseSymbol = Symbol("response");
+const passThroughSymbol = Symbol("passThrough");
+const waitUntilSymbol = Symbol("waitUntil");
+class FetchEvent {
+    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+    constructor(_request){
+        this[waitUntilSymbol] = [];
+        this[passThroughSymbol] = false;
+    }
+    respondWith(response) {
+        if (!this[responseSymbol]) {
+            this[responseSymbol] = Promise.resolve(response);
+        }
+    }
+    passThroughOnException() {
+        this[passThroughSymbol] = true;
+    }
+    waitUntil(promise) {
+        this[waitUntilSymbol].push(promise);
+    }
+}
+class NextFetchEvent extends FetchEvent {
+    constructor(params){
+        super(params.request);
+        this.sourcePage = params.page;
+    }
+    /**
+   * @deprecated The `request` is now the first parameter and the API is now async.
+   *
+   * Read more: https://nextjs.org/docs/messages/middleware-new-signature
+   */ get request() {
+        throw new _error.PageSignatureError({
+            page: this.sourcePage
+        });
+    }
+    /**
+   * @deprecated Using `respondWith` is no longer needed.
+   *
+   * Read more: https://nextjs.org/docs/messages/middleware-new-signature
+   */ respondWith() {
+        throw new _error.PageSignatureError({
+            page: this.sourcePage
+        });
+    }
+}
+
+//# sourceMappingURL=fetch-event.js.map

node_modules/next/dist/server/web/spec-extension/fetch-event.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/spec-extension/fetch-event.ts"],"names":["NextFetchEvent","waitUntilSymbol","responseSymbol","Symbol","passThroughSymbol","FetchEvent","constructor","_request","respondWith","response","Promise","resolve","passThroughOnException","waitUntil","promise","push","params","request","sourcePage","page","PageSignatureError"],"mappings":";;;;;;;;;;;;;;;IA8BaA,cAAc;eAAdA;;IAzBAC,eAAe;eAAfA;;;uBALsB;AAGnC,MAAMC,iBAAiBC,OAAO;AAC9B,MAAMC,oBAAoBD,OAAO;AAC1B,MAAMF,kBAAkBE,OAAO;AAEtC,MAAME;IAKJ,qEAAqE;IACrEC,YAAYC,QAAiB,CAAE;YALtB,CAACN,gBAAgB,GAAmB,EAAE;YAE/C,CAACG,kBAAkB,GAAG;IAGU;IAEhCI,YAAYC,QAAsC,EAAQ;QACxD,IAAI,CAAC,IAAI,CAACP,eAAe,EAAE;YACzB,IAAI,CAACA,eAAe,GAAGQ,QAAQC,OAAO,CAACF;QACzC;IACF;IAEAG,yBAA+B;QAC7B,IAAI,CAACR,kBAAkB,GAAG;IAC5B;IAEAS,UAAUC,OAAqB,EAAQ;QACrC,IAAI,CAACb,gBAAgB,CAACc,IAAI,CAACD;IAC7B;AACF;AAEO,MAAMd,uBAAuBK;IAGlCC,YAAYU,MAA8C,CAAE;QAC1D,KAAK,CAACA,OAAOC,OAAO;QACpB,IAAI,CAACC,UAAU,GAAGF,OAAOG,IAAI;IAC/B;IAEA;;;;GAIC,GACD,IAAIF,UAAU;QACZ,MAAM,IAAIG,yBAAkB,CAAC;YAC3BD,MAAM,IAAI,CAACD,UAAU;QACvB;IACF;IAEA;;;;GAIC,GACDV,cAAc;QACZ,MAAM,IAAIY,yBAAkB,CAAC;YAC3BD,MAAM,IAAI,CAACD,UAAU;QACvB;IACF;AACF"}

node_modules/next/dist/server/web/spec-extension/image-response.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @deprecated ImageResponse moved from "next/server" to "next/og" since Next.js 14, please import from "next/og" instead.
+ * Migration with codemods: https://nextjs.org/docs/app/building-your-application/upgrading/codemods#next-og-import
+ */
+export declare function ImageResponse(): never;

node_modules/next/dist/server/web/spec-extension/image-response.js

@@ -0,0 +1,18 @@
+/**
+ * @deprecated ImageResponse moved from "next/server" to "next/og" since Next.js 14, please import from "next/og" instead.
+ * Migration with codemods: https://nextjs.org/docs/app/building-your-application/upgrading/codemods#next-og-import
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ImageResponse", {
+    enumerable: true,
+    get: function() {
+        return ImageResponse;
+    }
+});
+function ImageResponse() {
+    throw new Error('ImageResponse moved from "next/server" to "next/og" since Next.js 14, please import from "next/og" instead');
+}
+
+//# sourceMappingURL=image-response.js.map

node_modules/next/dist/server/web/spec-extension/image-response.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/spec-extension/image-response.ts"],"names":["ImageResponse","Error"],"mappings":"AAAA;;;CAGC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA;IACd,MAAM,IAAIC,MACR;AAEJ"}

node_modules/next/dist/server/web/spec-extension/request.d.ts

@@ -0,0 +1,57 @@
+import type { I18NConfig } from '../../config-shared';
+import type { RequestData } from '../types';
+import { NextURL } from '../next-url';
+import { RequestCookies } from './cookies';
+export declare const INTERNALS: unique symbol;
+/**
+ * This class extends the [Web `Request` API](https://developer.mozilla.org/docs/Web/API/Request) with additional convenience methods.
+ *
+ * Read more: [Next.js Docs: `NextRequest`](https://nextjs.org/docs/app/api-reference/functions/next-request)
+ */
+export declare class NextRequest extends Request {
+    [INTERNALS]: {
+        cookies: RequestCookies;
+        geo: RequestData['geo'];
+        ip?: string;
+        url: string;
+        nextUrl: NextURL;
+    };
+    constructor(input: URL | RequestInfo, init?: RequestInit);
+    get cookies(): RequestCookies;
+    get geo(): {
+        city?: string | undefined;
+        country?: string | undefined;
+        region?: string | undefined;
+        latitude?: string | undefined;
+        longitude?: string | undefined;
+    } | undefined;
+    get ip(): string | undefined;
+    get nextUrl(): NextURL;
+    /**
+     * @deprecated
+     * `page` has been deprecated in favour of `URLPattern`.
+     * Read more: https://nextjs.org/docs/messages/middleware-request-page
+     */
+    get page(): void;
+    /**
+     * @deprecated
+     * `ua` has been removed in favour of \`userAgent\` function.
+     * Read more: https://nextjs.org/docs/messages/middleware-parse-user-agent
+     */
+    get ua(): void;
+    get url(): string;
+}
+export interface RequestInit extends globalThis.RequestInit {
+    geo?: {
+        city?: string;
+        country?: string;
+        region?: string;
+    };
+    ip?: string;
+    nextConfig?: {
+        basePath?: string;
+        i18n?: I18NConfig | null;
+        trailingSlash?: boolean;
+    };
+    signal?: AbortSignal;
+}

node_modules/next/dist/server/web/spec-extension/request.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    INTERNALS: null,
+    NextRequest: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    INTERNALS: function() {
+        return INTERNALS;
+    },
+    NextRequest: function() {
+        return NextRequest;
+    }
+});
+const _nexturl = require("../next-url");
+const _utils = require("../utils");
+const _error = require("../error");
+const _cookies = require("./cookies");
+const INTERNALS = Symbol("internal request");
+class NextRequest extends Request {
+    constructor(input, init = {}){
+        const url = typeof input !== "string" && "url" in input ? input.url : String(input);
+        (0, _utils.validateURL)(url);
+        if (input instanceof Request) super(input, init);
+        else super(url, init);
+        const nextUrl = new _nexturl.NextURL(url, {
+            headers: (0, _utils.toNodeOutgoingHttpHeaders)(this.headers),
+            nextConfig: init.nextConfig
+        });
+        this[INTERNALS] = {
+            cookies: new _cookies.RequestCookies(this.headers),
+            geo: init.geo || {},
+            ip: init.ip,
+            nextUrl,
+            url: process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE ? url : nextUrl.toString()
+        };
+    }
+    [Symbol.for("edge-runtime.inspect.custom")]() {
+        return {
+            cookies: this.cookies,
+            geo: this.geo,
+            ip: this.ip,
+            nextUrl: this.nextUrl,
+            url: this.url,
+            // rest of props come from Request
+            bodyUsed: this.bodyUsed,
+            cache: this.cache,
+            credentials: this.credentials,
+            destination: this.destination,
+            headers: Object.fromEntries(this.headers),
+            integrity: this.integrity,
+            keepalive: this.keepalive,
+            method: this.method,
+            mode: this.mode,
+            redirect: this.redirect,
+            referrer: this.referrer,
+            referrerPolicy: this.referrerPolicy,
+            signal: this.signal
+        };
+    }
+    get cookies() {
+        return this[INTERNALS].cookies;
+    }
+    get geo() {
+        return this[INTERNALS].geo;
+    }
+    get ip() {
+        return this[INTERNALS].ip;
+    }
+    get nextUrl() {
+        return this[INTERNALS].nextUrl;
+    }
+    /**
+   * @deprecated
+   * `page` has been deprecated in favour of `URLPattern`.
+   * Read more: https://nextjs.org/docs/messages/middleware-request-page
+   */ get page() {
+        throw new _error.RemovedPageError();
+    }
+    /**
+   * @deprecated
+   * `ua` has been removed in favour of \`userAgent\` function.
+   * Read more: https://nextjs.org/docs/messages/middleware-parse-user-agent
+   */ get ua() {
+        throw new _error.RemovedUAError();
+    }
+    get url() {
+        return this[INTERNALS].url;
+    }
+}
+
+//# sourceMappingURL=request.js.map

node_modules/next/dist/server/web/spec-extension/request.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/spec-extension/request.ts"],"names":["INTERNALS","NextRequest","Symbol","Request","constructor","input","init","url","String","validateURL","nextUrl","NextURL","headers","toNodeOutgoingHttpHeaders","nextConfig","cookies","RequestCookies","geo","ip","process","env","__NEXT_NO_MIDDLEWARE_URL_NORMALIZE","toString","for","bodyUsed","cache","credentials","destination","Object","fromEntries","integrity","keepalive","method","mode","redirect","referrer","referrerPolicy","signal","page","RemovedPageError","ua","RemovedUAError"],"mappings":";;;;;;;;;;;;;;;IAOaA,SAAS;eAATA;;IAOAC,WAAW;eAAXA;;;yBAZW;uBAC+B;uBACN;yBAClB;AAExB,MAAMD,YAAYE,OAAO;AAOzB,MAAMD,oBAAoBE;IAS/BC,YAAYC,KAAwB,EAAEC,OAAoB,CAAC,CAAC,CAAE;QAC5D,MAAMC,MACJ,OAAOF,UAAU,YAAY,SAASA,QAAQA,MAAME,GAAG,GAAGC,OAAOH;QACnEI,IAAAA,kBAAW,EAACF;QACZ,IAAIF,iBAAiBF,SAAS,KAAK,CAACE,OAAOC;aACtC,KAAK,CAACC,KAAKD;QAChB,MAAMI,UAAU,IAAIC,gBAAO,CAACJ,KAAK;YAC/BK,SAASC,IAAAA,gCAAyB,EAAC,IAAI,CAACD,OAAO;YAC/CE,YAAYR,KAAKQ,UAAU;QAC7B;QACA,IAAI,CAACd,UAAU,GAAG;YAChBe,SAAS,IAAIC,uBAAc,CAAC,IAAI,CAACJ,OAAO;YACxCK,KAAKX,KAAKW,GAAG,IAAI,CAAC;YAClBC,IAAIZ,KAAKY,EAAE;YACXR;YACAH,KAAKY,QAAQC,GAAG,CAACC,kCAAkC,GAC/Cd,MACAG,QAAQY,QAAQ;QACtB;IACF;IAEA,CAACpB,OAAOqB,GAAG,CAAC,+BAA+B,GAAG;QAC5C,OAAO;YACLR,SAAS,IAAI,CAACA,OAAO;YACrBE,KAAK,IAAI,CAACA,GAAG;YACbC,IAAI,IAAI,CAACA,EAAE;YACXR,SAAS,IAAI,CAACA,OAAO;YACrBH,KAAK,IAAI,CAACA,GAAG;YACb,kCAAkC;YAClCiB,UAAU,IAAI,CAACA,QAAQ;YACvBC,OAAO,IAAI,CAACA,KAAK;YACjBC,aAAa,IAAI,CAACA,WAAW;YAC7BC,aAAa,IAAI,CAACA,WAAW;YAC7Bf,SAASgB,OAAOC,WAAW,CAAC,IAAI,CAACjB,OAAO;YACxCkB,WAAW,IAAI,CAACA,SAAS;YACzBC,WAAW,IAAI,CAACA,SAAS;YACzBC,QAAQ,IAAI,CAACA,MAAM;YACnBC,MAAM,IAAI,CAACA,IAAI;YACfC,UAAU,IAAI,CAACA,QAAQ;YACvBC,UAAU,IAAI,CAACA,QAAQ;YACvBC,gBAAgB,IAAI,CAACA,cAAc;YACnCC,QAAQ,IAAI,CAACA,MAAM;QACrB;IACF;IAEA,IAAWtB,UAAU;QACnB,OAAO,IAAI,CAACf,UAAU,CAACe,OAAO;IAChC;IAEA,IAAWE,MAAM;QACf,OAAO,IAAI,CAACjB,UAAU,CAACiB,GAAG;IAC5B;IAEA,IAAWC,KAAK;QACd,OAAO,IAAI,CAAClB,UAAU,CAACkB,EAAE;IAC3B;IAEA,IAAWR,UAAU;QACnB,OAAO,IAAI,CAACV,UAAU,CAACU,OAAO;IAChC;IAEA;;;;GAIC,GACD,IAAW4B,OAAO;QAChB,MAAM,IAAIC,uBAAgB;IAC5B;IAEA;;;;GAIC,GACD,IAAWC,KAAK;QACd,MAAM,IAAIC,qBAAc;IAC1B;IAEA,IAAWlC,MAAM;QACf,OAAO,IAAI,CAACP,UAAU,CAACO,GAAG;IAC5B;AACF"}

node_modules/next/dist/server/web/spec-extension/response.d.ts

@@ -0,0 +1,43 @@
+import type { I18NConfig } from '../../config-shared';
+import { NextURL } from '../next-url';
+import { ResponseCookies } from './cookies';
+declare const INTERNALS: unique symbol;
+/**
+ * This class extends the [Web `Response` API](https://developer.mozilla.org/docs/Web/API/Response) with additional convenience methods.
+ *
+ * Read more: [Next.js Docs: `NextResponse`](https://nextjs.org/docs/app/api-reference/functions/next-response)
+ */
+export declare class NextResponse<Body = unknown> extends Response {
+    [INTERNALS]: {
+        cookies: ResponseCookies;
+        url?: NextURL;
+        body?: Body;
+    };
+    constructor(body?: BodyInit | null, init?: ResponseInit);
+    get cookies(): ResponseCookies;
+    static json<JsonBody>(body: JsonBody, init?: ResponseInit): NextResponse<JsonBody>;
+    static redirect(url: string | NextURL | URL, init?: number | ResponseInit): NextResponse<unknown>;
+    static rewrite(destination: string | NextURL | URL, init?: MiddlewareResponseInit): NextResponse<unknown>;
+    static next(init?: MiddlewareResponseInit): NextResponse<unknown>;
+}
+interface ResponseInit extends globalThis.ResponseInit {
+    nextConfig?: {
+        basePath?: string;
+        i18n?: I18NConfig;
+        trailingSlash?: boolean;
+    };
+    url?: string;
+}
+interface ModifiedRequest {
+    /**
+     * If this is set, the request headers will be overridden with this value.
+     */
+    headers?: Headers;
+}
+interface MiddlewareResponseInit extends globalThis.ResponseInit {
+    /**
+     * These fields will override the request from clients.
+     */
+    request?: ModifiedRequest;
+}
+export {};

node_modules/next/dist/server/web/spec-extension/response.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NextResponse", {
+    enumerable: true,
+    get: function() {
+        return NextResponse;
+    }
+});
+const _cookies = require("../../web/spec-extension/cookies");
+const _nexturl = require("../next-url");
+const _utils = require("../utils");
+const _reflect = require("./adapters/reflect");
+const _cookies1 = require("./cookies");
+const INTERNALS = Symbol("internal response");
+const REDIRECTS = new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+]);
+function handleMiddlewareField(init, headers) {
+    var _init_request;
+    if (init == null ? void 0 : (_init_request = init.request) == null ? void 0 : _init_request.headers) {
+        if (!(init.request.headers instanceof Headers)) {
+            throw new Error("request.headers must be an instance of Headers");
+        }
+        const keys = [];
+        for (const [key, value] of init.request.headers){
+            headers.set("x-middleware-request-" + key, value);
+            keys.push(key);
+        }
+        headers.set("x-middleware-override-headers", keys.join(","));
+    }
+}
+class NextResponse extends Response {
+    constructor(body, init = {}){
+        super(body, init);
+        const headers = this.headers;
+        const cookies = new _cookies1.ResponseCookies(headers);
+        const cookiesProxy = new Proxy(cookies, {
+            get (target, prop, receiver) {
+                switch(prop){
+                    case "delete":
+                    case "set":
+                        {
+                            return (...args)=>{
+                                const result = Reflect.apply(target[prop], target, args);
+                                const newHeaders = new Headers(headers);
+                                if (result instanceof _cookies1.ResponseCookies) {
+                                    headers.set("x-middleware-set-cookie", result.getAll().map((cookie)=>(0, _cookies.stringifyCookie)(cookie)).join(","));
+                                }
+                                handleMiddlewareField(init, newHeaders);
+                                return result;
+                            };
+                        }
+                    default:
+                        return _reflect.ReflectAdapter.get(target, prop, receiver);
+                }
+            }
+        });
+        this[INTERNALS] = {
+            cookies: cookiesProxy,
+            url: init.url ? new _nexturl.NextURL(init.url, {
+                headers: (0, _utils.toNodeOutgoingHttpHeaders)(headers),
+                nextConfig: init.nextConfig
+            }) : undefined
+        };
+    }
+    [Symbol.for("edge-runtime.inspect.custom")]() {
+        return {
+            cookies: this.cookies,
+            url: this.url,
+            // rest of props come from Response
+            body: this.body,
+            bodyUsed: this.bodyUsed,
+            headers: Object.fromEntries(this.headers),
+            ok: this.ok,
+            redirected: this.redirected,
+            status: this.status,
+            statusText: this.statusText,
+            type: this.type
+        };
+    }
+    get cookies() {
+        return this[INTERNALS].cookies;
+    }
+    static json(body, init) {
+        const response = Response.json(body, init);
+        return new NextResponse(response.body, response);
+    }
+    static redirect(url, init) {
+        const status = typeof init === "number" ? init : (init == null ? void 0 : init.status) ?? 307;
+        if (!REDIRECTS.has(status)) {
+            throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
+        }
+        const initObj = typeof init === "object" ? init : {};
+        const headers = new Headers(initObj == null ? void 0 : initObj.headers);
+        headers.set("Location", (0, _utils.validateURL)(url));
+        return new NextResponse(null, {
+            ...initObj,
+            headers,
+            status
+        });
+    }
+    static rewrite(destination, init) {
+        const headers = new Headers(init == null ? void 0 : init.headers);
+        headers.set("x-middleware-rewrite", (0, _utils.validateURL)(destination));
+        handleMiddlewareField(init, headers);
+        return new NextResponse(null, {
+            ...init,
+            headers
+        });
+    }
+    static next(init) {
+        const headers = new Headers(init == null ? void 0 : init.headers);
+        headers.set("x-middleware-next", "1");
+        handleMiddlewareField(init, headers);
+        return new NextResponse(null, {
+            ...init,
+            headers
+        });
+    }
+}
+
+//# sourceMappingURL=response.js.map

node_modules/next/dist/server/web/spec-extension/response.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/spec-extension/response.ts"],"names":["NextResponse","INTERNALS","Symbol","REDIRECTS","Set","handleMiddlewareField","init","headers","request","Headers","Error","keys","key","value","set","push","join","Response","constructor","body","cookies","ResponseCookies","cookiesProxy","Proxy","get","target","prop","receiver","args","result","Reflect","apply","newHeaders","getAll","map","cookie","stringifyCookie","ReflectAdapter","url","NextURL","toNodeOutgoingHttpHeaders","nextConfig","undefined","for","bodyUsed","Object","fromEntries","ok","redirected","status","statusText","type","json","response","redirect","has","RangeError","initObj","validateURL","rewrite","destination","next"],"mappings":"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"}

node_modules/next/dist/server/web/spec-extension/revalidate.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This function allows you to purge [cached data](https://nextjs.org/docs/app/building-your-application/caching) on-demand for a specific cache tag.
+ *
+ * Read more: [Next.js Docs: `revalidateTag`](https://nextjs.org/docs/app/api-reference/functions/revalidateTag)
+ */
+export declare function revalidateTag(tag: string): void;
+/**
+ * This function allows you to purge [cached data](https://nextjs.org/docs/app/building-your-application/caching) on-demand for a specific path.
+ *
+ * Read more: [Next.js Docs: `revalidatePath`](https://nextjs.org/docs/app/api-reference/functions/revalidatePath)
+ */
+export declare function revalidatePath(originalPath: string, type?: 'layout' | 'page'): void;

node_modules/next/dist/server/web/spec-extension/revalidate.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    revalidatePath: null,
+    revalidateTag: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    revalidatePath: function() {
+        return revalidatePath;
+    },
+    revalidateTag: function() {
+        return revalidateTag;
+    }
+});
+const _dynamicrendering = require("../../app-render/dynamic-rendering");
+const _utils = require("../../../shared/lib/router/utils");
+const _constants = require("../../../lib/constants");
+const _url = require("../../../lib/url");
+const _staticgenerationasyncstorageexternal = require("../../../client/components/static-generation-async-storage.external");
+function revalidateTag(tag) {
+    return revalidate(tag, `revalidateTag ${tag}`);
+}
+function revalidatePath(originalPath, type) {
+    if (originalPath.length > _constants.NEXT_CACHE_SOFT_TAG_MAX_LENGTH) {
+        console.warn(`Warning: revalidatePath received "${originalPath}" which exceeded max length of ${_constants.NEXT_CACHE_SOFT_TAG_MAX_LENGTH}. See more info here https://nextjs.org/docs/app/api-reference/functions/revalidatePath`);
+        return;
+    }
+    let normalizedPath = `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${originalPath}`;
+    if (type) {
+        normalizedPath += `${normalizedPath.endsWith("/") ? "" : "/"}${type}`;
+    } else if ((0, _utils.isDynamicRoute)(originalPath)) {
+        console.warn(`Warning: a dynamic page path "${originalPath}" was passed to "revalidatePath", but the "type" parameter is missing. This has no effect by default, see more info here https://nextjs.org/docs/app/api-reference/functions/revalidatePath`);
+    }
+    return revalidate(normalizedPath, `revalidatePath ${originalPath}`);
+}
+function revalidate(tag, expression) {
+    const store = _staticgenerationasyncstorageexternal.staticGenerationAsyncStorage.getStore();
+    if (!store || !store.incrementalCache) {
+        throw new Error(`Invariant: static generation store missing in ${expression}`);
+    }
+    if (store.isUnstableCacheCallback) {
+        throw new Error(`Route ${(0, _url.getPathname)(store.urlPathname)} used "${expression}" inside a function cached with "unstable_cache(...)" which is unsupported. To ensure revalidation is performed consistently it must always happen outside of renders and cached functions. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`);
+    }
+    // a route that makes use of revalidation APIs should be considered dynamic
+    // as otherwise it would be impossible to revalidate
+    (0, _dynamicrendering.trackDynamicDataAccessed)(store, expression);
+    if (!store.revalidatedTags) {
+        store.revalidatedTags = [];
+    }
+    if (!store.revalidatedTags.includes(tag)) {
+        store.revalidatedTags.push(tag);
+    }
+    // TODO: only revalidate if the path matches
+    store.pathWasRevalidated = true;
+}
+
+//# sourceMappingURL=revalidate.js.map

node_modules/next/dist/server/web/spec-extension/revalidate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/spec-extension/revalidate.ts"],"names":["revalidatePath","revalidateTag","tag","revalidate","originalPath","type","length","NEXT_CACHE_SOFT_TAG_MAX_LENGTH","console","warn","normalizedPath","NEXT_CACHE_IMPLICIT_TAG_ID","endsWith","isDynamicRoute","expression","store","staticGenerationAsyncStorage","getStore","incrementalCache","Error","isUnstableCacheCallback","getPathname","urlPathname","trackDynamicDataAccessed","revalidatedTags","includes","push","pathWasRevalidated"],"mappings":";;;;;;;;;;;;;;;IAuBgBA,cAAc;eAAdA;;IATAC,aAAa;eAAbA;;;kCAdyB;uBACV;2BAIxB;qBACqB;sDACiB;AAOtC,SAASA,cAAcC,GAAW;IACvC,OAAOC,WAAWD,KAAK,CAAC,cAAc,EAAEA,IAAI,CAAC;AAC/C;AAOO,SAASF,eAAeI,YAAoB,EAAEC,IAAwB;IAC3E,IAAID,aAAaE,MAAM,GAAGC,yCAA8B,EAAE;QACxDC,QAAQC,IAAI,CACV,CAAC,kCAAkC,EAAEL,aAAa,+BAA+B,EAAEG,yCAA8B,CAAC,uFAAuF,CAAC;QAE5M;IACF;IAEA,IAAIG,iBAAiB,CAAC,EAAEC,qCAA0B,CAAC,EAAEP,aAAa,CAAC;IAEnE,IAAIC,MAAM;QACRK,kBAAkB,CAAC,EAAEA,eAAeE,QAAQ,CAAC,OAAO,KAAK,IAAI,EAAEP,KAAK,CAAC;IACvE,OAAO,IAAIQ,IAAAA,qBAAc,EAACT,eAAe;QACvCI,QAAQC,IAAI,CACV,CAAC,8BAA8B,EAAEL,aAAa,2LAA2L,CAAC;IAE9O;IACA,OAAOD,WAAWO,gBAAgB,CAAC,eAAe,EAAEN,aAAa,CAAC;AACpE;AAEA,SAASD,WAAWD,GAAW,EAAEY,UAAkB;IACjD,MAAMC,QAAQC,kEAA4B,CAACC,QAAQ;IACnD,IAAI,CAACF,SAAS,CAACA,MAAMG,gBAAgB,EAAE;QACrC,MAAM,IAAIC,MACR,CAAC,8CAA8C,EAAEL,WAAW,CAAC;IAEjE;IAEA,IAAIC,MAAMK,uBAAuB,EAAE;QACjC,MAAM,IAAID,MACR,CAAC,MAAM,EAAEE,IAAAA,gBAAW,EAClBN,MAAMO,WAAW,EACjB,OAAO,EAAER,WAAW,oTAAoT,CAAC;IAE/U;IAEA,2EAA2E;IAC3E,oDAAoD;IACpDS,IAAAA,0CAAwB,EAACR,OAAOD;IAEhC,IAAI,CAACC,MAAMS,eAAe,EAAE;QAC1BT,MAAMS,eAAe,GAAG,EAAE;IAC5B;IACA,IAAI,CAACT,MAAMS,eAAe,CAACC,QAAQ,CAACvB,MAAM;QACxCa,MAAMS,eAAe,CAACE,IAAI,CAACxB;IAC7B;IAEA,4CAA4C;IAC5Ca,MAAMY,kBAAkB,GAAG;AAC7B"}

node_modules/next/dist/server/web/spec-extension/unstable-cache.d.ts

@@ -0,0 +1,14 @@
+type Callback = (...args: any[]) => Promise<any>;
+/**
+ * This function allows you to cache the results of expensive operations, like database queries, and reuse them across multiple requests.
+ *
+ * Read more: [Next.js Docs: `unstable_cache`](https://nextjs.org/docs/app/api-reference/functions/unstable_cache)
+ */
+export declare function unstable_cache<T extends Callback>(cb: T, keyParts?: string[], options?: {
+    /**
+     * The revalidation interval in seconds.
+     */
+    revalidate?: number | false;
+    tags?: string[];
+}): T;
+export {};

node_modules/next/dist/server/web/spec-extension/unstable-cache.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "unstable_cache", {
+    enumerable: true,
+    get: function() {
+        return unstable_cache;
+    }
+});
+const _constants = require("../../../lib/constants");
+const _patchfetch = require("../../lib/patch-fetch");
+const _staticgenerationasyncstorageexternal = require("../../../client/components/static-generation-async-storage.external");
+let noStoreFetchIdx = 0;
+async function cacheNewResult(result, incrementalCache, cacheKey, tags, revalidate, fetchIdx, fetchUrl) {
+    await incrementalCache.set(cacheKey, {
+        kind: "FETCH",
+        data: {
+            headers: {},
+            // TODO: handle non-JSON values?
+            body: JSON.stringify(result),
+            status: 200,
+            url: ""
+        },
+        revalidate: typeof revalidate !== "number" ? _constants.CACHE_ONE_YEAR : revalidate
+    }, {
+        revalidate,
+        fetchCache: true,
+        tags,
+        fetchIdx,
+        fetchUrl
+    });
+    return;
+}
+function unstable_cache(cb, keyParts, options = {}) {
+    if (options.revalidate === 0) {
+        throw new Error(`Invariant revalidate: 0 can not be passed to unstable_cache(), must be "false" or "> 0" ${cb.toString()}`);
+    }
+    // Validate the tags provided are valid
+    const tags = options.tags ? (0, _patchfetch.validateTags)(options.tags, `unstable_cache ${cb.toString()}`) : [];
+    // Validate the revalidate options
+    (0, _patchfetch.validateRevalidate)(options.revalidate, `unstable_cache ${cb.name || cb.toString()}`);
+    // Stash the fixed part of the key at construction time. The invocation key will combine
+    // the fixed key with the arguments when actually called
+    // @TODO if cb.toString() is long we should hash it
+    // @TODO come up with a collision-free way to combine keyParts
+    // @TODO consider validating the keyParts are all strings. TS can't provide runtime guarantees
+    // and the error produced by accidentally using something that cannot be safely coerced is likely
+    // hard to debug
+    const fixedKey = `${cb.toString()}-${Array.isArray(keyParts) && keyParts.join(",")}`;
+    const cachedCb = async (...args)=>{
+        const store = _staticgenerationasyncstorageexternal.staticGenerationAsyncStorage.getStore();
+        // We must be able to find the incremental cache otherwise we throw
+        const maybeIncrementalCache = (store == null ? void 0 : store.incrementalCache) || globalThis.__incrementalCache;
+        if (!maybeIncrementalCache) {
+            throw new Error(`Invariant: incrementalCache missing in unstable_cache ${cb.toString()}`);
+        }
+        const incrementalCache = maybeIncrementalCache;
+        const { pathname, searchParams } = new URL((store == null ? void 0 : store.urlPathname) || "/", "http://n");
+        const sortedSearchKeys = [
+            ...searchParams.keys()
+        ].sort((a, b)=>{
+            return a.localeCompare(b);
+        });
+        const sortedSearch = sortedSearchKeys.map((key)=>`${key}=${searchParams.get(key)}`).join("&");
+        // Construct the complete cache key for this function invocation
+        // @TODO stringify is likely not safe here. We will coerce undefined to null which will make
+        // the keyspace smaller than the execution space
+        const invocationKey = `${fixedKey}-${JSON.stringify(args)}`;
+        const cacheKey = await incrementalCache.fetchCacheKey(invocationKey);
+        // $urlWithPath,$sortedQueryStringKeys,$hashOfEveryThingElse
+        const fetchUrl = `unstable_cache ${pathname}${sortedSearch.length ? "?" : ""}${sortedSearch} ${cb.name ? ` ${cb.name}` : cacheKey}`;
+        const fetchIdx = (store ? store.nextFetchId : noStoreFetchIdx) ?? 1;
+        if (store) {
+            store.nextFetchId = fetchIdx + 1;
+            // We are in an App Router context. We try to return the cached entry if it exists and is valid
+            // If the entry is fresh we return it. If the entry is stale we return it but revalidate the entry in
+            // the background. If the entry is missing or invalid we generate a new entry and return it.
+            // We update the store's revalidate property if the option.revalidate is a higher precedence
+            if (typeof options.revalidate === "number") {
+                if (typeof store.revalidate === "number" && store.revalidate < options.revalidate) {
+                // The store is already revalidating on a shorter time interval, leave it alone
+                } else {
+                    store.revalidate = options.revalidate;
+                }
+            } else if (options.revalidate === false && typeof store.revalidate === "undefined") {
+                // The store has not defined revalidate type so we can use the false option
+                store.revalidate = options.revalidate;
+            }
+            // We need to accumulate the tags for this invocation within the store
+            if (!store.tags) {
+                store.tags = tags.slice();
+            } else {
+                for (const tag of tags){
+                    // @TODO refactor tags to be a set to avoid this O(n) lookup
+                    if (!store.tags.includes(tag)) {
+                        store.tags.push(tag);
+                    }
+                }
+            }
+            // @TODO check on this API. addImplicitTags mutates the store and returns the implicit tags. The naming
+            // of this function is potentially a little confusing
+            const implicitTags = (0, _patchfetch.addImplicitTags)(store);
+            if (// when we are nested inside of other unstable_cache's
+            // we should bypass cache similar to fetches
+            store.fetchCache !== "force-no-store" && !store.isOnDemandRevalidate && !incrementalCache.isOnDemandRevalidate && !store.isDraftMode) {
+                // We attempt to get the current cache entry from the incremental cache.
+                const cacheEntry = await incrementalCache.get(cacheKey, {
+                    kindHint: "fetch",
+                    revalidate: options.revalidate,
+                    tags,
+                    softTags: implicitTags,
+                    fetchIdx,
+                    fetchUrl
+                });
+                if (cacheEntry && cacheEntry.value) {
+                    // The entry exists and has a value
+                    if (cacheEntry.value.kind !== "FETCH") {
+                        // The entry is invalid and we need a special warning
+                        // @TODO why do we warn this way? Should this just be an error? How are these errors surfaced
+                        // so bugs can be reported
+                        // @TODO the invocation key can have sensitive data in it. we should not log this entire object
+                        console.error(`Invariant invalid cacheEntry returned for ${invocationKey}`);
+                    // will fall through to generating a new cache entry below
+                    } else {
+                        // We have a valid cache entry so we will be returning it. We also check to see if we need
+                        // to background revalidate it by checking if it is stale.
+                        const cachedResponse = cacheEntry.value.data.body !== undefined ? JSON.parse(cacheEntry.value.data.body) : undefined;
+                        if (cacheEntry.isStale) {
+                            // In App Router we return the stale result and revalidate in the background
+                            if (!store.pendingRevalidates) {
+                                store.pendingRevalidates = {};
+                            }
+                            // We run the cache function asynchronously and save the result when it completes
+                            store.pendingRevalidates[invocationKey] = _staticgenerationasyncstorageexternal.staticGenerationAsyncStorage.run({
+                                ...store,
+                                // force any nested fetches to bypass cache so they revalidate
+                                // when the unstable_cache call is revalidated
+                                fetchCache: "force-no-store",
+                                isUnstableCacheCallback: true
+                            }, cb, ...args).then((result)=>{
+                                return cacheNewResult(result, incrementalCache, cacheKey, tags, options.revalidate, fetchIdx, fetchUrl);
+                            })// @TODO This error handling seems wrong. We swallow the error?
+                            .catch((err)=>console.error(`revalidating cache with key: ${invocationKey}`, err));
+                        }
+                        // We had a valid cache entry so we return it here
+                        return cachedResponse;
+                    }
+                }
+            }
+            // If we got this far then we had an invalid cache entry and need to generate a new one
+            const result = await _staticgenerationasyncstorageexternal.staticGenerationAsyncStorage.run({
+                ...store,
+                // force any nested fetches to bypass cache so they revalidate
+                // when the unstable_cache call is revalidated
+                fetchCache: "force-no-store",
+                isUnstableCacheCallback: true
+            }, cb, ...args);
+            if (!store.isDraftMode) {
+                cacheNewResult(result, incrementalCache, cacheKey, tags, options.revalidate, fetchIdx, fetchUrl);
+            }
+            return result;
+        } else {
+            noStoreFetchIdx += 1;
+            // We are in Pages Router or were called outside of a render. We don't have a store
+            // so we just call the callback directly when it needs to run.
+            // If the entry is fresh we return it. If the entry is stale we return it but revalidate the entry in
+            // the background. If the entry is missing or invalid we generate a new entry and return it.
+            if (!incrementalCache.isOnDemandRevalidate) {
+                // We aren't doing an on demand revalidation so we check use the cache if valid
+                // @TODO check on this API. addImplicitTags mutates the store and returns the implicit tags. The naming
+                // of this function is potentially a little confusing
+                const implicitTags = store && (0, _patchfetch.addImplicitTags)(store);
+                const cacheEntry = await incrementalCache.get(cacheKey, {
+                    kindHint: "fetch",
+                    revalidate: options.revalidate,
+                    tags,
+                    fetchIdx,
+                    fetchUrl,
+                    softTags: implicitTags
+                });
+                if (cacheEntry && cacheEntry.value) {
+                    // The entry exists and has a value
+                    if (cacheEntry.value.kind !== "FETCH") {
+                        // The entry is invalid and we need a special warning
+                        // @TODO why do we warn this way? Should this just be an error? How are these errors surfaced
+                        // so bugs can be reported
+                        console.error(`Invariant invalid cacheEntry returned for ${invocationKey}`);
+                    // will fall through to generating a new cache entry below
+                    } else if (!cacheEntry.isStale) {
+                        // We have a valid cache entry and it is fresh so we return it
+                        return cacheEntry.value.data.body !== undefined ? JSON.parse(cacheEntry.value.data.body) : undefined;
+                    }
+                }
+            }
+            // If we got this far then we had an invalid cache entry and need to generate a new one
+            // @TODO this storage wrapper is included here because it existed prior to the latest refactor
+            // however it is incorrect logic because it causes any internal cache calls to follow the App Router
+            // path rather than Pages router path. This may mean there is existing buggy behavior however no specific
+            // issues are known at this time. The whole static generation storage pathways should be reworked
+            // to allow tracking which "mode" we are in without the presence of a store or not. For now I have
+            // maintained the existing behavior to limit the impact of the current refactor
+            const result = await _staticgenerationasyncstorageexternal.staticGenerationAsyncStorage.run(// We are making a fake store that is useful for scoping fetchCache: 'force-no-store' and isUnstableCacheCallback: true
+            // The fact that we need to construct this kind of fake store indicates the code is not factored correctly
+            // @TODO refactor to not require this fake store object
+            {
+                // force any nested fetches to bypass cache so they revalidate
+                // when the unstable_cache call is revalidated
+                fetchCache: "force-no-store",
+                isUnstableCacheCallback: true,
+                urlPathname: "/",
+                isStaticGeneration: false,
+                prerenderState: null
+            }, cb, ...args);
+            cacheNewResult(result, incrementalCache, cacheKey, tags, options.revalidate, fetchIdx, fetchUrl);
+            return result;
+        }
+    };
+    // TODO: once AsyncLocalStorage.run() returns the correct types this override will no longer be necessary
+    return cachedCb;
+}
+
+//# sourceMappingURL=unstable-cache.js.map

node_modules/next/dist/server/web/spec-extension/unstable-no-store.d.ts

@@ -0,0 +1,16 @@
+/**
+ * This function can be used to declaratively opt out of static rendering and indicate a particular component should not be cached.
+ *
+ * It marks the current scope as dynamic.
+ *
+ * - In [non-PPR](https://nextjs.org/docs/app/api-reference/next-config-js/partial-prerendering) cases this will make a static render
+ * halt and mark the page as dynamic.
+ * - In PPR cases this will postpone the render at this location.
+ *
+ * If we are inside a cache scope then this function does nothing.
+ *
+ * @note It expects to be called within App Router and will error otherwise.
+ *
+ * Read more: [Next.js Docs: `unstable_noStore`](https://nextjs.org/docs/app/api-reference/functions/unstable_noStore)
+ */
+export declare function unstable_noStore(): void;

node_modules/next/dist/server/web/spec-extension/unstable-no-store.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "unstable_noStore", {
+    enumerable: true,
+    get: function() {
+        return unstable_noStore;
+    }
+});
+const _staticgenerationasyncstorageexternal = require("../../../client/components/static-generation-async-storage.external");
+const _dynamicrendering = require("../../app-render/dynamic-rendering");
+function unstable_noStore() {
+    const callingExpression = "unstable_noStore()";
+    const store = _staticgenerationasyncstorageexternal.staticGenerationAsyncStorage.getStore();
+    if (!store) {
+        // This generally implies we are being called in Pages router. We should probably not support
+        // unstable_noStore in contexts outside of `react-server` condition but since we historically
+        // have not errored here previously, we maintain that behavior for now.
+        return;
+    } else if (store.forceStatic) {
+        return;
+    } else {
+        store.isUnstableNoStore = true;
+        (0, _dynamicrendering.markCurrentScopeAsDynamic)(store, callingExpression);
+    }
+}
+
+//# sourceMappingURL=unstable-no-store.js.map

node_modules/next/dist/server/web/spec-extension/unstable-no-store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/spec-extension/unstable-no-store.ts"],"names":["unstable_noStore","callingExpression","store","staticGenerationAsyncStorage","getStore","forceStatic","isUnstableNoStore","markCurrentScopeAsDynamic"],"mappings":";;;;+BAkBgBA;;;eAAAA;;;sDAlB6B;kCACH;AAiBnC,SAASA;IACd,MAAMC,oBAAoB;IAC1B,MAAMC,QAAQC,kEAA4B,CAACC,QAAQ;IACnD,IAAI,CAACF,OAAO;QACV,6FAA6F;QAC7F,6FAA6F;QAC7F,uEAAuE;QACvE;IACF,OAAO,IAAIA,MAAMG,WAAW,EAAE;QAC5B;IACF,OAAO;QACLH,MAAMI,iBAAiB,GAAG;QAC1BC,IAAAA,2CAAyB,EAACL,OAAOD;IACnC;AACF"}

node_modules/next/dist/server/web/spec-extension/url-pattern.d.ts

@@ -0,0 +1,2 @@
+declare const GlobalURLPattern: any;
+export { GlobalURLPattern as URLPattern };

node_modules/next/dist/server/web/spec-extension/url-pattern.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "URLPattern", {
+    enumerable: true,
+    get: function() {
+        return GlobalURLPattern;
+    }
+});
+const GlobalURLPattern = // @ts-expect-error: URLPattern is not available in Node.js
+typeof URLPattern === "undefined" ? undefined : URLPattern;
+
+//# sourceMappingURL=url-pattern.js.map

node_modules/next/dist/server/web/spec-extension/url-pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/spec-extension/url-pattern.ts"],"names":["URLPattern","GlobalURLPattern","undefined"],"mappings":";;;;+BAI6BA;;;eAApBC;;;AAJT,MAAMA,mBACJ,2DAA2D;AAC3D,OAAOD,eAAe,cAAcE,YAAYF"}

node_modules/next/dist/server/web/spec-extension/user-agent.d.ts

@@ -0,0 +1,30 @@
+interface UserAgent {
+    isBot: boolean;
+    ua: string;
+    browser: {
+        name?: string;
+        version?: string;
+    };
+    device: {
+        model?: string;
+        type?: string;
+        vendor?: string;
+    };
+    engine: {
+        name?: string;
+        version?: string;
+    };
+    os: {
+        name?: string;
+        version?: string;
+    };
+    cpu: {
+        architecture?: string;
+    };
+}
+export declare function isBot(input: string): boolean;
+export declare function userAgentFromString(input: string | undefined): UserAgent;
+export declare function userAgent({ headers }: {
+    headers: Headers;
+}): UserAgent;
+export {};

node_modules/next/dist/server/web/spec-extension/user-agent.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    isBot: null,
+    userAgent: null,
+    userAgentFromString: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isBot: function() {
+        return isBot;
+    },
+    userAgent: function() {
+        return userAgent;
+    },
+    userAgentFromString: function() {
+        return userAgentFromString;
+    }
+});
+const _uaparserjs = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/ua-parser-js"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function isBot(input) {
+    return /Googlebot|Mediapartners-Google|AdsBot-Google|googleweblight|Storebot-Google|Google-PageRenderer|Google-InspectionTool|Bingbot|BingPreview|Slurp|DuckDuckBot|baiduspider|yandex|sogou|LinkedInBot|bitlybot|tumblr|vkShare|quora link preview|facebookexternalhit|facebookcatalog|Twitterbot|applebot|redditbot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|ia_archiver/i.test(input);
+}
+function userAgentFromString(input) {
+    return {
+        ...(0, _uaparserjs.default)(input),
+        isBot: input === undefined ? false : isBot(input)
+    };
+}
+function userAgent({ headers }) {
+    return userAgentFromString(headers.get("user-agent") || undefined);
+}
+
+//# sourceMappingURL=user-agent.js.map

node_modules/next/dist/server/web/spec-extension/user-agent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/spec-extension/user-agent.ts"],"names":["isBot","userAgent","userAgentFromString","input","test","parseua","undefined","headers","get"],"mappings":";;;;;;;;;;;;;;;;IA2BgBA,KAAK;eAALA;;IAaAC,SAAS;eAATA;;IAPAC,mBAAmB;eAAnBA;;;mEAjCI;;;;;;AA2Bb,SAASF,MAAMG,KAAa;IACjC,OAAO,0WAA0WC,IAAI,CACnXD;AAEJ;AAEO,SAASD,oBAAoBC,KAAyB;IAC3D,OAAO;QACL,GAAGE,IAAAA,mBAAO,EAACF,MAAM;QACjBH,OAAOG,UAAUG,YAAY,QAAQN,MAAMG;IAC7C;AACF;AAEO,SAASF,UAAU,EAAEM,OAAO,EAAwB;IACzD,OAAOL,oBAAoBK,QAAQC,GAAG,CAAC,iBAAiBF;AAC1D"}

node_modules/next/dist/server/web/types.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="node" />
+import type { I18NConfig } from '../config-shared';
+import type { NextRequest } from './spec-extension/request';
+import type { NextFetchEvent } from './spec-extension/fetch-event';
+import type { NextResponse } from './spec-extension/response';
+import type { CloneableBody } from '../body-streams';
+import type { OutgoingHttpHeaders } from 'http';
+import type { FetchMetrics } from '../base-http';
+export type { MiddlewareConfig } from '../../build/analysis/get-page-static-info';
+export interface RequestData {
+    geo?: {
+        city?: string;
+        country?: string;
+        region?: string;
+        latitude?: string;
+        longitude?: string;
+    };
+    headers: OutgoingHttpHeaders;
+    ip?: string;
+    method: string;
+    nextConfig?: {
+        basePath?: string;
+        i18n?: I18NConfig | null;
+        trailingSlash?: boolean;
+    };
+    page?: {
+        name?: string;
+        params?: {
+            [key: string]: string | string[];
+        };
+    };
+    url: string;
+    body?: ReadableStream<Uint8Array>;
+    signal: AbortSignal;
+}
+export type NodejsRequestData = Omit<RequestData, 'body'> & {
+    body?: CloneableBody;
+};
+export interface FetchEventResult {
+    response: Response;
+    waitUntil: Promise<any>;
+    fetchMetrics?: FetchMetrics;
+}
+export type NextMiddlewareResult = NextResponse | Response | null | undefined | void;
+/**
+ * Middleware allows you to run code before a request is completed.
+ * Then, based on the incoming request, you can modify the response
+ * by rewriting, redirecting, modifying the request or response headers,
+ * or responding directly.
+ *
+ * Read more: [Next.js Docs: Middleware](https://nextjs.org/docs/app/building-your-application/routing/middleware)
+ */
+export type NextMiddleware = (request: NextRequest, event: NextFetchEvent) => NextMiddlewareResult | Promise<NextMiddlewareResult>;

node_modules/next/dist/server/web/types.js

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

node_modules/next/dist/server/web/types.js.map

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

node_modules/next/dist/server/web/utils.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import type { OutgoingHttpHeaders } from 'http';
+/**
+ * Converts a Node.js IncomingHttpHeaders object to a Headers object. Any
+ * headers with multiple values will be joined with a comma and space. Any
+ * headers that have an undefined value will be ignored and others will be
+ * coerced to strings.
+ *
+ * @param nodeHeaders the headers object to convert
+ * @returns the converted headers object
+ */
+export declare function fromNodeOutgoingHttpHeaders(nodeHeaders: OutgoingHttpHeaders): Headers;
+export declare function splitCookiesString(cookiesString: string): string[];
+/**
+ * Converts a Headers object to a Node.js OutgoingHttpHeaders object. This is
+ * required to support the set-cookie header, which may have multiple values.
+ *
+ * @param headers the headers object to convert
+ * @returns the converted headers object
+ */
+export declare function toNodeOutgoingHttpHeaders(headers: Headers): OutgoingHttpHeaders;
+/**
+ * Validate the correctness of a user-provided URL.
+ */
+export declare function validateURL(url: string | URL): string;

node_modules/next/dist/server/web/utils.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    fromNodeOutgoingHttpHeaders: null,
+    splitCookiesString: null,
+    toNodeOutgoingHttpHeaders: null,
+    validateURL: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    fromNodeOutgoingHttpHeaders: function() {
+        return fromNodeOutgoingHttpHeaders;
+    },
+    splitCookiesString: function() {
+        return splitCookiesString;
+    },
+    toNodeOutgoingHttpHeaders: function() {
+        return toNodeOutgoingHttpHeaders;
+    },
+    validateURL: function() {
+        return validateURL;
+    }
+});
+function fromNodeOutgoingHttpHeaders(nodeHeaders) {
+    const headers = new Headers();
+    for (let [key, value] of Object.entries(nodeHeaders)){
+        const values = Array.isArray(value) ? value : [
+            value
+        ];
+        for (let v of values){
+            if (typeof v === "undefined") continue;
+            if (typeof v === "number") {
+                v = v.toString();
+            }
+            headers.append(key, v);
+        }
+    }
+    return headers;
+}
+function splitCookiesString(cookiesString) {
+    var cookiesStrings = [];
+    var pos = 0;
+    var start;
+    var ch;
+    var lastComma;
+    var nextStart;
+    var cookiesSeparatorFound;
+    function skipWhitespace() {
+        while(pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))){
+            pos += 1;
+        }
+        return pos < cookiesString.length;
+    }
+    function notSpecialChar() {
+        ch = cookiesString.charAt(pos);
+        return ch !== "=" && ch !== ";" && ch !== ",";
+    }
+    while(pos < cookiesString.length){
+        start = pos;
+        cookiesSeparatorFound = false;
+        while(skipWhitespace()){
+            ch = cookiesString.charAt(pos);
+            if (ch === ",") {
+                // ',' is a cookie separator if we have later first '=', not ';' or ','
+                lastComma = pos;
+                pos += 1;
+                skipWhitespace();
+                nextStart = pos;
+                while(pos < cookiesString.length && notSpecialChar()){
+                    pos += 1;
+                }
+                // currently special character
+                if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+                    // we found cookies separator
+                    cookiesSeparatorFound = true;
+                    // pos is inside the next cookie, so back up and return it.
+                    pos = nextStart;
+                    cookiesStrings.push(cookiesString.substring(start, lastComma));
+                    start = pos;
+                } else {
+                    // in param ',' or param separator ';',
+                    // we continue from that comma
+                    pos = lastComma + 1;
+                }
+            } else {
+                pos += 1;
+            }
+        }
+        if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+            cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+        }
+    }
+    return cookiesStrings;
+}
+function toNodeOutgoingHttpHeaders(headers) {
+    const nodeHeaders = {};
+    const cookies = [];
+    if (headers) {
+        for (const [key, value] of headers.entries()){
+            if (key.toLowerCase() === "set-cookie") {
+                // We may have gotten a comma joined string of cookies, or multiple
+                // set-cookie headers. We need to merge them into one header array
+                // to represent all the cookies.
+                cookies.push(...splitCookiesString(value));
+                nodeHeaders[key] = cookies.length === 1 ? cookies[0] : cookies;
+            } else {
+                nodeHeaders[key] = value;
+            }
+        }
+    }
+    return nodeHeaders;
+}
+function validateURL(url) {
+    try {
+        return String(new URL(String(url)));
+    } catch (error) {
+        throw new Error(`URL is malformed "${String(url)}". Please use only absolute URLs - https://nextjs.org/docs/messages/middleware-relative-urls`, {
+            cause: error
+        });
+    }
+}
+
+//# sourceMappingURL=utils.js.map

node_modules/next/dist/server/web/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/web/utils.ts"],"names":["fromNodeOutgoingHttpHeaders","splitCookiesString","toNodeOutgoingHttpHeaders","validateURL","nodeHeaders","headers","Headers","key","value","Object","entries","values","Array","isArray","v","toString","append","cookiesString","cookiesStrings","pos","start","ch","lastComma","nextStart","cookiesSeparatorFound","skipWhitespace","length","test","charAt","notSpecialChar","push","substring","cookies","toLowerCase","url","String","URL","error","Error","cause"],"mappings":"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"}

node_modules/next/dist/server/web/utils.test.d.ts

@@ -0,0 +1 @@
+export {};