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

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/README.md

@@ -0,0 +1,26 @@
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+
+<h1 align="center">Modern.js</h1>
+
+<p align="center">
+  A Progressive React Framework for modern web development.
+</p>
+
+## Getting Started
+
+Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+
+## Documentation
+
+- [English Documentation](https://modernjs.dev/en/)
+- [中文文档](https://modernjs.dev)
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/blob/main/CONTRIBUTING.md).
+
+## License
+
+Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).

package/dist/cjs/browser/deferreds.js

@@ -0,0 +1,161 @@
+"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__, {
+    AbortedDeferredError: ()=>AbortedDeferredError,
+    DeferredData: ()=>DeferredData,
+    activeDeferreds: ()=>activeDeferreds,
+    invariant: ()=>invariant
+});
+function invariant(value, message) {
+    if (false === value || null == value) throw new Error(message);
+}
+class AbortedDeferredError extends Error {
+}
+function isTrackedPromise(value) {
+    return value instanceof Promise && true === value._tracked;
+}
+function unwrapTrackedPromise(value) {
+    if (!isTrackedPromise(value)) return value;
+    if (value._error) throw value._error;
+    return value._data;
+}
+class DeferredData {
+    trackPromise(key, value) {
+        if (!(value instanceof Promise)) return value;
+        this.deferredKeys.push(key);
+        this.pendingKeysSet.add(key);
+        const promise = Promise.race([
+            value,
+            this.abortPromise
+        ]).then((data)=>this.onSettle(promise, key, void 0, data), (error)=>this.onSettle(promise, key, error));
+        promise.catch(()=>{});
+        Object.defineProperty(promise, '_tracked', {
+            get: ()=>true
+        });
+        return promise;
+    }
+    onSettle(promise, key, error, data) {
+        if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {
+            this.unlistenAbortSignal();
+            Object.defineProperty(promise, '_error', {
+                get: ()=>error
+            });
+            return Promise.reject(error);
+        }
+        this.pendingKeysSet.delete(key);
+        if (this.done) this.unlistenAbortSignal();
+        if (void 0 === error && void 0 === data) {
+            const undefinedError = new Error(`Deferred data for key "${key}" resolved/rejected with \`undefined\`, you must resolve/reject with a value or \`null\`.`);
+            Object.defineProperty(promise, '_error', {
+                get: ()=>undefinedError
+            });
+            this.emit(false, key);
+            return Promise.reject(undefinedError);
+        }
+        if (void 0 === data) {
+            Object.defineProperty(promise, '_error', {
+                get: ()=>error
+            });
+            this.emit(false, key);
+            return Promise.reject(error);
+        }
+        Object.defineProperty(promise, '_data', {
+            get: ()=>data
+        });
+        this.emit(false, key);
+        return data;
+    }
+    emit(aborted, settledKey) {
+        this.subscribers.forEach((subscriber)=>subscriber(aborted, settledKey));
+    }
+    subscribe(fn) {
+        this.subscribers.add(fn);
+        return ()=>this.subscribers.delete(fn);
+    }
+    cancel() {
+        this.controller.abort();
+        this.pendingKeysSet.forEach((v, k)=>this.pendingKeysSet.delete(k));
+        this.emit(true);
+    }
+    async resolveData(signal) {
+        let aborted = false;
+        if (!this.done) {
+            const onAbort = ()=>this.cancel();
+            signal.addEventListener('abort', onAbort);
+            aborted = await new Promise((resolve)=>{
+                this.subscribe((aborted)=>{
+                    signal.removeEventListener('abort', onAbort);
+                    if (aborted || this.done) resolve(aborted);
+                });
+            });
+        }
+        return aborted;
+    }
+    get done() {
+        return 0 === this.pendingKeysSet.size;
+    }
+    get unwrappedData() {
+        invariant(null !== this.data && this.done, 'Can only unwrap data on initialized and settled deferreds');
+        return Object.entries(this.data).reduce((acc, [key, value])=>Object.assign(acc, {
+                [key]: unwrapTrackedPromise(value)
+            }), {});
+    }
+    get pendingKeys() {
+        return Array.from(this.pendingKeysSet);
+    }
+    constructor(data, responseInit){
+        this.pendingKeysSet = new Set();
+        this.subscribers = new Set();
+        this.__modern_deferred = true;
+        this.deferredKeys = [];
+        invariant(data && 'object' == typeof data && !Array.isArray(data), 'defer() only accepts plain objects');
+        let reject;
+        this.abortPromise = new Promise((_, r)=>reject = r);
+        this.controller = new AbortController();
+        const onAbort = ()=>reject(new AbortedDeferredError('Deferred data aborted'));
+        this.unlistenAbortSignal = ()=>this.controller.signal.removeEventListener('abort', onAbort);
+        this.controller.signal.addEventListener('abort', onAbort);
+        this.data = Object.entries(data).reduce((acc, [key, value])=>Object.assign(acc, {
+                [key]: this.trackPromise(key, value)
+            }), {});
+        if (this.done) this.unlistenAbortSignal();
+        this.init = responseInit;
+    }
+}
+const activeDeferreds = new Map();
+exports.AbortedDeferredError = __webpack_exports__.AbortedDeferredError;
+exports.DeferredData = __webpack_exports__.DeferredData;
+exports.activeDeferreds = __webpack_exports__.activeDeferreds;
+exports.invariant = __webpack_exports__.invariant;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AbortedDeferredError",
+    "DeferredData",
+    "activeDeferreds",
+    "invariant"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/browser/index.js

