@bleedingdev/modern-js-renderer-core 0.0.0-bootstrap → 3.9.3-ultramodern.1

package/dist/cjs/server/dispatch.js

@@ -0,0 +1,351 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    dispatchNativeNodeRequest: ()=>dispatchNativeNodeRequest,
+    dispatchNativeRequest: ()=>dispatchNativeRequest,
+    rejectNativeRscRequest: ()=>rejectNativeRscRequest
+});
+const external_abort_js_namespaceObject = require("../abort.js");
+const external_identity_js_namespaceObject = require("../identity.js");
+const index_js_namespaceObject = require("../session/index.js");
+function rejectNativeRscRequest(request) {
+    if (request.headers.has('x-rsc-tree') || request.headers.has('x-rsc-action')) return Response.json({
+        code: 'unsupported-renderer-capability',
+        capability: 'rsc'
+    }, {
+        status: 400,
+        headers: {
+            'cache-control': 'no-store'
+        }
+    });
+}
+function permitsCacheLookup(request) {
+    const url = new URL(request.url);
+    const cacheControl = request.headers.get('cache-control') ?? '';
+    return 'GET' === request.method && !request.headers.has('authorization') && !request.headers.has('cookie') && !request.headers.has('range') && !request.headers.has('if-none-match') && !request.headers.has('if-modified-since') && !request.headers.has('if-match') && !request.headers.has('if-unmodified-since') && !/(?:^|,)\s*(?:private|no-store|no-cache)(?:\s|,|=|$)/i.test(cacheControl) && !/(?:^|,)\s*max-age\s*=\s*(?:0+|"0+")\s*(?:,|$)/i.test(cacheControl) && !/(?:^|,)\s*min-fresh(?:\s|,|=|$)/i.test(cacheControl) && (cacheControl.match(/(?:^|,)\s*max-age\s*=/gi)?.length ?? 0) <= 1 && !request.headers.get('pragma')?.split(',').some((directive)=>'no-cache' === directive.trim().toLowerCase()) && !url.searchParams.has('__loader') && !url.searchParams.has('__ssrDirect');
+}
+function requestMaxAgeSeconds(request) {
+    const match = /(?:^|,)\s*max-age\s*=\s*(?:(\d+)|"(\d+)")\s*(?:,|$)/i.exec(request.headers.get('cache-control') ?? '');
+    return match ? Number(match[1] ?? match[2]) : void 0;
+}
+function documentAgeSeconds(document) {
+    return Math.floor((Date.now() - document.storedAt) / 1000);
+}
+function isReusableDocument(document, key, maxAgeSeconds) {
+    return document.identityKey === key && Number.isFinite(document.storedAt) && document.storedAt <= Date.now() && (void 0 === maxAgeSeconds || Date.now() - document.storedAt < 1000 * maxAgeSeconds) && document.expiresAt > Date.now() && 200 === document.status && document.bytes instanceof Uint8Array && (0, index_js_namespaceObject.permitsDocumentCache)({
+        kind: 'document',
+        status: document.status,
+        headers: document.headers,
+        cache: {
+            mode: 'public',
+            maxAgeSeconds: 1
+        }
+    }) && !(0, index_js_namespaceObject.policyHeaders)(document.headers).has('vary');
+}
+function defaultStatusText(status) {
+    return new Response(null, {
+        status
+    }).statusText;
+}
+function normalizeTerminalResponse(response, session) {
+    if (session.committedPolicy) {
+        if (response.status !== session.committedPolicy.status) throw new Error('Native handler changed HTTP status after committing its response policy.');
+        if (response.statusText !== (session.committedPolicy.statusText ?? defaultStatusText(session.committedPolicy.status))) throw new Error('Native handler changed HTTP status text after committing its response policy.');
+        if (!session.ownsResponseBody(response)) throw new Error('Native handler returned a body outside its committed request session.');
+        return response;
+    }
+    session.resolveResponse({
+        kind: 'terminal',
+        status: response.status,
+        statusText: response.statusText,
+        headers: (0, index_js_namespaceObject.responseHeaders)(response.headers),
+        cache: {
+            mode: 'no-store'
+        }
+    });
+    return session.respond(response.body);
+}
+async function chooseCSR(request, manifest, context) {
+    const url = new URL(request.url);
+    if ('GET' !== request.method && 'HEAD' !== request.method || url.searchParams.has('__loader') || url.searchParams.has('__ssrDirect')) return false;
+    const config = context.serverConfig;
+    if (config?.ssr === false || config?.forceCSR) return true;
+    const selectedIds = config?.ssrByRouteIds;
+    if (!selectedIds?.length) return false;
+    if (!manifest.nativeMatchRouteIds) throw new Error('unsupported-renderer-capability: ssrByRouteIds requires native route matching.');
+    const matchedIds = await (0, external_abort_js_namespaceObject.untilAborted)(manifest.nativeMatchRouteIds(request, context), context.session.signal);
+    const leafId = matchedIds.at(-1);
+    return !leafId || !selectedIds.includes(leafId);
+}
+function captureDocument(response, session, options, key, identityKey) {
+    if (!response.body || !options.cache) return response;
+    const reader = response.body.getReader();
+    const chunks = [];
+    const maximum = options.maxCacheBytes ?? 2097152;
+    let total = 0;
+    let canCapture = Number.isSafeInteger(maximum) && maximum > 0;
+    let delivered;
+    const nativeHeaders = (0, index_js_namespaceObject.responseHeaders)(response.headers);
+    const body = new ReadableStream({
+        async pull (controller) {
+            try {
+                const part = await reader.read();
+                if (!part.done) {
+                    if (canCapture) {
+                        total += part.value.byteLength;
+                        if (total <= maximum) chunks.push(part.value.slice());
+                        else {
+                            canCapture = false;
+                            chunks.length = 0;
+                        }
+                    }
+                    controller.enqueue(part.value);
+                    return;
+                }
+                reader.releaseLock();
+                const completion = await session.completion;
+                const policy = session.committedPolicy;
+                if (canCapture && completion.cacheEligible && policy?.cache.mode === 'public' && policy.cache.maxAgeSeconds > 0 && 200 === delivered.status && !delivered.headers.has('vary') && (0, index_js_namespaceObject.permitsDocumentCache)({
+                    ...policy,
+                    status: delivered.status,
+                    headers: (0, index_js_namespaceObject.responseHeaders)(delivered.headers)
+                })) {
+                    const maxAgeSeconds = policy.cache.maxAgeSeconds;
+                    const bytes = new Uint8Array(total);
+                    let offset = 0;
+                    for (const chunk of chunks){
+                        bytes.set(chunk, offset);
+                        offset += chunk.byteLength;
+                    }
+                    const commit = async (headers)=>{
+                        if (!headers || headers.has('vary') || !(0, index_js_namespaceObject.permitsDocumentCache)({
+                            ...policy,
+                            status: delivered.status,
+                            headers: (0, index_js_namespaceObject.responseHeaders)(headers)
+                        })) return;
+                        const lifetimeSeconds = Math.min(maxAgeSeconds, ...(0, index_js_namespaceObject.headerMaxAgeSeconds)(headers));
+                        const age = headers.get('age')?.trim() ?? '0';
+                        const date = Date.parse(headers.get('date') ?? '');
+                        const ageSeconds = Math.max(/^\d+$/u.test(age) ? Number(age) : 0, Number.isFinite(date) ? Math.floor((Date.now() - date) / 1000) : 0);
+                        if (lifetimeSeconds - ageSeconds <= 0) return;
+                        try {
+                            const storedAt = Date.now() - 1000 * ageSeconds;
+                            await options.cache?.set(key, {
+                                identityKey,
+                                storedAt,
+                                expiresAt: storedAt + 1000 * lifetimeSeconds,
+                                status: 200,
+                                statusText: delivered.statusText,
+                                headers: nativeHeaders,
+                                bytes
+                            });
+                        } catch (error) {
+                            options.onCacheError?.(error);
+                        }
+                    };
+                    if (options.confirmDelivery) {
+                        chunks.length = 0;
+                        controller.close();
+                        options.confirmDelivery(delivered).then(commit).catch((error)=>{
+                            options.onCacheError?.(error);
+                        });
+                        return;
+                    }
+                    commit(delivered.headers).catch((error)=>{
+                        options.onCacheError?.(error);
+                    });
+                }
+                chunks.length = 0;
+                controller.close();
+            } catch (error) {
+                chunks.length = 0;
+                session.fail(error);
+                await session.completion;
+                controller.error(error);
+            }
+        },
+        async cancel (reason) {
+            chunks.length = 0;
+            reader.cancel(reason).catch(()=>void 0);
+            session.abort(reason);
+            await session.completion;
+            reader.releaseLock();
+        }
+    }, {
+        highWaterMark: 0
+    });
+    delivered = new Response(body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+    });
+    return delivered;
+}
+function openSession(request, options) {
+    const session = (0, index_js_namespaceObject.createRequestSession)({
+        request,
+        identity: options.identity,
+        platform: {
+            kind: options.platform ?? 'node',
+            bindings: options.context.bindings
+        }
+    });
+    options.executionContext?.waitUntil(session.completion);
+    return session;
+}
+async function dispatchNativeRequest(request, options) {
+    const rscRejection = rejectNativeRscRequest(request);
+    if (rscRejection) return rscRejection;
+    const identityKey = (0, external_identity_js_namespaceObject.identityCacheKey)(options.identity);
+    if ('react' === options.identity.renderer) throw new Error('Native dispatch requires Solid or Octane.');
+    let session = openSession(request, options);
+    const { bindings: _bindings, ...renderContext } = options.context;
+    let context = {
+        ...renderContext,
+        session,
+        entry: session.identity
+    };
+    let handlerStarted = false;
+    try {
+        session.signal.throwIfAborted();
+        const manifest = await (0, external_abort_js_namespaceObject.untilAborted)(options.loadManifest(), session.signal);
+        (0, external_identity_js_namespaceObject.assertRendererIdentity)(manifest.rendererIdentity, options.identity);
+        if ('function' != typeof manifest.nativeRequestHandler) throw new Error('Native renderer manifest has no request handler.');
+        const csr = await chooseCSR(request, manifest, context);
+        session.signal.throwIfAborted();
+        if (csr && !manifest.nativeCSRRequestHandler) throw new Error('unsupported-renderer-capability: selected CSR requires a native document handler.');
+        if (csr) session.markFallback();
+        if (void 0 !== options.hydrationBuildId && ('string' != typeof options.hydrationBuildId || !options.hydrationBuildId.trim())) throw new Error('Native hydration cache identity requires a nonempty build ID.');
+        const cacheKey = (0, index_js_namespaceObject.documentCacheKey)(options.identity, JSON.stringify([
+            request.url,
+            options.hydrationBuildId ?? options.identity.buildId,
+            options.context.assets ?? [],
+            options.context.nonce ?? null
+        ]));
+        const cacheAllowed = !csr && permitsCacheLookup(request);
+        if (cacheAllowed && options.cache) try {
+            const cached = await (0, external_abort_js_namespaceObject.untilAborted)(options.cache.get(cacheKey), session.signal);
+            if (cached && isReusableDocument(cached, identityKey, requestMaxAgeSeconds(request))) {
+                const age = documentAgeSeconds(cached);
+                session.resolveResponse({
+                    kind: 'terminal',
+                    status: cached.status,
+                    statusText: cached.statusText,
+                    headers: [
+                        ...cached.headers.filter(([name])=>'age' !== name.toLowerCase()),
+                        [
+                            'age',
+                            String(age)
+                        ]
+                    ],
+                    cache: {
+                        mode: 'no-store'
+                    }
+                });
+                return session.respond(new ReadableStream({
+                    start (controller) {
+                        controller.enqueue(cached.bytes.slice());
+                        controller.close();
+                    }
+                }));
+            }
+        } catch (error) {
+            if (session.signal.aborted) throw error;
+            options.onCacheError?.(error);
+        }
+        session.signal.throwIfAborted();
+        handlerStarted = true;
+        let response = await (0, external_abort_js_namespaceObject.untilAborted)((csr ? manifest.nativeCSRRequestHandler : manifest.nativeRequestHandler)(request, context), session.signal);
+        if (!(response instanceof Response)) throw new TypeError('Native renderer handler must return a Fetch Response.');
+        response = normalizeTerminalResponse(response, session);
+        if ('HEAD' === request.method && response.body) {
+            response.body.cancel().catch(()=>{});
+            return new Response(null, {
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers
+            });
+        }
+        return cacheAllowed ? captureDocument(response, session, options, cacheKey, identityKey) : response;
+    } catch (error) {
+        const committed = void 0 !== session.committedPolicy;
+        session.fail(error);
+        await session.completion;
+        if (!handlerStarted || committed || request.signal.aborted || !options.onError) throw error;
+        session = openSession(request, options);
+        session.markFallback();
+        context = {
+            ...context,
+            session
+        };
+        try {
+            const response = await (0, external_abort_js_namespaceObject.untilAborted)(options.onError(error, request, context), session.signal);
+            if (!(response instanceof Response)) throw new TypeError('Native fallback must return a Fetch Response.');
+            const owned = normalizeTerminalResponse(response, session);
+            if ('HEAD' === request.method && owned.body) {
+                owned.body.cancel().catch(()=>{});
+                return new Response(null, {
+                    status: owned.status,
+                    statusText: owned.statusText,
+                    headers: owned.headers
+                });
+            }
+            return owned;
+        } catch (fallbackError) {
+            session.fail(fallbackError);
+            await session.completion;
+            throw fallbackError;
+        }
+    }
+}
+function dispatchNativeNodeRequest(request, options) {
+    const fetchRequest = null === request.body ? request : new Request(request.url, {
+        method: request.method,
+        headers: request.headers,
+        body: request.body,
+        signal: request.signal,
+        duplex: 'half'
+    });
+    return dispatchNativeRequest(fetchRequest, {
+        ...options,
+        platform: 'node'
+    });
+}
+exports.dispatchNativeNodeRequest = __webpack_exports__.dispatchNativeNodeRequest;
+exports.dispatchNativeRequest = __webpack_exports__.dispatchNativeRequest;
+exports.rejectNativeRscRequest = __webpack_exports__.rejectNativeRscRequest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "dispatchNativeNodeRequest",
+    "dispatchNativeRequest",
+    "rejectNativeRscRequest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/server/index.js

