@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.4 → 3.9.0-ultramodern.5

package/dist/cjs/request-policy/requestContext.js

@@ -0,0 +1,137 @@
+"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__, {
+    BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS: ()=>external_types_js_namespaceObject.BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS,
+    BFF_ENVELOPE_HEADER: ()=>external_types_js_namespaceObject.BFF_ENVELOPE_HEADER,
+    BFF_LOCALE_HEADER: ()=>BFF_LOCALE_HEADER,
+    BFF_OPERATION_CONTEXT_DETAIL_HEADER: ()=>external_types_js_namespaceObject.BFF_OPERATION_CONTEXT_DETAIL_HEADER,
+    BFF_OPERATION_CONTEXT_HEADER: ()=>external_types_js_namespaceObject.BFF_OPERATION_CONTEXT_HEADER,
+    BFF_TRACEPARENT_HEADER: ()=>BFF_TRACEPARENT_HEADER,
+    createRequestContextHeaders: ()=>createRequestContextHeaders,
+    createRequestContextSnapshot: ()=>createRequestContextSnapshot,
+    parseTraceparent: ()=>external_traceparent_js_namespaceObject.parseTraceparent
+});
+const external_traceparent_js_namespaceObject = require("./traceparent.js");
+const external_types_js_namespaceObject = require("./types.js");
+const BFF_LOCALE_HEADER = 'accept-language';
+const BFF_TRACEPARENT_HEADER = 'traceparent';
+const readHeader = (headers, header)=>{
+    if (!headers) return;
+    const normalized = header.toLowerCase();
+    const key = Object.keys(headers).find((current)=>current.toLowerCase() === normalized);
+    if (!key) return;
+    const value = headers[key];
+    return Array.isArray(value) ? value[0] : value;
+};
+const readString = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
+function createOperationContextSnapshot(operationContext, safeContext) {
+    if (!operationContext) return;
+    const snapshot = {
+        ...operationContext,
+        ...safeContext.locale || operationContext?.locale ? {
+            locale: safeContext.locale || operationContext?.locale
+        } : {},
+        ...safeContext.traceparent || operationContext?.traceparent ? {
+            traceparent: safeContext.traceparent || operationContext?.traceparent
+        } : {},
+        ...safeContext.traceId || operationContext?.traceId ? {
+            traceId: safeContext.traceId || operationContext?.traceId
+        } : {},
+        ...safeContext.spanId || operationContext?.spanId ? {
+            spanId: safeContext.spanId || operationContext?.spanId
+        } : {}
+    };
+    return Object.keys(snapshot).some((key)=>void 0 !== snapshot[key]) ? snapshot : void 0;
+}
+function createRequestContextSnapshot(input = {}) {
+    const locale = readString(input.locale) || readString(readHeader(input.headers, BFF_LOCALE_HEADER));
+    const traceparent = readString(input.traceparent) || readString(input.operationContext?.traceparent) || readString(readHeader(input.headers, BFF_TRACEPARENT_HEADER));
+    const parsedTraceparent = input.operationContext?.traceId && input.operationContext?.spanId ? {
+        traceId: input.operationContext.traceId,
+        spanId: input.operationContext.spanId
+    } : (0, external_traceparent_js_namespaceObject.parseTraceparent)(traceparent);
+    const headers = {};
+    if (locale) headers[BFF_LOCALE_HEADER] = locale;
+    if (traceparent) headers[BFF_TRACEPARENT_HEADER] = traceparent;
+    const operationContext = createOperationContextSnapshot(input.operationContext, {
+        ...locale ? {
+            locale
+        } : {},
+        ...traceparent ? {
+            traceparent
+        } : {},
+        ...parsedTraceparent ? {
+            traceId: parsedTraceparent.traceId,
+            spanId: parsedTraceparent.spanId
+        } : {}
+    });
+    return {
+        headers,
+        ...locale ? {
+            locale
+        } : {},
+        ...traceparent ? {
+            traceparent
+        } : {},
+        ...parsedTraceparent ? {
+            traceId: parsedTraceparent.traceId,
+            spanId: parsedTraceparent.spanId
+        } : {},
+        ...operationContext ? {
+            operationContext
+        } : {}
+    };
+}
+function createRequestContextHeaders(input = {}) {
+    return createRequestContextSnapshot(input).headers;
+}
+exports.BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS = __webpack_exports__.BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS;
+exports.BFF_ENVELOPE_HEADER = __webpack_exports__.BFF_ENVELOPE_HEADER;
+exports.BFF_LOCALE_HEADER = __webpack_exports__.BFF_LOCALE_HEADER;
+exports.BFF_OPERATION_CONTEXT_DETAIL_HEADER = __webpack_exports__.BFF_OPERATION_CONTEXT_DETAIL_HEADER;
+exports.BFF_OPERATION_CONTEXT_HEADER = __webpack_exports__.BFF_OPERATION_CONTEXT_HEADER;
+exports.BFF_TRACEPARENT_HEADER = __webpack_exports__.BFF_TRACEPARENT_HEADER;
+exports.createRequestContextHeaders = __webpack_exports__.createRequestContextHeaders;
+exports.createRequestContextSnapshot = __webpack_exports__.createRequestContextSnapshot;
+exports.parseTraceparent = __webpack_exports__.parseTraceparent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS",
+    "BFF_ENVELOPE_HEADER",
+    "BFF_LOCALE_HEADER",
+    "BFF_OPERATION_CONTEXT_DETAIL_HEADER",
+    "BFF_OPERATION_CONTEXT_HEADER",
+    "BFF_TRACEPARENT_HEADER",
+    "createRequestContextHeaders",
+    "createRequestContextSnapshot",
+    "parseTraceparent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/request-policy/traceparent.js