@@ -0,0 +1,65 @@
+"use strict";
+var __webpack_modules__ = {
+    "./deferreds" (module) {
+        module.exports = require("./deferreds.js");
+    },
+    "./nestedRoutes" (module) {
+        module.exports = require("./nestedRoutes.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 _deferreds__rspack_import_0 = __webpack_require__("./deferreds");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _deferreds__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_deferreds__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _nestedRoutes__rspack_import_1 = __webpack_require__("./nestedRoutes");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _nestedRoutes__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_nestedRoutes__rspack_import_1[__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/browser/nestedRoutes.js

@@ -0,0 +1,141 @@
+"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__, {
+    renderNestedRoute: ()=>renderNestedRoute,
+    transformNestedRoutes: ()=>transformNestedRoutes
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const external_react_namespaceObject = require("react");
+const external_react_router_namespaceObject = require("react-router");
+const external_time_js_namespaceObject = require("../time.js");
+const async_storage_js_namespaceObject = require("../universal/async_storage.js");
+const external_deferreds_js_namespaceObject = require("./deferreds.js");
+const privateDefer = (data)=>new external_deferreds_js_namespaceObject.DeferredData(data);
+const transformNestedRoutes = (routes)=>{
+    const routeElements = [];
+    for (const route of routes){
+        const routeElement = renderNestedRoute(route);
+        routeElements.push(routeElement);
+    }
+    return (0, external_react_router_namespaceObject.createRoutesFromElements)(routeElements);
+};
+const renderNestedRoute = (nestedRoute, options = {})=>{
+    const { children, index, id, component, isRoot, lazyImport, config, handle } = nestedRoute;
+    const Component = component;
+    const { parent, props = {} } = options;
+    const routeProps = {
+        caseSensitive: nestedRoute.caseSensitive,
+        path: nestedRoute.path,
+        id: nestedRoute.id,
+        loader: createLoader(nestedRoute),
+        action: nestedRoute.action,
+        hasErrorBoundary: nestedRoute.hasErrorBoundary,
+        shouldRevalidate: nestedRoute.shouldRevalidate,
+        handle: {
+            ...handle,
+            ...'object' == typeof config ? config?.handle : {}
+        },
+        index: nestedRoute.index,
+        element: nestedRoute.element,
+        errorElement: nestedRoute.errorElement
+    };
+    if (nestedRoute.error) {
+        const errorElement = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(nestedRoute.error, {});
+        routeProps.errorElement = errorElement;
+    }
+    let element;
+    if (Component) if (parent?.loading && lazyImport) {
+        const Loading = parent.loading;
+        element = isLoadableComponent(Component) ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Component, {
+            fallback: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Loading, {})
+        }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_react_namespaceObject.Suspense, {
+            fallback: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Loading, {}),
+            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Component, {})
+        });
+    } else element = isLoadableComponent(Component) && lazyImport ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Component, {}) : isRoot ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Component, {
+        ...props
+    }) : lazyImport ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_react_namespaceObject.Suspense, {
+        fallback: null,
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Component, {})
+    }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Component, {});
+    else {
+        nestedRoute.loading = parent?.loading;
+        routeProps.element = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_react_router_namespaceObject.Outlet, {});
+    }
+    if (element) routeProps.element = element;
+    const childElements = children?.map((childRoute)=>renderNestedRoute(childRoute, {
+            parent: nestedRoute
+        }));
+    const routeElement = index ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_react_router_namespaceObject.Route, {
+        ...routeProps,
+        index: true
+    }, id) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_react_router_namespaceObject.Route, {
+        ...routeProps,
+        index: false,
+        children: childElements
+    }, id);
+    return routeElement;
+};
+function isPlainObject(value) {
+    return null != value && 'object' == typeof value && Object.getPrototypeOf(value) === Object.prototype;
+}
+function createLoader(route) {
+    const { loader } = route;
+    if (loader) return async (args)=>{
+        if ('function' == typeof route.lazyImport) route.lazyImport();
+        const end = (0, external_time_js_namespaceObject.time)();
+        const res = await loader(args);
+        let activeDeferreds = null;
+        activeDeferreds = "u" < typeof document ? (await (0, async_storage_js_namespaceObject.getAsyncLocalStorage)())?.useContext()?.activeDeferreds : external_deferreds_js_namespaceObject.activeDeferreds;
+        if (isPlainObject(res)) {
+            const deferredData = privateDefer(res);
+            activeDeferreds.set(route.id, deferredData);
+        }
+        const cost = end();
+        if ("u" < typeof document) {
+            const storage = await (0, async_storage_js_namespaceObject.getAsyncLocalStorage)();
+            storage?.useContext().monitors?.timing(`${constants_namespaceObject.LOADER_REPORTER_NAME}-${route.id?.replace(/\//g, '_')}`, cost);
+        }
+        return res;
+    };
+    return ()=>{
+        if ('function' == typeof route.lazyImport) route.lazyImport();
+        return null;
+    };
+}
+function isLoadableComponent(component) {
+    return component && 'Loadable' === component.displayName && component.preload && 'function' == typeof component.preload;
+}
+exports.renderNestedRoute = __webpack_exports__.renderNestedRoute;
+exports.transformNestedRoutes = __webpack_exports__.transformNestedRoutes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "renderNestedRoute",
+    "transformNestedRoutes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/merge.js

