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

package/dist/cjs/router/runtime/tanstack/rsc/server.js

@@ -0,0 +1,246 @@
+"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__, {
+    CompositeComponent: ()=>external_CompositeComponent_js_namespaceObject.CompositeComponent,
+    createCompositeComponent: ()=>createCompositeComponent,
+    getTanstackRscSerializationAdapters: ()=>getTanstackRscSerializationAdapters,
+    renderServerComponent: ()=>renderServerComponent,
+    rscSerializationAdapter: ()=>rscSerializationAdapter
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const react_router_namespaceObject = require("@tanstack/react-router");
+const router_core_namespaceObject = require("@tanstack/router-core");
+const external_react_namespaceObject = require("react");
+const server_js_namespaceObject = require("../../../../rsc/server.js");
+const external_ClientSlot_js_namespaceObject = require("./ClientSlot.js");
+const external_createRscProxy_js_namespaceObject = require("./createRscProxy.js");
+const external_ReplayableStream_js_namespaceObject = require("./ReplayableStream.js");
+const external_slotUsageSanitizer_js_namespaceObject = require("./slotUsageSanitizer.js");
+const external_symbols_js_namespaceObject = require("./symbols.js");
+const external_CompositeComponent_js_namespaceObject = require("./CompositeComponent.js");
+function createTreeGetter(stream) {
+    let ready = false;
+    let tree;
+    const treePromise = Promise.resolve((0, server_js_namespaceObject.createFromReadableStream)(stream.createReplayStream())).then((value)=>{
+        tree = value;
+        ready = true;
+        return value;
+    });
+    return ()=>{
+        if (ready) return tree;
+        return (0, external_react_namespaceObject.use)(treePromise);
+    };
+}
+function createSlotProxy(options) {
+    const cache = new Map();
+    return new Proxy({}, {
+        get (_target, prop) {
+            if ('then' === prop || 'string' != typeof prop) return;
+            if ('children' === prop) {
+                options?.onSlotCall?.('children', []);
+                return /*#__PURE__*/ (0, external_react_namespaceObject.createElement)(external_ClientSlot_js_namespaceObject.ClientSlot, {
+                    args: [],
+                    slot: 'children'
+                });
+            }
+            if (!cache.has(prop)) cache.set(prop, (...args)=>{
+                options?.onSlotCall?.(prop, args);
+                return /*#__PURE__*/ (0, external_react_namespaceObject.createElement)(external_ClientSlot_js_namespaceObject.ClientSlot, {
+                    args,
+                    slot: prop
+                });
+            });
+            return cache.get(prop);
+        }
+    });
+}
+function toReplayableFlightStream(node, handlers) {
+    const flightStream = (0, server_js_namespaceObject.renderRsc)({
+        element: node
+    });
+    return new external_ReplayableStream_js_namespaceObject.ReplayableStream(handlers ? wrapReadableStream(flightStream, handlers) : flightStream);
+}
+async function renderServerComponent(node) {
+    const stream = toReplayableFlightStream(/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
+        children: node
+    }));
+    const streamWrapper = {
+        createReplayStream: ()=>stream.createReplayStream()
+    };
+    return (0, external_createRscProxy_js_namespaceObject.createRscProxy)(createTreeGetter(streamWrapper), {
+        renderable: true,
+        stream: streamWrapper
+    });
+}
+async function createCompositeComponent(component) {
+    const slotUsagesEmitter = 'development' === process.env.NODE_ENV ? createReadableStreamEmitter() : void 0;
+    const slotProxy = createSlotProxy({
+        onSlotCall: slotUsagesEmitter ? (slot, args)=>{
+            const sanitizedArgs = (0, external_slotUsageSanitizer_js_namespaceObject.sanitizeSlotArgs)(args);
+            slotUsagesEmitter.emit({
+                slot,
+                ...sanitizedArgs.length ? {
+                    args: sanitizedArgs
+                } : {}
+            });
+        } : void 0
+    });
+    async function ServerComponentWrapper() {
+        return component(slotProxy);
+    }
+    const flightStream = toReplayableFlightStream(/*#__PURE__*/ (0, external_react_namespaceObject.createElement)(ServerComponentWrapper), slotUsagesEmitter ? {
+        onCancel: slotUsagesEmitter.close,
+        onDone: slotUsagesEmitter.close,
+        onError: slotUsagesEmitter.close
+    } : void 0);
+    const streamWrapper = {
+        createReplayStream: ()=>flightStream.createReplayStream()
+    };
+    return (0, external_createRscProxy_js_namespaceObject.createRscProxy)(createTreeGetter(streamWrapper), {
+        renderable: false,
+        slotUsagesStream: slotUsagesEmitter?.stream,
+        stream: streamWrapper
+    });
+}
+const adapter = (0, react_router_namespaceObject.createSerializationAdapter)({
+    key: '$MODERN_TANSTACK_RSC',
+    test: external_symbols_js_namespaceObject.isServerComponent,
+    toSerializable: (component)=>{
+        const streamWrapper = component[external_symbols_js_namespaceObject.SERVER_COMPONENT_STREAM];
+        if (!streamWrapper) throw new Error('Cannot serialize TanStack RSC without a Flight stream.');
+        const kind = (0, external_symbols_js_namespaceObject.isRenderableServerComponent)(component) ? 'renderable' : 'composite';
+        const slotUsagesStream = 'development' === process.env.NODE_ENV && 'composite' === kind ? component[external_symbols_js_namespaceObject.RSC_SLOT_USAGES_STREAM] : void 0;
+        return {
+            kind,
+            stream: new router_core_namespaceObject.RawStream(streamWrapper.createReplayStream(), {
+                hint: 'text'
+            }),
+            ...slotUsagesStream ? {
+                slotUsagesStream
+            } : {}
+        };
+    },
+    fromSerializable: ()=>{
+        throw new Error('TanStack RSC data should not be deserialized on server.');
+    }
+});
+function getTanstackRscSerializationAdapters() {
+    return [
+        adapter
+    ];
+}
+const rscSerializationAdapter = getTanstackRscSerializationAdapters;
+function createReadableStreamEmitter() {
+    let closed = false;
+    const queue = [];
+    let controller = null;
+    const stream = new ReadableStream({
+        start (ctrl) {
+            controller = ctrl;
+            for (const value of queue)ctrl.enqueue(value);
+            queue.length = 0;
+            if (closed) ctrl.close();
+        },
+        cancel () {
+            closed = true;
+            controller = null;
+            queue.length = 0;
+        }
+    });
+    const emit = (value)=>{
+        if (closed) return;
+        if (!controller) return void queue.push(value);
+        try {
+            controller.enqueue(value);
+        } catch  {}
+    };
+    const close = ()=>{
+        if (closed) return;
+        closed = true;
+        try {
+            controller?.close();
+        } catch  {}
+        controller = null;
+    };
+    return {
+        close,
+        emit,
+        stream
+    };
+}
+function wrapReadableStream(source, handlers) {
+    const reader = source.getReader();
+    let finished = false;
+    const finish = (kind)=>{
+        if (finished) return;
+        finished = true;
+        if ('cancel' === kind) handlers.onCancel?.();
+        else if ('error' === kind) handlers.onError?.();
+        else handlers.onDone?.();
+        try {
+            reader.releaseLock();
+        } catch  {}
+    };
+    return new ReadableStream({
+        async pull (controller) {
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    controller.close();
+                    finish('done');
+                    return;
+                }
+                controller.enqueue(value);
+            } catch (err) {
+                try {
+                    controller.error(err);
+                } catch  {}
+                finish('error');
+            }
+        },
+        async cancel (reason) {
+            try {
+                await reader.cancel(reason);
+            } catch  {}
+            finish('cancel');
+        }
+    });
+}
+exports.CompositeComponent = __webpack_exports__.CompositeComponent;
+exports.createCompositeComponent = __webpack_exports__.createCompositeComponent;
+exports.getTanstackRscSerializationAdapters = __webpack_exports__.getTanstackRscSerializationAdapters;
+exports.renderServerComponent = __webpack_exports__.renderServerComponent;
+exports.rscSerializationAdapter = __webpack_exports__.rscSerializationAdapter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CompositeComponent",
+    "createCompositeComponent",
+    "getTanstackRscSerializationAdapters",
+    "renderServerComponent",
+    "rscSerializationAdapter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/runtime/tanstack/rsc/slotUsageSanitizer.js

