main repo

node_modules/next/dist/esm/server/app-render/action-handler.js

@@ -0,0 +1,345 @@
+import { ACTION, RSC, RSC_CONTENT_TYPE_HEADER } from "../../client/components/app-router-headers";
+import { isNotFoundError } from "../../client/components/not-found";
+import { getURLFromRedirectError, isRedirectError } from "../../client/components/redirect";
+import RenderResult from "../render-result";
+import { FlightRenderResult } from "./flight-render-result";
+import { filterReqHeaders, actionsForbiddenHeaders } from "../lib/server-ipc/utils";
+import { appendMutableCookies, getModifiedCookieValues } from "../web/spec-extension/adapters/request-cookies";
+import { NEXT_CACHE_REVALIDATED_TAGS_HEADER, NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER } from "../../lib/constants";
+function nodeToWebReadableStream(nodeReadable) {
+    if (process.env.NEXT_RUNTIME !== "edge") {
+        const { Readable } = require("stream");
+        if ("toWeb" in Readable && typeof Readable.toWeb === "function") {
+            return Readable.toWeb(nodeReadable);
+        }
+        return new ReadableStream({
+            start (controller) {
+                nodeReadable.on("data", (chunk)=>{
+                    controller.enqueue(chunk);
+                });
+                nodeReadable.on("end", ()=>{
+                    controller.close();
+                });
+                nodeReadable.on("error", (error)=>{
+                    controller.error(error);
+                });
+            }
+        });
+    } else {
+        throw new Error("Invalid runtime");
+    }
+}
+function formDataFromSearchQueryString(query) {
+    const searchParams = new URLSearchParams(query);
+    const formData = new FormData();
+    for (const [key, value] of searchParams){
+        formData.append(key, value);
+    }
+    return formData;
+}
+function nodeHeadersToRecord(headers) {
+    const record = {};
+    for (const [key, value] of Object.entries(headers)){
+        if (value !== undefined) {
+            record[key] = Array.isArray(value) ? value.join(", ") : `${value}`;
+        }
+    }
+    return record;
+}
+function getForwardedHeaders(req, res) {
+    // Get request headers and cookies
+    const requestHeaders = req.headers;
+    const requestCookies = requestHeaders["cookie"] ?? "";
+    // Get response headers and Set-Cookie header
+    const responseHeaders = res.getHeaders();
+    const rawSetCookies = responseHeaders["set-cookie"];
+    const setCookies = (Array.isArray(rawSetCookies) ? rawSetCookies : [
+        rawSetCookies
+    ]).map((setCookie)=>{
+        // remove the suffixes like 'HttpOnly' and 'SameSite'
+        const [cookie] = `${setCookie}`.split(";");
+        return cookie;
+    });
+    // Merge request and response headers
+    const mergedHeaders = filterReqHeaders({
+        ...nodeHeadersToRecord(requestHeaders),
+        ...nodeHeadersToRecord(responseHeaders)
+    }, actionsForbiddenHeaders);
+    // Merge cookies
+    const mergedCookies = requestCookies.split("; ").concat(setCookies).join("; ");
+    // Update the 'cookie' header with the merged cookies
+    mergedHeaders["cookie"] = mergedCookies;
+    // Remove headers that should not be forwarded
+    delete mergedHeaders["transfer-encoding"];
+    return new Headers(mergedHeaders);
+}
+async function addRevalidationHeader(res, { staticGenerationStore, requestStore }) {
+    var _staticGenerationStore_revalidatedTags;
+    await Promise.all(staticGenerationStore.pendingRevalidates || []);
+    // If a tag was revalidated, the client router needs to invalidate all the
+    // client router cache as they may be stale. And if a path was revalidated, the
+    // client needs to invalidate all subtrees below that path.
+    // To keep the header size small, we use a tuple of
+    // [[revalidatedPaths], isTagRevalidated ? 1 : 0, isCookieRevalidated ? 1 : 0]
+    // instead of a JSON object.
+    // TODO-APP: Currently the prefetch cache doesn't have subtree information,
+    // so we need to invalidate the entire cache if a path was revalidated.
+    // TODO-APP: Currently paths are treated as tags, so the second element of the tuple
+    // is always empty.
+    const isTagRevalidated = ((_staticGenerationStore_revalidatedTags = staticGenerationStore.revalidatedTags) == null ? void 0 : _staticGenerationStore_revalidatedTags.length) ? 1 : 0;
+    const isCookieRevalidated = getModifiedCookieValues(requestStore.mutableCookies).length ? 1 : 0;
+    res.setHeader("x-action-revalidated", JSON.stringify([
+        [],
+        isTagRevalidated,
+        isCookieRevalidated
+    ]));
+}
+async function createRedirectRenderResult(req, res, redirectUrl, staticGenerationStore) {
+    res.setHeader("x-action-redirect", redirectUrl);
+    // if we're redirecting to a relative path, we'll try to stream the response
+    if (redirectUrl.startsWith("/")) {
+        var _staticGenerationStore_incrementalCache;
+        const forwardedHeaders = getForwardedHeaders(req, res);
+        forwardedHeaders.set(RSC, "1");
+        const host = req.headers["host"];
+        const proto = ((_staticGenerationStore_incrementalCache = staticGenerationStore.incrementalCache) == null ? void 0 : _staticGenerationStore_incrementalCache.requestProtocol) || "https";
+        const fetchUrl = new URL(`${proto}://${host}${redirectUrl}`);
+        if (staticGenerationStore.revalidatedTags) {
+            var _staticGenerationStore_incrementalCache_prerenderManifest_preview, _staticGenerationStore_incrementalCache_prerenderManifest, _staticGenerationStore_incrementalCache1;
+            forwardedHeaders.set(NEXT_CACHE_REVALIDATED_TAGS_HEADER, staticGenerationStore.revalidatedTags.join(","));
+            forwardedHeaders.set(NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER, ((_staticGenerationStore_incrementalCache1 = staticGenerationStore.incrementalCache) == null ? void 0 : (_staticGenerationStore_incrementalCache_prerenderManifest = _staticGenerationStore_incrementalCache1.prerenderManifest) == null ? void 0 : (_staticGenerationStore_incrementalCache_prerenderManifest_preview = _staticGenerationStore_incrementalCache_prerenderManifest.preview) == null ? void 0 : _staticGenerationStore_incrementalCache_prerenderManifest_preview.previewModeId) || "");
+        }
+        // Ensures that when the path was revalidated we don't return a partial response on redirects
+        // if (staticGenerationStore.pathWasRevalidated) {
+        forwardedHeaders.delete("next-router-state-tree");
+        // }
+        try {
+            const headResponse = await fetch(fetchUrl, {
+                method: "HEAD",
+                headers: forwardedHeaders,
+                next: {
+                    // @ts-ignore
+                    internal: 1
+                }
+            });
+            if (headResponse.headers.get("content-type") === RSC_CONTENT_TYPE_HEADER) {
+                const response = await fetch(fetchUrl, {
+                    method: "GET",
+                    headers: forwardedHeaders,
+                    next: {
+                        // @ts-ignore
+                        internal: 1
+                    }
+                });
+                // copy the headers from the redirect response to the response we're sending
+                for (const [key, value] of response.headers){
+                    if (!actionsForbiddenHeaders.includes(key)) {
+                        res.setHeader(key, value);
+                    }
+                }
+                return new FlightRenderResult(response.body);
+            }
+        } catch (err) {
+            // we couldn't stream the redirect response, so we'll just do a normal redirect
+            console.error(`failed to get redirect response`, err);
+        }
+    }
+    return new RenderResult(JSON.stringify({}));
+}
+export async function handleAction({ req, res, ComponentMod, page, serverActionsManifest, generateFlight, staticGenerationStore, requestStore, serverActionsBodySizeLimit }) {
+    let actionId = req.headers[ACTION.toLowerCase()];
+    const contentType = req.headers["content-type"];
+    const isURLEncodedAction = req.method === "POST" && contentType === "application/x-www-form-urlencoded";
+    const isMultipartAction = req.method === "POST" && (contentType == null ? void 0 : contentType.startsWith("multipart/form-data"));
+    const isFetchAction = actionId !== undefined && typeof actionId === "string" && req.method === "POST";
+    if (isFetchAction || isURLEncodedAction || isMultipartAction) {
+        // ensure we avoid caching server actions unexpectedly
+        res.setHeader("Cache-Control", "no-cache, no-store, max-age=0, must-revalidate");
+        let bound = [];
+        const workerName = "app" + page;
+        const serverModuleMap = new Proxy({}, {
+            get: (_, id)=>{
+                return {
+                    id: serverActionsManifest[process.env.NEXT_RUNTIME === "edge" ? "edge" : "node"][id].workers[workerName],
+                    name: id,
+                    chunks: []
+                };
+            }
+        });
+        const { actionAsyncStorage } = ComponentMod;
+        let actionResult;
+        try {
+            await actionAsyncStorage.run({
+                isAction: true
+            }, async ()=>{
+                if (process.env.NEXT_RUNTIME === "edge") {
+                    // Use react-server-dom-webpack/server.edge
+                    const { decodeReply, decodeAction } = ComponentMod;
+                    const webRequest = req;
+                    if (!webRequest.body) {
+                        throw new Error("invariant: Missing request body.");
+                    }
+                    if (isMultipartAction) {
+                        // TODO-APP: Add streaming support
+                        const formData = await webRequest.request.formData();
+                        if (isFetchAction) {
+                            bound = await decodeReply(formData, serverModuleMap);
+                        } else {
+                            const action = await decodeAction(formData, serverModuleMap);
+                            await action();
+                            // Skip the fetch path
+                            return;
+                        }
+                    } else {
+                        let actionData = "";
+                        const reader = webRequest.body.getReader();
+                        while(true){
+                            const { done, value } = await reader.read();
+                            if (done) {
+                                break;
+                            }
+                            actionData += new TextDecoder().decode(value);
+                        }
+                        if (isURLEncodedAction) {
+                            const formData = formDataFromSearchQueryString(actionData);
+                            bound = await decodeReply(formData, serverModuleMap);
+                        } else {
+                            bound = await decodeReply(actionData, serverModuleMap);
+                        }
+                    }
+                } else {
+                    // Use react-server-dom-webpack/server.node which supports streaming
+                    const { decodeReply, decodeReplyFromBusboy, decodeAction } = require(`react-server-dom-webpack/server.node`);
+                    if (isMultipartAction) {
+                        if (isFetchAction) {
+                            const busboy = require("busboy");
+                            const bb = busboy({
+                                headers: req.headers
+                            });
+                            req.pipe(bb);
+                            bound = await decodeReplyFromBusboy(bb, serverModuleMap);
+                        } else {
+                            // React doesn't yet publish a busboy version of decodeAction
+                            // so we polyfill the parsing of FormData.
+                            const UndiciRequest = require("next/dist/compiled/undici").Request;
+                            const fakeRequest = new UndiciRequest("http://localhost", {
+                                method: "POST",
+                                headers: {
+                                    "Content-Type": req.headers["content-type"]
+                                },
+                                body: nodeToWebReadableStream(req),
+                                duplex: "half"
+                            });
+                            const formData = await fakeRequest.formData();
+                            const action = await decodeAction(formData, serverModuleMap);
+                            await action();
+                            // Skip the fetch path
+                            return;
+                        }
+                    } else {
+                        const { parseBody } = require("../api-utils/node");
+                        let actionData;
+                        try {
+                            actionData = await parseBody(req, serverActionsBodySizeLimit ?? "1mb") || "";
+                        } catch (e) {
+                            if (e && e.statusCode === 413) {
+                                // Exceeded the size limit
+                                e.message = e.message + "\nTo configure the body size limit for Server Actions, see: https://nextjs.org/docs/app/api-reference/server-actions#size-limitation";
+                            }
+                            throw e;
+                        }
+                        if (isURLEncodedAction) {
+                            const formData = formDataFromSearchQueryString(actionData);
+                            bound = await decodeReply(formData, serverModuleMap);
+                        } else {
+                            bound = await decodeReply(actionData, serverModuleMap);
+                        }
+                    }
+                }
+                // actions.js
+                // app/page.js
+                //   action worker1
+                //     appRender1
+                // app/foo/page.js
+                //   action worker2
+                //     appRender
+                // / -> fire action -> POST / -> appRender1 -> modId for the action file
+                // /foo -> fire action -> POST /foo -> appRender2 -> modId for the action file
+                const actionModId = serverActionsManifest[process.env.NEXT_RUNTIME === "edge" ? "edge" : "node"][actionId].workers[workerName];
+                const actionHandler = ComponentMod.__next_app__.require(actionModId)[actionId];
+                const returnVal = await actionHandler.apply(null, bound);
+                // For form actions, we need to continue rendering the page.
+                if (isFetchAction) {
+                    await addRevalidationHeader(res, {
+                        staticGenerationStore,
+                        requestStore
+                    });
+                    actionResult = await generateFlight({
+                        actionResult: Promise.resolve(returnVal),
+                        // if the page was not revalidated, we can skip the rendering the flight tree
+                        skipFlight: !staticGenerationStore.pathWasRevalidated
+                    });
+                }
+            });
+            return actionResult;
+        } catch (err) {
+            if (isRedirectError(err)) {
+                const redirectUrl = getURLFromRedirectError(err);
+                // if it's a fetch action, we don't want to mess with the status code
+                // and we'll handle it on the client router
+                await addRevalidationHeader(res, {
+                    staticGenerationStore,
+                    requestStore
+                });
+                if (isFetchAction) {
+                    return createRedirectRenderResult(req, res, redirectUrl, staticGenerationStore);
+                }
+                if (err.mutableCookies) {
+                    const headers = new Headers();
+                    // If there were mutable cookies set, we need to set them on the
+                    // response.
+                    if (appendMutableCookies(headers, err.mutableCookies)) {
+                        res.setHeader("set-cookie", Array.from(headers.values()));
+                    }
+                }
+                res.setHeader("Location", redirectUrl);
+                res.statusCode = 303;
+                return new RenderResult("");
+            } else if (isNotFoundError(err)) {
+                res.statusCode = 404;
+                await addRevalidationHeader(res, {
+                    staticGenerationStore,
+                    requestStore
+                });
+                if (isFetchAction) {
+                    const promise = Promise.reject(err);
+                    try {
+                        await promise;
+                    } catch  {}
+                    return generateFlight({
+                        skipFlight: false,
+                        actionResult: promise,
+                        asNotFound: true
+                    });
+                }
+                return "not-found";
+            }
+            if (isFetchAction) {
+                res.statusCode = 500;
+                await Promise.all(staticGenerationStore.pendingRevalidates || []);
+                const promise = Promise.reject(err);
+                try {
+                    await promise;
+                } catch  {}
+                return generateFlight({
+                    actionResult: promise,
+                    // if the page was not revalidated, we can skip the rendering the flight tree
+                    skipFlight: !staticGenerationStore.pathWasRevalidated
+                });
+            }
+            throw err;
+        }
+    }
+}
+
+//# sourceMappingURL=action-handler.js.map

