@bleedingdev/modern-js-runtime 3.2.0-ultramodern.0

package/dist/cjs/router/cli/index.js

@@ -0,0 +1,194 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    BUILT_IN_ROUTES_OWNER: ()=>external_entry_js_namespaceObject.BUILT_IN_ROUTES_OWNER,
+    default: ()=>cli,
+    getEntrypointRoutesDir: ()=>external_entry_js_namespaceObject.getEntrypointRoutesDir,
+    getEntrypointRoutesOwner: ()=>external_entry_js_namespaceObject.getEntrypointRoutesOwner,
+    handleFileChange: ()=>external_handler_js_namespaceObject.handleFileChange,
+    handleGeneratorEntryCode: ()=>external_handler_js_namespaceObject.handleGeneratorEntryCode,
+    handleModifyEntrypoints: ()=>external_handler_js_namespaceObject.handleModifyEntrypoints,
+    isRouteEntry: ()=>external_entry_js_namespaceObject.isRouteEntry,
+    routerPlugin: ()=>routerPlugin
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_entry_js_namespaceObject = require("./entry.js");
+const external_handler_js_namespaceObject = require("./handler.js");
+const JS_OR_TS_EXTS = [
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+];
+function hasRouterConfigInRuntimeFile(runtimeConfigBase) {
+    const runtimeConfigFile = (0, utils_namespaceObject.findExists)(JS_OR_TS_EXTS.map((ext)=>`${runtimeConfigBase}${ext}`));
+    if (!runtimeConfigFile) return false;
+    try {
+        const content = utils_namespaceObject.fs.readFileSync(runtimeConfigFile, 'utf-8');
+        return /router\s*:/.test(content);
+    } catch  {
+        return false;
+    }
+}
+function isBuiltInRouteEntrypoint(entrypoint) {
+    const entrypointRoutesOwner = (0, external_entry_js_namespaceObject.getEntrypointRoutesOwner)(entrypoint);
+    if (entrypointRoutesOwner) return entrypointRoutesOwner === external_entry_js_namespaceObject.BUILT_IN_ROUTES_OWNER;
+    if (entrypoint.pageRoutesEntry) return true;
+    const entrypointRoutesDir = (0, external_entry_js_namespaceObject.getEntrypointRoutesDir)(entrypoint);
+    if (entrypointRoutesDir) return entrypointRoutesDir === external_constants_js_namespaceObject.NESTED_ROUTES_DIR;
+    return Boolean(entrypoint.entry && (0, external_entry_js_namespaceObject.isRouteEntry)(entrypoint.entry));
+}
+function isPluginOwnedRouteEntrypoint(entrypoint) {
+    const entrypointRoutesOwner = (0, external_entry_js_namespaceObject.getEntrypointRoutesOwner)(entrypoint);
+    if (entrypointRoutesOwner) return entrypointRoutesOwner !== external_entry_js_namespaceObject.BUILT_IN_ROUTES_OWNER;
+    const entrypointRoutesDir = (0, external_entry_js_namespaceObject.getEntrypointRoutesDir)(entrypoint);
+    return Boolean(entrypointRoutesDir && entrypointRoutesDir !== external_constants_js_namespaceObject.NESTED_ROUTES_DIR);
+}
+const routerPlugin = ()=>({
+        name: '@modern-js/plugin-router',
+        required: [
+            '@modern-js/runtime'
+        ],
+        setup: (api)=>{
+            const nestedRoutesForServer = {};
+            const { metaName } = api.getAppContext();
+            api.addCommand(({ program })=>{
+                program.command('routes').description('generate routes inspect report').action(async ()=>{
+                    const { generateRoutesInspectReport } = await import("./code/inspect.js");
+                    await generateRoutesInspectReport(api);
+                });
+            });
+            api._internalRuntimePlugins(({ entrypoint, plugins })=>{
+                const { serverRoutes, metaName, srcDirectory, runtimeConfigFile } = api.getAppContext();
+                const normalizedConfig = api.getNormalizedConfig();
+                const hasUserRouterConfig = normalizedConfig.router && Object.keys(normalizedConfig.router).length > 0;
+                const hasRuntimeRouterConfig = hasRouterConfigInRuntimeFile(external_node_path_default().join(srcDirectory, runtimeConfigFile));
+                const serverBase = serverRoutes.filter((route)=>route.entryName === entrypoint.entryName).map((route)=>route.urlPath).sort((a, b)=>a.length - b.length > 0 ? -1 : 1);
+                const shouldInstallBuiltInRouter = isBuiltInRouteEntrypoint(entrypoint) || !isPluginOwnedRouteEntrypoint(entrypoint) && (hasUserRouterConfig || hasRuntimeRouterConfig);
+                if (shouldInstallBuiltInRouter) plugins.push({
+                    name: 'router',
+                    path: `@${metaName}/runtime/router/internal`,
+                    config: {
+                        serverBase
+                    }
+                });
+                return {
+                    entrypoint,
+                    plugins
+                };
+            });
+            api.checkEntryPoint(({ path, entry })=>({
+                    path,
+                    entry: entry || (0, external_entry_js_namespaceObject.isRouteEntry)(path)
+                }));
+            api.config(()=>({
+                    source: {
+                        include: [
+                            /[\\/]node_modules[\\/]react-router[\\/]/,
+                            /[\\/]node_modules[\\/]react-router-dom[\\/]/,
+                            external_node_path_default().resolve(__dirname, '../runtime').replace('cjs', 'esm')
+                        ]
+                    }
+                }));
+            api.modifyEntrypoints(async ({ entrypoints })=>{
+                const newEntryPoints = await (0, external_handler_js_namespaceObject.handleModifyEntrypoints)(entrypoints);
+                return {
+                    entrypoints: newEntryPoints
+                };
+            });
+            api.generateEntryCode(async ({ entrypoints })=>{
+                const builtInEntrypoints = entrypoints.filter(isBuiltInRouteEntrypoint);
+                if (builtInEntrypoints.length > 0) await (0, external_handler_js_namespaceObject.handleGeneratorEntryCode)(api, builtInEntrypoints);
+            });
+            api.onFileChanged(async (e)=>{
+                await (0, external_handler_js_namespaceObject.handleFileChange)(api, e, {
+                    includeEntry: isBuiltInRouteEntrypoint
+                });
+            });
+            api.modifyFileSystemRoutes(({ entrypoint, routes })=>{
+                if (isBuiltInRouteEntrypoint(entrypoint)) nestedRoutesForServer[entrypoint.entryName] = (0, utils_namespaceObject.filterRoutesForServer)(routes);
+                return {
+                    entrypoint,
+                    routes
+                };
+            });
+            api.onBeforeGenerateRoutes(async ({ entrypoint, code })=>{
+                if (isBuiltInRouteEntrypoint(entrypoint)) {
+                    const { distDirectory } = api.getAppContext();
+                    const nestedRoutesSpecPath = external_node_path_default().resolve(distDirectory, utils_namespaceObject.NESTED_ROUTE_SPEC_FILE);
+                    const existingNestedRoutes = await utils_namespaceObject.fs.pathExists(nestedRoutesSpecPath) ? await utils_namespaceObject.fs.readJSON(nestedRoutesSpecPath) : {};
+                    await utils_namespaceObject.fs.outputJSON(nestedRoutesSpecPath, {
+                        ...existingNestedRoutes,
+                        ...nestedRoutesForServer
+                    });
+                }
+                return {
+                    entrypoint,
+                    code
+                };
+            });
+        }
+    });
+const cli = routerPlugin;
+exports.BUILT_IN_ROUTES_OWNER = __webpack_exports__.BUILT_IN_ROUTES_OWNER;
+exports["default"] = __webpack_exports__["default"];
+exports.getEntrypointRoutesDir = __webpack_exports__.getEntrypointRoutesDir;
+exports.getEntrypointRoutesOwner = __webpack_exports__.getEntrypointRoutesOwner;
+exports.handleFileChange = __webpack_exports__.handleFileChange;
+exports.handleGeneratorEntryCode = __webpack_exports__.handleGeneratorEntryCode;
+exports.handleModifyEntrypoints = __webpack_exports__.handleModifyEntrypoints;
+exports.isRouteEntry = __webpack_exports__.isRouteEntry;
+exports.routerPlugin = __webpack_exports__.routerPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BUILT_IN_ROUTES_OWNER",
+    "default",
+    "getEntrypointRoutesDir",
+    "getEntrypointRoutesOwner",
+    "handleFileChange",
+    "handleGeneratorEntryCode",
+    "handleModifyEntrypoints",
+    "isRouteEntry",
+    "routerPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/index.js

