fixed version control heatmap and activity

.next/standalone/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

.next/standalone/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

.next/standalone/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

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

@@ -0,0 +1,421 @@
+"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() {
+    const pairs = Object.keys(process.env).map((key)=>[
+            key,
+            process.env[key]
+        ]);
+    const env = Object.fromEntries(pairs);
+    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() {
+    const processPolyfill = {
+        env: buildEnvironmentVariablesFrom()
+    };
+    const overridenValue = {};
+    for (const key of Object.keys(process)){
+        if (key === "env") continue;
+        Object.defineProperty(processPolyfill, key, {
+            get () {
+                if (overridenValue[key] !== undefined) {
+                    return overridenValue[key];
+                }
+                if (typeof process[key] === "function") {
+                    return ()=>throwUnsupportedAPIError(`process.${key}`);
+                }
+                return undefined;
+            },
+            set (value) {
+                overridenValue[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 wasm = await loadWasm(options.edgeFunctionEntry.wasm ?? []);
+    const runtime = new _edgeruntime.EdgeRuntime({
+        codeGeneration: process.env.NODE_ENV !== "production" ? {
+            strings: true,
+            wasm: true
+        } : undefined,
+        extend: (context)=>{
+            context.process = createProcessPolyfill();
+            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

.next/standalone/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

.next/standalone/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

.next/standalone/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

.next/standalone/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

.next/standalone/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

.next/standalone/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

.next/standalone/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

.next/standalone/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

.next/standalone/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

.next/standalone/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

.next/standalone/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