node_modules/next/dist/esm/server/app-render/create-error-handler.js

@@ -0,0 +1,59 @@
+import { DYNAMIC_ERROR_CODE } from "../../client/components/hooks-server-context";
+import stringHash from "next/dist/compiled/string-hash";
+import { formatServerError } from "../../lib/format-server-error";
+import { isNotFoundError } from "../../client/components/not-found";
+import { isRedirectError } from "../../client/components/redirect";
+import { NEXT_DYNAMIC_NO_SSR_CODE } from "../../shared/lib/lazy-dynamic/no-ssr-error";
+import { SpanStatusCode, getTracer } from "../lib/trace/tracer";
+/**
+ * Create error handler for renderers.
+ * Tolerate dynamic server errors during prerendering so console
+ * isn't spammed with unactionable errors
+ */ export function createErrorHandler({ /**
+   * Used for debugging
+   */ _source, dev, isNextExport, errorLogger, capturedErrors, allCapturedErrors }) {
+    return (err)=>{
+        var _err_message;
+        if (allCapturedErrors) allCapturedErrors.push(err);
+        if (err && (err.digest === DYNAMIC_ERROR_CODE || isNotFoundError(err) || err.digest === NEXT_DYNAMIC_NO_SSR_CODE || isRedirectError(err))) {
+            return err.digest;
+        }
+        // Format server errors in development to add more helpful error messages
+        if (dev) {
+            formatServerError(err);
+        }
+        // Used for debugging error source
+        // console.error(_source, err)
+        // Don't log the suppressed error during export
+        if (!(isNextExport && (err == null ? void 0 : (_err_message = err.message) == null ? void 0 : _err_message.includes("The specific message is omitted in production builds to avoid leaking sensitive details.")))) {
+            // Record exception in an active span, if available.
+            const span = getTracer().getActiveScopeSpan();
+            if (span) {
+                span.recordException(err);
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: err.message
+                });
+            }
+            if (errorLogger) {
+                errorLogger(err).catch(()=>{});
+            } else {
+                // The error logger is currently not provided in the edge runtime.
+                // Use `log-app-dir-error` instead.
+                // It won't log the source code, but the error will be more useful.
+                if (process.env.NODE_ENV !== "production") {
+                    const { logAppDirError } = require("../dev/log-app-dir-error");
+                    logAppDirError(err);
+                }
+                if (process.env.NODE_ENV === "production") {
+                    console.error(err);
+                }
+            }
+        }
+        capturedErrors.push(err);
+        // TODO-APP: look at using webcrypto instead. Requires a promise to be awaited.
+        return stringHash(err.message + err.stack + (err.digest || "")).toString();
+    };
+}
+
+//# sourceMappingURL=create-error-handler.js.map