@@ -0,0 +1,56 @@
+"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__);
+const TRACEPARENT_REGEX = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/i;
+const isAllZeroHex = (value)=>/^0+$/.test(value);
+function parseTraceparent(traceparent) {
+    if (!traceparent) return;
+    const match = traceparent.trim().match(TRACEPARENT_REGEX);
+    if (!match) return;
+    const [, rawTraceId, rawSpanId, rawFlags] = match;
+    if (!rawTraceId || !rawSpanId || !rawFlags) return;
+    const traceId = rawTraceId.toLowerCase();
+    const spanId = rawSpanId.toLowerCase();
+    if (isAllZeroHex(traceId) || isAllZeroHex(spanId)) return;
+    return {
+        traceId,
+        spanId,
+        sampled: (0x1 & Number.parseInt(rawFlags, 16)) === 1
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    parseTraceparent: ()=>parseTraceparent
+});
+exports.parseTraceparent = __webpack_exports__.parseTraceparent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "parseTraceparent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/request-policy/transport.js

@@ -0,0 +1,234 @@
+"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__);
+const DEFAULT_RETRYABLE_STATUS_CODES = [
+    408,
+    425,
+    429,
+    500,
+    502,
+    503,
+    504
+];
+const DEFAULT_BASE_DELAY_MS = 100;
+const DEFAULT_MAX_DELAY_MS = 1000;
+const DEFAULT_JITTER_RATIO = 0.1;
+const DEFAULT_RETRYABLE_METHODS = new Set([
+    'DELETE',
+    'GET',
+    'HEAD',
+    'OPTIONS',
+    'PUT',
+    'TRACE'
+]);
+const createTimeoutError = (timeoutMs)=>{
+    const error = new Error(`Request timed out after ${timeoutMs}ms`);
+    error.name = 'TimeoutError';
+    return error;
+};
+const unrefTimer = (timer)=>{
+    if ('object' == typeof timer && null !== timer && 'unref' in timer && 'function' == typeof timer.unref) timer.unref();
+};
+const wait = (ms)=>new Promise((resolve)=>{
+        const timer = setTimeout(()=>resolve(), ms);
+        unrefTimer(timer);
+    });
+const toStatusCode = (error)=>{
+    if (!error || 'object' != typeof error) return;
+    const status = error.status;
+    if ('number' == typeof status) return status;
+    const responseStatus = error.response?.status;
+    if ('number' == typeof responseStatus) return responseStatus;
+};
+const isRetryableNetworkError = (error)=>{
+    if (!error || 'object' != typeof error) return false;
+    const name = error.name;
+    if ('FetchError' === name || 'TimeoutError' === name || 'TypeError' === name) return true;
+    const code = error.code;
+    return 'ECONNRESET' === code || 'ETIMEDOUT' === code || 'ECONNREFUSED' === code || 'EPIPE' === code;
+};
+const normalizePositiveNumber = (value, fallback)=>'number' == typeof value && Number.isFinite(value) && value > 0 ? value : fallback;
+const normalizeNonNegativeInt = (value, fallback)=>'number' == typeof value && Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
+const normalizeJitterRatio = (value)=>{
+    if ('number' != typeof value || !Number.isFinite(value)) return DEFAULT_JITTER_RATIO;
+    return Math.max(0, Math.min(1, value));
+};
+const shouldRetryWithDefaults = (method, statusCode, error, retryableStatusCodes)=>{
+    if (!DEFAULT_RETRYABLE_METHODS.has(method.toUpperCase())) return false;
+    if ('number' == typeof statusCode) return retryableStatusCodes.includes(statusCode);
+    return isRetryableNetworkError(error);
+};
+const shouldRetry = (retryOptions, context, retryableStatusCodes)=>{
+    if ('function' == typeof retryOptions?.shouldRetry) try {
+        return retryOptions.shouldRetry(context);
+    } catch (error) {
+        return false;
+    }
+    return shouldRetryWithDefaults(context.method, context.statusCode, context.error, retryableStatusCodes);
+};
+const getBackoffMs = (retryOptions, attempt)=>{
+    const baseDelayMs = normalizePositiveNumber(retryOptions?.baseDelayMs, DEFAULT_BASE_DELAY_MS);
+    const maxDelayMs = normalizePositiveNumber(retryOptions?.maxDelayMs, DEFAULT_MAX_DELAY_MS);
+    const jitterRatio = normalizeJitterRatio(retryOptions?.jitterRatio);
+    const exponentialDelay = Math.min(maxDelayMs, baseDelayMs * 2 ** Math.max(0, attempt - 1));
+    const jitterFactor = 0 === jitterRatio ? 1 : 1 + (2 * Math.random() - 1) * jitterRatio;
+    return Math.max(0, Math.floor(exponentialDelay * jitterFactor));
+};
+const emitDegradedEvent = (transport, event)=>{
+    if ('function' != typeof transport?.onDegraded) return;
+    try {
+        transport.onDegraded(event);
+    } catch (error) {}
+};
+const withTimeout = async (promise, timeoutMs, signalBuilder)=>{
+    if (!timeoutMs || timeoutMs <= 0) {
+        const result = await promise;
+        return {
+            result
+        };
+    }
+    const controller = signalBuilder?.();
+    let timeoutTriggered = false;
+    let rejectTimeout;
+    const timeoutPromise = new Promise((_, reject)=>{
+        rejectTimeout = reject;
+    });
+    const timer = setTimeout(()=>{
+        timeoutTriggered = true;
+        if (controller) controller.abort();
+        rejectTimeout?.(createTimeoutError(timeoutMs));
+    }, timeoutMs);
+    unrefTimer(timer);
+    try {
+        const result = await Promise.race([
+            promise,
+            timeoutPromise
+        ]);
+        return {
+            result,
+            timeoutTriggered
+        };
+    } catch (error) {
+        if (timeoutTriggered && error?.name === 'AbortError') throw createTimeoutError(timeoutMs);
+        throw error;
+    } finally{
+        clearTimeout(timer);
+    }
+};
+const executeWithResilience = async ({ requestId, target, method, url, init, fetcher, transport })=>{
+    const retries = normalizeNonNegativeInt(transport?.retry?.retries, 0);
+    const timeoutMs = 'number' == typeof transport?.timeoutMs && transport.timeoutMs > 0 ? transport.timeoutMs : void 0;
+    const maxAttempts = retries + 1;
+    const retryableStatusCodes = transport?.retry?.retryableStatusCodes && transport.retry.retryableStatusCodes.length > 0 ? transport.retry.retryableStatusCodes : DEFAULT_RETRYABLE_STATUS_CODES;
+    let attempt = 0;
+    while(attempt < maxAttempts){
+        attempt += 1;
+        const canUseAbortController = "u" > typeof AbortController;
+        let controller;
+        if (timeoutMs && canUseAbortController) controller = new AbortController();
+        const callerSignal = init.signal;
+        const requestSignal = controller ? callerSignal && !callerSignal.aborted ? AbortSignal.any([
+            callerSignal,
+            controller.signal
+        ]) : callerSignal || controller.signal : callerSignal;
+        const nextInit = requestSignal ? {
+            ...init,
+            signal: requestSignal
+        } : init;
+        try {
+            const { result } = await withTimeout(fetcher(url, nextInit), timeoutMs, ()=>controller);
+            return result;
+        } catch (error) {
+            const statusCode = toStatusCode(error);
+            const decisionContext = {
+                requestId,
+                target,
+                method,
+                url,
+                attempt,
+                maxAttempts,
+                error,
+                statusCode
+            };
+            if (error?.name === 'TimeoutError') emitDegradedEvent(transport, {
+                requestId,
+                target,
+                method,
+                url,
+                reason: 'timeout',
+                attempt,
+                maxAttempts,
+                timeoutMs,
+                statusCode,
+                error
+            });
+            const canRetry = attempt < maxAttempts && shouldRetry(transport?.retry, decisionContext, retryableStatusCodes);
+            if (!canRetry) {
+                if (retries > 0 || error?.name === 'TimeoutError') emitDegradedEvent(transport, {
+                    requestId,
+                    target,
+                    method,
+                    url,
+                    reason: 'retry_exhausted',
+                    attempt,
+                    maxAttempts,
+                    timeoutMs,
+                    statusCode,
+                    error
+                });
+                throw error;
+            }
+            const backoffMs = getBackoffMs(transport?.retry, attempt);
+            emitDegradedEvent(transport, {
+                requestId,
+                target,
+                method,
+                url,
+                reason: 'retry',
+                attempt,
+                maxAttempts,
+                timeoutMs,
+                backoffMs,
+                statusCode,
+                error
+            });
+            if (backoffMs > 0) await wait(backoffMs);
+        }
+    }
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    executeWithResilience: executeWithResilience
+});
+exports.executeWithResilience = __webpack_exports__.executeWithResilience;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "executeWithResilience"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/request-policy/types.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__);
+const BFF_ENVELOPE_HEADER = 'x-modernjs-bff-envelope';
+const BFF_OPERATION_CONTEXT_HEADER = 'x-operation-id';
+const BFF_OPERATION_CONTEXT_DETAIL_HEADER = 'x-modernjs-bff-operation-context';
+const BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS = [
+    'x-tenant-id',
+    'x-subject-id',
+    'x-user-id',
+    BFF_OPERATION_CONTEXT_HEADER
+];
+__webpack_require__.d(__webpack_exports__, {}, {
+    BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS: BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS,
+    BFF_ENVELOPE_HEADER: BFF_ENVELOPE_HEADER,
+    BFF_OPERATION_CONTEXT_DETAIL_HEADER: BFF_OPERATION_CONTEXT_DETAIL_HEADER,
+    BFF_OPERATION_CONTEXT_HEADER: BFF_OPERATION_CONTEXT_HEADER
+});
+exports.BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS = __webpack_exports__.BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS;
+exports.BFF_ENVELOPE_HEADER = __webpack_exports__.BFF_ENVELOPE_HEADER;
+exports.BFF_OPERATION_CONTEXT_DETAIL_HEADER = __webpack_exports__.BFF_OPERATION_CONTEXT_DETAIL_HEADER;
+exports.BFF_OPERATION_CONTEXT_HEADER = __webpack_exports__.BFF_OPERATION_CONTEXT_HEADER;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS",
+    "BFF_ENVELOPE_HEADER",
+    "BFF_OPERATION_CONTEXT_DETAIL_HEADER",
+    "BFF_OPERATION_CONTEXT_HEADER"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/routeHydration.js