@@ -0,0 +1,57 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    RENDERER_ASSET_MANIFEST_FILE: ()=>external_assets_js_namespaceObject.RENDERER_ASSET_MANIFEST_FILE,
+    dispatchNativeNodeRequest: ()=>external_dispatch_js_namespaceObject.dispatchNativeNodeRequest,
+    dispatchNativeRequest: ()=>external_dispatch_js_namespaceObject.dispatchNativeRequest,
+    dispatchNativeWorkerRequest: ()=>external_worker_js_namespaceObject.dispatchNativeWorkerRequest,
+    rejectNativeRscRequest: ()=>external_dispatch_js_namespaceObject.rejectNativeRscRequest,
+    validateNativeClientAssetManifest: ()=>external_assets_js_namespaceObject.validateNativeClientAssetManifest
+});
+const external_assets_js_namespaceObject = require("./assets.js");
+const external_dispatch_js_namespaceObject = require("./dispatch.js");
+const external_worker_js_namespaceObject = require("./worker.js");
+exports.RENDERER_ASSET_MANIFEST_FILE = __webpack_exports__.RENDERER_ASSET_MANIFEST_FILE;
+exports.dispatchNativeNodeRequest = __webpack_exports__.dispatchNativeNodeRequest;
+exports.dispatchNativeRequest = __webpack_exports__.dispatchNativeRequest;
+exports.dispatchNativeWorkerRequest = __webpack_exports__.dispatchNativeWorkerRequest;
+exports.rejectNativeRscRequest = __webpack_exports__.rejectNativeRscRequest;
+exports.validateNativeClientAssetManifest = __webpack_exports__.validateNativeClientAssetManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RENDERER_ASSET_MANIFEST_FILE",
+    "dispatchNativeNodeRequest",
+    "dispatchNativeRequest",
+    "dispatchNativeWorkerRequest",
+    "rejectNativeRscRequest",
+    "validateNativeClientAssetManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/server/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/server/worker.js