node_modules/next/dist/esm/server/app-render/create-error-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/create-error-handler.tsx"],"names":["DYNAMIC_ERROR_CODE","stringHash","formatServerError","isNotFoundError","isRedirectError","NEXT_DYNAMIC_NO_SSR_CODE","SpanStatusCode","getTracer","createErrorHandler","_source","dev","isNextExport","errorLogger","capturedErrors","allCapturedErrors","err","push","digest","message","includes","span","getActiveScopeSpan","recordException","setStatus","code","ERROR","catch","process","env","NODE_ENV","logAppDirError","require","console","error","stack","toString"],"mappings":"AAAA,SAASA,kBAAkB,QAAQ,+CAA8C;AACjF,OAAOC,gBAAgB,iCAAgC;AACvD,SAASC,iBAAiB,QAAQ,gCAA+B;AACjE,SAASC,eAAe,QAAQ,oCAAmC;AACnE,SAASC,eAAe,QAAQ,mCAAkC;AAClE,SAASC,wBAAwB,QAAQ,6CAA4C;AACrF,SAASC,cAAc,EAAEC,SAAS,QAAQ,sBAAqB;AAE/D;;;;CAIC,GACD,OAAO,SAASC,mBAAmB,EACjC;;GAEC,GACDC,OAAO,EACPC,GAAG,EACHC,YAAY,EACZC,WAAW,EACXC,cAAc,EACdC,iBAAiB,EAQlB;IACC,OAAO,CAACC;YAuBFA;QAtBJ,IAAID,mBAAmBA,kBAAkBE,IAAI,CAACD;QAE9C,IACEA,OACCA,CAAAA,IAAIE,MAAM,KAAKjB,sBACdG,gBAAgBY,QAChBA,IAAIE,MAAM,KAAKZ,4BACfD,gBAAgBW,IAAG,GACrB;YACA,OAAOA,IAAIE,MAAM;QACnB;QAEA,yEAAyE;QACzE,IAAIP,KAAK;YACPR,kBAAkBa;QACpB;QACA,kCAAkC;QAClC,8BAA8B;QAC9B,+CAA+C;QAC/C,IACE,CACEJ,CAAAA,iBACAI,wBAAAA,eAAAA,IAAKG,OAAO,qBAAZH,aAAcI,QAAQ,CACpB,4FACF,GAEF;YACA,oDAAoD;YACpD,MAAMC,OAAOb,YAAYc,kBAAkB;YAC3C,IAAID,MAAM;gBACRA,KAAKE,eAAe,CAACP;gBACrBK,KAAKG,SAAS,CAAC;oBACbC,MAAMlB,eAAemB,KAAK;oBAC1BP,SAASH,IAAIG,OAAO;gBACtB;YACF;YAEA,IAAIN,aAAa;gBACfA,YAAYG,KAAKW,KAAK,CAAC,KAAO;YAChC,OAAO;gBACL,kEAAkE;gBAClE,mCAAmC;gBACnC,mEAAmE;gBACnE,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;oBACzC,MAAM,EAAEC,cAAc,EAAE,GACtBC,QAAQ;oBACVD,eAAef;gBACjB;gBACA,IAAIY,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;oBACzCG,QAAQC,KAAK,CAAClB;gBAChB;YACF;QACF;QAEAF,eAAeG,IAAI,CAACD;QACpB,+EAA+E;QAC/E,OAAOd,WAAWc,IAAIG,OAAO,GAAGH,IAAImB,KAAK,GAAInB,CAAAA,IAAIE,MAAM,IAAI,EAAC,GAAIkB,QAAQ;IAC1E;AACF"}

node_modules/next/dist/esm/server/app-render/create-flight-router-state-from-loader-tree.js

@@ -0,0 +1,28 @@
+import { PAGE_SEGMENT_KEY } from "../../shared/lib/constants";
+export function addSearchParamsIfPageSegment(segment, searchParams) {
+    const isPageSegment = segment === PAGE_SEGMENT_KEY;
+    if (isPageSegment) {
+        const stringifiedQuery = JSON.stringify(searchParams);
+        return stringifiedQuery !== "{}" ? segment + "?" + stringifiedQuery : segment;
+    }
+    return segment;
+}
+export function createFlightRouterStateFromLoaderTree([segment, parallelRoutes, { layout }], getDynamicParamFromSegment, searchParams, rootLayoutIncluded = false) {
+    const dynamicParam = getDynamicParamFromSegment(segment);
+    const treeSegment = dynamicParam ? dynamicParam.treeSegment : segment;
+    const segmentTree = [
+        addSearchParamsIfPageSegment(treeSegment, searchParams),
+        {}
+    ];
+    if (!rootLayoutIncluded && typeof layout !== "undefined") {
+        rootLayoutIncluded = true;
+        segmentTree[4] = true;
+    }
+    segmentTree[1] = Object.keys(parallelRoutes).reduce((existingValue, currentValue)=>{
+        existingValue[currentValue] = createFlightRouterStateFromLoaderTree(parallelRoutes[currentValue], getDynamicParamFromSegment, searchParams, rootLayoutIncluded);
+        return existingValue;
+    }, {});
+    return segmentTree;
+}
+
+//# sourceMappingURL=create-flight-router-state-from-loader-tree.js.map

node_modules/next/dist/esm/server/app-render/create-flight-router-state-from-loader-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/create-flight-router-state-from-loader-tree.ts"],"names":["PAGE_SEGMENT_KEY","addSearchParamsIfPageSegment","segment","searchParams","isPageSegment","stringifiedQuery","JSON","stringify","createFlightRouterStateFromLoaderTree","parallelRoutes","layout","getDynamicParamFromSegment","rootLayoutIncluded","dynamicParam","treeSegment","segmentTree","Object","keys","reduce","existingValue","currentValue"],"mappings":"AAGA,SAASA,gBAAgB,QAAQ,6BAA4B;AAE7D,OAAO,SAASC,6BACdC,OAAgB,EAChBC,YAAiB;IAEjB,MAAMC,gBAAgBF,YAAYF;IAElC,IAAII,eAAe;QACjB,MAAMC,mBAAmBC,KAAKC,SAAS,CAACJ;QACxC,OAAOE,qBAAqB,OACxBH,UAAU,MAAMG,mBAChBH;IACN;IAEA,OAAOA;AACT;AAEA,OAAO,SAASM,sCACd,CAACN,SAASO,gBAAgB,EAAEC,MAAM,EAAE,CAAa,EACjDC,0BAAsD,EACtDR,YAAiB,EACjBS,qBAAqB,KAAK;IAE1B,MAAMC,eAAeF,2BAA2BT;IAChD,MAAMY,cAAcD,eAAeA,aAAaC,WAAW,GAAGZ;IAE9D,MAAMa,cAAiC;QACrCd,6BAA6Ba,aAAaX;QAC1C,CAAC;KACF;IAED,IAAI,CAACS,sBAAsB,OAAOF,WAAW,aAAa;QACxDE,qBAAqB;QACrBG,WAAW,CAAC,EAAE,GAAG;IACnB;IAEAA,WAAW,CAAC,EAAE,GAAGC,OAAOC,IAAI,CAACR,gBAAgBS,MAAM,CACjD,CAACC,eAAeC;QACdD,aAAa,CAACC,aAAa,GAAGZ,sCAC5BC,cAAc,CAACW,aAAa,EAC5BT,4BACAR,cACAS;QAEF,OAAOO;IACT,GACA,CAAC;IAGH,OAAOJ;AACT"}

node_modules/next/dist/esm/server/app-render/create-server-components-renderer.js

@@ -0,0 +1,28 @@
+import React, { use } from "react";
+import { useFlightResponse } from "./use-flight-response";
+/**
+ * Create a component that renders the Flight stream.
+ * This is only used for renderToHTML, the Flight response does not need additional wrappers.
+ */ export function createServerComponentRenderer(ComponentToRender, ComponentMod, { transformStream, clientReferenceManifest, serverContexts, rscChunks }, serverComponentsErrorHandler, nonce) {
+    let RSCStream;
+    const createRSCStream = (props)=>{
+        if (!RSCStream) {
+            RSCStream = ComponentMod.renderToReadableStream(/*#__PURE__*/ React.createElement(ComponentToRender, props), clientReferenceManifest.clientModules, {
+                context: serverContexts,
+                onError: serverComponentsErrorHandler
+            });
+        }
+        return RSCStream;
+    };
+    const flightResponseRef = {
+        current: null
+    };
+    const writable = transformStream.writable;
+    return function ServerComponentWrapper(props) {
+        const reqStream = createRSCStream(props);
+        const response = useFlightResponse(writable, reqStream, clientReferenceManifest, rscChunks, flightResponseRef, nonce);
+        return use(response);
+    };
+}
+
+//# sourceMappingURL=create-server-components-renderer.js.map

node_modules/next/dist/esm/server/app-render/create-server-components-renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/create-server-components-renderer.tsx"],"names":["React","use","useFlightResponse","createServerComponentRenderer","ComponentToRender","ComponentMod","transformStream","clientReferenceManifest","serverContexts","rscChunks","serverComponentsErrorHandler","nonce","RSCStream","createRSCStream","props","renderToReadableStream","clientModules","context","onError","flightResponseRef","current","writable","ServerComponentWrapper","reqStream","response"],"mappings":"AAGA,OAAOA,SAASC,GAAG,QAAQ,QAAO;AAElC,SAASC,iBAAiB,QAAQ,wBAAuB;AAEzD;;;CAGC,GACD,OAAO,SAASC,8BACdC,iBAAwC,EACxCC,YAMC,EACD,EACEC,eAAe,EACfC,uBAAuB,EACvBC,cAAc,EACdC,SAAS,EAQV,EACDC,4BAAmE,EACnEC,KAAc;IAEd,IAAIC;IACJ,MAAMC,kBAAkB,CAACC;QACvB,IAAI,CAACF,WAAW;YACdA,YAAYP,aAAaU,sBAAsB,eAC7C,oBAACX,mBAAuBU,QACxBP,wBAAwBS,aAAa,EACrC;gBACEC,SAAST;gBACTU,SAASR;YACX;QAEJ;QACA,OAAOE;IACT;IAEA,MAAMO,oBAAuC;QAAEC,SAAS;IAAK;IAE7D,MAAMC,WAAWf,gBAAgBe,QAAQ;IACzC,OAAO,SAASC,uBAAuBR,KAAY;QACjD,MAAMS,YAAYV,gBAAgBC;QAClC,MAAMU,WAAWtB,kBACfmB,UACAE,WACAhB,yBACAE,WACAU,mBACAR;QAEF,OAAOV,IAAIuB;IACb;AACF"}

