@bleedingdev/modern-js-runtime-extensions 3.8.3-ultramodern.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cjs/helmetCompat.js

@@ -0,0 +1,419 @@
+"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 CONTENT_PROPERTIES = new Set([
+    'innerHTML',
+    'cssText'
+]);
+const HTML_ATTRIBUTE_NAMES = {
+    charSet: 'charset',
+    className: 'class',
+    contentEditable: 'contenteditable',
+    httpEquiv: 'http-equiv',
+    hrefLang: 'hreflang',
+    itemProp: 'itemprop',
+    tabIndex: 'tabindex'
+};
+const REACT_ATTRIBUTE_NAMES = {
+    accesskey: 'accessKey',
+    charset: 'charSet',
+    class: 'className',
+    contenteditable: 'contentEditable',
+    contextmenu: 'contextMenu',
+    'http-equiv': 'httpEquiv',
+    hreflang: 'hrefLang',
+    itemprop: 'itemProp',
+    tabindex: 'tabIndex'
+};
+const SEO_PRIORITY_VALUES = {
+    link: {
+        rel: [
+            'amphtml',
+            'canonical',
+            'alternate'
+        ]
+    },
+    meta: {
+        charset: [
+            ''
+        ],
+        name: [
+            'generator',
+            'robots',
+            "description"
+        ],
+        property: [
+            'og:type',
+            'og:title',
+            'og:url',
+            'og:image',
+            'og:image:alt',
+            "og:description",
+            'twitter:url',
+            'twitter:title',
+            "twitter:description",
+            'twitter:image',
+            'twitter:image:alt',
+            'twitter:card',
+            'twitter:site'
+        ]
+    },
+    script: {
+        type: [
+            'application/ld+json'
+        ]
+    }
+};
+const TAG_PRIMARY_ATTRIBUTES = {
+    link: [
+        'rel',
+        'href'
+    ],
+    meta: [
+        'name',
+        'charset',
+        'http-equiv',
+        'property',
+        'itemprop'
+    ],
+    noscript: [
+        'innerHTML'
+    ],
+    script: [
+        'src',
+        'innerHTML'
+    ],
+    style: [
+        'cssText'
+    ]
+};
+const priorityRecords = new WeakSet();
+const priorityTags = new WeakSet();
+const immediateRecords = new WeakMap();
+const createElementFactory = (react)=>react.createElement;
+const renderHeadMarker = (react, marker)=>marker ? createElementFactory(react)('template', marker) : null;
+const toReactAttributes = (tag)=>{
+    const props = {};
+    for (const [attribute, value] of Object.entries(tag))if (!CONTENT_PROPERTIES.has(attribute)) props[REACT_ATTRIBUTE_NAMES[attribute] ?? attribute] = value;
+    return props;
+};
+const toReactProps = (tag, key)=>{
+    const props = {
+        ...toReactAttributes(tag),
+        key,
+        'data-rh': true
+    };
+    if ('innerHTML' in tag || 'cssText' in tag) props.dangerouslySetInnerHTML = {
+        __html: tag.innerHTML ?? tag.cssText ?? ''
+    };
+    return props;
+};
+const escapeHtml = (value)=>String(value).replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+const toHtmlAttributeName = (name)=>HTML_ATTRIBUTE_NAMES[name] ?? name;
+const attributesToString = (tag, includeHelmetAttribute = false)=>{
+    const attributes = includeHelmetAttribute ? [
+        'data-rh="true"'
+    ] : [];
+    for (const [name, value] of Object.entries(tag)){
+        if (CONTENT_PROPERTIES.has(name) || false === value || null == value) continue;
+        const attribute = toHtmlAttributeName(name);
+        attributes.push(true === value ? attribute : `${attribute}="${escapeHtml(value)}"`);
+    }
+    return attributes.join(' ');
+};
+const tagsToString = (tagName, tags)=>tags.map((tag)=>{
+        const attributes = attributesToString(tag, true);
+        if (("script" === tagName || "noscript" === tagName) && 'string' == typeof tag.innerHTML) return `<${tagName} ${attributes}>${tag.innerHTML}</${tagName}>`;
+        if ('style' === tagName && 'string' == typeof tag.cssText) return `<style ${attributes}>${tag.cssText}</style>`;
+        return `<${tagName} ${attributes}>`;
+    }).join('');
+const markPriorityHeadRecord = (record, prioritize)=>{
+    if (prioritize) priorityRecords.add(record);
+};
+const isPriorityHeadTag = (tag)=>priorityTags.has(tag);
+const headTagsToComponents = (react, tagName, tags)=>{
+    const createElement = createElementFactory(react);
+    return tags.filter((tag)=>!priorityTags.has(tag)).map((tag, index)=>createElement(tagName, toReactProps(tag, index)));
+};
+const headTitleToComponent = (react, title, attributes)=>{
+    if (!title) return [];
+    const createElement = createElementFactory(react);
+    return [
+        createElement('title', toReactProps(attributes, title), title)
+    ];
+};
+const normalizedEntries = (tag)=>Object.entries(tag).map(([name, value])=>[
+            toHtmlAttributeName(name).toLowerCase(),
+            String(value).toLowerCase()
+        ]);
+const isSeoPriorityTag = (tagName, tag)=>{
+    const values = SEO_PRIORITY_VALUES[tagName];
+    return normalizedEntries(tag).some(([name, value])=>{
+        const allowed = values[name];
+        return void 0 !== allowed && ('charset' === name || allowed.includes(value));
+    });
+};
+const createPriorityHeadDatum = (react, records, dedupe)=>{
+    if (!records.some((record)=>'object' == typeof record && null !== record && priorityRecords.has(record))) return {
+        toComponent: ()=>[],
+        toString: ()=>''
+    };
+    const groups = [
+        'meta',
+        'link',
+        "script"
+    ].map((tagName)=>({
+            tagName,
+            tags: dedupe(tagName, records).filter((tag)=>isSeoPriorityTag(tagName, tag))
+        }));
+    for (const { tags } of groups)for (const tag of tags)priorityTags.add(tag);
+    const createElement = createElementFactory(react);
+    return {
+        toComponent: ()=>groups.flatMap(({ tagName, tags })=>tags.map((tag, index)=>createElement(tagName, toReactProps(tag, `${tagName}-${index}`)))),
+        toString: ()=>groups.map(({ tagName, tags })=>tagsToString(tagName, tags)).join('')
+    };
+};
+const createDatum = (react, tagName, tags)=>({
+        toComponent: ()=>headTagsToComponents(react, tagName, tags),
+        toString: ()=>tagsToString(tagName, tags.filter((tag)=>!priorityTags.has(tag)))
+    });
+const createAttributeDatum = (attributes)=>({
+        toComponent: ()=>toReactAttributes(attributes),
+        toString: ()=>attributesToString(attributes)
+    });
+const createTitleDatum = (react, title, attributes)=>({
+        toComponent: ()=>headTitleToComponent(react, title, attributes),
+        toString: ()=>{
+            if (!title) return '';
+            const serialized = attributesToString(attributes, true);
+            return `<title ${serialized}>${escapeHtml(title)}</title>`;
+        }
+    });
+const normalizeHelmetTitle = (title)=>{
+    if ('string' == typeof title) return title;
+    if (Array.isArray(title)) return title.map((part)=>String(part)).join('');
+};
+const mergeAttributes = (current, next)=>({
+        ...current,
+        ...next ?? {}
+    });
+const isHeadElement = (value)=>'object' == typeof value && null !== value && 'type' in value && 'props' in value && 'object' == typeof value.props && null !== value.props;
+const collectChildren = (react, children, draft)=>{
+    react.Children.forEach(children, (child)=>{
+        if (!react.isValidElement(child) || !isHeadElement(child)) return;
+        const element = child;
+        if (element.type === react.Fragment) return void collectChildren(react, element.props.children, draft);
+        if ('string' != typeof element.type) return;
+        const { children: nestedChildren, ...props } = element.props;
+        if ('title' === element.type) {
+            draft.title = react.Children.toArray(nestedChildren).join('');
+            draft.titleAttributes = mergeAttributes(draft.titleAttributes, props);
+            return;
+        }
+        if ('html' === element.type) {
+            draft.htmlAttributes = mergeAttributes(draft.htmlAttributes ?? {}, props);
+            return;
+        }
+        if ('body' === element.type) {
+            draft.bodyAttributes = mergeAttributes(draft.bodyAttributes ?? {}, props);
+            return;
+        }
+        if ('base' === element.type || 'link' === element.type || 'meta' === element.type || "noscript" === element.type || "script" === element.type || 'style' === element.type) {
+            const tag = {
+                ...props
+            };
+            if (("script" === element.type || 'style' === element.type || "noscript" === element.type) && 'string' == typeof nestedChildren) tag['style' === element.type ? 'cssText' : 'innerHTML'] = nestedChildren;
+            draft[element.type].push(tag);
+        }
+    });
+};
+const createHelmetRecord = (reactValue, props)=>{
+    const draft = {
+        base: void 0 === props.base ? [] : [
+            {
+                ...props.base
+            }
+        ],
+        bodyAttributes: void 0 === props.bodyAttributes ? void 0 : {
+            ...props.bodyAttributes
+        },
+        htmlAttributes: void 0 === props.htmlAttributes ? void 0 : {
+            ...props.htmlAttributes
+        },
+        link: (props.link ?? []).map((tag)=>({
+                ...tag
+            })),
+        meta: (props.meta ?? []).map((tag)=>({
+                ...tag
+            })),
+        noscript: (props.noscript ?? []).map((tag)=>({
+                ...tag
+            })),
+        script: (props.script ?? []).map((tag)=>({
+                ...tag
+            })),
+        style: (props.style ?? []).map((tag)=>({
+                ...tag
+            })),
+        title: normalizeHelmetTitle(props.title),
+        titleAttributes: {
+            ...props.titleAttributes ?? {}
+        }
+    };
+    collectChildren(reactValue, props.children, draft);
+    const record = {
+        ...draft,
+        defaultTitle: props.defaultTitle,
+        prioritizeSeoTags: true === props.prioritizeSeoTags,
+        titleTemplate: props.titleTemplate
+    };
+    markPriorityHeadRecord(record, record.prioritizeSeoTags);
+    return record;
+};
+const getInnermostDefined = (records, pick)=>{
+    for(let index = records.length - 1; index >= 0; index -= 1){
+        const value = pick(records[index]);
+        if (void 0 !== value) return value;
+    }
+};
+const deriveTitle = (records)=>{
+    const title = getInnermostDefined(records, (record)=>record.title);
+    const template = getInnermostDefined(records, (record)=>record.titleTemplate);
+    if (template && title) return template.replaceAll('%s', title);
+    return title || getInnermostDefined(records, (record)=>record.defaultTitle);
+};
+const mergeRecordAttributes = (records, pick)=>records.reduce((merged, record)=>mergeAttributes(merged, pick(record)), {});
+const deriveBaseTags = (records)=>{
+    for(let recordIndex = records.length - 1; recordIndex >= 0; recordIndex--){
+        const tags = records[recordIndex].base;
+        for(let tagIndex = tags.length - 1; tagIndex >= 0; tagIndex--)if (tags[tagIndex].href) return [
+            tags[tagIndex]
+        ];
+    }
+    return [];
+};
+const getPrimaryAttribute = (tagName, tag)=>{
+    const candidates = TAG_PRIMARY_ATTRIBUTES[tagName];
+    let selectedKey;
+    let selectedValue;
+    for (const [key, value] of Object.entries(tag)){
+        const normalizedKey = CONTENT_PROPERTIES.has(key) ? key : toHtmlAttributeName(key).toLowerCase();
+        if (candidates.includes(normalizedKey)) {
+            if ('rel' !== selectedKey || 'canonical' !== String(selectedValue).toLowerCase()) {
+                if ('rel' !== normalizedKey || 'stylesheet' !== String(value).toLowerCase()) {
+                    selectedKey = normalizedKey;
+                    selectedValue = value;
+                }
+            }
+        }
+    }
+    if (void 0 === selectedKey || !selectedValue) return;
+    return {
+        key: selectedKey,
+        value: String(selectedValue).toLowerCase()
+    };
+};
+const dedupeTags = (tagName, records)=>{
+    const approvedValues = new Map();
+    const approved = [];
+    for(let index = records.length - 1; index >= 0; index -= 1){
+        const instanceValues = new Map();
+        const kept = [];
+        for (const tag of records[index][tagName]){
+            const primary = getPrimaryAttribute(tagName, tag);
+            if (void 0 === primary || approvedValues.get(primary.key)?.has(primary.value)) continue;
+            const seen = instanceValues.get(primary.key) ?? new Set();
+            seen.add(primary.value);
+            instanceValues.set(primary.key, seen);
+            kept.push(tag);
+        }
+        approved.unshift(...kept);
+        for (const [key, values] of instanceValues){
+            const target = approvedValues.get(key);
+            if (void 0 === target) approvedValues.set(key, values);
+            else for (const value of values)target.add(value);
+        }
+    }
+    return approved;
+};
+const deriveHelmetServerState = (react, records)=>{
+    const priority = createPriorityHeadDatum(react, records, dedupeTags);
+    return {
+        base: createDatum(react, 'base', deriveBaseTags(records)),
+        bodyAttributes: createAttributeDatum(mergeRecordAttributes(records, (record)=>record.bodyAttributes)),
+        htmlAttributes: createAttributeDatum(mergeRecordAttributes(records, (record)=>record.htmlAttributes)),
+        link: createDatum(react, 'link', dedupeTags('link', records)),
+        meta: createDatum(react, 'meta', dedupeTags('meta', records)),
+        noscript: createDatum(react, "noscript", dedupeTags("noscript", records)),
+        priority,
+        script: createDatum(react, "script", dedupeTags("script", records)),
+        style: createDatum(react, 'style', dedupeTags('style', records)),
+        title: createTitleDatum(react, deriveTitle(records), mergeRecordAttributes(records, (record)=>record.titleAttributes))
+    };
+};
+const collectImmediateHelmetState = (react, context, record)=>{
+    const records = immediateRecords.get(context) ?? [];
+    if (!immediateRecords.has(context)) immediateRecords.set(context, records);
+    records.push(record);
+    return deriveHelmetServerState(react, records);
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    collectImmediateHelmetState: collectImmediateHelmetState,
+    createHelmetRecord: createHelmetRecord,
+    createPriorityHeadDatum: createPriorityHeadDatum,
+    deriveHelmetServerState: deriveHelmetServerState,
+    headTagsToComponents: headTagsToComponents,
+    headTitleToComponent: headTitleToComponent,
+    isPriorityHeadTag: isPriorityHeadTag,
+    markPriorityHeadRecord: markPriorityHeadRecord,
+    renderHeadMarker: renderHeadMarker
+});
+exports.collectImmediateHelmetState = __webpack_exports__.collectImmediateHelmetState;
+exports.createHelmetRecord = __webpack_exports__.createHelmetRecord;
+exports.createPriorityHeadDatum = __webpack_exports__.createPriorityHeadDatum;
+exports.deriveHelmetServerState = __webpack_exports__.deriveHelmetServerState;
+exports.headTagsToComponents = __webpack_exports__.headTagsToComponents;
+exports.headTitleToComponent = __webpack_exports__.headTitleToComponent;
+exports.isPriorityHeadTag = __webpack_exports__.isPriorityHeadTag;
+exports.markPriorityHeadRecord = __webpack_exports__.markPriorityHeadRecord;
+exports.renderHeadMarker = __webpack_exports__.renderHeadMarker;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "collectImmediateHelmetState",
+    "createHelmetRecord",
+    "createPriorityHeadDatum",
+    "deriveHelmetServerState",
+    "headTagsToComponents",
+    "headTitleToComponent",
+    "isPriorityHeadTag",
+    "markPriorityHeadRecord",
+    "renderHeadMarker"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/html.js

