react-router 7.4.1 → 7.5.0-pre.0

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # `react-router`
 
+## 7.5.0-pre.0
+
+### Minor Changes
+
+- Add granular object-based API for `route.lazy` to support lazy loading of individual route properties, for example: ([#13294](https://github.com/remix-run/react-router/pull/13294))
+
+  ```ts
+  createBrowserRouter([
+    {
+      path: "/show/:showId",
+      lazy: {
+        loader: async () => (await import("./show.loader.js")).loader,
+        action: async () => (await import("./show.action.js")).action,
+        Component: async () => (await import("./show.component.js")).Component,
+      },
+    },
+  ]);
+  ```
+
+  **Breaking change for `route.unstable_lazyMiddleware` consumers**
+
+  The `route.unstable_lazyMiddleware` property is no longer supported. If you want to lazily load middleware, you must use the new object-based `route.lazy` API with `route.lazy.unstable_middleware`, for example:
+
+  ```ts
+  createBrowserRouter([
+    {
+      path: "/show/:showId",
+      lazy: {
+        unstable_middleware: async () =>
+          (await import("./show.middleware.js")).middleware,
+        // etc.
+      },
+    },
+  ]);
+  ```
+
+### Patch Changes
+
+- Introduce `unstable_subResourceIntegrity` future flag that enables generation of an importmap with integrity for the scripts that will be loaded by the browser. ([#13163](https://github.com/remix-run/react-router/pull/13163))
+
 ## 7.4.1
 
 ### Patch Changes

package/dist/development/{chunk-XJI4KG32.mjs → chunk-YTH545ZN.mjs}

@@ -1,5 +1,5 @@
 /**
- * react-router v7.4.1
+ * react-router v7.5.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -383,6 +383,19 @@ var unstable_RouterContextProvider = class {
   }
 };
 _map = new WeakMap();
+var unsupportedLazyRouteObjectKeys = /* @__PURE__ */ new Set([
+  "lazy",
+  "caseSensitive",
+  "path",
+  "id",
+  "index",
+  "children"
+]);
+function isUnsupportedLazyRouteObjectKey(key) {
+  return unsupportedLazyRouteObjectKeys.has(
+    key
+  );
+}
 var unsupportedLazyRouteFunctionKeys = /* @__PURE__ */ new Set([
   "lazy",
   "caseSensitive",
@@ -390,9 +403,13 @@ var unsupportedLazyRouteFunctionKeys = /* @__PURE__ */ new Set([
   "id",
   "index",
   "unstable_middleware",
-  "unstable_lazyMiddleware",
   "children"
 ]);
+function isUnsupportedLazyRouteFunctionKey(key) {
+  return unsupportedLazyRouteFunctionKeys.has(
+    key
+  );
+}
 function isIndexRoute(route) {
   return route.index === true;
 }
@@ -2683,14 +2700,18 @@ function createStaticHandler(routes, opts) {
       return respond ? respond(staticContext) : staticContext;
     }
     if (respond && matches.some(
-      (m) => m.route.unstable_middleware || m.route.unstable_lazyMiddleware
+      (m) => m.route.unstable_middleware || typeof m.route.lazy === "object" && m.route.lazy.unstable_middleware
     )) {
       invariant(
         requestContext instanceof unstable_RouterContextProvider,
         "When using middleware in `staticHandler.query()`, any provided `requestContext` must be an instance of `unstable_RouterContextProvider`"
       );
       try {
-        await loadLazyMiddlewareForMatches(matches, manifest);
+        await loadLazyMiddlewareForMatches(
+          matches,
+          manifest,
+          mapRouteProperties2
+        );
         let renderedStaticContext;
         let response = await runMiddlewarePipeline(
           {
@@ -2807,13 +2828,13 @@ function createStaticHandler(routes, opts) {
       throw getInternalRouterError(404, { pathname: location.pathname });
     }
     if (respond && matches.some(
-      (m) => m.route.unstable_middleware || m.route.unstable_lazyMiddleware
+      (m) => m.route.unstable_middleware || typeof m.route.lazy === "object" && m.route.lazy.unstable_middleware
     )) {
       invariant(
         requestContext instanceof unstable_RouterContextProvider,
         "When using middleware in `staticHandler.queryRoute()`, any provided `requestContext` must be an instance of `unstable_RouterContextProvider`"
       );
-      await loadLazyMiddlewareForMatches(matches, manifest);
+      await loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2);
       let response = await runMiddlewarePipeline(
         {
           request,
@@ -3531,79 +3552,139 @@ function isSameRoute(newRoute, existingRoute) {
     (aChild, i) => existingRoute.children?.some((bChild) => isSameRoute(aChild, bChild))
   );
 }
-var lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
-async function loadLazyRouteModule(route, mapRouteProperties2, manifest) {
+var lazyRoutePropertyCache = /* @__PURE__ */ new WeakMap();
+var loadLazyRouteProperty = ({
+  key,
+  route,
+  manifest,
+  mapRouteProperties: mapRouteProperties2
+}) => {
   let routeToUpdate = manifest[route.id];
   invariant(routeToUpdate, "No route found in manifest");
-  if (!route.lazy) {
+  if (!routeToUpdate.lazy || typeof routeToUpdate.lazy !== "object") {
     return;
   }
-  let cachedPromise = lazyRouteFunctionCache.get(routeToUpdate);
-  if (cachedPromise) {
-    await cachedPromise;
+  let lazyFn = routeToUpdate.lazy[key];
+  if (!lazyFn) {
     return;
   }
-  let lazyRoutePromise = route.lazy().then((lazyRoute) => {
-    let routeUpdates = {};
-    for (let lazyRouteProperty in lazyRoute) {
-      let staticRouteValue = routeToUpdate[lazyRouteProperty];
-      let isPropertyStaticallyDefined = staticRouteValue !== void 0 && // This property isn't static since it should always be updated based
-      // on the route updates
-      lazyRouteProperty !== "hasErrorBoundary";
+  let cache = lazyRoutePropertyCache.get(routeToUpdate);
+  if (!cache) {
+    cache = {};
+    lazyRoutePropertyCache.set(routeToUpdate, cache);
+  }
+  let cachedPromise = cache[key];
+  if (cachedPromise) {
+    return cachedPromise;
+  }
+  let propertyPromise = (async () => {
+    let isUnsupported = isUnsupportedLazyRouteObjectKey(key);
+    let staticRouteValue = routeToUpdate[key];
+    let isStaticallyDefined = staticRouteValue !== void 0 && key !== "hasErrorBoundary";
+    if (isUnsupported) {
       warning(
-        !isPropertyStaticallyDefined,
-        `Route "${routeToUpdate.id}" has a static property "${lazyRouteProperty}" defined but its lazy function is also returning a value for this property. The lazy route property "${lazyRouteProperty}" will be ignored.`
+        !isUnsupported,
+        "Route property " + key + " is not a supported lazy route property. This property will be ignored."
       );
+      cache[key] = Promise.resolve();
+    } else if (isStaticallyDefined) {
       warning(
-        !unsupportedLazyRouteFunctionKeys.has(
-          lazyRouteProperty
-        ),
-        "Route property " + lazyRouteProperty + " is not a supported property to be returned from a lazy route function. This property will be ignored."
+        false,
+        `Route "${routeToUpdate.id}" has a static property "${key}" defined. The lazy property will be ignored.`
       );
-      if (!isPropertyStaticallyDefined && !unsupportedLazyRouteFunctionKeys.has(
-        lazyRouteProperty
-      )) {
-        routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];
+    } else {
+      let value = await lazyFn();
+      if (value != null) {
+        Object.assign(routeToUpdate, { [key]: value });
+        Object.assign(routeToUpdate, mapRouteProperties2(routeToUpdate));
       }
     }
-    Object.assign(routeToUpdate, routeUpdates);
-    Object.assign(routeToUpdate, {
-      // To keep things framework agnostic, we use the provided `mapRouteProperties`
-      // function to set the framework-aware properties (`element`/`hasErrorBoundary`)
-      // since the logic will differ between frameworks.
-      ...mapRouteProperties2(routeToUpdate),
-      lazy: void 0
-    });
-  });
-  lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise);
-  await lazyRoutePromise;
-}
-async function loadLazyMiddleware(route, manifest) {
-  if (!route.unstable_lazyMiddleware) {
-    return;
-  }
+    if (typeof routeToUpdate.lazy === "object") {
+      routeToUpdate.lazy[key] = void 0;
+      if (Object.values(routeToUpdate.lazy).every((value) => value === void 0)) {
+        routeToUpdate.lazy = void 0;
+      }
+    }
+  })();
+  cache[key] = propertyPromise;
+  return propertyPromise;
+};
+var lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
+async function loadLazyRoute(route, manifest, mapRouteProperties2) {
   let routeToUpdate = manifest[route.id];
   invariant(routeToUpdate, "No route found in manifest");
-  if (routeToUpdate.unstable_middleware) {
-    warning(
-      false,
-      `Route "${routeToUpdate.id}" has a static property "unstable_middleware" defined. The "unstable_lazyMiddleware" function will be ignored.`
-    );
-  } else {
-    let middleware = await route.unstable_lazyMiddleware();
-    if (!route.unstable_lazyMiddleware) {
+  if (!route.lazy) {
+    return;
+  }
+  if (typeof route.lazy === "function") {
+    let cachedPromise = lazyRouteFunctionCache.get(routeToUpdate);
+    if (cachedPromise) {
+      await cachedPromise;
       return;
     }
-    if (!routeToUpdate.unstable_middleware) {
-      routeToUpdate.unstable_middleware = middleware;
-    }
+    let lazyRoutePromise = route.lazy().then((lazyRoute) => {
+      let routeUpdates = {};
+      for (let lazyRouteProperty in lazyRoute) {
+        let lazyValue = lazyRoute[lazyRouteProperty];
+        if (lazyValue === void 0) {
+          continue;
+        }
+        let isUnsupported = isUnsupportedLazyRouteFunctionKey(lazyRouteProperty);
+        let staticRouteValue = routeToUpdate[lazyRouteProperty];
+        let isStaticallyDefined = staticRouteValue !== void 0 && // This property isn't static since it should always be updated based
+        // on the route updates
+        lazyRouteProperty !== "hasErrorBoundary";
+        if (isUnsupported) {
+          warning(
+            !isUnsupported,
+            "Route property " + lazyRouteProperty + " is not a supported property to be returned from a lazy route function. This property will be ignored."
+          );
+        } else if (isStaticallyDefined) {
+          warning(
+            !isStaticallyDefined,
+            `Route "${routeToUpdate.id}" has a static property "${lazyRouteProperty}" defined but its lazy function is also returning a value for this property. The lazy route property "${lazyRouteProperty}" will be ignored.`
+          );
+        } else {
+          routeUpdates[lazyRouteProperty] = lazyValue;
+        }
+      }
+      Object.assign(routeToUpdate, routeUpdates);
+      Object.assign(routeToUpdate, {
+        // To keep things framework agnostic, we use the provided `mapRouteProperties`
+        // function to set the framework-aware properties (`element`/`hasErrorBoundary`)
+        // since the logic will differ between frameworks.
+        ...mapRouteProperties2(routeToUpdate),
+        lazy: void 0
+      });
+    });
+    lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise);
+    await lazyRoutePromise;
+    return;
   }
-  routeToUpdate.unstable_lazyMiddleware = void 0;
+  let lazyKeys = Object.keys(route.lazy);
+  await Promise.all(
+    lazyKeys.map(
+      (key) => loadLazyRouteProperty({
+        key,
+        route,
+        manifest,
+        mapRouteProperties: mapRouteProperties2
+      })
+    )
+  );
 }
-function loadLazyMiddlewareForMatches(matches, manifest) {
-  let promises = matches.map(
-    (m) => m.route.unstable_lazyMiddleware ? loadLazyMiddleware(m.route, manifest) : void 0
-  ).filter(Boolean);
+function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
+  let promises = matches.map(({ route }) => {
+    if (typeof route.lazy !== "object" || !route.lazy.unstable_middleware) {
+      return void 0;
+    }
+    return loadLazyRouteProperty({
+      key: "unstable_middleware",
+      route,
+      manifest,
+      mapRouteProperties: mapRouteProperties2
+    });
+  }).filter((p) => p != null);
   return promises.length > 0 ? Promise.all(promises) : void 0;
 }
 async function defaultDataStrategy(args) {
@@ -3721,15 +3802,19 @@ async function callRouteMiddleware(args, middlewares, propagateResult, middlewar
   }
 }
 async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties2, scopedContext) {
-  let loadMiddlewarePromise = loadLazyMiddlewareForMatches(matches, manifest);
-  let loadRouteDefinitionsPromises = matches.map(
-    (m) => m.route.lazy ? loadLazyRouteModule(m.route, mapRouteProperties2, manifest) : void 0
+  let loadMiddlewarePromise = loadLazyMiddlewareForMatches(
+    matches,
+    manifest,
+    mapRouteProperties2
+  );
+  let loadLazyRoutePromises = matches.map(
+    (m) => m.route.lazy ? loadLazyRoute(m.route, manifest, mapRouteProperties2) : void 0
   );
   if (loadMiddlewarePromise) {
     await loadMiddlewarePromise;
   }
   let dsMatches = matches.map((match, i) => {
-    let loadRoutePromise = loadRouteDefinitionsPromises[i];
+    let loadRoutePromise = loadLazyRoutePromises[i];
     let shouldLoad = matchesToLoad.some((m) => m.route.id === match.route.id);
     let resolve = async (handlerOverride) => {
       if (handlerOverride && request.method === "GET" && (match.route.lazy || match.route.loader)) {
@@ -3758,7 +3843,7 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
     context: scopedContext
   });
   try {
-    await Promise.all(loadRouteDefinitionsPromises);
+    await Promise.all(loadLazyRoutePromises);
   } catch (e) {
   }
   return results;
@@ -6746,22 +6831,6 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
         dataRoute.loader = (_, singleFetch) => prefetchStylesAndCallHandler(() => {
           return fetchServerLoader(singleFetch);
         });
-      } else if (route.clientLoaderModule) {
-        dataRoute.loader = async (args, singleFetch) => {
-          invariant2(route.clientLoaderModule);
-          let { clientLoader } = await import(
-            /* @vite-ignore */
-            /* webpackIgnore: true */
-            route.clientLoaderModule
-          );
-          return clientLoader({
-            ...args,
-            async serverLoader() {
-              preventInvalidServerHandlerCall("loader", route);
-              return fetchServerLoader(singleFetch);
-            }
-          });
-        };
       }
       if (!route.hasClientAction) {
         dataRoute.action = (_, singleFetch) => prefetchStylesAndCallHandler(() => {
@@ -6770,86 +6839,84 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
           }
           return fetchServerAction(singleFetch);
         });
-      } else if (route.clientActionModule) {
-        dataRoute.action = async (args, singleFetch) => {
-          invariant2(route.clientActionModule);
-          prefetchRouteModuleChunks(route);
-          let { clientAction } = await import(
-            /* @vite-ignore */
-            /* webpackIgnore: true */
-            route.clientActionModule
+      }
+      let lazyRoutePromise;
+      async function getLazyRoute() {
+        if (lazyRoutePromise) {
+          return await lazyRoutePromise;
+        }
+        lazyRoutePromise = (async () => {
+          if (route.clientLoaderModule || route.clientActionModule) {
+            await new Promise((resolve) => setTimeout(resolve, 0));
+          }
+          let routeModulePromise = loadRouteModuleWithBlockingLinks(
+            route,
+            routeModulesCache
           );
-          return clientAction({
-            ...args,
-            async serverAction() {
-              preventInvalidServerHandlerCall("action", route);
-              return fetchServerAction(singleFetch);
-            }
-          });
-        };
+          prefetchRouteModuleChunks(route);
+          return await routeModulePromise;
+        })();
+        return await lazyRoutePromise;
       }
-      if (route.hasClientMiddleware) {
-        dataRoute.unstable_lazyMiddleware = async () => {
-          invariant2(route);
-          let clientMiddlewareModule = await import(
+      dataRoute.lazy = {
+        loader: route.hasClientLoader ? async () => {
+          let { clientLoader } = route.clientLoaderModule ? await import(
             /* @vite-ignore */
             /* webpackIgnore: true */
-            route.clientMiddlewareModule || route.module
-          );
-          invariant2(
-            clientMiddlewareModule?.unstable_clientMiddleware,
-            "No `unstable_clientMiddleware` export in chunk"
-          );
-          return clientMiddlewareModule.unstable_clientMiddleware;
-        };
-      }
-      dataRoute.lazy = async () => {
-        if (route.clientLoaderModule || route.clientActionModule) {
-          await new Promise((resolve) => setTimeout(resolve, 0));
-        }
-        let modPromise = loadRouteModuleWithBlockingLinks(
-          route,
-          routeModulesCache
-        );
-        prefetchRouteModuleChunks(route);
-        let mod = await modPromise;
-        let lazyRoute = { ...mod };
-        if (mod.clientLoader) {
-          let clientLoader = mod.clientLoader;
-          lazyRoute.loader = (args, singleFetch) => clientLoader({
+            route.clientLoaderModule
+          ) : await getLazyRoute();
+          invariant2(clientLoader, "No `clientLoader` export found");
+          return (args, singleFetch) => clientLoader({
             ...args,
             async serverLoader() {
               preventInvalidServerHandlerCall("loader", route);
               return fetchServerLoader(singleFetch);
             }
           });
-        }
-        if (mod.clientAction) {
-          let clientAction = mod.clientAction;
-          lazyRoute.action = (args, singleFetch) => clientAction({
+        } : void 0,
+        action: route.hasClientAction ? async () => {
+          let clientActionPromise = route.clientActionModule ? import(
+            /* @vite-ignore */
+            /* webpackIgnore: true */
+            route.clientActionModule
+          ) : getLazyRoute();
+          prefetchRouteModuleChunks(route);
+          let { clientAction } = await clientActionPromise;
+          invariant2(clientAction, "No `clientAction` export found");
+          return (args, singleFetch) => clientAction({
             ...args,
             async serverAction() {
               preventInvalidServerHandlerCall("action", route);
               return fetchServerAction(singleFetch);
             }
           });
-        }
-        return {
-          ...lazyRoute.loader ? { loader: lazyRoute.loader } : {},
-          ...lazyRoute.action ? { action: lazyRoute.action } : {},
-          hasErrorBoundary: lazyRoute.hasErrorBoundary,
-          shouldRevalidate: getShouldRevalidateFunction(
+        } : void 0,
+        unstable_middleware: route.hasClientMiddleware ? async () => {
+          let { unstable_clientMiddleware } = route.clientMiddlewareModule ? await import(
+            /* @vite-ignore */
+            /* webpackIgnore: true */
+            route.clientMiddlewareModule
+          ) : await getLazyRoute();
+          invariant2(
+            unstable_clientMiddleware,
+            "No `unstable_clientMiddleware` export found"
+          );
+          return unstable_clientMiddleware;
+        } : void 0,
+        shouldRevalidate: async () => {
+          let lazyRoute = await getLazyRoute();
+          return getShouldRevalidateFunction(
             lazyRoute,
             route,
             ssr,
             needsRevalidation
-          ),
-          handle: lazyRoute.handle,
-          // No need to wrap these in layout since the root route is never
-          // loaded via route.lazy()
-          Component: lazyRoute.Component,
-          ErrorBoundary: lazyRoute.ErrorBoundary
-        };
+          );
+        },
+        handle: async () => (await getLazyRoute()).handle,
+        // No need to wrap these in layout since the root route is never
+        // loaded via route.lazy()
+        Component: async () => (await getLazyRoute()).Component,
+        ErrorBoundary: route.hasErrorBoundary ? async () => (await getLazyRoute()).ErrorBoundary : void 0
       };
     }
     let children = createClientRoutes(
@@ -6937,7 +7004,7 @@ var URL_LIMIT = 7680;
 function isFogOfWarEnabled(ssr) {
   return ssr === true;
 }
-function getPartialManifest(manifest, router) {
+function getPartialManifest({ sri, ...manifest }, router) {
   let routeIds = new Set(router.state.matches.map((m) => m.route.id));
   let segments = router.state.location.pathname.split("/").filter(Boolean);
   let paths = ["/"];
@@ -6958,7 +7025,8 @@ function getPartialManifest(manifest, router) {
   );
   return {
     ...manifest,
-    routes: initialRoutes
+    routes: initialRoutes,
+    sri: sri ? true : void 0
   };
 }
 function getPatchRoutesOnNavigationFunction(manifest, routeModules, ssr, isSpaMode, basename) {
@@ -7538,32 +7606,53 @@ import(${JSON.stringify(manifest.entry.module)});`;
       }
     ));
   }, []);
-  let preloads = isHydrated ? [] : manifest.entry.imports.concat(
-    getModuleLinkHrefs(matches, manifest, {
-      includeHydrateFallback: true
-    })
+  let preloads = isHydrated ? [] : dedupe(
+    manifest.entry.imports.concat(
+      getModuleLinkHrefs(matches, manifest, {
+        includeHydrateFallback: true
+      })
+    )
   );
-  return isHydrated ? null : /* @__PURE__ */ React9.createElement(React9.Fragment, null, !enableFogOfWar ? /* @__PURE__ */ React9.createElement(
+  let sri = typeof manifest.sri === "object" ? manifest.sri : {};
+  return isHydrated ? null : /* @__PURE__ */ React9.createElement(React9.Fragment, null, typeof manifest.sri === "object" ? /* @__PURE__ */ React9.createElement(
+    "script",
+    {
+      "rr-importmap": "",
+      type: "importmap",
+      suppressHydrationWarning: true,
+      dangerouslySetInnerHTML: {
+        __html: JSON.stringify({
+          integrity: sri
+        })
+      }
+    }
+  ) : null, !enableFogOfWar ? /* @__PURE__ */ React9.createElement(
     "link",
     {
       rel: "modulepreload",
       href: manifest.url,
-      crossOrigin: props.crossOrigin
+      crossOrigin: props.crossOrigin,
+      integrity: sri[manifest.url],
+      suppressHydrationWarning: true
     }
   ) : null, /* @__PURE__ */ React9.createElement(
     "link",
     {
       rel: "modulepreload",
       href: manifest.entry.module,
-      crossOrigin: props.crossOrigin
+      crossOrigin: props.crossOrigin,
+      integrity: sri[manifest.entry.module],
+      suppressHydrationWarning: true
     }
-  ), dedupe(preloads).map((path) => /* @__PURE__ */ React9.createElement(
+  ), preloads.map((path) => /* @__PURE__ */ React9.createElement(
     "link",
     {
       key: path,
       rel: "modulepreload",
       href: path,
-      crossOrigin: props.crossOrigin
+      crossOrigin: props.crossOrigin,
+      integrity: sri[path],
+      suppressHydrationWarning: true
     }
   )), initialScripts);
 }
@@ -7586,7 +7675,7 @@ function mergeRefs(...refs) {
 var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
 try {
   if (isBrowser) {
-    window.__reactRouterVersion = "7.4.1";
+    window.__reactRouterVersion = "7.5.0-pre.0";
   }
 } catch (e) {
 }
@@ -8741,6 +8830,7 @@ function createRoutesStub(routes, unstable_getContext) {
     if (routerRef.current == null) {
       remixContextRef.current = {
         future: {
+          unstable_subResourceIntegrity: future?.unstable_subResourceIntegrity === true,
           unstable_middleware: future?.unstable_middleware === true
         },
         manifest: {

package/dist/development/dom-export.d.mts

@@ -1,6 +1,6 @@
 import * as React from 'react';
-import { R as RouterProviderProps$1 } from './fog-of-war-BjgPfDmv.mjs';
-import { R as RouterInit } from './route-data-BL8ToWby.mjs';
+import { R as RouterProviderProps$1 } from './fog-of-war-1hWhK5ey.mjs';
+import { R as RouterInit } from './route-data-5OzAzQtT.mjs';
 
 type RouterProviderProps = Omit<RouterProviderProps$1, "flushSync">;
 declare function RouterProvider(props: Omit<RouterProviderProps, "flushSync">): React.JSX.Element;

package/dist/development/dom-export.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
-import { R as RouterProviderProps$1 } from './fog-of-war-BaM-ohjc.js';
-import { R as RouterInit } from './route-data-BL8ToWby.js';
+import { R as RouterProviderProps$1 } from './fog-of-war-oa9CGk10.js';
+import { R as RouterInit } from './route-data-5OzAzQtT.js';
 
 type RouterProviderProps = Omit<RouterProviderProps$1, "flushSync">;
 declare function RouterProvider(props: Omit<RouterProviderProps, "flushSync">): React.JSX.Element;