node_modules/next/dist/esm/server/app-render/entry-base.js

@@ -0,0 +1,16 @@
+const { renderToReadableStream, decodeReply, decodeAction } = require("react-server-dom-webpack/server.edge");
+import AppRouter from "../../client/components/app-router";
+import LayoutRouter from "../../client/components/layout-router";
+import RenderFromTemplateContext from "../../client/components/render-from-template-context";
+import { staticGenerationAsyncStorage } from "../../client/components/static-generation-async-storage.external";
+import { requestAsyncStorage } from "../../client/components/request-async-storage.external";
+import { actionAsyncStorage } from "../../client/components/action-async-storage.external";
+import { staticGenerationBailout } from "../../client/components/static-generation-bailout";
+import StaticGenerationSearchParamsBailoutProvider from "../../client/components/static-generation-searchparams-bailout-provider";
+import { createSearchParamsBailoutProxy } from "../../client/components/searchparams-bailout-proxy";
+import * as serverHooks from "../../client/components/hooks-server-context";
+import { preloadStyle, preloadFont, preconnect } from "../../server/app-render/rsc/preloads";
+const { NotFoundBoundary } = require("next/dist/client/components/not-found-boundary");
+export { AppRouter, LayoutRouter, RenderFromTemplateContext, staticGenerationAsyncStorage, requestAsyncStorage, actionAsyncStorage, staticGenerationBailout, createSearchParamsBailoutProxy, serverHooks, renderToReadableStream, decodeReply, decodeAction, preloadStyle, preloadFont, preconnect, StaticGenerationSearchParamsBailoutProvider, NotFoundBoundary,  };
+
+//# sourceMappingURL=entry-base.js.map

node_modules/next/dist/esm/server/app-render/entry-base.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/entry-base.ts"],"names":["renderToReadableStream","decodeReply","decodeAction","require","AppRouter","LayoutRouter","RenderFromTemplateContext","staticGenerationAsyncStorage","requestAsyncStorage","actionAsyncStorage","staticGenerationBailout","StaticGenerationSearchParamsBailoutProvider","createSearchParamsBailoutProxy","serverHooks","preloadStyle","preloadFont","preconnect","NotFoundBoundary"],"mappings":"AAAA,MAAM,EACJA,sBAAsB,EACtBC,WAAW,EACXC,YAAY,EAEb,GAAGC,QAAQ;AAEZ,OAAOC,eAAe,qCAAoC;AAC1D,OAAOC,kBAAkB,wCAAuC;AAChE,OAAOC,+BAA+B,uDAAsD;AAC5F,SAASC,4BAA4B,QAAQ,mEAAkE;AAC/G,SAASC,mBAAmB,QAAQ,yDAAwD;AAC5F,SAASC,kBAAkB,QAAQ,wDAAuD;AAC1F,SAASC,uBAAuB,QAAQ,oDAAmD;AAC3F,OAAOC,iDAAiD,0EAAyE;AACjI,SAASC,8BAA8B,QAAQ,qDAAoD;AACnG,YAAYC,iBAAiB,+CAA8C;AAE3E,SACEC,YAAY,EACZC,WAAW,EACXC,UAAU,QACL,uCAAsC;AAE7C,MAAM,EAAEC,gBAAgB,EAAE,GACxBd,QAAQ;AAEV,SACEC,SAAS,EACTC,YAAY,EACZC,yBAAyB,EACzBC,4BAA4B,EAC5BC,mBAAmB,EACnBC,kBAAkB,EAClBC,uBAAuB,EACvBE,8BAA8B,EAC9BC,WAAW,EACXb,sBAAsB,EACtBC,WAAW,EACXC,YAAY,EACZY,YAAY,EACZC,WAAW,EACXC,UAAU,EACVL,2CAA2C,EAC3CM,gBAAgB,KACjB"}

node_modules/next/dist/esm/server/app-render/flight-render-result.js

@@ -0,0 +1,13 @@
+import { RSC_CONTENT_TYPE_HEADER } from "../../client/components/app-router-headers";
+import RenderResult from "../render-result";
+/**
+ * Flight Response is always set to RSC_CONTENT_TYPE_HEADER to ensure it does not get interpreted as HTML.
+ */ export class FlightRenderResult extends RenderResult {
+    constructor(response){
+        super(response, {
+            contentType: RSC_CONTENT_TYPE_HEADER
+        });
+    }
+}
+
+//# sourceMappingURL=flight-render-result.js.map

node_modules/next/dist/esm/server/app-render/flight-render-result.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/flight-render-result.ts"],"names":["RSC_CONTENT_TYPE_HEADER","RenderResult","FlightRenderResult","constructor","response","contentType"],"mappings":"AAAA,SAASA,uBAAuB,QAAQ,6CAA4C;AACpF,OAAOC,kBAAkB,mBAAkB;AAE3C;;CAEC,GACD,OAAO,MAAMC,2BAA2BD;IACtCE,YAAYC,QAA6C,CAAE;QACzD,KAAK,CAACA,UAAU;YAAEC,aAAaL;QAAwB;IACzD;AACF"}

node_modules/next/dist/esm/server/app-render/flight-response-ref.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=flight-response-ref.js.map

node_modules/next/dist/esm/server/app-render/flight-response-ref.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/flight-response-ref.tsx"],"names":[],"mappings":"AAAA,WAEC"}

node_modules/next/dist/esm/server/app-render/get-css-inlined-link-tags.js

@@ -0,0 +1,22 @@
+/**
+ * Get external stylesheet link hrefs based on server CSS manifest.
+ */ export function getCssInlinedLinkTags(clientReferenceManifest, filePath, injectedCSS, collectNewCSSImports) {
+    const filePathWithoutExt = filePath.replace(/\.[^.]+$/, "");
+    const chunks = new Set();
+    const entryCSSFiles = clientReferenceManifest.entryCSSFiles[filePathWithoutExt];
+    if (entryCSSFiles) {
+        for (const file of entryCSSFiles){
+            if (!injectedCSS.has(file)) {
+                if (collectNewCSSImports) {
+                    injectedCSS.add(file);
+                }
+                chunks.add(file);
+            }
+        }
+    }
+    return [
+        ...chunks
+    ];
+}
+
+//# sourceMappingURL=get-css-inlined-link-tags.js.map

node_modules/next/dist/esm/server/app-render/get-css-inlined-link-tags.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/get-css-inlined-link-tags.tsx"],"names":["getCssInlinedLinkTags","clientReferenceManifest","filePath","injectedCSS","collectNewCSSImports","filePathWithoutExt","replace","chunks","Set","entryCSSFiles","file","has","add"],"mappings":"AAEA;;CAEC,GACD,OAAO,SAASA,sBACdC,uBAAgD,EAChDC,QAAgB,EAChBC,WAAwB,EACxBC,oBAA8B;IAE9B,MAAMC,qBAAqBH,SAASI,OAAO,CAAC,YAAY;IACxD,MAAMC,SAAS,IAAIC;IAEnB,MAAMC,gBACJR,wBAAwBQ,aAAa,CAACJ,mBAAmB;IAE3D,IAAII,eAAe;QACjB,KAAK,MAAMC,QAAQD,cAAe;YAChC,IAAI,CAACN,YAAYQ,GAAG,CAACD,OAAO;gBAC1B,IAAIN,sBAAsB;oBACxBD,YAAYS,GAAG,CAACF;gBAClB;gBACAH,OAAOK,GAAG,CAACF;YACb;QACF;IACF;IAEA,OAAO;WAAIH;KAAO;AACpB"}

node_modules/next/dist/esm/server/app-render/get-preloadable-fonts.js

@@ -0,0 +1,35 @@
+/**
+ * Get hrefs for fonts to preload
+ * Returns null if there are no fonts at all.
+ * Returns string[] if there are fonts to preload (font paths)
+ * Returns empty string[] if there are fonts but none to preload and no other fonts have been preloaded
+ * Returns null if there are fonts but none to preload and at least some were previously preloaded
+ */ export function getPreloadableFonts(nextFontManifest, filePath, injectedFontPreloadTags) {
+    if (!nextFontManifest || !filePath) {
+        return null;
+    }
+    const filepathWithoutExtension = filePath.replace(/\.[^.]+$/, "");
+    const fontFiles = new Set();
+    let foundFontUsage = false;
+    const preloadedFontFiles = nextFontManifest.app[filepathWithoutExtension];
+    if (preloadedFontFiles) {
+        foundFontUsage = true;
+        for (const fontFile of preloadedFontFiles){
+            if (!injectedFontPreloadTags.has(fontFile)) {
+                fontFiles.add(fontFile);
+                injectedFontPreloadTags.add(fontFile);
+            }
+        }
+    }
+    if (fontFiles.size) {
+        return [
+            ...fontFiles
+        ].sort();
+    } else if (foundFontUsage && injectedFontPreloadTags.size === 0) {
+        return [];
+    } else {
+        return null;
+    }
+}
+
+//# sourceMappingURL=get-preloadable-fonts.js.map