@@ -0,0 +1,65 @@
+"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__, {
+    sanitizeSlotArgs: ()=>sanitizeSlotArgs
+});
+const external_react_namespaceObject = require("react");
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_TRANSITIONAL_ELEMENT_TYPE = Symbol.for('react.transitional.element');
+function isReactElementLike(value) {
+    if (!value || 'object' != typeof value && 'function' != typeof value) return false;
+    if ((0, external_react_namespaceObject.isValidElement)(value)) return true;
+    const type = value.$$typeof;
+    return type === REACT_ELEMENT_TYPE || type === REACT_TRANSITIONAL_ELEMENT_TYPE || type === REACT_PORTAL_TYPE;
+}
+function sanitizeSlotArg(value, seen) {
+    if (isReactElementLike(value)) return 'React element';
+    if (null == value) return value;
+    if ('string' == typeof value || 'number' == typeof value || 'boolean' == typeof value || 'bigint' == typeof value) return value;
+    if ('object' != typeof value && 'function' != typeof value) return String(value);
+    if (seen.has(value)) return '[Circular]';
+    seen.add(value);
+    if (Array.isArray(value)) return value.map((item)=>sanitizeSlotArg(item, seen));
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || null === proto) {
+        const out = {};
+        for (const [key, item] of Object.entries(value))out[key] = sanitizeSlotArg(item, seen);
+        return out;
+    }
+    return String(value);
+}
+function sanitizeSlotArgs(args) {
+    const seen = new WeakSet();
+    return args.map((arg)=>sanitizeSlotArg(arg, seen));
+}
+exports.sanitizeSlotArgs = __webpack_exports__.sanitizeSlotArgs;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "sanitizeSlotArgs"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/runtime/tanstack/rsc/symbols.js