@@ -0,0 +1,127 @@
+"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__, {
+    createRouteHydrationScriptTags: ()=>createRouteHydrationScriptTags,
+    getMatchedRouteChunks: ()=>getMatchedRouteChunks,
+    injectBeforeHydrationEntryScript: ()=>injectBeforeHydrationEntryScript,
+    orderHydrationScriptChunks: ()=>orderHydrationScriptChunks,
+    replaceChunkJsPlaceholder: ()=>replaceChunkJsPlaceholder
+});
+const external_html_js_namespaceObject = require("./html.js");
+function getScriptTags(template) {
+    const scriptRegExp = /<script\b[^>]*\bsrc=(["'])(.*?)\1[^>]*><\/script>/g;
+    return Array.from(template.matchAll(scriptRegExp)).map((match)=>({
+            index: match.index ?? 0,
+            tag: match[0],
+            src: match[2]
+        }));
+}
+function getAssetBasename(src) {
+    const withoutQuery = src.split(/[?#]/)[0];
+    return withoutQuery.split('/').pop() || withoutQuery;
+}
+function isEntryScript(src, entryName, asyncEntry) {
+    const basename = getAssetBasename(src);
+    const prefix = asyncEntry ? `async-${entryName}` : entryName;
+    return basename === `${prefix}.js` || basename.startsWith(`${prefix}.`) || basename.startsWith(`${prefix}-`);
+}
+const dedupeByUrl = (chunks)=>{
+    const seen = new Set();
+    return chunks.filter((chunk)=>{
+        if (void 0 === chunk.url || '' === chunk.url || seen.has(chunk.url)) return false;
+        seen.add(chunk.url);
+        return true;
+    });
+};
+const isAsyncEntryScriptChunk = (chunk, entryName)=>{
+    if (void 0 === chunk.url || !chunk.url.endsWith('.js')) return false;
+    const asyncEntryName = `async-${entryName}`;
+    const filename = chunk.filename ?? chunk.url;
+    const basename = filename.split('/').pop() ?? filename;
+    return basename === `${asyncEntryName}.js` || basename.startsWith(`${asyncEntryName}.`) || basename.startsWith(`${asyncEntryName}-`);
+};
+function getMatchedRouteChunks(routeManifest, matchedRouteIds, routeAssetToChunk) {
+    const routeAssets = routeManifest?.routeAssets;
+    if (void 0 === routeAssets) return [];
+    return matchedRouteIds.flatMap((routeId)=>routeAssets[routeId]?.assets ?? []).map(routeAssetToChunk);
+}
+const orderHydrationScriptChunks = ({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName })=>{
+    const asyncEntryScriptChunks = [];
+    const asyncEntryDependencyChunks = [];
+    for (const chunk of asyncEntryChunks)if (isAsyncEntryScriptChunk(chunk, entryName)) asyncEntryScriptChunks.push(chunk);
+    else asyncEntryDependencyChunks.push(chunk);
+    return dedupeByUrl([
+        ...asyncEntryDependencyChunks,
+        ...collectedChunks,
+        ...matchedRouteChunks,
+        ...asyncEntryScriptChunks
+    ]);
+};
+function injectBeforeHydrationEntryScript(template, scripts, entryName = 'index') {
+    if ('' === scripts) return template;
+    const scriptTags = getScriptTags(template);
+    const target = scriptTags.find((match)=>isEntryScript(match.src, entryName, false)) ?? scriptTags.find((match)=>isEntryScript(match.src, entryName, true));
+    if (void 0 === target) return template;
+    return `${template.slice(0, target.index)}${scripts}${template.slice(target.index)}`;
+}
+function replaceChunkJsPlaceholder(template, scripts, entryName, placeholder) {
+    if (!template.includes(placeholder)) return template;
+    if ('' === scripts) return template.replace(placeholder, ()=>'');
+    const withoutPlaceholder = template.replace(placeholder, ()=>'');
+    const withEarlyScripts = injectBeforeHydrationEntryScript(withoutPlaceholder, scripts, entryName);
+    if (withEarlyScripts !== withoutPlaceholder) return withEarlyScripts;
+    return template.replace(placeholder, ()=>scripts);
+}
+function createRouteHydrationScriptTags(routeManifest, matchedRouteIds, entryName, options = {}) {
+    const { nonce, template } = options;
+    const routeAssets = routeManifest?.routeAssets;
+    if (void 0 === routeAssets) return '';
+    const existingScriptSrcs = void 0 === template ? new Set() : new Set(getScriptTags(template).map(({ src })=>src));
+    const jsAssets = Array.from(new Set([
+        ...getMatchedRouteChunks(routeManifest, matchedRouteIds, (asset)=>asset),
+        ...routeAssets[`async-${entryName}`]?.assets ?? []
+    ].filter((asset)=>asset.endsWith('.js'))));
+    return jsAssets.filter((asset)=>!existingScriptSrcs.has(asset)).map((asset)=>`<script src="${(0, external_html_js_namespaceObject.escapeHtmlAttribute)(asset)}"${nonce ? ` nonce="${(0, external_html_js_namespaceObject.escapeHtmlAttribute)(nonce)}"` : ''}></script>`).join(' ');
+}
+exports.createRouteHydrationScriptTags = __webpack_exports__.createRouteHydrationScriptTags;
+exports.getMatchedRouteChunks = __webpack_exports__.getMatchedRouteChunks;
+exports.injectBeforeHydrationEntryScript = __webpack_exports__.injectBeforeHydrationEntryScript;
+exports.orderHydrationScriptChunks = __webpack_exports__.orderHydrationScriptChunks;
+exports.replaceChunkJsPlaceholder = __webpack_exports__.replaceChunkJsPlaceholder;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRouteHydrationScriptTags",
+    "getMatchedRouteChunks",
+    "injectBeforeHydrationEntryScript",
+    "orderHydrationScriptChunks",
+    "replaceChunkJsPlaceholder"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});