@@ -0,0 +1,73 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    dispatchNativeWorkerRequest: ()=>dispatchNativeWorkerRequest
+});
+const external_document_js_namespaceObject = require("../document.js");
+const external_identity_js_namespaceObject = require("../identity.js");
+const external_dispatch_js_namespaceObject = require("./dispatch.js");
+function workerManifest(bundle, identity) {
+    const candidate = bundle && 'object' == typeof bundle && !('rendererIdentity' in bundle) && 'default' in bundle ? bundle.default : bundle;
+    if (!candidate || 'object' != typeof candidate && 'function' != typeof candidate || !('rendererIdentity' in candidate) || !('nativeRequestHandler' in candidate) || 'function' != typeof candidate.nativeRequestHandler) throw new Error('Native worker bundle requires its renderer identity and request handler.');
+    (0, external_identity_js_namespaceObject.assertRendererIdentity)(candidate.rendererIdentity, identity);
+    return candidate;
+}
+function dispatchNativeWorkerRequest(request, options) {
+    const rejection = (0, external_dispatch_js_namespaceObject.rejectNativeRscRequest)(request);
+    if (rejection) return Promise.resolve(rejection);
+    const { resources } = options;
+    const query = new URL(request.url).searchParams;
+    const forceCSR = Boolean(resources.csrFallbackHeader && (query.get('csr') || request.headers.get(resources.csrFallbackHeader)));
+    const bindings = null !== options.bindings && 'object' == typeof options.bindings ? options.bindings : {};
+    return (0, external_dispatch_js_namespaceObject.dispatchNativeRequest)(request, {
+        identity: options.identity,
+        platform: 'worker',
+        executionContext: options.executionContext,
+        hydrationBuildId: resources.hydrationBuildId,
+        loadManifest: ()=>workerManifest(options.bundle, options.identity),
+        context: {
+            assets: (0, external_document_js_namespaceObject.collectDocumentAssets)(resources.assets),
+            nativeManifest: resources.nativeManifest,
+            bindings,
+            serverConfig: {
+                ...resources.serverConfig,
+                forceCSR
+            },
+            nonce: resources.nonce
+        }
+    });
+}
+exports.dispatchNativeWorkerRequest = __webpack_exports__.dispatchNativeWorkerRequest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "dispatchNativeWorkerRequest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/session/cache.js