@@ -0,0 +1,72 @@
+"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__, {
+    RENDERABLE_RSC: ()=>RENDERABLE_RSC,
+    RSC_PROXY_GET_TREE: ()=>RSC_PROXY_GET_TREE,
+    RSC_PROXY_PATH: ()=>RSC_PROXY_PATH,
+    RSC_SLOT_USAGES: ()=>RSC_SLOT_USAGES,
+    RSC_SLOT_USAGES_STREAM: ()=>RSC_SLOT_USAGES_STREAM,
+    SERVER_COMPONENT_STREAM: ()=>SERVER_COMPONENT_STREAM,
+    isRenderableServerComponent: ()=>isRenderableServerComponent,
+    isServerComponent: ()=>isServerComponent
+});
+const SERVER_COMPONENT_STREAM = Symbol.for('modern.tanstack.rsc.stream');
+const RENDERABLE_RSC = Symbol.for('modern.tanstack.rsc.renderable');
+const RSC_PROXY_GET_TREE = Symbol.for('modern.tanstack.rsc.proxy.getTree');
+const RSC_PROXY_PATH = Symbol.for('modern.tanstack.rsc.proxy.path');
+const RSC_SLOT_USAGES_STREAM = Symbol.for('modern.tanstack.rsc.slotUsages.stream');
+const RSC_SLOT_USAGES = Symbol.for('modern.tanstack.rsc.slotUsages');
+function isServerComponent(value) {
+    if (null == value) return false;
+    if ('object' != typeof value && 'function' != typeof value) return false;
+    return SERVER_COMPONENT_STREAM in value && void 0 !== value[SERVER_COMPONENT_STREAM];
+}
+function isRenderableServerComponent(value) {
+    if (null == value) return false;
+    if ('object' != typeof value && 'function' != typeof value) return false;
+    return RENDERABLE_RSC in value && true === value[RENDERABLE_RSC];
+}
+exports.RENDERABLE_RSC = __webpack_exports__.RENDERABLE_RSC;
+exports.RSC_PROXY_GET_TREE = __webpack_exports__.RSC_PROXY_GET_TREE;
+exports.RSC_PROXY_PATH = __webpack_exports__.RSC_PROXY_PATH;
+exports.RSC_SLOT_USAGES = __webpack_exports__.RSC_SLOT_USAGES;
+exports.RSC_SLOT_USAGES_STREAM = __webpack_exports__.RSC_SLOT_USAGES_STREAM;
+exports.SERVER_COMPONENT_STREAM = __webpack_exports__.SERVER_COMPONENT_STREAM;
+exports.isRenderableServerComponent = __webpack_exports__.isRenderableServerComponent;
+exports.isServerComponent = __webpack_exports__.isServerComponent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RENDERABLE_RSC",
+    "RSC_PROXY_GET_TREE",
+    "RSC_PROXY_PATH",
+    "RSC_SLOT_USAGES",
+    "RSC_SLOT_USAGES_STREAM",
+    "SERVER_COMPONENT_STREAM",
+    "isRenderableServerComponent",
+    "isServerComponent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

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