node_modules/next/dist/esm/server/app-render/get-preloadable-fonts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/get-preloadable-fonts.tsx"],"names":["getPreloadableFonts","nextFontManifest","filePath","injectedFontPreloadTags","filepathWithoutExtension","replace","fontFiles","Set","foundFontUsage","preloadedFontFiles","app","fontFile","has","add","size","sort"],"mappings":"AAEA;;;;;;CAMC,GACD,OAAO,SAASA,oBACdC,gBAA8C,EAC9CC,QAA4B,EAC5BC,uBAAoC;IAEpC,IAAI,CAACF,oBAAoB,CAACC,UAAU;QAClC,OAAO;IACT;IACA,MAAME,2BAA2BF,SAASG,OAAO,CAAC,YAAY;IAC9D,MAAMC,YAAY,IAAIC;IACtB,IAAIC,iBAAiB;IAErB,MAAMC,qBAAqBR,iBAAiBS,GAAG,CAACN,yBAAyB;IACzE,IAAIK,oBAAoB;QACtBD,iBAAiB;QACjB,KAAK,MAAMG,YAAYF,mBAAoB;YACzC,IAAI,CAACN,wBAAwBS,GAAG,CAACD,WAAW;gBAC1CL,UAAUO,GAAG,CAACF;gBACdR,wBAAwBU,GAAG,CAACF;YAC9B;QACF;IACF;IAEA,IAAIL,UAAUQ,IAAI,EAAE;QAClB,OAAO;eAAIR;SAAU,CAACS,IAAI;IAC5B,OAAO,IAAIP,kBAAkBL,wBAAwBW,IAAI,KAAK,GAAG;QAC/D,OAAO,EAAE;IACX,OAAO;QACL,OAAO;IACT;AACF"}

node_modules/next/dist/esm/server/app-render/get-script-nonce-from-header.js

@@ -0,0 +1,30 @@
+import { ESCAPE_REGEX } from "../htmlescape";
+export function getScriptNonceFromHeader(cspHeaderValue) {
+    var _directive_split_slice_map_find;
+    const directives = cspHeaderValue// Directives are split by ';'.
+    .split(";").map((directive)=>directive.trim());
+    // First try to find the directive for the 'script-src', otherwise try to
+    // fallback to the 'default-src'.
+    const directive = directives.find((dir)=>dir.startsWith("script-src")) || directives.find((dir)=>dir.startsWith("default-src"));
+    // If no directive could be found, then we're done.
+    if (!directive) {
+        return;
+    }
+    // Extract the nonce from the directive
+    const nonce = (_directive_split_slice_map_find = directive.split(" ")// Remove the 'strict-src'/'default-src' string, this can't be the nonce.
+    .slice(1).map((source)=>source.trim())// Find the first source with the 'nonce-' prefix.
+    .find((source)=>source.startsWith("'nonce-") && source.length > 8 && source.endsWith("'"))) == null ? void 0 : _directive_split_slice_map_find.slice(7, -1);
+    // If we could't find the nonce, then we're done.
+    if (!nonce) {
+        return;
+    }
+    // Don't accept the nonce value if it contains HTML escape characters.
+    // Technically, the spec requires a base64'd value, but this is just an
+    // extra layer.
+    if (ESCAPE_REGEX.test(nonce)) {
+        throw new Error("Nonce value from Content-Security-Policy contained HTML escape characters.\nLearn more: https://nextjs.org/docs/messages/nonce-contained-invalid-characters");
+    }
+    return nonce;
+}
+
+//# sourceMappingURL=get-script-nonce-from-header.js.map

node_modules/next/dist/esm/server/app-render/get-script-nonce-from-header.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/get-script-nonce-from-header.tsx"],"names":["ESCAPE_REGEX","getScriptNonceFromHeader","cspHeaderValue","directive","directives","split","map","trim","find","dir","startsWith","nonce","slice","source","length","endsWith","test","Error"],"mappings":"AAAA,SAASA,YAAY,QAAQ,gBAAe;AAE5C,OAAO,SAASC,yBACdC,cAAsB;QAmBRC;IAjBd,MAAMC,aAAaF,cACjB,+BAA+B;KAC9BG,KAAK,CAAC,KACNC,GAAG,CAAC,CAACH,YAAcA,UAAUI,IAAI;IAEpC,yEAAyE;IACzE,iCAAiC;IACjC,MAAMJ,YACJC,WAAWI,IAAI,CAAC,CAACC,MAAQA,IAAIC,UAAU,CAAC,kBACxCN,WAAWI,IAAI,CAAC,CAACC,MAAQA,IAAIC,UAAU,CAAC;IAE1C,mDAAmD;IACnD,IAAI,CAACP,WAAW;QACd;IACF;IAEA,uCAAuC;IACvC,MAAMQ,SAAQR,kCAAAA,UACXE,KAAK,CAAC,IACP,yEAAyE;KACxEO,KAAK,CAAC,GACNN,GAAG,CAAC,CAACO,SAAWA,OAAON,IAAI,GAC5B,kDAAkD;KACjDC,IAAI,CACH,CAACK,SACCA,OAAOH,UAAU,CAAC,cAClBG,OAAOC,MAAM,GAAG,KAChBD,OAAOE,QAAQ,CAAC,0BAVRZ,gCAaVS,KAAK,CAAC,GAAG,CAAC;IAEd,iDAAiD;IACjD,IAAI,CAACD,OAAO;QACV;IACF;IAEA,sEAAsE;IACtE,uEAAuE;IACvE,eAAe;IACf,IAAIX,aAAagB,IAAI,CAACL,QAAQ;QAC5B,MAAM,IAAIM,MACR;IAEJ;IAEA,OAAON;AACT"}

node_modules/next/dist/esm/server/app-render/get-segment-param.js

@@ -0,0 +1,32 @@
+import { INTERCEPTION_ROUTE_MARKERS } from "../future/helpers/interception-routes";
+/**
+ * Parse dynamic route segment to type of parameter
+ */ export function getSegmentParam(segment) {
+    const interceptionMarker = INTERCEPTION_ROUTE_MARKERS.find((marker)=>segment.startsWith(marker));
+    // if an interception marker is part of the path segment, we need to jump ahead
+    // to the relevant portion for param parsing
+    if (interceptionMarker) {
+        segment = segment.slice(interceptionMarker.length);
+    }
+    if (segment.startsWith("[[...") && segment.endsWith("]]")) {
+        return {
+            type: "optional-catchall",
+            param: segment.slice(5, -2)
+        };
+    }
+    if (segment.startsWith("[...") && segment.endsWith("]")) {
+        return {
+            type: "catchall",
+            param: segment.slice(4, -1)
+        };
+    }
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+        return {
+            type: "dynamic",
+            param: segment.slice(1, -1)
+        };
+    }
+    return null;
+}
+
+//# sourceMappingURL=get-segment-param.js.map

node_modules/next/dist/esm/server/app-render/get-segment-param.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/get-segment-param.tsx"],"names":["INTERCEPTION_ROUTE_MARKERS","getSegmentParam","segment","interceptionMarker","find","marker","startsWith","slice","length","endsWith","type","param"],"mappings":"AAAA,SAASA,0BAA0B,QAAQ,wCAAuC;AAGlF;;CAEC,GACD,OAAO,SAASC,gBAAgBC,OAAe;IAI7C,MAAMC,qBAAqBH,2BAA2BI,IAAI,CAAC,CAACC,SAC1DH,QAAQI,UAAU,CAACD;IAGrB,+EAA+E;IAC/E,4CAA4C;IAC5C,IAAIF,oBAAoB;QACtBD,UAAUA,QAAQK,KAAK,CAACJ,mBAAmBK,MAAM;IACnD;IAEA,IAAIN,QAAQI,UAAU,CAAC,YAAYJ,QAAQO,QAAQ,CAAC,OAAO;QACzD,OAAO;YACLC,MAAM;YACNC,OAAOT,QAAQK,KAAK,CAAC,GAAG,CAAC;QAC3B;IACF;IAEA,IAAIL,QAAQI,UAAU,CAAC,WAAWJ,QAAQO,QAAQ,CAAC,MAAM;QACvD,OAAO;YACLC,MAAM;YACNC,OAAOT,QAAQK,KAAK,CAAC,GAAG,CAAC;QAC3B;IACF;IAEA,IAAIL,QAAQI,UAAU,CAAC,QAAQJ,QAAQO,QAAQ,CAAC,MAAM;QACpD,OAAO;YACLC,MAAM;YACNC,OAAOT,QAAQK,KAAK,CAAC,GAAG,CAAC;QAC3B;IACF;IAEA,OAAO;AACT"}

node_modules/next/dist/esm/server/app-render/get-short-dynamic-param-type.js

@@ -0,0 +1,16 @@
+export const dynamicParamTypes = {
+    catchall: "c",
+    "optional-catchall": "oc",
+    dynamic: "d"
+};
+/**
+ * Shorten the dynamic param in order to make it smaller when transmitted to the browser.
+ */ export function getShortDynamicParamType(type) {
+    const short = dynamicParamTypes[type];
+    if (!short) {
+        throw new Error("Unknown dynamic param type");
+    }
+    return short;
+}
+
+//# sourceMappingURL=get-short-dynamic-param-type.js.map

node_modules/next/dist/esm/server/app-render/get-short-dynamic-param-type.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/get-short-dynamic-param-type.tsx"],"names":["dynamicParamTypes","catchall","dynamic","getShortDynamicParamType","type","short","Error"],"mappings":"AAEA,OAAO,MAAMA,oBAGT;IACFC,UAAU;IACV,qBAAqB;IACrBC,SAAS;AACX,EAAC;AAED;;CAEC,GACD,OAAO,SAASC,yBACdC,IAAuB;IAEvB,MAAMC,QAAQL,iBAAiB,CAACI,KAAK;IACrC,IAAI,CAACC,OAAO;QACV,MAAM,IAAIC,MAAM;IAClB;IACA,OAAOD;AACT"}