@@ -0,0 +1,58 @@
+"use strict";
+var __webpack_modules__ = {
+    "./runtime" (module) {
+        module.exports = require("./runtime/index.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, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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 _runtime__rspack_import_0 = __webpack_require__("./runtime");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _runtime__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_runtime__rspack_import_0[__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/router/internal.js

@@ -0,0 +1,64 @@
+"use strict";
+var __webpack_modules__ = {
+    "./runtime/internal" (module) {
+        module.exports = require("./runtime/internal.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, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+        default: ()=>_runtime_internal__rspack_import_0.routerPlugin
+    });
+    var _runtime_internal__rspack_import_0 = __webpack_require__("./runtime/internal");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _runtime_internal__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_runtime_internal__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/runtime/CSSLinks.js

@@ -0,0 +1,46 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    CSSLinks: ()=>CSSLinks
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+require("react");
+function CSSLinks({ cssFiles }) {
+    if (0 === cssFiles.length) return null;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
+        children: cssFiles.map((css)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("link", {
+                href: css,
+                rel: "stylesheet"
+            }, css))
+    });
+}
+exports.CSSLinks = __webpack_exports__.CSSLinks;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CSSLinks"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/runtime/DefaultNotFound.js

@@ -0,0 +1,47 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    DefaultNotFound: ()=>DefaultNotFound
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+require("react");
+const DefaultNotFound = ()=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        style: {
+            margin: '150px auto',
+            textAlign: 'center',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center'
+        },
+        children: "404"
+    });
+exports.DefaultNotFound = __webpack_exports__.DefaultNotFound;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DefaultNotFound"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/runtime/DeferredDataScripts.js

