@modern-js/runtime 2.69.5 → 3.0.0-alpha.0

package/dist/cjs/router/runtime/rsc-router.js

@@ -1,322 +1,289 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var rsc_router_exports = {};
-__export(rsc_router_exports, {
-  RSCStaticRouter: () => RSCStaticRouter,
-  createClientRouterFromPayload: () => createClientRouterFromPayload,
-  createServerPayload: () => createServerPayload,
-  handleRSCRedirect: () => handleRSCRedirect,
-  prepareRSCRoutes: () => prepareRSCRoutes
+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__, {
+    createClientRouterFromPayload: ()=>createClientRouterFromPayload,
+    createServerPayload: ()=>createServerPayload,
+    handleRSCRedirect: ()=>handleRSCRedirect,
+    prepareRSCRoutes: ()=>prepareRSCRoutes,
+    RSCStaticRouter: ()=>RSCStaticRouter
 });
-module.exports = __toCommonJS(rsc_router_exports);
-var import_jsx_runtime = require("react/jsx-runtime");
-var import_client = require("@modern-js/render/client");
-var import_router = require("@modern-js/runtime-utils/node/router");
-var import_router2 = require("@modern-js/runtime-utils/router");
-var import_react = __toESM(require("react"));
-const safeUse = (promise) => {
-  if (typeof import_react.default.use === "function") {
-    return import_react.default.use(promise);
-  }
-  return null;
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const client_namespaceObject = require("@modern-js/render/client");
+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 safeUse = (promise)=>{
+    if ('function' == typeof external_react_default().use) return external_react_default().use(promise);
+    return null;
 };
-const createServerPayload = (routerContext, routes) => {
-  return {
-    type: "render",
-    actionData: routerContext.actionData,
-    errors: routerContext.errors,
-    loaderData: routerContext.loaderData,
-    location: routerContext.location,
-    routes: routerContext.matches.map((match, index, matches) => {
-      const element = match.route.element;
-      const parentMatch = index > 0 ? matches[index - 1] : void 0;
-      let processedElement;
-      if (element) {
-        var _routerContext_loaderData, _routerContext_actionData;
-        const ElementComponent = element.type;
-        processedElement = /* @__PURE__ */ import_react.default.createElement(ElementComponent, {
-          loaderData: routerContext === null || routerContext === void 0 ? void 0 : (_routerContext_loaderData = routerContext.loaderData) === null || _routerContext_loaderData === void 0 ? void 0 : _routerContext_loaderData[match.route.id],
-          actionData: routerContext === null || routerContext === void 0 ? void 0 : (_routerContext_actionData = routerContext.actionData) === null || _routerContext_actionData === void 0 ? void 0 : _routerContext_actionData[match.route.id],
-          params: match.params,
-          matches: routerContext.matches.map((m) => {
-            var _routerContext_loaderData2;
-            const { route, pathname, params } = m;
+const createServerPayload = (routerContext, routes)=>({
+        type: 'render',
+        actionData: routerContext.actionData,
+        errors: routerContext.errors,
+        loaderData: routerContext.loaderData,
+        location: routerContext.location,
+        routes: routerContext.matches.map((match, index, matches)=>{
+            const element = match.route.element;
+            const parentMatch = index > 0 ? matches[index - 1] : void 0;
+            let processedElement;
+            if (element) {
+                const ElementComponent = element.type;
+                processedElement = /*#__PURE__*/ external_react_default().createElement(ElementComponent, {
+                    loaderData: routerContext?.loaderData?.[match.route.id],
+                    actionData: routerContext?.actionData?.[match.route.id],
+                    params: match.params,
+                    matches: routerContext.matches.map((m)=>{
+                        const { route, pathname, params } = m;
+                        return {
+                            id: route.id,
+                            pathname,
+                            params,
+                            data: routerContext?.loaderData?.[route.id],
+                            handle: route.handle
+                        };
+                    })
+                });
+            }
             return {
-              id: route.id,
-              pathname,
-              params,
-              data: routerContext === null || routerContext === void 0 ? void 0 : (_routerContext_loaderData2 = routerContext.loaderData) === null || _routerContext_loaderData2 === void 0 ? void 0 : _routerContext_loaderData2[route.id],
-              handle: route.handle
+                element: processedElement,
+                errorElement: match.route.errorElement,
+                handle: match.route.handle,
+                hasAction: !!match.route.action,
+                hasErrorBoundary: !!match.route.hasErrorBoundary,
+                hasLoader: !!match.route.loader,
+                hasClientLoader: !!match.route.hasClientLoader,
+                id: match.route.id,
+                index: match.route.index,
+                params: match.params,
+                parentId: parentMatch?.route.id || match.route.parentId,
+                path: match.route.path,
+                pathname: match.pathname,
+                pathnameBase: match.pathnameBase
             };
-          })
-        });
-      }
-      return {
-        element: processedElement,
-        errorElement: match.route.errorElement,
-        handle: match.route.handle,
-        hasAction: !!match.route.action,
-        hasErrorBoundary: !!match.route.hasErrorBoundary,
-        hasLoader: !!match.route.loader,
-        hasClientLoader: !!match.route.hasClientLoader,
-        id: match.route.id,
-        index: match.route.index,
-        params: match.params,
-        parentId: (parentMatch === null || parentMatch === void 0 ? void 0 : parentMatch.route.id) || match.route.parentId,
-        path: match.route.path,
-        pathname: match.pathname,
-        pathnameBase: match.pathnameBase
-      };
-    })
-  };
-};
-const handleRSCRedirect = (headers, basename, status) => {
-  const newHeaders = new Headers(headers);
-  let redirectUrl = headers.get("Location");
-  if (basename !== "/") {
-    redirectUrl = redirectUrl.replace(basename, "");
-  }
-  newHeaders.set("X-Modernjs-Redirect", redirectUrl);
-  newHeaders.set("X-Modernjs-BaseUrl", basename);
-  newHeaders.delete("Location");
-  return new Response(null, {
-    status,
-    headers: newHeaders
-  });
-};
-const prepareRSCRoutes = async (routes) => {
-  const isLazyComponent = (component) => {
-    return component && typeof component === "object" && component._init !== void 0 && component._payload !== void 0;
-  };
-  const processRoutes = async (routesList) => {
-    await Promise.all(routesList.map(async (route) => {
-      if ("lazyImport" in route && isLazyComponent(route.component)) {
-        route.component = (await route.lazyImport()).default;
-      }
-      if (route.children && Array.isArray(route.children)) {
-        await processRoutes(route.children);
-      }
-    }));
-  };
-  await processRoutes(routes);
-};
-const mergeRoutes = (routes, originalRoutes) => {
-  if (!originalRoutes || !Array.isArray(originalRoutes)) {
-    return routes;
-  }
-  const routesMap = /* @__PURE__ */ new Map();
-  const buildRoutesMap = (routesList) => {
-    routesList.forEach((route) => {
-      if (route.id) {
-        routesMap.set(route.id, route);
-      }
-      if ("children" in route && route.children && Array.isArray(route.children)) {
-        buildRoutesMap(route.children);
-      }
+        })
     });
-  };
-  buildRoutesMap(routes);
-  const mergeRoutesRecursive = (origRoutes) => {
-    return origRoutes.map((origRoute) => {
-      if (origRoute.id && routesMap.has(origRoute.id)) {
-        const matchedRoute = routesMap.get(origRoute.id);
-        const result = {
-          loader: origRoute.hasClientLoader ? origRoute.loader : void 0,
-          ...matchedRoute
-        };
-        if (origRoute.children && Array.isArray(origRoute.children)) {
-          result.children = mergeRoutesRecursive(origRoute.children);
-        }
-        return result;
-      }
-      return origRoute;
+const handleRSCRedirect = (headers, basename, status)=>{
+    const newHeaders = new Headers(headers);
+    let redirectUrl = headers.get('Location');
+    if ('/' !== basename) redirectUrl = redirectUrl.replace(basename, '');
+    newHeaders.set('X-Modernjs-Redirect', redirectUrl);
+    newHeaders.set('X-Modernjs-BaseUrl', basename);
+    newHeaders.delete('Location');
+    return new Response(null, {
+        status: status,
+        headers: newHeaders
     });
-  };
-  return mergeRoutesRecursive(originalRoutes);
 };
-const findRouteInTree = (routes, routeId) => {
-  for (const route of routes) {
-    if (route.id === routeId) {
-      return route;
-    }
-    if (route.children && Array.isArray(route.children)) {
-      const found = findRouteInTree(route.children, routeId);
-      if (found) {
-        return found;
-      }
-    }
-  }
-  return null;
+const prepareRSCRoutes = async (routes)=>{
+    const isLazyComponent = (component)=>component && 'object' == typeof component && void 0 !== component._init && void 0 !== component._payload;
+    const processRoutes = async (routesList)=>{
+        await Promise.all(routesList.map(async (route)=>{
+            if ('lazyImport' in route && isLazyComponent(route.component)) route.component = (await route.lazyImport()).default;
+            if (route.children && Array.isArray(route.children)) await processRoutes(route.children);
+        }));
+    };
+    await processRoutes(routes);
 };
-const createClientRouterFromPayload = (payload, originalRoutes, basename = "") => {
-  const processedRoutes = payload.routes.reduceRight((previous, route) => {
-    if (previous.length > 0) {
-      return [
-        {
-          ...route,
-          children: previous
-        }
-      ];
-    }
-    return [
-      route
-    ];
-  }, []);
-  const mergedRoutes = mergeRoutes(processedRoutes, originalRoutes);
-  const router = (0, import_router2.createBrowserRouter)(mergedRoutes, {
-    //@ts-ignore
-    hydrationData: payload,
-    basename,
-    dataStrategy: async (context) => {
-      const { request, matches } = context;
-      const results = {};
-      const clientMatches = matches.filter((match) => match.route.hasClientLoader);
-      const fetchPromise = fetch(request.url, {
-        headers: {
-          "x-rsc-tree": "true"
-        }
-      });
-      const clientLoadersPromise = clientMatches.length > 0 ? Promise.all(clientMatches.map(async (clientMatch) => {
-        const foundRoute = findRouteInTree(originalRoutes, clientMatch.route.id);
-        clientMatch.route.loader = foundRoute === null || foundRoute === void 0 ? void 0 : foundRoute.loader;
-        const res2 = await clientMatch.resolve();
-        return {
-          routeId: clientMatch.route.id,
-          result: res2
-        };
-      })) : Promise.resolve([]);
-      const res = await fetchPromise;
-      const redirectLocation = res.headers.get("X-Modernjs-Redirect");
-      if (redirectLocation) {
-        matches.forEach((match) => {
-          const routeId = match.route.id;
-          if (routeId) {
-            results[routeId] = {
-              type: "redirect",
-              result: (0, import_router2.redirect)(redirectLocation)
-            };
-          }
+const mergeRoutes = (routes, originalRoutes)=>{
+    if (!originalRoutes || !Array.isArray(originalRoutes)) return routes;
+    const routesMap = new Map();
+    const buildRoutesMap = (routesList)=>{
+        routesList.forEach((route)=>{
+            if (route.id) routesMap.set(route.id, route);
+            if ('children' in route && route.children && Array.isArray(route.children)) buildRoutesMap(route.children);
         });
-        return results;
-      }
-      const [clientLoaderResults] = await Promise.all([
-        clientLoadersPromise
-      ]);
-      clientLoaderResults.forEach(({ routeId, result }) => {
-        results[routeId] = result;
-      });
-      const payload2 = await (0, import_client.createFromReadableStream)(res.body);
-      if (typeof payload2.type === "undefined" || payload2.type !== "render") {
-        throw new Error("Unexpected payload type");
-      }
-      matches.forEach((match) => {
-        var _payload_loaderData;
-        const routeId = match.route.id;
-        const matchedRoute = payload2.routes.find((route) => route.id === routeId);
-        if (matchedRoute) {
-          router.patchRoutes(matchedRoute.parentId, [
-            matchedRoute
-          ], true);
-        }
-        if ((_payload_loaderData = payload2.loaderData) === null || _payload_loaderData === void 0 ? void 0 : _payload_loaderData[routeId]) {
-          results[routeId] = {
-            type: "data",
-            result: payload2.loaderData[routeId]
-          };
+    };
+    buildRoutesMap(routes);
+    const mergeRoutesRecursive = (origRoutes)=>origRoutes.map((origRoute)=>{
+            if (origRoute.id && routesMap.has(origRoute.id)) {
+                const matchedRoute = routesMap.get(origRoute.id);
+                const result = {
+                    loader: origRoute.hasClientLoader ? origRoute.loader : void 0,
+                    ...matchedRoute
+                };
+                if (origRoute.children && Array.isArray(origRoute.children)) result.children = mergeRoutesRecursive(origRoute.children);
+                return result;
+            }
+            return origRoute;
+        });
+    return mergeRoutesRecursive(originalRoutes);
+};
+const findRouteInTree = (routes, routeId)=>{
+    for (const route of routes){
+        if (route.id === routeId) return route;
+        if (route.children && Array.isArray(route.children)) {
+            const found = findRouteInTree(route.children, routeId);
+            if (found) return found;
         }
-      });
-      return results;
     }
-  });
-  return router;
+    return null;
 };
-const createRSCStaticRouterComponent = (payload, basename) => {
-  const routerContext = {
-    actionData: payload.actionData,
-    actionHeaders: {},
-    activeDeferreds: {},
-    basename: basename || "",
-    errors: payload.errors,
-    loaderData: payload.loaderData,
-    loaderHeaders: {},
-    location: payload.location,
-    statusCode: 200,
-    matches: payload.routes.map((match) => ({
-      params: match.params,
-      pathname: match.pathname,
-      pathnameBase: match.pathnameBase,
-      route: {
-        id: match.id,
-        action: match.hasAction || !!match.clientAction,
-        handle: match.handle,
-        hasErrorBoundary: match.hasErrorBoundary,
-        loader: match.hasLoader || !!match.clientLoader,
-        index: match.index,
-        path: match.path,
-        shouldRevalidate: match.shouldRevalidate
-      }
-    }))
-  };
-  const processedRoutes = payload.routes.reduceRight((previous, route) => {
-    if (previous.length > 0) {
-      return [
-        {
-          ...route,
-          children: previous
+const createClientRouterFromPayload = (payload, originalRoutes, basename = '')=>{
+    const processedRoutes = payload.routes.reduceRight((previous, route)=>{
+        if (previous.length > 0) return [
+            {
+                ...route,
+                children: previous
+            }
+        ];
+        return [
+            route
+        ];
+    }, []);
+    const mergedRoutes = mergeRoutes(processedRoutes, originalRoutes);
+    const router = (0, router_namespaceObject.createBrowserRouter)(mergedRoutes, {
+        hydrationData: payload,
+        basename: basename,
+        dataStrategy: async (context)=>{
+            const { request, matches } = context;
+            const results = {};
+            const clientMatches = matches.filter((match)=>match.route.hasClientLoader);
+            const fetchPromise = fetch(request.url, {
+                headers: {
+                    'x-rsc-tree': 'true'
+                }
+            });
+            const clientLoadersPromise = clientMatches.length > 0 ? Promise.all(clientMatches.map(async (clientMatch)=>{
+                const foundRoute = findRouteInTree(originalRoutes, clientMatch.route.id);
+                clientMatch.route.loader = foundRoute?.loader;
+                const res = await clientMatch.resolve();
+                return {
+                    routeId: clientMatch.route.id,
+                    result: res
+                };
+            })) : Promise.resolve([]);
+            const res = await fetchPromise;
+            const redirectLocation = res.headers.get('X-Modernjs-Redirect');
+            if (redirectLocation) {
+                matches.forEach((match)=>{
+                    const routeId = match.route.id;
+                    if (routeId) results[routeId] = {
+                        type: 'redirect',
+                        result: (0, router_namespaceObject.redirect)(redirectLocation)
+                    };
+                });
+                return results;
+            }
+            const [clientLoaderResults] = await Promise.all([
+                clientLoadersPromise
+            ]);
+            clientLoaderResults.forEach(({ routeId, result })=>{
+                results[routeId] = result;
+            });
+            const payload = await (0, client_namespaceObject.createFromReadableStream)(res.body);
+            if (void 0 === payload.type || 'render' !== payload.type) throw new Error('Unexpected payload type');
+            matches.forEach((match)=>{
+                const routeId = match.route.id;
+                const matchedRoute = payload.routes.find((route)=>route.id === routeId);
+                if (matchedRoute) router.patchRoutes(matchedRoute.parentId, [
+                    matchedRoute
+                ], true);
+                if (payload.loaderData?.[routeId]) results[routeId] = {
+                    type: 'data',
+                    result: payload.loaderData[routeId]
+                };
+            });
+            return results;
         }
-      ];
-    }
-    return [
-      route
-    ];
-  }, []);
-  const router = (0, import_router.createStaticRouter)(processedRoutes, routerContext);
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_router.StaticRouterProvider, {
-    context: routerContext,
-    router,
-    hydrate: false
-  });
+    });
+    return router;
 };
-const RSCStaticRouter = ({ basename }) => {
-  const payload = safeUse(safeUse(import_client.ElementsContext));
-  if (!payload || payload.type !== "render") {
-    return null;
-  }
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {
-    children: createRSCStaticRouterComponent(payload, basename)
-  });
+const createRSCStaticRouterComponent = (payload, basename)=>{
+    const routerContext = {
+        actionData: payload.actionData,
+        actionHeaders: {},
+        activeDeferreds: {},
+        basename: basename || '',
+        errors: payload.errors,
+        loaderData: payload.loaderData,
+        loaderHeaders: {},
+        location: payload.location,
+        statusCode: 200,
+        matches: payload.routes.map((match)=>({
+                params: match.params,
+                pathname: match.pathname,
+                pathnameBase: match.pathnameBase,
+                route: {
+                    id: match.id,
+                    action: match.hasAction || !!match.clientAction,
+                    handle: match.handle,
+                    hasErrorBoundary: match.hasErrorBoundary,
+                    loader: match.hasLoader || !!match.clientLoader,
+                    index: match.index,
+                    path: match.path,
+                    shouldRevalidate: match.shouldRevalidate
+                }
+            }))
+    };
+    const processedRoutes = payload.routes.reduceRight((previous, route)=>{
+        if (previous.length > 0) return [
+            {
+                ...route,
+                children: previous
+            }
+        ];
+        return [
+            route
+        ];
+    }, []);
+    const router = (0, router_namespaceObject.createStaticRouter)(processedRoutes, routerContext);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(router_namespaceObject.StaticRouterProvider, {
+        context: routerContext,
+        router: router,
+        hydrate: false
+    });
+};
+const RSCStaticRouter = ({ basename })=>{
+    const payload = safeUse(safeUse(client_namespaceObject.ElementsContext));
+    if (!payload || 'render' !== payload.type) return null;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
+        children: createRSCStaticRouterComponent(payload, basename)
+    });
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  RSCStaticRouter,
-  createClientRouterFromPayload,
-  createServerPayload,
-  handleRSCRedirect,
-  prepareRSCRoutes
+exports.RSCStaticRouter = __webpack_exports__.RSCStaticRouter;
+exports.createClientRouterFromPayload = __webpack_exports__.createClientRouterFromPayload;
+exports.createServerPayload = __webpack_exports__.createServerPayload;
+exports.handleRSCRedirect = __webpack_exports__.handleRSCRedirect;
+exports.prepareRSCRoutes = __webpack_exports__.prepareRSCRoutes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RSCStaticRouter",
+    "createClientRouterFromPayload",
+    "createServerPayload",
+    "handleRSCRedirect",
+    "prepareRSCRoutes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

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

@@ -0,0 +1,58 @@
+"use strict";
+var __webpack_modules__ = {
+    "@modern-js/runtime-utils/router/rsc" (module) {
+        module.exports = require("@modern-js/runtime-utils/router/rsc");
+    }
+};
+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 _modern_js_runtime_utils_router_rsc__rspack_import_0 = __webpack_require__("@modern-js/runtime-utils/router/rsc");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _modern_js_runtime_utils_router_rsc__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_modern_js_runtime_utils_router_rsc__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
+});