node_modules/next/dist/esm/server/app-render/interop-default.js

@@ -0,0 +1,7 @@
+/**
+ * Interop between "export default" and "module.exports".
+ */ export function interopDefault(mod) {
+    return mod.default || mod;
+}
+
+//# sourceMappingURL=interop-default.js.map

node_modules/next/dist/esm/server/app-render/interop-default.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/interop-default.ts"],"names":["interopDefault","mod","default"],"mappings":"AAAA;;CAEC,GACD,OAAO,SAASA,eAAeC,GAAQ;IACrC,OAAOA,IAAIC,OAAO,IAAID;AACxB"}

node_modules/next/dist/esm/server/app-render/parse-and-validate-flight-router-state.js

@@ -0,0 +1,24 @@
+import { flightRouterStateSchema } from "./types";
+export function parseAndValidateFlightRouterState(stateHeader) {
+    if (typeof stateHeader === "undefined") {
+        return undefined;
+    }
+    if (Array.isArray(stateHeader)) {
+        throw new Error("Multiple router state headers were sent. This is not allowed.");
+    }
+    // We limit the size of the router state header to ~40kb. This is to prevent
+    // a malicious user from sending a very large header and slowing down the
+    // resolving of the router state.
+    // This is around 2,000 nested or parallel route segment states:
+    // '{"children":["",{}]}'.length === 20.
+    if (stateHeader.length > 20 * 2000) {
+        throw new Error("The router state header was too large.");
+    }
+    try {
+        return flightRouterStateSchema.parse(JSON.parse(decodeURIComponent(stateHeader)));
+    } catch  {
+        throw new Error("The router state header was sent but could not be parsed.");
+    }
+}
+
+//# sourceMappingURL=parse-and-validate-flight-router-state.js.map

node_modules/next/dist/esm/server/app-render/parse-and-validate-flight-router-state.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/parse-and-validate-flight-router-state.tsx"],"names":["flightRouterStateSchema","parseAndValidateFlightRouterState","stateHeader","undefined","Array","isArray","Error","length","parse","JSON","decodeURIComponent"],"mappings":"AACA,SAASA,uBAAuB,QAAQ,UAAS;AAEjD,OAAO,SAASC,kCACdC,WAA0C;IAE1C,IAAI,OAAOA,gBAAgB,aAAa;QACtC,OAAOC;IACT;IACA,IAAIC,MAAMC,OAAO,CAACH,cAAc;QAC9B,MAAM,IAAII,MACR;IAEJ;IAEA,4EAA4E;IAC5E,yEAAyE;IACzE,iCAAiC;IACjC,gEAAgE;IAChE,wCAAwC;IACxC,IAAIJ,YAAYK,MAAM,GAAG,KAAK,MAAM;QAClC,MAAM,IAAID,MAAM;IAClB;IAEA,IAAI;QACF,OAAON,wBAAwBQ,KAAK,CAClCC,KAAKD,KAAK,CAACE,mBAAmBR;IAElC,EAAE,OAAM;QACN,MAAM,IAAII,MAAM;IAClB;AACF"}

node_modules/next/dist/esm/server/app-render/preload-component.js

@@ -0,0 +1,30 @@
+export function preloadComponent(Component, props) {
+    const prev = console.error;
+    // Hide invalid hook call warning when calling component
+    console.error = function(msg) {
+        if (msg.startsWith("Warning: Invalid hook call.")) {
+        // ignore
+        } else {
+            // @ts-expect-error argument is defined
+            prev.apply(console, arguments);
+        }
+    };
+    try {
+        let result = Component(props);
+        if (result && typeof result.then === "function") {
+            // Catch promise rejections to prevent unhandledRejection errors
+            result.then(()=>{}, ()=>{});
+        }
+        return function() {
+            // We know what this component will render already.
+            return result;
+        };
+    } catch (x) {
+    // something suspended or errored, try again later
+    } finally{
+        console.error = prev;
+    }
+    return Component;
+}
+
+//# sourceMappingURL=preload-component.js.map

node_modules/next/dist/esm/server/app-render/preload-component.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/preload-component.ts"],"names":["preloadComponent","Component","props","prev","console","error","msg","startsWith","apply","arguments","result","then","x"],"mappings":"AAAA,OAAO,SAASA,iBAAiBC,SAAc,EAAEC,KAAU;IACzD,MAAMC,OAAOC,QAAQC,KAAK;IAC1B,wDAAwD;IACxDD,QAAQC,KAAK,GAAG,SAAUC,GAAG;QAC3B,IAAIA,IAAIC,UAAU,CAAC,gCAAgC;QACjD,SAAS;QACX,OAAO;YACL,uCAAuC;YACvCJ,KAAKK,KAAK,CAACJ,SAASK;QACtB;IACF;IACA,IAAI;QACF,IAAIC,SAAST,UAAUC;QACvB,IAAIQ,UAAU,OAAOA,OAAOC,IAAI,KAAK,YAAY;YAC/C,gEAAgE;YAChED,OAAOC,IAAI,CACT,KAAO,GACP,KAAO;QAEX;QACA,OAAO;YACL,mDAAmD;YACnD,OAAOD;QACT;IACF,EAAE,OAAOE,GAAG;IACV,kDAAkD;IACpD,SAAU;QACRR,QAAQC,KAAK,GAAGF;IAClB;IACA,OAAOF;AACT"}

node_modules/next/dist/esm/server/app-render/render-to-string.js

@@ -0,0 +1,12 @@
+import { streamToString } from "../stream-utils/node-web-streams-helper";
+import { AppRenderSpan } from "../lib/trace/constants";
+import { getTracer } from "../lib/trace/tracer";
+export async function renderToString({ ReactDOMServer, element }) {
+    return getTracer().trace(AppRenderSpan.renderToString, async ()=>{
+        const renderStream = await ReactDOMServer.renderToReadableStream(element);
+        await renderStream.allReady;
+        return streamToString(renderStream);
+    });
+}
+
+//# sourceMappingURL=render-to-string.js.map

node_modules/next/dist/esm/server/app-render/render-to-string.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/render-to-string.tsx"],"names":["streamToString","AppRenderSpan","getTracer","renderToString","ReactDOMServer","element","trace","renderStream","renderToReadableStream","allReady"],"mappings":"AAAA,SAASA,cAAc,QAAQ,0CAAyC;AACxE,SAASC,aAAa,QAAQ,yBAAwB;AACtD,SAASC,SAAS,QAAQ,sBAAqB;AAE/C,OAAO,eAAeC,eAAe,EACnCC,cAAc,EACdC,OAAO,EAIR;IACC,OAAOH,YAAYI,KAAK,CAACL,cAAcE,cAAc,EAAE;QACrD,MAAMI,eAAe,MAAMH,eAAeI,sBAAsB,CAACH;QACjE,MAAME,aAAaE,QAAQ;QAC3B,OAAOT,eAAeO;IACxB;AACF"}

node_modules/next/dist/esm/server/app-render/required-scripts.js

@@ -0,0 +1,52 @@
+import ReactDOM from "react-dom";
+export function getRequiredScripts(buildManifest, assetPrefix, SRIManifest, qs, nonce) {
+    let preinitScripts;
+    let preinitScriptCommands = [];
+    let bootstrapScript = "";
+    const files = buildManifest.rootMainFiles;
+    if (files.length === 0) {
+        throw new Error("Invariant: missing bootstrap script. This is a bug in Next.js");
+    }
+    if (SRIManifest) {
+        bootstrapScript = {
+            src: `${assetPrefix}/_next/` + files[0] + qs,
+            integrity: SRIManifest[files[0]]
+        };
+        for(let i = 1; i < files.length; i++){
+            const src = `${assetPrefix}/_next/` + files[i] + qs;
+            const integrity = SRIManifest[files[i]];
+            preinitScriptCommands.push(src, integrity);
+        }
+        preinitScripts = ()=>{
+            // preinitScriptCommands is a double indexed array of src/integrity pairs
+            for(let i = 0; i < preinitScriptCommands.length; i += 2){
+                ReactDOM.preinit(preinitScriptCommands[i], {
+                    as: "script",
+                    integrity: preinitScriptCommands[i + 1],
+                    nonce
+                });
+            }
+        };
+    } else {
+        bootstrapScript = `${assetPrefix}/_next/` + files[0] + qs;
+        for(let i = 1; i < files.length; i++){
+            const src = `${assetPrefix}/_next/` + files[i] + qs;
+            preinitScriptCommands.push(src);
+        }
+        preinitScripts = ()=>{
+            // preinitScriptCommands is a singled indexed array of src values
+            for(let i = 0; i < preinitScriptCommands.length; i++){
+                ReactDOM.preinit(preinitScriptCommands[i], {
+                    as: "script",
+                    nonce
+                });
+            }
+        };
+    }
+    return [
+        preinitScripts,
+        bootstrapScript
+    ];
+}
+
+//# sourceMappingURL=required-scripts.js.map