@@ -0,0 +1,45 @@
+"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 SAFE_HTML_ATTRIBUTE_NAME = /^[^\u0000-\u0020"'<>/=]+$/u;
+const isSafeHtmlAttributeName = (name)=>SAFE_HTML_ATTRIBUTE_NAME.test(name);
+const escapeHtmlAttribute = (value)=>String(value).replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+__webpack_require__.d(__webpack_exports__, {}, {
+    escapeHtmlAttribute: escapeHtmlAttribute,
+    isSafeHtmlAttributeName: isSafeHtmlAttributeName
+});
+exports.escapeHtmlAttribute = __webpack_exports__.escapeHtmlAttribute;
+exports.isSafeHtmlAttributeName = __webpack_exports__.isSafeHtmlAttributeName;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "escapeHtmlAttribute",
+    "isSafeHtmlAttributeName"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/index.js

@@ -0,0 +1,83 @@
+"use strict";
+var __webpack_modules__ = {
+    "./html" (module) {
+        module.exports = require("./html.js");
+    },
+    "./navigationWarmup" (module) {
+        module.exports = require("./navigationWarmup.js");
+    },
+    "./rendererHead" (module) {
+        module.exports = require("./rendererHead.js");
+    },
+    "./shellStream" (module) {
+        module.exports = require("./shellStream.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__);
+    var _html__rspack_import_0 = __webpack_require__("./html");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _html__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_html__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _navigationWarmup__rspack_import_1 = __webpack_require__("./navigationWarmup");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _navigationWarmup__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_navigationWarmup__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _rendererHead__rspack_import_2 = __webpack_require__("./rendererHead");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _rendererHead__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_rendererHead__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _shellStream__rspack_import_3 = __webpack_require__("./shellStream");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _shellStream__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_shellStream__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/navigationWarmup.js

@@ -0,0 +1,59 @@
+"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 realmNamespaces = new WeakMap();
+let nextRealmNamespace = 0;
+function getNavigationWarmupCacheKey(runtimeContext, chunkLoader, publicPath, warmupKey) {
+    let loaderNamespaces = realmNamespaces.get(runtimeContext);
+    if (void 0 === loaderNamespaces) {
+        loaderNamespaces = new WeakMap();
+        realmNamespaces.set(runtimeContext, loaderNamespaces);
+    }
+    let publicPathNamespaces = loaderNamespaces.get(chunkLoader);
+    if (void 0 === publicPathNamespaces) {
+        publicPathNamespaces = new Map();
+        loaderNamespaces.set(chunkLoader, publicPathNamespaces);
+    }
+    let namespace = publicPathNamespaces.get(publicPath);
+    if (void 0 === namespace) {
+        namespace = `realm-${++nextRealmNamespace}`;
+        publicPathNamespaces.set(publicPath, namespace);
+    }
+    return `${namespace}:${warmupKey}`;
+}
+__webpack_require__.d(__webpack_exports__, {
+    getNavigationWarmupCacheKey: ()=>getNavigationWarmupCacheKey
+});
+exports.getNavigationWarmupCacheKey = __webpack_exports__.getNavigationWarmupCacheKey;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getNavigationWarmupCacheKey"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});