@@ -0,0 +1,60 @@
+"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__, {
+    merge: ()=>merge
+});
+function isObject(obj) {
+    return obj && 'object' == typeof obj && !Array.isArray(obj);
+}
+function isComplexInstance(obj) {
+    if (!isObject(obj)) return false;
+    const hasMethods = 'function' == typeof obj.init || 'function' == typeof obj.changeLanguage || 'function' == typeof obj.t;
+    const hasInternalProps = void 0 !== obj.isInitialized || void 0 !== obj.language || void 0 !== obj.store;
+    return hasMethods || hasInternalProps;
+}
+function merge(target, ...sources) {
+    if (!sources.length) return target;
+    const source = sources.shift();
+    if (isObject(target) && isObject(source)) for(const key in source)if (isComplexInstance(source[key])) Object.assign(target, {
+        [key]: source[key]
+    });
+    else if (isObject(source[key])) {
+        if (!target[key]) Object.assign(target, {
+            [key]: {}
+        });
+        merge(target[key], source[key]);
+    } else Object.assign(target, {
+        [key]: source[key]
+    });
+    return merge(target, ...sources);
+}
+exports.merge = __webpack_exports__.merge;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "merge"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/node/fileReader.js

@@ -0,0 +1,94 @@
+"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__, {
+    FileReader: ()=>FileReader,
+    fileReader: ()=>fileReader
+});
+const fs_extra_namespaceObject = require("@modern-js/utils/fs-extra");
+var fs_extra_default = /*#__PURE__*/ __webpack_require__.n(fs_extra_namespaceObject);
+const index_js_namespaceObject = require("./storer/index.js");
+class FileReader {
+    async readFile(path, encoding = 'utf-8') {
+        const { fs } = this;
+        const _readfile = this._readFileFactory(fs);
+        return _readfile(path, encoding);
+    }
+    async readFileFromSystem(path, encoding = 'utf-8') {
+        const _readfile = this._readFileFactory(fs_extra_default());
+        return _readfile(path, encoding);
+    }
+    _readFileFactory(fs) {
+        return async (path, encoding = 'utf-8')=>{
+            const cache = await this.storage.get(path);
+            if (null === cache) return null;
+            if (cache) return this.encodingContent(cache, encoding);
+            const isExistFile = await new Promise((resolve)=>{
+                fs.stat(path, (err, stats)=>{
+                    if (err) return void resolve(false);
+                    stats.isFile() ? resolve(true) : resolve(false);
+                });
+            });
+            if (isExistFile) {
+                const content = await fs.promises.readFile(path);
+                this.storage.set(path, content);
+                return this.encodingContent(content, encoding);
+            }
+            this.storage.set(path, null);
+            return null;
+        };
+    }
+    reset(fs) {
+        fs && (this.fs = fs);
+        return this.storage.clear?.();
+    }
+    encodingContent(value, encoding) {
+        if ('utf-8' === encoding) return value.toString();
+        return value;
+    }
+    constructor(storage){
+        this.fs = fs_extra_default();
+        this.storage = storage;
+    }
+}
+const fileReader = new FileReader((0, index_js_namespaceObject.createMemoryStorage)('__file__system'));
+exports.FileReader = __webpack_exports__.FileReader;
+exports.fileReader = __webpack_exports__.fileReader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "FileReader",
+    "fileReader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/node/index.js

