main repo

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 = {
+    ReadonlyHeadersError: null,
+    HeadersAdapter: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ReadonlyHeadersError: function() {
+        return ReadonlyHeadersError;
+    },
+    HeadersAdapter: function() {
+        return HeadersAdapter;
+    }
+});
+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":["ReadonlyHeadersError","HeadersAdapter","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 @@
+import '../../../node-polyfill-fetch';

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

@@ -0,0 +1,20 @@
+/// <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';
+/**
+ * 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,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    signalFromNodeResponse: null,
+    NextRequestAdapter: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    signalFromNodeResponse: function() {
+        return signalFromNodeResponse;
+    },
+    NextRequestAdapter: function() {
+        return NextRequestAdapter;
+    }
+});
+const _requestmeta = require("../../../request-meta");
+const _utils = require("../../utils");
+const _request = require("../request");
+function signalFromNodeResponse(response) {
+    const { errored, destroyed } = response;
+    if (errored || destroyed) return AbortSignal.abort(errored);
+    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.
+    function onClose() {
+        controller.abort();
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        response.off("finish", onFinish);
+    }
+    function onFinish() {
+        response.off("close", onClose);
+    }
+    response.once("close", onClose);
+    response.once("finish", onFinish);
+    return controller.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, "__NEXT_INIT_URL");
+            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, {
+            body,
+            method: request.method,
+            headers: (0, _utils.fromNodeOutgoingHttpHeaders)(request.headers),
+            // @ts-expect-error - see https://github.com/whatwg/fetch/pull/1457
+            duplex: "half",
+            signal
+        });
+    }
+    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, {
+            body,
+            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
+        });
+    }
+}
+
+//# 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":["signalFromNodeResponse","NextRequestAdapter","response","errored","destroyed","AbortSignal","abort","controller","AbortController","onClose","off","onFinish","once","signal","fromBaseNextRequest","request","fromWebNextRequest","fromNodeNextRequest","body","method","url","startsWith","URL","base","getRequestMeta","NextRequest","headers","fromNodeOutgoingHttpHeaders","duplex"],"mappings":";;;;;;;;;;;;;;;IAiBgBA,sBAAsB;eAAtBA;;IAsBHC,kBAAkB;eAAlBA;;;6BAlCkB;uBACa;yBAChB;AAUrB,SAASD,uBAAuBE,QAAkB;IACvD,MAAM,EAAEC,OAAO,EAAEC,SAAS,EAAE,GAAGF;IAC/B,IAAIC,WAAWC,WAAW,OAAOC,YAAYC,KAAK,CAACH;IAEnD,MAAMI,aAAa,IAAIC;IACvB,6EAA6E;IAC7E,4EAA4E;IAC5E,mDAAmD;IACnD,SAASC;QACPF,WAAWD,KAAK;QAChB,mEAAmE;QACnEJ,SAASQ,GAAG,CAAC,UAAUC;IACzB;IACA,SAASA;QACPT,SAASQ,GAAG,CAAC,SAASD;IACxB;IACAP,SAASU,IAAI,CAAC,SAASH;IACvBP,SAASU,IAAI,CAAC,UAAUD;IAExB,OAAOJ,WAAWM,MAAM;AAC1B;AAEO,MAAMZ;IACX,OAAca,oBACZC,OAAwB,EACxBF,MAAmB,EACN;QACb,oCAAoC;QACpC,IAAI,aAAaE,WAAW,AAACA,QAA2BA,OAAO,EAAE;YAC/D,OAAOd,mBAAmBe,kBAAkB,CAACD;QAC/C;QAEA,OAAOd,mBAAmBgB,mBAAmB,CAC3CF,SACAF;IAEJ;IAEA,OAAcI,oBACZF,OAAwB,EACxBF,MAAmB,EACN;QACb,6CAA6C;QAC7C,IAAIK,OAAwB;QAC5B,IAAIH,QAAQI,MAAM,KAAK,SAASJ,QAAQI,MAAM,KAAK,UAAUJ,QAAQG,IAAI,EAAE;YACzE,qFAAqF;YACrFA,OAAOH,QAAQG,IAAI;QACrB;QAEA,IAAIE;QACJ,IAAIL,QAAQK,GAAG,CAACC,UAAU,CAAC,SAAS;YAClCD,MAAM,IAAIE,IAAIP,QAAQK,GAAG;QAC3B,OAAO;YACL,+CAA+C;YAC/C,MAAMG,OAAOC,IAAAA,2BAAc,EAACT,SAAS;YACrC,IAAI,CAACQ,QAAQ,CAACA,KAAKF,UAAU,CAAC,SAAS;gBACrC,wEAAwE;gBACxE,uEAAuE;gBACvE,4DAA4D;gBAC5DD,MAAM,IAAIE,IAAIP,QAAQK,GAAG,EAAE;YAC7B,OAAO;gBACLA,MAAM,IAAIE,IAAIP,QAAQK,GAAG,EAAEG;YAC7B;QACF;QAEA,OAAO,IAAIE,oBAAW,CAACL,KAAK;YAC1BF;YACAC,QAAQJ,QAAQI,MAAM;YACtBO,SAASC,IAAAA,kCAA2B,EAACZ,QAAQW,OAAO;YACpD,mEAAmE;YACnEE,QAAQ;YACRf;QAIF;IACF;IAEA,OAAcG,mBAAmBD,OAAuB,EAAe;QACrE,6CAA6C;QAC7C,IAAIG,OAA8B;QAClC,IAAIH,QAAQI,MAAM,KAAK,SAASJ,QAAQI,MAAM,KAAK,QAAQ;YACzDD,OAAOH,QAAQG,IAAI;QACrB;QAEA,OAAO,IAAIO,oBAAW,CAACV,QAAQK,GAAG,EAAE;YAClCF;YACAC,QAAQJ,QAAQI,MAAM;YACtBO,SAASC,IAAAA,kCAA2B,EAACZ,QAAQW,OAAO;YACpD,mEAAmE;YACnEE,QAAQ;YACRf,QAAQE,QAAQA,OAAO,CAACF,MAAM;QAIhC;IACF;AACF"}

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 = {
+    ReadonlyRequestCookiesError: null,
+    RequestCookiesAdapter: null,
+    getModifiedCookieValues: null,
+    appendMutableCookies: null,
+    MutableRequestCookiesAdapter: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ReadonlyRequestCookiesError: function() {
+        return ReadonlyRequestCookiesError;
+    },
+    RequestCookiesAdapter: function() {
+        return RequestCookiesAdapter;
+    },
+    getModifiedCookieValues: function() {
+        return getModifiedCookieValues;
+    },
+    appendMutableCookies: function() {
+        return appendMutableCookies;
+    },
+    MutableRequestCookiesAdapter: function() {
+        return MutableRequestCookiesAdapter;
+    }
+});
+const _cookies = require("../cookies");
+const _reflect = require("./reflect");
+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 responseCookes = new _cookies.ResponseCookies(new Headers());
+        for (const cookie of cookies.getAll()){
+            responseCookes.set(cookie);
+        }
+        let modifiedValues = [];
+        const modifiedCookies = new Set();
+        const updateResponseCookies = ()=>{
+            var _fetch___nextGetStaticStore;
+            // TODO-APP: change method of getting staticGenerationAsyncStore
+            const staticGenerationAsyncStore = fetch.__nextGetStaticStore == null ? void 0 : (_fetch___nextGetStaticStore = fetch.__nextGetStaticStore.call(fetch)) == null ? void 0 : _fetch___nextGetStaticStore.getStore();
+            if (staticGenerationAsyncStore) {
+                staticGenerationAsyncStore.pathWasRevalidated = true;
+            }
+            const allCookies = responseCookes.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(responseCookes, {
+            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":["ReadonlyRequestCookiesError","RequestCookiesAdapter","getModifiedCookieValues","appendMutableCookies","MutableRequestCookiesAdapter","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","responseCookes","Headers","modifiedValues","modifiedCookies","Set","updateResponseCookies","staticGenerationAsyncStore","fetch","__nextGetStaticStore","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 @@
+import '../../../node-polyfill-fetch';

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

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

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    RequestCookies: null,
+    ResponseCookies: 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;
+    }
+});
+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"],"mappings":";;;;;;;;;;;;;;;IACEA,cAAc;eAAdA,uBAAc;;IACdC,eAAe;eAAfA,wBAAe;;;yBACV"}

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

@@ -0,0 +1,33 @@
+import { 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 = {
+    waitUntilSymbol: null,
+    NextFetchEvent: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    waitUntilSymbol: function() {
+        return waitUntilSymbol;
+    },
+    NextFetchEvent: function() {
+        return NextFetchEvent;
+    }
+});
+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":["waitUntilSymbol","NextFetchEvent","responseSymbol","Symbol","passThroughSymbol","FetchEvent","constructor","_request","respondWith","response","Promise","resolve","passThroughOnException","waitUntil","promise","push","params","request","sourcePage","page","PageSignatureError"],"mappings":";;;;;;;;;;;;;;;IAKaA,eAAe;eAAfA;;IAyBAC,cAAc;eAAdA;;;uBA9BsB;AAGnC,MAAMC,iBAAiBC,OAAO;AAC9B,MAAMC,oBAAoBD,OAAO;AAC1B,MAAMH,kBAAkBG,OAAO;AAEtC,MAAME;IAKJ,qEAAqE;IACrEC,YAAYC,QAAiB,CAAE;YALtB,CAACP,gBAAgB,GAAmB,EAAE;YAE/C,CAACI,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,CAACd,gBAAgB,CAACe,IAAI,CAACD;IAC7B;AACF;AAEO,MAAMb,uBAAuBI;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,4 @@
+export declare class ImageResponse extends Response {
+    static displayName: string;
+    constructor(...args: ConstructorParameters<typeof import('next/dist/compiled/@vercel/og').ImageResponse>);
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ImageResponse", {
+    enumerable: true,
+    get: function() {
+        return ImageResponse;
+    }
+});
+class ImageResponse extends Response {
+    static #_ = this.displayName = "NextImageResponse";
+    constructor(...args){
+        const readable = new ReadableStream({
+            async start (controller) {
+                const OGImageResponse = // So far we have to manually determine which build to use,
+                // as the auto resolving is not working
+                (await import(process.env.NEXT_RUNTIME === "edge" ? "next/dist/compiled/@vercel/og/index.edge.js" : "next/dist/compiled/@vercel/og/index.node.js")).ImageResponse;
+                const imageResponse = new OGImageResponse(...args);
+                if (!imageResponse.body) {
+                    return controller.close();
+                }
+                const reader = imageResponse.body.getReader();
+                while(true){
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        return controller.close();
+                    }
+                    controller.enqueue(value);
+                }
+            }
+        });
+        const options = args[1] || {};
+        super(readable, {
+            headers: {
+                "content-type": "image/png",
+                "cache-control": process.env.NODE_ENV === "development" ? "no-cache, no-store" : "public, immutable, no-transform, max-age=31536000",
+                ...options.headers
+            },
+            status: options.status,
+            statusText: options.statusText
+        });
+    }
+}
+
+//# 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","Response","displayName","constructor","args","readable","ReadableStream","start","controller","OGImageResponse","process","env","NEXT_RUNTIME","imageResponse","body","close","reader","getReader","done","value","read","enqueue","options","headers","NODE_ENV","status","statusText"],"mappings":";;;;+BAAaA;;;eAAAA;;;AAAN,MAAMA,sBAAsBC;qBACnBC,cAAc;IAC5BC,YACE,GAAGC,IAEF,CACD;QACA,MAAMC,WAAW,IAAIC,eAAe;YAClC,MAAMC,OAAMC,UAAU;gBACpB,MAAMC,kBAGJ,AAFA,2DAA2D;gBAC3D,uCAAuC;gBAErC,CAAA,MAAM,MAAM,CACVC,QAAQC,GAAG,CAACC,YAAY,KAAK,SACzB,gDACA,8CACN,EACAZ,aAAa;gBACjB,MAAMa,gBAAgB,IAAIJ,mBAAmBL;gBAE7C,IAAI,CAACS,cAAcC,IAAI,EAAE;oBACvB,OAAON,WAAWO,KAAK;gBACzB;gBAEA,MAAMC,SAASH,cAAcC,IAAI,CAAEG,SAAS;gBAC5C,MAAO,KAAM;oBACX,MAAM,EAAEC,IAAI,EAAEC,KAAK,EAAE,GAAG,MAAMH,OAAOI,IAAI;oBACzC,IAAIF,MAAM;wBACR,OAAOV,WAAWO,KAAK;oBACzB;oBACAP,WAAWa,OAAO,CAACF;gBACrB;YACF;QACF;QAEA,MAAMG,UAAUlB,IAAI,CAAC,EAAE,IAAI,CAAC;QAE5B,KAAK,CAACC,UAAU;YACdkB,SAAS;gBACP,gBAAgB;gBAChB,iBACEb,QAAQC,GAAG,CAACa,QAAQ,KAAK,gBACrB,uBACA;gBACN,GAAGF,QAAQC,OAAO;YACpB;YACAE,QAAQH,QAAQG,MAAM;YACtBC,YAAYJ,QAAQI,UAAU;QAChC;IACF;AACF"}

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

@@ -0,0 +1,52 @@
+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;
+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;;IAEAC,WAAW;eAAXA;;;yBAPW;uBAC+B;uBACN;yBAClB;AAExB,MAAMD,YAAYE,OAAO;AAEzB,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,38 @@
+import type { I18NConfig } from '../../config-shared';
+import { NextURL } from '../next-url';
+import { ResponseCookies } from './cookies';
+declare const INTERNALS: unique symbol;
+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,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NextResponse", {
+    enumerable: true,
+    get: function() {
+        return NextResponse;
+    }
+});
+const _nexturl = require("../next-url");
+const _utils = require("../utils");
+const _cookies = 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);
+        this[INTERNALS] = {
+            cookies: new _cookies.ResponseCookies(this.headers),
+            url: init.url ? new _nexturl.NextURL(init.url, {
+                headers: (0, _utils.toNodeOutgoingHttpHeaders)(this.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","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-path.d.ts

@@ -0,0 +1 @@
+export declare function revalidatePath(originalPath: string, type?: 'layout' | 'page'): void;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "revalidatePath", {
+    enumerable: true,
+    get: function() {
+        return revalidatePath;
+    }
+});
+const _revalidatetag = require("./revalidate-tag");
+const _utils = require("../../../shared/lib/router/utils");
+const _constants = require("../../../lib/constants");
+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" without the "page" argument. This has no affect by default, see more info here https://nextjs.org/docs/app/api-reference/functions/revalidatePath`);
+    }
+    return (0, _revalidatetag.revalidateTag)(normalizedPath);
+}
+
+//# sourceMappingURL=revalidate-path.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/spec-extension/revalidate-path.ts"],"names":["revalidatePath","originalPath","type","length","NEXT_CACHE_SOFT_TAG_MAX_LENGTH","console","warn","normalizedPath","NEXT_CACHE_IMPLICIT_TAG_ID","endsWith","isDynamicRoute","revalidateTag"],"mappings":";;;;+BAOgBA;;;eAAAA;;;+BAPc;uBACC;2BAIxB;AAEA,SAASA,eAAeC,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,kLAAkL,CAAC;IAErO;IACA,OAAOU,IAAAA,4BAAa,EAACJ;AACvB"}

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

@@ -0,0 +1 @@
+export declare function revalidateTag(tag: string): void;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "revalidateTag", {
+    enumerable: true,
+    get: function() {
+        return revalidateTag;
+    }
+});
+function revalidateTag(tag) {
+    const staticGenerationAsyncStorage = fetch.__nextGetStaticStore == null ? void 0 : fetch.__nextGetStaticStore.call(fetch);
+    const store = staticGenerationAsyncStorage == null ? void 0 : staticGenerationAsyncStorage.getStore();
+    if (!store || !store.incrementalCache) {
+        throw new Error(`Invariant: static generation store missing in revalidateTag ${tag}`);
+    }
+    if (!store.revalidatedTags) {
+        store.revalidatedTags = [];
+    }
+    if (!store.revalidatedTags.includes(tag)) {
+        store.revalidatedTags.push(tag);
+    }
+    if (!store.pendingRevalidates) {
+        store.pendingRevalidates = [];
+    }
+    store.pendingRevalidates.push(store.incrementalCache.revalidateTag == null ? void 0 : store.incrementalCache.revalidateTag.call(store.incrementalCache, tag).catch((err)=>{
+        console.error(`revalidateTag failed for ${tag}`, err);
+    }));
+    // TODO: only revalidate if the path matches
+    store.pathWasRevalidated = true;
+}
+
+//# sourceMappingURL=revalidate-tag.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/spec-extension/revalidate-tag.ts"],"names":["revalidateTag","tag","staticGenerationAsyncStorage","fetch","__nextGetStaticStore","store","getStore","incrementalCache","Error","revalidatedTags","includes","push","pendingRevalidates","catch","err","console","error","pathWasRevalidated"],"mappings":";;;;+BAKgBA;;;eAAAA;;;AAAT,SAASA,cAAcC,GAAW;IACvC,MAAMC,+BAA+B,AACnCC,MACAC,oBAAoB,oBAFe,AACnCD,MACAC,oBAAoB,MADpBD;IAGF,MAAME,QACJH,gDAAAA,6BAA8BI,QAAQ;IAExC,IAAI,CAACD,SAAS,CAACA,MAAME,gBAAgB,EAAE;QACrC,MAAM,IAAIC,MACR,CAAC,4DAA4D,EAAEP,IAAI,CAAC;IAExE;IACA,IAAI,CAACI,MAAMI,eAAe,EAAE;QAC1BJ,MAAMI,eAAe,GAAG,EAAE;IAC5B;IACA,IAAI,CAACJ,MAAMI,eAAe,CAACC,QAAQ,CAACT,MAAM;QACxCI,MAAMI,eAAe,CAACE,IAAI,CAACV;IAC7B;IAEA,IAAI,CAACI,MAAMO,kBAAkB,EAAE;QAC7BP,MAAMO,kBAAkB,GAAG,EAAE;IAC/B;IACAP,MAAMO,kBAAkB,CAACD,IAAI,CAC3BN,MAAME,gBAAgB,CAACP,aAAa,oBAApCK,MAAME,gBAAgB,CAACP,aAAa,MAApCK,MAAME,gBAAgB,EAAiBN,KAAKY,KAAK,CAAC,CAACC;QACjDC,QAAQC,KAAK,CAAC,CAAC,yBAAyB,EAAEf,IAAI,CAAC,EAAEa;IACnD;IAGF,4CAA4C;IAC5CT,MAAMY,kBAAkB,GAAG;AAC7B"}

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

@@ -0,0 +1,6 @@
+type Callback = (...args: any[]) => Promise<any>;
+export declare function unstable_cache<T extends Callback>(cb: T, keyParts?: string[], options?: {
+    revalidate?: number | false;
+    tags?: string[];
+}): T;
+export {};

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "unstable_cache", {
+    enumerable: true,
+    get: function() {
+        return unstable_cache;
+    }
+});
+const _staticgenerationasyncstorageexternal = require("../../../client/components/static-generation-async-storage.external");
+const _constants = require("../../../lib/constants");
+const _patchfetch = require("../../lib/patch-fetch");
+function unstable_cache(cb, keyParts, options = {}) {
+    const staticGenerationAsyncStorage = (fetch.__nextGetStaticStore == null ? void 0 : fetch.__nextGetStaticStore.call(fetch)) || _staticgenerationasyncstorageexternal.staticGenerationAsyncStorage;
+    if (options.revalidate === 0) {
+        throw new Error(`Invariant revalidate: 0 can not be passed to unstable_cache(), must be "false" or "> 0" ${cb.toString()}`);
+    }
+    const cachedCb = async (...args)=>{
+        const store = staticGenerationAsyncStorage == null ? void 0 : staticGenerationAsyncStorage.getStore();
+        const incrementalCache = (store == null ? void 0 : store.incrementalCache) || globalThis.__incrementalCache;
+        if (!incrementalCache) {
+            throw new Error(`Invariant: incrementalCache missing in unstable_cache ${cb.toString()}`);
+        }
+        const joinedKey = `${cb.toString()}-${Array.isArray(keyParts) && keyParts.join(",")}-${JSON.stringify(args)}`;
+        // We override the default fetch cache handling inside of the
+        // cache callback so that we only cache the specific values returned
+        // from the callback instead of also caching any fetches done inside
+        // of the callback as well
+        return staticGenerationAsyncStorage.run({
+            ...store,
+            fetchCache: "only-no-store",
+            urlPathname: (store == null ? void 0 : store.urlPathname) || "/",
+            isStaticGeneration: !!(store == null ? void 0 : store.isStaticGeneration)
+        }, async ()=>{
+            const tags = (0, _patchfetch.validateTags)(options.tags || [], `unstable_cache ${cb.toString()}`);
+            if (Array.isArray(tags) && store) {
+                if (!store.tags) {
+                    store.tags = [];
+                }
+                for (const tag of tags){
+                    if (!store.tags.includes(tag)) {
+                        store.tags.push(tag);
+                    }
+                }
+            }
+            const implicitTags = (0, _patchfetch.addImplicitTags)(store);
+            const cacheKey = await (incrementalCache == null ? void 0 : incrementalCache.fetchCacheKey(joinedKey));
+            const cacheEntry = cacheKey && !((store == null ? void 0 : store.isOnDemandRevalidate) || incrementalCache.isOnDemandRevalidate) && await (incrementalCache == null ? void 0 : incrementalCache.get(cacheKey, {
+                fetchCache: true,
+                revalidate: options.revalidate,
+                tags,
+                softTags: implicitTags
+            }));
+            const invokeCallback = async ()=>{
+                const result = await cb(...args);
+                if (cacheKey && incrementalCache) {
+                    await incrementalCache.set(cacheKey, {
+                        kind: "FETCH",
+                        data: {
+                            headers: {},
+                            // TODO: handle non-JSON values?
+                            body: JSON.stringify(result),
+                            status: 200,
+                            url: ""
+                        },
+                        revalidate: typeof options.revalidate !== "number" ? _constants.CACHE_ONE_YEAR : options.revalidate
+                    }, {
+                        revalidate: options.revalidate,
+                        fetchCache: true,
+                        tags
+                    });
+                }
+                return result;
+            };
+            if (!cacheEntry || !cacheEntry.value) {
+                return invokeCallback();
+            }
+            if (cacheEntry.value.kind !== "FETCH") {
+                console.error(`Invariant invalid cacheEntry returned for ${joinedKey}`);
+                return invokeCallback();
+            }
+            let cachedValue;
+            const isStale = cacheEntry.isStale;
+            if (cacheEntry) {
+                const resData = cacheEntry.value.data;
+                cachedValue = JSON.parse(resData.body);
+            }
+            if (isStale) {
+                if (!store) {
+                    return invokeCallback();
+                } else {
+                    if (!store.pendingRevalidates) {
+                        store.pendingRevalidates = [];
+                    }
+                    store.pendingRevalidates.push(invokeCallback().catch((err)=>console.error(`revalidating cache with key: ${joinedKey}`, err)));
+                }
+            }
+            return cachedValue;
+        });
+    };
+    // 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-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/web/spec-extension/unstable-cache.ts"],"names":["unstable_cache","cb","keyParts","options","staticGenerationAsyncStorage","fetch","__nextGetStaticStore","_staticGenerationAsyncStorage","revalidate","Error","toString","cachedCb","args","store","getStore","incrementalCache","globalThis","__incrementalCache","joinedKey","Array","isArray","join","JSON","stringify","run","fetchCache","urlPathname","isStaticGeneration","tags","validateTags","tag","includes","push","implicitTags","addImplicitTags","cacheKey","fetchCacheKey","cacheEntry","isOnDemandRevalidate","get","softTags","invokeCallback","result","set","kind","data","headers","body","status","url","CACHE_ONE_YEAR","value","console","error","cachedValue","isStale","resData","parse","pendingRevalidates","catch","err"],"mappings":"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"}

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,
+    userAgentFromString: null,
+    userAgent: 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;
+    },
+    userAgentFromString: function() {
+        return userAgentFromString;
+    },
+    userAgent: function() {
+        return userAgent;
+    }
+});
+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","userAgentFromString","userAgent","input","test","parseua","undefined","headers","get"],"mappings":";;;;;;;;;;;;;;;;IA2BgBA,KAAK;eAALA;;IAMAC,mBAAmB;eAAnBA;;IAOAC,SAAS;eAATA;;;mEAxCI;;;;;;AA2Bb,SAASF,MAAMG,KAAa;IACjC,OAAO,0WAA0WC,IAAI,CACnXD;AAEJ;AAEO,SAASF,oBAAoBE,KAAyB;IAC3D,OAAO;QACL,GAAGE,IAAAA,mBAAO,EAACF,MAAM;QACjBH,OAAOG,UAAUG,YAAY,QAAQN,MAAMG;IAC7C;AACF;AAEO,SAASD,UAAU,EAAEK,OAAO,EAAwB;IACzD,OAAON,oBAAoBM,QAAQC,GAAG,CAAC,iBAAiBF;AAC1D"}