@@ -0,0 +1,172 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    documentCacheKey: ()=>documentCacheKey,
+    headerMaxAgeSeconds: ()=>headerMaxAgeSeconds,
+    parseCacheControl: ()=>parseCacheControl,
+    permitsDocumentCache: ()=>permitsDocumentCache,
+    policyHeaders: ()=>policyHeaders,
+    responseHeaders: ()=>responseHeaders,
+    restrictDocumentCache: ()=>restrictDocumentCache
+});
+const external_identity_js_namespaceObject = require("../identity.js");
+function documentCacheKey(identity, requestKey) {
+    if ('string' != typeof requestKey || 0 === requestKey.length) throw new TypeError('A document cache request key must be nonempty.');
+    return JSON.stringify([
+        (0, external_identity_js_namespaceObject.identityCacheKey)(identity),
+        requestKey
+    ]);
+}
+function responseHeaders(headers) {
+    const fields = [];
+    headers.forEach((value, name)=>{
+        if ('set-cookie' !== name) fields.push([
+            name,
+            value
+        ]);
+    });
+    for (const cookie of headers.getSetCookie())fields.push([
+        'set-cookie',
+        cookie
+    ]);
+    return fields;
+}
+function policyHeaders(headers) {
+    const result = new Headers();
+    for (const [name, value] of headers)result.append(name, value);
+    return result;
+}
+const NO_STORE = {
+    mode: 'no-store',
+    ages: []
+};
+const CACHE_DIRECTIVE = /\s*([!#$%&'*+.^_`|~\w-]+)\s*(?:=\s*([!#$%&'*+.^_`|~\w-]+|"(?:[^"\\]|\\.)*"))?\s*(?:,|$)/uy;
+function parseCacheControl(value) {
+    const directives = [];
+    let index = 0;
+    while(index < value.length){
+        CACHE_DIRECTIVE.lastIndex = index;
+        const match = CACHE_DIRECTIVE.exec(value);
+        if (!match || CACHE_DIRECTIVE.lastIndex === index) return;
+        directives.push({
+            name: match[1].toLowerCase(),
+            value: match[2]
+        });
+        index = CACHE_DIRECTIVE.lastIndex;
+    }
+    return directives;
+}
+function cacheDirectives(value) {
+    let mode = 'public';
+    const ages = [];
+    const ageNames = new Set();
+    const parsed = parseCacheControl(value ?? '');
+    if (!parsed) return NO_STORE;
+    for (const { name, value: raw } of parsed){
+        if ('no-store' === name || 'no-cache' === name) mode = 'no-store';
+        else if ('private' === name && 'no-store' !== mode) mode = 'private';
+        if ('max-age' === name || 's-maxage' === name) {
+            const age = Number(raw);
+            if (ageNames.has(name) || !/^\d+$/u.test(raw ?? '') || !Number.isSafeInteger(age)) return NO_STORE;
+            ageNames.add(name);
+            ages.push(age);
+        }
+    }
+    return {
+        mode,
+        ages
+    };
+}
+function headerMaxAgeSeconds(headers) {
+    return cacheDirectives(headers.get('cache-control')).ages;
+}
+function headerCacheMode(headers, ages) {
+    const control = cacheDirectives(headers.get('cache-control'));
+    ages.push(...control.ages);
+    if (headers.has('set-cookie') || headers.get('vary')?.split(',').some((value)=>'*' === value.trim())) return 'no-store';
+    return control.mode;
+}
+function isSingleHtmlContentType(headers) {
+    const type = headers.get('content-type');
+    return !type?.includes(',') && type?.split(';')[0].trim().toLowerCase() === 'text/html';
+}
+function permitsDocumentCache(policy) {
+    if ('document' !== policy.kind || 200 !== policy.status || 'public' !== policy.cache.mode) return false;
+    const headers = policyHeaders(policy.headers);
+    return 'public' === headerCacheMode(headers, []) && isSingleHtmlContentType(headers);
+}
+function restrictDocumentCache(policy, sources, outgoing) {
+    const original = policyHeaders(policy.headers);
+    let mode = policy.cache.mode;
+    const ages = 'public' === policy.cache.mode ? [
+        policy.cache.maxAgeSeconds
+    ] : [];
+    for (const headers of [
+        original,
+        ...sources,
+        outgoing
+    ]){
+        const restricted = headerCacheMode(headers, ages);
+        if ('no-store' === restricted) mode = 'no-store';
+        else if ('private' === restricted && 'public' === mode) mode = 'private';
+    }
+    if ('document' !== policy.kind || 200 !== policy.status || !isSingleHtmlContentType(original) || !isSingleHtmlContentType(outgoing)) mode = 'no-store';
+    if ('public' === mode) {
+        const maxAgeSeconds = Math.min(...ages);
+        outgoing.set('cache-control', `public, max-age=${maxAgeSeconds}, s-maxage=${maxAgeSeconds}, must-revalidate`);
+        return {
+            mode,
+            maxAgeSeconds
+        };
+    }
+    outgoing.set('cache-control', 'private' === mode ? 'private, max-age=0, must-revalidate' : 'no-store');
+    return {
+        mode
+    };
+}
+exports.documentCacheKey = __webpack_exports__.documentCacheKey;
+exports.headerMaxAgeSeconds = __webpack_exports__.headerMaxAgeSeconds;
+exports.parseCacheControl = __webpack_exports__.parseCacheControl;
+exports.permitsDocumentCache = __webpack_exports__.permitsDocumentCache;
+exports.policyHeaders = __webpack_exports__.policyHeaders;
+exports.responseHeaders = __webpack_exports__.responseHeaders;
+exports.restrictDocumentCache = __webpack_exports__.restrictDocumentCache;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "documentCacheKey",
+    "headerMaxAgeSeconds",
+    "parseCacheControl",
+    "permitsDocumentCache",
+    "policyHeaders",
+    "responseHeaders",
+    "restrictDocumentCache"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});