@@ -0,0 +1,99 @@
+"use strict";
+var __webpack_modules__ = {
+    "../universal/async_storage.server" (module) {
+        module.exports = require("../universal/async_storage.server.js");
+    },
+    "./loaderContext" (module) {
+        module.exports = require("./loaderContext/index.js");
+    },
+    "./nestedRoutes" (module) {
+        module.exports = require("./nestedRoutes.js");
+    },
+    "./sanitize" (module) {
+        module.exports = require("./sanitize.js");
+    },
+    "./serialize" (module) {
+        module.exports = require("./serialize.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__, {
+        sanitizeSSRPayload: ()=>_sanitize__rspack_import_3.sanitizeSSRPayload,
+        serializeJson: ()=>_serialize__rspack_import_4.serializeJson,
+        storage: ()=>_universal_async_storage_server__rspack_import_0.storage
+    });
+    var _universal_async_storage_server__rspack_import_0 = __webpack_require__("../universal/async_storage.server");
+    var _loaderContext__rspack_import_1 = __webpack_require__("./loaderContext");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _loaderContext__rspack_import_1)if ([
+        "sanitizeSSRPayload",
+        "default",
+        "storage",
+        "serializeJson"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_loaderContext__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _nestedRoutes__rspack_import_2 = __webpack_require__("./nestedRoutes");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _nestedRoutes__rspack_import_2)if ([
+        "sanitizeSSRPayload",
+        "default",
+        "storage",
+        "serializeJson"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_nestedRoutes__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _sanitize__rspack_import_3 = __webpack_require__("./sanitize");
+    var _serialize__rspack_import_4 = __webpack_require__("./serialize");
+})();
+exports.sanitizeSSRPayload = __webpack_exports__.sanitizeSSRPayload;
+exports.serializeJson = __webpack_exports__.serializeJson;
+exports.storage = __webpack_exports__.storage;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "sanitizeSSRPayload",
+    "serializeJson",
+    "storage"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});