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

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

@@ -0,0 +1,262 @@
+"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__, {
+    beforeCreateRouter: ()=>beforeCreateRouter,
+    finalRouteConfig: ()=>finalRouteConfig,
+    modifyRoutes: ()=>modifyRoutes,
+    routerPlugin: ()=>routerPlugin
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
+const router_namespaceObject = require("@modern-js/runtime-utils/router");
+const url_namespaceObject = require("@modern-js/runtime-utils/url");
+const external_react_namespaceObject = require("react");
+const index_js_namespaceObject = require("../../core/context/index.js");
+const external_hooks_js_namespaceObject = require("./hooks.js");
+const external_lifecycle_js_namespaceObject = require("./lifecycle.js");
+const external_rsc_router_js_namespaceObject = require("./rsc-router.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+let finalRouteConfig = {
+    routes: []
+};
+let beforeCreateRouter = true;
+function modifyRoutes(modifyFunction) {
+    if (beforeCreateRouter) {
+        const { routes: originRoutes } = finalRouteConfig;
+        const newRoutes = modifyFunction(originRoutes);
+        finalRouteConfig.routes = newRoutes;
+    } else console.error('It is not allowed to modify routes config after create router.');
+}
+const routerPlugin = (userConfig = {})=>({
+        name: '@modern-js/plugin-router',
+        registryHooks: {
+            onAfterCreateRouter: external_hooks_js_namespaceObject.onAfterCreateRouter,
+            onAfterHydrateRouter: external_hooks_js_namespaceObject.onAfterHydrateRouter,
+            onBeforeCreateRouter: external_hooks_js_namespaceObject.onBeforeCreateRouter,
+            modifyRoutes: external_hooks_js_namespaceObject.modifyRoutes,
+            onBeforeCreateRoutes: external_hooks_js_namespaceObject.onBeforeCreateRoutes,
+            onBeforeHydrateRouter: external_hooks_js_namespaceObject.onBeforeHydrateRouter
+        },
+        setup: (api)=>{
+            const routesContainer = {
+                current: []
+            };
+            api.onBeforeRender((context)=>{
+                if (window._SSR_DATA && userConfig.unstable_reloadOnURLMismatch) {
+                    const { ssrContext } = context;
+                    const currentPathname = (0, url_namespaceObject.normalizePathname)(window.location.pathname);
+                    const initialPathname = ssrContext?.request?.pathname && (0, url_namespaceObject.normalizePathname)(ssrContext.request.pathname);
+                    if (initialPathname && initialPathname !== currentPathname) {
+                        const errorMsg = `The initial URL ${initialPathname} and the URL ${currentPathname} to be hydrated do not match, reload.`;
+                        console.error(errorMsg);
+                        window.location.reload();
+                    }
+                }
+                context.router = {
+                    useMatches: router_namespaceObject.useMatches,
+                    useLocation: router_namespaceObject.useLocation,
+                    useHref: router_namespaceObject.useHref
+                };
+                Object.defineProperty(context, 'routes', {
+                    get () {
+                        return routesContainer.current;
+                    },
+                    enumerable: true
+                });
+            });
+            api.wrapRoot((App)=>{
+                const mergedConfig = (0, merge_namespaceObject.merge)(api.getRuntimeConfig().router || {}, userConfig);
+                const { serverBase = [], supportHtml5History = true, basename = '', routesConfig, createRoutes } = mergedConfig;
+                finalRouteConfig = {
+                    routes: (0, index_js_namespaceObject.getGlobalRoutes)(),
+                    globalApp: (0, index_js_namespaceObject.getGlobalLayoutApp)(),
+                    ...routesConfig
+                };
+                if (!finalRouteConfig.routes && !createRoutes) return App;
+                const selectBasePath = (pathname)=>{
+                    const match = serverBase.find((baseUrl)=>isSegmentPrefix(pathname, baseUrl));
+                    return match || '/';
+                };
+                let cachedRouter = null;
+                const RouterWrapper = (props)=>{
+                    const routerResult = useRouterCreation({
+                        ...props,
+                        rscPayload: props?.rscPayload
+                    }, {
+                        api: api,
+                        createRoutes,
+                        supportHtml5History,
+                        selectBasePath,
+                        basename
+                    });
+                    const router = (0, external_react_namespaceObject.useMemo)(()=>{
+                        if (cachedRouter) return cachedRouter;
+                        cachedRouter = routerResult.router;
+                        return cachedRouter;
+                    }, []);
+                    const { routes } = routerResult;
+                    routesContainer.current = routes;
+                    beforeCreateRouter = false;
+                    const RouterContent = ()=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+                            children: [
+                                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(router_namespaceObject.RouterProvider, {
+                                    router: router
+                                }),
+                                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(EmptyComponent, {}),
+                                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(EmptyComponent, {})
+                            ]
+                        });
+                    return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
+                        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(RouterContent, {})
+                    }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(RouterContent, {});
+                };
+                return RouterWrapper;
+            });
+        }
+    });
+const EmptyComponent = ()=>null;
+const safeUse = (promise)=>{
+    const useProp = 'use';
+    const useHook = external_react_namespaceObject && external_react_namespaceObject[useProp];
+    if ('function' == typeof useHook) return useHook(promise);
+    return null;
+};
+function normalizeBase(b) {
+    if (b.length > 1 && b.endsWith('/')) return b.slice(0, -1);
+    return b || '/';
+}
+function isSegmentPrefix(pathname, base) {
+    const b = normalizeBase(base);
+    const p = pathname || '/';
+    return p === b || p.startsWith(`${b}/`);
+}
+function useRouterCreation(props, options) {
+    const { api, createRoutes, supportHtml5History, selectBasePath, basename } = options;
+    const runtimeContext = (0, external_react_namespaceObject.useContext)(index_js_namespaceObject.InternalRuntimeContext);
+    const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
+    const _basename = '/' === baseUrl ? (0, external_utils_js_namespaceObject.urlJoin)(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
+    const { unstable_getBlockNavState: getBlockNavState } = runtimeContext;
+    const rscPayload = props?.rscPayload ? safeUse(props.rscPayload) : null;
+    let hydrationData = window._ROUTER_DATA || rscPayload;
+    return (0, external_react_namespaceObject.useMemo)(()=>{
+        if (hydrationData?.errors) hydrationData = {
+            ...hydrationData,
+            errors: (0, external_utils_js_namespaceObject.deserializeErrors)(hydrationData.errors)
+        };
+        const isRscClient = (0, index_js_namespaceObject.getGlobalIsRscClient)();
+        let routes = null;
+        routes = isRscClient ? createRoutes ? createRoutes() : (0, external_utils_js_namespaceObject.createRouteObjectsFromConfig)({
+            routesConfig: finalRouteConfig
+        }) : createRoutes ? createRoutes() : (0, router_namespaceObject.createRoutesFromElements)((0, external_utils_js_namespaceObject.renderRoutes)({
+            routesConfig: finalRouteConfig,
+            props
+        }));
+        if (!routes) routes = [];
+        const hooks = api.getHooks();
+        if (rscPayload) try {
+            const router = (0, external_rsc_router_js_namespaceObject.createClientRouterFromPayload)(rscPayload, routes, _basename);
+            return {
+                router,
+                routes: router.routes || []
+            };
+        } catch (e) {
+            console.error('Failed to create router from RSC payload:', e);
+        }
+        const modifiedRoutes = hooks.modifyRoutes.call(routes);
+        const routerLifecycleContext = {
+            framework: 'react-router',
+            phase: 'client-create',
+            routes: modifiedRoutes,
+            runtimeContext,
+            basename: _basename,
+            hydrationData
+        };
+        hooks.onBeforeCreateRouter.call(routerLifecycleContext);
+        const router = supportHtml5History ? (0, router_namespaceObject.createBrowserRouter)(modifiedRoutes, {
+            basename: _basename,
+            hydrationData
+        }) : (0, router_namespaceObject.createHashRouter)(modifiedRoutes, {
+            basename: _basename,
+            hydrationData
+        });
+        (0, external_lifecycle_js_namespaceObject.applyRouterRuntimeState)(runtimeContext, {
+            framework: 'react-router',
+            basename: _basename,
+            instance: router
+        });
+        hooks.onAfterCreateRouter.call({
+            ...routerLifecycleContext,
+            router,
+            runtimeContext
+        });
+        if (hydrationData) {
+            hooks.onBeforeHydrateRouter.call({
+                ...routerLifecycleContext,
+                phase: 'hydrate',
+                router,
+                runtimeContext
+            });
+            hooks.onAfterHydrateRouter.call({
+                ...routerLifecycleContext,
+                phase: 'hydrate',
+                router,
+                runtimeContext
+            });
+        }
+        const originSubscribe = router.subscribe;
+        router.subscribe = (listener)=>{
+            const wrappedListener = (...args)=>{
+                const blockRoute = getBlockNavState ? getBlockNavState() : false;
+                if (blockRoute) return;
+                return listener(...args);
+            };
+            return originSubscribe(wrappedListener);
+        };
+        return {
+            router,
+            routes: modifiedRoutes
+        };
+    }, [
+        finalRouteConfig,
+        props,
+        _basename,
+        hydrationData,
+        getBlockNavState
+    ]);
+}
+exports.beforeCreateRouter = __webpack_exports__.beforeCreateRouter;
+exports.finalRouteConfig = __webpack_exports__.finalRouteConfig;
+exports.modifyRoutes = __webpack_exports__.modifyRoutes;
+exports.routerPlugin = __webpack_exports__.routerPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "beforeCreateRouter",
+    "finalRouteConfig",
+    "modifyRoutes",
+    "routerPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,226 @@
+"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__, {
+    modifyRoutes: ()=>modifyRoutes,
+    routerPlugin: ()=>routerPlugin
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
+const node_namespaceObject = require("@modern-js/runtime-utils/node");
+const router_namespaceObject = require("@modern-js/runtime-utils/router");
+const time_namespaceObject = require("@modern-js/runtime-utils/time");
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const external_react_namespaceObject = require("react");
+const index_js_namespaceObject = require("../../core/context/index.js");
+const index_server_js_namespaceObject = require("../../core/context/serverPayload/index.server.js");
+const external_DeferredDataScripts_node_js_namespaceObject = require("./DeferredDataScripts.node.js");
+var external_DeferredDataScripts_node_js_default = /*#__PURE__*/ __webpack_require__.n(external_DeferredDataScripts_node_js_namespaceObject);
+const external_hooks_js_namespaceObject = require("./hooks.js");
+const external_lifecycle_js_namespaceObject = require("./lifecycle.js");
+const external_rsc_router_js_namespaceObject = require("./rsc-router.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+function createRemixRequest(request) {
+    const method = 'GET';
+    const { headers } = request;
+    const controller = new AbortController();
+    return new Request(request.url, {
+        method,
+        headers,
+        signal: controller.signal
+    });
+}
+function createReactRouterServerSnapshot(routerContext, basename) {
+    return (0, external_lifecycle_js_namespaceObject.createRouterServerSnapshot)({
+        framework: 'react-router',
+        basename,
+        statusCode: routerContext.statusCode,
+        errors: routerContext.errors,
+        routerData: {
+            loaderData: routerContext.loaderData,
+            errors: routerContext.errors
+        },
+        matches: routerContext.matches.map((match)=>{
+            const routeId = match.route.id;
+            return 'string' == typeof routeId ? {
+                routeId
+            } : void 0;
+        }).filter((match)=>void 0 !== match)
+    });
+}
+const routerPlugin = (userConfig = {})=>({
+        name: '@modern-js/plugin-router',
+        registryHooks: {
+            onAfterCreateRouter: external_hooks_js_namespaceObject.onAfterCreateRouter,
+            onBeforeCreateRouter: external_hooks_js_namespaceObject.onBeforeCreateRouter,
+            modifyRoutes: external_hooks_js_namespaceObject.modifyRoutes,
+            onBeforeCreateRoutes: external_hooks_js_namespaceObject.onBeforeCreateRoutes
+        },
+        setup: (api)=>{
+            let finalRouteConfig = {};
+            api.onBeforeRender(async (context, interrupt)=>{
+                const pluginConfig = api.getRuntimeConfig();
+                const { basename = '', routesConfig, createRoutes } = (0, merge_namespaceObject.merge)(pluginConfig.router || {}, userConfig);
+                finalRouteConfig = {
+                    routes: (0, index_js_namespaceObject.getGlobalRoutes)(),
+                    globalApp: (0, index_js_namespaceObject.getGlobalLayoutApp)(),
+                    ...routesConfig
+                };
+                if (!finalRouteConfig.routes && !createRoutes) return;
+                const enableRsc = (0, index_js_namespaceObject.getGlobalEnableRsc)();
+                if (enableRsc) await (0, external_rsc_router_js_namespaceObject.prepareRSCRoutes)(finalRouteConfig.routes);
+                const { request, mode: ssrMode, nonce, loaderFailureMode = 'errorBoundary', baseUrl } = context.ssrContext;
+                const _basename = '/' === baseUrl ? (0, external_utils_js_namespaceObject.urlJoin)(baseUrl, basename) : baseUrl;
+                const requestContext = (0, node_namespaceObject.createRequestContext)(context.ssrContext?.loaderContext);
+                const hooks = api.getHooks();
+                await hooks.onBeforeCreateRoutes.call(context);
+                let routes = [];
+                routes = enableRsc ? createRoutes ? createRoutes() : (0, external_utils_js_namespaceObject.createRouteObjectsFromConfig)({
+                    routesConfig: finalRouteConfig
+                }) : createRoutes ? createRoutes() : (0, router_namespaceObject.createRoutesFromElements)((0, external_utils_js_namespaceObject.renderRoutes)({
+                    routesConfig: finalRouteConfig,
+                    ssrMode,
+                    props: {
+                        nonce
+                    }
+                }));
+                routes = hooks.modifyRoutes.call(routes);
+                const routerLifecycleContext = {
+                    framework: 'react-router',
+                    phase: 'ssr-prepare',
+                    routes,
+                    runtimeContext: context,
+                    basename: _basename
+                };
+                hooks.onBeforeCreateRouter.call(routerLifecycleContext);
+                const { query } = (0, router_namespaceObject.createStaticHandler)(routes, {
+                    basename: _basename
+                });
+                const remixRequest = createRemixRequest(context.ssrContext.request.raw);
+                const end = (0, time_namespaceObject.time)();
+                const routerContext = await query(remixRequest, {
+                    requestContext
+                });
+                const cost = end();
+                context.ssrContext?.onTiming?.(constants_namespaceObject.LOADER_REPORTER_NAME, cost);
+                const isRSCNavigation = 'true' === remixRequest.headers.get('x-rsc-tree');
+                if (routerContext instanceof Response) if (enableRsc && isRSCNavigation) return interrupt((0, external_rsc_router_js_namespaceObject.handleRSCRedirect)(routerContext.headers, _basename, routerContext.status));
+                else return interrupt(routerContext);
+                const errors = Object.values(routerContext.errors || {});
+                if (errors.length > 0 && 'clientRender' === loaderFailureMode) {
+                    routerContext.statusCode = 200;
+                    throw errors[0];
+                }
+                context.routerContext = routerContext;
+                const routerServerSnapshot = createReactRouterServerSnapshot(routerContext, _basename);
+                (0, external_lifecycle_js_namespaceObject.applyRouterRuntimeState)(context, {
+                    framework: 'react-router',
+                    basename: _basename,
+                    instance: routerContext,
+                    matchedRouteIds: routerServerSnapshot.matchedRouteIds,
+                    serverSnapshot: routerServerSnapshot
+                });
+                hooks.onAfterCreateRouter.call({
+                    ...routerLifecycleContext,
+                    router: routerContext,
+                    serverSnapshot: routerServerSnapshot,
+                    runtimeContext: context
+                });
+                let payload;
+                if (enableRsc) {
+                    if (isRSCNavigation) {
+                        for (const match of routerContext.matches)if (match.route.hasClientLoader) delete routerContext.loaderData[match.route.id];
+                    }
+                    payload = (0, external_rsc_router_js_namespaceObject.createServerPayload)(routerContext, routes);
+                    (0, index_server_js_namespaceObject.setServerPayload)(payload);
+                }
+                Object.defineProperty(context, 'routes', {
+                    get () {
+                        return routes;
+                    },
+                    enumerable: true
+                });
+            });
+            api.wrapRoot((App)=>{
+                if (!finalRouteConfig) return App;
+                const getRouteApp = ()=>{
+                    const enableRsc = (0, index_js_namespaceObject.getGlobalEnableRsc)();
+                    return (props)=>{
+                        const context = (0, external_react_namespaceObject.useContext)(index_js_namespaceObject.InternalRuntimeContext);
+                        const { routerContext, ssrContext, routes } = context;
+                        const { nonce, mode, useJsonScript } = ssrContext;
+                        const { basename } = routerContext;
+                        const remixRouter = (0, router_namespaceObject.createStaticRouter)(routes, routerContext);
+                        if (enableRsc) return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
+                            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_rsc_router_js_namespaceObject.RSCStaticRouter, {
+                                basename: basename
+                            })
+                        }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_rsc_router_js_namespaceObject.RSCStaticRouter, {
+                            basename: basename
+                        });
+                        {
+                            const routerWrapper = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+                                children: [
+                                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(router_namespaceObject.StaticRouterProvider, {
+                                        router: remixRouter,
+                                        context: routerContext,
+                                        hydrate: false
+                                    }),
+                                    'stream' === mode && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_DeferredDataScripts_node_js_default(), {
+                                        nonce: nonce,
+                                        context: routerContext,
+                                        useJsonScript: useJsonScript
+                                    })
+                                ]
+                            });
+                            return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
+                                children: routerWrapper
+                            }) : routerWrapper;
+                        }
+                    };
+                };
+                return getRouteApp();
+            });
+        }
+    });
+const modifyRoutes = ()=>{};
+exports.modifyRoutes = __webpack_exports__.modifyRoutes;
+exports.routerPlugin = __webpack_exports__.routerPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "modifyRoutes",
+    "routerPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,55 @@
+"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__, {
+    createShouldRevalidate: ()=>createShouldRevalidate,
+    handleRouteModule: ()=>handleRouteModule,
+    handleRouteModuleError: ()=>handleRouteModuleError
+});
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const createShouldRevalidate = (routeId)=>(arg)=>{
+        const routeModule = "u" > typeof window ? window?.[constants_namespaceObject.ROUTE_MODULES]?.[routeId] : void 0;
+        if (routeModule && 'function' == typeof routeModule.shouldRevalidate) return routeModule.shouldRevalidate(arg);
+        return arg.defaultShouldRevalidate;
+    };
+const handleRouteModule = (routeModule, routeId)=>{
+    if ("u" > typeof document) window[constants_namespaceObject.ROUTE_MODULES][routeId] = routeModule;
+    return routeModule;
+};
+const handleRouteModuleError = (error)=>{
+    console.error(error);
+    return null;
+};
+exports.createShouldRevalidate = __webpack_exports__.createShouldRevalidate;
+exports.handleRouteModule = __webpack_exports__.handleRouteModule;
+exports.handleRouteModuleError = __webpack_exports__.handleRouteModuleError;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createShouldRevalidate",
+    "handleRouteModule",
+    "handleRouteModuleError"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});