@@ -0,0 +1,36 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    default: ()=>__rspack_default_export
+});
+const __rspack_default_export = ()=>null;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/runtime/DeferredDataScripts.node.js

@@ -0,0 +1,154 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    default: ()=>DeferredDataScripts_node
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const node_namespaceObject = require("@modern-js/runtime-utils/node");
+const external_react_namespaceObject = require("react");
+const constants_js_namespaceObject = require("../../core/constants.js");
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const DeferredDataScripts = (props)=>{
+    const staticContext = props?.context;
+    const useJsonScript = props?.useJsonScript;
+    const hydratedRef = (0, external_react_namespaceObject.useRef)(false);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        hydratedRef.current = true;
+    }, []);
+    const deferredScripts = (0, external_react_namespaceObject.useMemo)(()=>{
+        if (!staticContext) return null;
+        const activeDeferreds = node_namespaceObject.storage.useContext().activeDeferreds;
+        const _ROUTER_DATA = {
+            loaderData: staticContext.loaderData,
+            errors: (0, external_utils_js_namespaceObject.serializeErrors)(staticContext.errors)
+        };
+        const initialScript0 = useJsonScript ? `${(0, node_namespaceObject.serializeJson)(_ROUTER_DATA)}` : '';
+        const initialScript1 = useJsonScript ? external_constants_js_namespaceObject.modernInline : [
+            `_ROUTER_DATA = ${(0, node_namespaceObject.serializeJson)(_ROUTER_DATA)};`,
+            external_constants_js_namespaceObject.modernInline
+        ].join('\n');
+        const deferredDataScripts = [];
+        const initialScripts = Array.from(activeDeferreds.entries()).map(([routeId, deferredData])=>{
+            const pendingKeys = new Set(deferredData.pendingKeys);
+            const { deferredKeys } = deferredData;
+            const deferredKeyPromiseManifests = deferredKeys.map((key)=>{
+                if (pendingKeys.has(key)) return {
+                    key,
+                    routerDataFnName: 's',
+                    routerDataFnArgs: [
+                        (0, node_namespaceObject.serializeJson)(routeId),
+                        (0, node_namespaceObject.serializeJson)(key)
+                    ]
+                };
+                {
+                    const trackedPromise = deferredData.data[key];
+                    if (void 0 !== trackedPromise._error) {
+                        const error = {
+                            message: trackedPromise._error.message,
+                            stack: 'production' !== process.env.NODE_ENV ? trackedPromise._error.stack : void 0
+                        };
+                        return {
+                            key,
+                            routerDataFnName: 'p',
+                            routerDataFnArgs: [
+                                (0, node_namespaceObject.serializeJson)(void 0),
+                                (0, node_namespaceObject.serializeJson)(error)
+                            ]
+                        };
+                    }
+                    if (void 0 === trackedPromise._data) throw new Error(`The deferred data for ${key} was not resolved, did you forget to return data from a deferred promise`);
+                    return {
+                        key,
+                        routerDataFnName: 'p',
+                        routerDataFnArgs: [
+                            (0, node_namespaceObject.serializeJson)(trackedPromise._data)
+                        ]
+                    };
+                }
+            });
+            return {
+                fnName: "mergeLoaderData",
+                fnRun: external_constants_js_namespaceObject.runWindowFnStr,
+                fnArgs: [
+                    routeId,
+                    deferredKeyPromiseManifests
+                ],
+                fnScriptSrc: 'modern-run-window-fn'
+            };
+        });
+        return [
+            initialScript0,
+            initialScript1,
+            initialScripts,
+            deferredDataScripts
+        ];
+    }, []);
+    if (!deferredScripts) return null;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
+        children: !hydratedRef.current && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+            children: [
+                0 !== deferredScripts[0].length && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("script", {
+                    type: "application/json",
+                    id: constants_js_namespaceObject.ROUTER_DATA_JSON_ID,
+                    nonce: props?.nonce,
+                    suppressHydrationWarning: true,
+                    dangerouslySetInnerHTML: {
+                        __html: deferredScripts[0]
+                    }
+                }),
+                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("script", {
+                    async: true,
+                    nonce: props?.nonce,
+                    "data-script-src": "modern-inline",
+                    suppressHydrationWarning: true,
+                    dangerouslySetInnerHTML: {
+                        __html: deferredScripts[1]
+                    }
+                }),
+                deferredScripts[2].map(({ fnName, fnArgs, fnRun, fnScriptSrc })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("script", {
+                        async: true,
+                        "data-script-src": fnScriptSrc,
+                        "data-fn-name": fnName,
+                        "data-fn-args": JSON.stringify(fnArgs),
+                        nonce: props?.nonce,
+                        suppressHydrationWarning: true,
+                        dangerouslySetInnerHTML: {
+                            __html: fnRun
+                        }
+                    }, fnName))
+            ]
+        })
+    });
+};
+const DeferredDataScripts_node = DeferredDataScripts;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});