@@ -0,0 +1,243 @@
+"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__, {
+    createRouteObjectsFromConfig: ()=>createRouteObjectsFromConfig,
+    deserializeErrors: ()=>deserializeErrors,
+    getLocation: ()=>getLocation,
+    getRouteComponents: ()=>getRouteComponents,
+    getRouteObjects: ()=>getRouteObjects,
+    renderRoutes: ()=>renderRoutes,
+    serializeErrors: ()=>serializeErrors,
+    standardSlash: ()=>standardSlash,
+    urlJoin: ()=>urlJoin
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const browser_namespaceObject = require("@modern-js/runtime-utils/browser");
+const router_namespaceObject = require("@modern-js/runtime-utils/router");
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+const external_DefaultNotFound_js_namespaceObject = require("./DefaultNotFound.js");
+const external_DeferredDataScripts_js_namespaceObject = require("./DeferredDataScripts.js");
+var external_DeferredDataScripts_js_default = /*#__PURE__*/ __webpack_require__.n(external_DeferredDataScripts_js_namespaceObject);
+function getRouteComponents(routes, { globalApp, ssrMode, props }) {
+    const Layout = ({ Component, ...props })=>{
+        const GlobalLayout = globalApp;
+        if (!GlobalLayout) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Component, {
+            ...props
+        });
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(GlobalLayout, {
+            Component: Component,
+            ...props
+        });
+    };
+    const routeElements = [];
+    for (const route of routes)if ('nested' === route.type) {
+        const routeElement = (0, browser_namespaceObject.renderNestedRoute)(route, {
+            DeferredDataComponent: 'stream' === ssrMode ? external_DeferredDataScripts_js_default() : void 0,
+            props
+        });
+        routeElements.push(routeElement);
+    } else {
+        const routeElement = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(router_namespaceObject.Route, {
+            path: route.path,
+            element: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Layout, {
+                Component: route.component
+            })
+        }, route.path);
+        routeElements.push(routeElement);
+    }
+    routeElements.push(/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(router_namespaceObject.Route, {
+        path: "*",
+        element: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_DefaultNotFound_js_namespaceObject.DefaultNotFound, {}),
+        loader: ()=>new Response('404', {
+                status: 404
+            })
+    }, "*"));
+    return routeElements;
+}
+function getRouteObjects(routes, { globalApp, ssrMode, props }) {
+    const createLayoutElement = (Component)=>{
+        const GlobalLayout = globalApp;
+        if (!GlobalLayout) return Component;
+        const LayoutWrapper = (props)=>{
+            const LayoutComponent = GlobalLayout;
+            return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(LayoutComponent, {
+                Component: Component,
+                ...props
+            });
+        };
+        return LayoutWrapper;
+    };
+    const routeObjects = [];
+    for (const route of routes)if ('nested' === route.type) {
+        const nestedRouteObject = {
+            path: route.path,
+            id: route.id,
+            loader: route.loader,
+            action: route.action,
+            hasErrorBoundary: route.hasErrorBoundary,
+            shouldRevalidate: route.shouldRevalidate,
+            handle: {
+                ...route.handle,
+                ...'object' == typeof route.config ? route.config?.handle : {}
+            },
+            index: route.index,
+            hasLoader: !!route.loader,
+            hasClientLoader: !!route.clientData,
+            hasAction: !!route.action,
+            ...route.isClientComponent ? {
+                isClientComponent: true
+            } : {},
+            ...route.inValidSSRRoute ? {
+                inValidSSRRoute: true
+            } : {},
+            lazyImport: route.lazyImport,
+            Component: route.component ? route.component : void 0,
+            errorElement: route.error ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(route.error, {}) : void 0,
+            children: route.children ? route.children.map((child)=>getRouteObjects([
+                    child
+                ], {
+                    globalApp,
+                    ssrMode,
+                    props
+                })[0]) : void 0
+        };
+        routeObjects.push(nestedRouteObject);
+    } else if ('function' == typeof route.component || 'object' == typeof route.component) {
+        const LayoutComponent = createLayoutElement(route.component);
+        const routeObject = {
+            path: route.path,
+            element: /*#__PURE__*/ external_react_default().createElement(LayoutComponent)
+        };
+        routeObjects.push(routeObject);
+    }
+    routeObjects.push({
+        path: '*',
+        element: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_DefaultNotFound_js_namespaceObject.DefaultNotFound, {})
+    });
+    return routeObjects;
+}
+function createRouteObjectsFromConfig({ routesConfig, props, ssrMode }) {
+    if (!routesConfig) return null;
+    const { routes, globalApp } = routesConfig;
+    if (!routes) return null;
+    return getRouteObjects(routes, {
+        globalApp,
+        ssrMode,
+        props
+    });
+}
+function renderRoutes({ routesConfig, props, ssrMode }) {
+    if (!routesConfig) return null;
+    const { routes, globalApp } = routesConfig;
+    if (!routes) return null;
+    const routeElements = getRouteComponents(routes, {
+        globalApp,
+        ssrMode,
+        props
+    });
+    return routeElements;
+}
+function getLocation(serverContext) {
+    const { pathname = '', url = '' } = serverContext?.request || {};
+    const cleanUrl = url?.replace('http://', '')?.replace('https://', '');
+    const index = (cleanUrl || '').indexOf(pathname);
+    if (-1 === index) return pathname;
+    return cleanUrl.substring(index);
+}
+const urlJoin = (...parts)=>{
+    const separator = '/';
+    const replace = new RegExp(`${separator}{1,}`, 'g');
+    return standardSlash(parts.join(separator).replace(replace, separator));
+};
+function standardSlash(str) {
+    let addr = str;
+    if (!addr || 'string' != typeof addr) return addr;
+    if (addr.startsWith('.')) addr = addr.slice(1);
+    if (!addr.startsWith('/')) addr = `/${addr}`;
+    if (addr.endsWith('/') && '/' !== addr) addr = addr.slice(0, addr.length - 1);
+    return addr;
+}
+function serializeErrors(errors) {
+    if (!errors) return null;
+    const entries = Object.entries(errors);
+    const serialized = {};
+    for (const [key, val] of entries)if ((0, router_namespaceObject.isRouteErrorResponse)(val)) serialized[key] = {
+        ...val,
+        __type: 'RouteErrorResponse'
+    };
+    else if (val instanceof Error) serialized[key] = {
+        message: val.message,
+        stack: val.stack,
+        __type: 'Error'
+    };
+    else serialized[key] = val;
+    return serialized;
+}
+function deserializeErrors(errors) {
+    if (!errors) return null;
+    const entries = Object.entries(errors);
+    const serialized = {};
+    for (const [key, val] of entries)if (val && 'RouteErrorResponse' === val.__type) serialized[key] = new router_namespaceObject.UNSAFE_ErrorResponseImpl(val.status, val.statusText, val.data, true === val.internal);
+    else if (val && 'Error' === val.__type) {
+        const error = new Error(val.message);
+        error.stack = val.stack;
+        serialized[key] = error;
+    } else serialized[key] = val;
+    return serialized;
+}
+exports.createRouteObjectsFromConfig = __webpack_exports__.createRouteObjectsFromConfig;
+exports.deserializeErrors = __webpack_exports__.deserializeErrors;
+exports.getLocation = __webpack_exports__.getLocation;
+exports.getRouteComponents = __webpack_exports__.getRouteComponents;
+exports.getRouteObjects = __webpack_exports__.getRouteObjects;
+exports.renderRoutes = __webpack_exports__.renderRoutes;
+exports.serializeErrors = __webpack_exports__.serializeErrors;
+exports.standardSlash = __webpack_exports__.standardSlash;
+exports.urlJoin = __webpack_exports__.urlJoin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRouteObjectsFromConfig",
+    "deserializeErrors",
+    "getLocation",
+    "getRouteComponents",
+    "getRouteObjects",
+    "renderRoutes",
+    "serializeErrors",
+    "standardSlash",
+    "urlJoin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});