node_modules/next/dist/esm/server/app-render/required-scripts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/required-scripts.tsx"],"names":["ReactDOM","getRequiredScripts","buildManifest","assetPrefix","SRIManifest","qs","nonce","preinitScripts","preinitScriptCommands","bootstrapScript","files","rootMainFiles","length","Error","src","integrity","i","push","preinit","as"],"mappings":"AAEA,OAAOA,cAAc,YAAW;AAEhC,OAAO,SAASC,mBACdC,aAA4B,EAC5BC,WAAmB,EACnBC,WAA+C,EAC/CC,EAAU,EACVC,KAAyB;IAEzB,IAAIC;IACJ,IAAIC,wBAAkC,EAAE;IACxC,IAAIC,kBAA+D;IACnE,MAAMC,QAAQR,cAAcS,aAAa;IACzC,IAAID,MAAME,MAAM,KAAK,GAAG;QACtB,MAAM,IAAIC,MACR;IAEJ;IACA,IAAIT,aAAa;QACfK,kBAAkB;YAChBK,KAAK,CAAC,EAAEX,YAAY,OAAO,CAAC,GAAGO,KAAK,CAAC,EAAE,GAAGL;YAC1CU,WAAWX,WAAW,CAACM,KAAK,CAAC,EAAE,CAAC;QAClC;QACA,IAAK,IAAIM,IAAI,GAAGA,IAAIN,MAAME,MAAM,EAAEI,IAAK;YACrC,MAAMF,MAAM,CAAC,EAAEX,YAAY,OAAO,CAAC,GAAGO,KAAK,CAACM,EAAE,GAAGX;YACjD,MAAMU,YAAYX,WAAW,CAACM,KAAK,CAACM,EAAE,CAAC;YACvCR,sBAAsBS,IAAI,CAACH,KAAKC;QAClC;QACAR,iBAAiB;YACf,yEAAyE;YACzE,IAAK,IAAIS,IAAI,GAAGA,IAAIR,sBAAsBI,MAAM,EAAEI,KAAK,EAAG;gBACxDhB,SAASkB,OAAO,CAACV,qBAAqB,CAACQ,EAAE,EAAE;oBACzCG,IAAI;oBACJJ,WAAWP,qBAAqB,CAACQ,IAAI,EAAE;oBACvCV;gBACF;YACF;QACF;IACF,OAAO;QACLG,kBAAkB,CAAC,EAAEN,YAAY,OAAO,CAAC,GAAGO,KAAK,CAAC,EAAE,GAAGL;QACvD,IAAK,IAAIW,IAAI,GAAGA,IAAIN,MAAME,MAAM,EAAEI,IAAK;YACrC,MAAMF,MAAM,CAAC,EAAEX,YAAY,OAAO,CAAC,GAAGO,KAAK,CAACM,EAAE,GAAGX;YACjDG,sBAAsBS,IAAI,CAACH;QAC7B;QACAP,iBAAiB;YACf,iEAAiE;YACjE,IAAK,IAAIS,IAAI,GAAGA,IAAIR,sBAAsBI,MAAM,EAAEI,IAAK;gBACrDhB,SAASkB,OAAO,CAACV,qBAAqB,CAACQ,EAAE,EAAE;oBACzCG,IAAI;oBACJb;gBACF;YACF;QACF;IACF;IAEA,OAAO;QAACC;QAAgBE;KAAgB;AAC1C"}

node_modules/next/dist/esm/server/app-render/rsc/preloads.js

@@ -0,0 +1,27 @@
+/*
+
+Files in the rsc directory are meant to be packaged as part of the RSC graph using next-app-loader.
+
+*/ import ReactDOM from "react-dom";
+export function preloadStyle(href) {
+    ReactDOM.preload(href, {
+        as: "style"
+    });
+}
+export function preloadFont(href, type) {
+    ReactDOM.preload(href, {
+        as: "font",
+        type
+    });
+}
+export function preconnect(href, crossOrigin) {
+    if (typeof crossOrigin === "string") {
+        ReactDOM.preconnect(href, {
+            crossOrigin
+        });
+    } else {
+        ReactDOM.preconnect(href);
+    }
+}
+
+//# sourceMappingURL=preloads.js.map

node_modules/next/dist/esm/server/app-render/rsc/preloads.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/app-render/rsc/preloads.ts"],"names":["ReactDOM","preloadStyle","href","preload","as","preloadFont","type","preconnect","crossOrigin"],"mappings":"AAAA;;;;AAIA,GAEA,OAAOA,cAAc,YAAW;AAEhC,OAAO,SAASC,aAAaC,IAAY;IACvCF,SAASG,OAAO,CAACD,MAAM;QAAEE,IAAI;IAAQ;AACvC;AAEA,OAAO,SAASC,YAAYH,IAAY,EAAEI,IAAY;IAClDN,SAAiBG,OAAO,CAACD,MAAM;QAAEE,IAAI;QAAQE;IAAK;AACtD;AAEA,OAAO,SAASC,WAAWL,IAAY,EAAEM,WAAoB;IAC3D,IAAI,OAAOA,gBAAgB,UAAU;QACjCR,SAAiBO,UAAU,CAACL,MAAM;YAAEM;QAAY;IACpD,OAAO;QACHR,SAAiBO,UAAU,CAACL;IAChC;AACF"}

node_modules/next/dist/esm/server/app-render/server-inserted-html.js

@@ -0,0 +1,24 @@
+// Provider for the `useServerInsertedHTML` API to register callbacks to insert
+// elements into the HTML stream.
+import React from "react";
+import { ServerInsertedHTMLContext } from "../../shared/lib/server-inserted-html.shared-runtime";
+export function createServerInsertedHTML() {
+    const serverInsertedHTMLCallbacks = [];
+    const addInsertedHtml = (handler)=>{
+        serverInsertedHTMLCallbacks.push(handler);
+    };
+    return {
+        ServerInsertedHTMLProvider ({ children }) {
+            return /*#__PURE__*/ React.createElement(ServerInsertedHTMLContext.Provider, {
+                value: addInsertedHtml
+            }, children);
+        },
+        renderServerInsertedHTML () {
+            return serverInsertedHTMLCallbacks.map((callback, index)=>/*#__PURE__*/ React.createElement(React.Fragment, {
+                    key: "__next_server_inserted__" + index
+                }, callback()));
+        }
+    };
+}
+
+//# sourceMappingURL=server-inserted-html.js.map

node_modules/next/dist/esm/server/app-render/server-inserted-html.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/server-inserted-html.tsx"],"names":["React","ServerInsertedHTMLContext","createServerInsertedHTML","serverInsertedHTMLCallbacks","addInsertedHtml","handler","push","ServerInsertedHTMLProvider","children","Provider","value","renderServerInsertedHTML","map","callback","index","Fragment","key"],"mappings":"AAAA,+EAA+E;AAC/E,iCAAiC;AAEjC,OAAOA,WAAW,QAAO;AACzB,SAASC,yBAAyB,QAAQ,uDAAsD;AAEhG,OAAO,SAASC;IACd,MAAMC,8BAAyD,EAAE;IACjE,MAAMC,kBAAkB,CAACC;QACvBF,4BAA4BG,IAAI,CAACD;IACnC;IAEA,OAAO;QACLE,4BAA2B,EAAEC,QAAQ,EAA6B;YAChE,qBACE,oBAACP,0BAA0BQ,QAAQ;gBAACC,OAAON;eACxCI;QAGP;QACAG;YACE,OAAOR,4BAA4BS,GAAG,CAAC,CAACC,UAAUC,sBAChD,oBAACd,MAAMe,QAAQ;oBAACC,KAAK,6BAA6BF;mBAC/CD;QAGP;IACF;AACF"}

node_modules/next/dist/esm/server/app-render/types.js

@@ -0,0 +1,48 @@
+import zod from "zod";
+const dynamicParamTypesSchema = zod.enum([
+    "c",
+    "oc",
+    "d"
+]);
+const segmentSchema = zod.union([
+    zod.string(),
+    zod.tuple([
+        zod.string(),
+        zod.string(),
+        dynamicParamTypesSchema
+    ])
+]);
+export const flightRouterStateSchema = zod.lazy(()=>{
+    const parallelRoutesSchema = zod.record(flightRouterStateSchema);
+    const urlSchema = zod.string().nullable().optional();
+    const refreshSchema = zod.literal("refetch").nullable().optional();
+    const isRootLayoutSchema = zod.boolean().optional();
+    // Due to the lack of optional tuple types in Zod, we need to use union here.
+    // https://github.com/colinhacks/zod/issues/1465
+    return zod.union([
+        zod.tuple([
+            segmentSchema,
+            parallelRoutesSchema,
+            urlSchema,
+            refreshSchema,
+            isRootLayoutSchema
+        ]),
+        zod.tuple([
+            segmentSchema,
+            parallelRoutesSchema,
+            urlSchema,
+            refreshSchema
+        ]),
+        zod.tuple([
+            segmentSchema,
+            parallelRoutesSchema,
+            urlSchema
+        ]),
+        zod.tuple([
+            segmentSchema,
+            parallelRoutesSchema
+        ])
+    ]);
+});
+
+//# sourceMappingURL=types.js.map

node_modules/next/dist/esm/server/app-render/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/types.ts"],"names":["zod","dynamicParamTypesSchema","enum","segmentSchema","union","string","tuple","flightRouterStateSchema","lazy","parallelRoutesSchema","record","urlSchema","nullable","optional","refreshSchema","literal","isRootLayoutSchema","boolean"],"mappings":"AAMA,OAAOA,SAAS,MAAK;AAIrB,MAAMC,0BAA0BD,IAAIE,IAAI,CAAC;IAAC;IAAK;IAAM;CAAI;AAQzD,MAAMC,gBAAgBH,IAAII,KAAK,CAAC;IAC9BJ,IAAIK,MAAM;IACVL,IAAIM,KAAK,CAAC;QAACN,IAAIK,MAAM;QAAIL,IAAIK,MAAM;QAAIJ;KAAwB;CAChE;AAMD,OAAO,MAAMM,0BAA0DP,IAAIQ,IAAI,CAC7E;IACE,MAAMC,uBAAuBT,IAAIU,MAAM,CAACH;IACxC,MAAMI,YAAYX,IAAIK,MAAM,GAAGO,QAAQ,GAAGC,QAAQ;IAClD,MAAMC,gBAAgBd,IAAIe,OAAO,CAAC,WAAWH,QAAQ,GAAGC,QAAQ;IAChE,MAAMG,qBAAqBhB,IAAIiB,OAAO,GAAGJ,QAAQ;IAEjD,6EAA6E;IAC7E,gDAAgD;IAChD,OAAOb,IAAII,KAAK,CAAC;QACfJ,IAAIM,KAAK,CAAC;YACRH;YACAM;YACAE;YACAG;YACAE;SACD;QACDhB,IAAIM,KAAK,CAAC;YACRH;YACAM;YACAE;YACAG;SACD;QACDd,IAAIM,KAAK,CAAC;YAACH;YAAeM;YAAsBE;SAAU;QAC1DX,IAAIM,KAAK,CAAC;YAACH;YAAeM;SAAqB;KAChD;AACH,GACD"}

node_modules/next/dist/esm/server/app-render/use-flight-response.js

@@ -0,0 +1,59 @@
+import { encodeText, decodeText } from "../stream-utils/encode-decode";
+import { htmlEscapeJsonString } from "../htmlescape";
+const isEdgeRuntime = process.env.NEXT_RUNTIME === "edge";
+/**
+ * Render Flight stream.
+ * This is only used for renderToHTML, the Flight response does not need additional wrappers.
+ */ export function useFlightResponse(writable, req, clientReferenceManifest, rscChunks, flightResponseRef, nonce) {
+    if (flightResponseRef.current !== null) {
+        return flightResponseRef.current;
+    }
+    // react-server-dom-webpack/client.edge must not be hoisted for require cache clearing to work correctly
+    const { createFromReadableStream } = require(`react-server-dom-webpack/client.edge`);
+    const [renderStream, forwardStream] = req.tee();
+    const res = createFromReadableStream(renderStream, {
+        moduleMap: isEdgeRuntime ? clientReferenceManifest.edgeSSRModuleMapping : clientReferenceManifest.ssrModuleMapping
+    });
+    flightResponseRef.current = res;
+    let bootstrapped = false;
+    // We only attach CSS chunks to the inlined data.
+    const forwardReader = forwardStream.getReader();
+    const writer = writable.getWriter();
+    const startScriptTag = nonce ? `<script nonce=${JSON.stringify(nonce)}>` : "<script>";
+    const textDecoder = new TextDecoder();
+    function read() {
+        forwardReader.read().then(({ done, value })=>{
+            if (value) {
+                rscChunks.push(value);
+            }
+            if (!bootstrapped) {
+                bootstrapped = true;
+                writer.write(encodeText(`${startScriptTag}(self.__next_f=self.__next_f||[]).push(${htmlEscapeJsonString(JSON.stringify([
+                    0
+                ]))})</script>`));
+            }
+            if (done) {
+                // Add a setTimeout here because the error component is too small, the first forwardReader.read() read will return the full chunk
+                // and then it immediately set flightResponseRef.current as null.
+                // react renders the component twice, the second render will run into the state with useFlightResponse where flightResponseRef.current is null,
+                // so it tries to render the flight payload again
+                setTimeout(()=>{
+                    flightResponseRef.current = null;
+                });
+                writer.close();
+            } else {
+                const responsePartial = decodeText(value, textDecoder);
+                const scripts = `${startScriptTag}self.__next_f.push(${htmlEscapeJsonString(JSON.stringify([
+                    1,
+                    responsePartial
+                ]))})</script>`;
+                writer.write(encodeText(scripts));
+                read();
+            }
+        });
+    }
+    read();
+    return res;
+}
+
+//# sourceMappingURL=use-flight-response.js.map

node_modules/next/dist/esm/server/app-render/use-flight-response.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/use-flight-response.tsx"],"names":["encodeText","decodeText","htmlEscapeJsonString","isEdgeRuntime","process","env","NEXT_RUNTIME","useFlightResponse","writable","req","clientReferenceManifest","rscChunks","flightResponseRef","nonce","current","createFromReadableStream","require","renderStream","forwardStream","tee","res","moduleMap","edgeSSRModuleMapping","ssrModuleMapping","bootstrapped","forwardReader","getReader","writer","getWriter","startScriptTag","JSON","stringify","textDecoder","TextDecoder","read","then","done","value","push","write","setTimeout","close","responsePartial","scripts"],"mappings":"AAEA,SAASA,UAAU,EAAEC,UAAU,QAAQ,gCAA+B;AACtE,SAASC,oBAAoB,QAAQ,gBAAe;AAEpD,MAAMC,gBAAgBC,QAAQC,GAAG,CAACC,YAAY,KAAK;AAEnD;;;CAGC,GACD,OAAO,SAASC,kBACdC,QAAoC,EACpCC,GAA+B,EAC/BC,uBAAgD,EAChDC,SAAuB,EACvBC,iBAAoC,EACpCC,KAAc;IAEd,IAAID,kBAAkBE,OAAO,KAAK,MAAM;QACtC,OAAOF,kBAAkBE,OAAO;IAClC;IACA,wGAAwG;IACxG,MAAM,EACJC,wBAAwB,EACzB,GAAGC,QAAQ,CAAC,oCAAoC,CAAC;IAElD,MAAM,CAACC,cAAcC,cAAc,GAAGT,IAAIU,GAAG;IAC7C,MAAMC,MAAML,yBAAyBE,cAAc;QACjDI,WAAWlB,gBACPO,wBAAwBY,oBAAoB,GAC5CZ,wBAAwBa,gBAAgB;IAC9C;IACAX,kBAAkBE,OAAO,GAAGM;IAE5B,IAAII,eAAe;IACnB,iDAAiD;IACjD,MAAMC,gBAAgBP,cAAcQ,SAAS;IAC7C,MAAMC,SAASnB,SAASoB,SAAS;IACjC,MAAMC,iBAAiBhB,QACnB,CAAC,cAAc,EAAEiB,KAAKC,SAAS,CAAClB,OAAO,CAAC,CAAC,GACzC;IACJ,MAAMmB,cAAc,IAAIC;IAExB,SAASC;QACPT,cAAcS,IAAI,GAAGC,IAAI,CAAC,CAAC,EAAEC,IAAI,EAAEC,KAAK,EAAE;YACxC,IAAIA,OAAO;gBACT1B,UAAU2B,IAAI,CAACD;YACjB;YAEA,IAAI,CAACb,cAAc;gBACjBA,eAAe;gBACfG,OAAOY,KAAK,CACVvC,WACE,CAAC,EAAE6B,eAAe,uCAAuC,EAAE3B,qBACzD4B,KAAKC,SAAS,CAAC;oBAAC;iBAAE,GAClB,UAAU,CAAC;YAGnB;YACA,IAAIK,MAAM;gBACR,iIAAiI;gBACjI,iEAAiE;gBACjE,+IAA+I;gBAC/I,iDAAiD;gBACjDI,WAAW;oBACT5B,kBAAkBE,OAAO,GAAG;gBAC9B;gBACAa,OAAOc,KAAK;YACd,OAAO;gBACL,MAAMC,kBAAkBzC,WAAWoC,OAAOL;gBAC1C,MAAMW,UAAU,CAAC,EAAEd,eAAe,mBAAmB,EAAE3B,qBACrD4B,KAAKC,SAAS,CAAC;oBAAC;oBAAGW;iBAAgB,GACnC,UAAU,CAAC;gBAEbf,OAAOY,KAAK,CAACvC,WAAW2C;gBACxBT;YACF;QACF;IACF;IACAA;IAEA,OAAOd;AACT"}

node_modules/next/dist/esm/server/app-render/validate-url.js

@@ -0,0 +1,19 @@
+const DUMMY_ORIGIN = "http://n";
+const INVALID_URL_MESSAGE = "Invalid request URL";
+export function validateURL(url) {
+    if (!url) {
+        throw new Error(INVALID_URL_MESSAGE);
+    }
+    try {
+        const parsed = new URL(url, DUMMY_ORIGIN);
+        // Avoid origin change by extra slashes in pathname
+        if (parsed.origin !== DUMMY_ORIGIN) {
+            throw new Error(INVALID_URL_MESSAGE);
+        }
+        return url;
+    } catch  {
+        throw new Error(INVALID_URL_MESSAGE);
+    }
+}
+
+//# sourceMappingURL=validate-url.js.map

node_modules/next/dist/esm/server/app-render/validate-url.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/validate-url.tsx"],"names":["DUMMY_ORIGIN","INVALID_URL_MESSAGE","validateURL","url","Error","parsed","URL","origin"],"mappings":"AAAA,MAAMA,eAAe;AACrB,MAAMC,sBAAsB;AAE5B,OAAO,SAASC,YAAYC,GAAuB;IACjD,IAAI,CAACA,KAAK;QACR,MAAM,IAAIC,MAAMH;IAClB;IACA,IAAI;QACF,MAAMI,SAAS,IAAIC,IAAIH,KAAKH;QAC5B,mDAAmD;QACnD,IAAIK,OAAOE,MAAM,KAAKP,cAAc;YAClC,MAAM,IAAII,MAAMH;QAClB;QACA,OAAOE;IACT,EAAE,OAAM;QACN,MAAM,IAAIC,MAAMH;IAClB;AACF"}