react-router 7.4.1 → 7.5.0-pre.1

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;

package/dist/development/dom-export.js

@@ -1,5 +1,5 @@
 /**
- * react-router v7.4.1
+ * react-router v7.5.0-pre.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -275,6 +275,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",
@@ -282,9 +295,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;
 }
@@ -2823,79 +2840,166 @@ 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();
+function loadLazyRoute(route, type, 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) {
-      return;
+  if (!route.lazy) {
+    return {
+      lazyRoutePromise: void 0,
+      lazyHandlerPromise: void 0
+    };
+  }
+  if (typeof route.lazy === "function") {
+    let cachedPromise = lazyRouteFunctionCache.get(routeToUpdate);
+    if (cachedPromise) {
+      return {
+        lazyRoutePromise: cachedPromise,
+        lazyHandlerPromise: cachedPromise
+      };
     }
-    if (!routeToUpdate.unstable_middleware) {
-      routeToUpdate.unstable_middleware = middleware;
+    let lazyRoutePromise2 = (async () => {
+      invariant(
+        typeof route.lazy === "function",
+        "No lazy route function found"
+      );
+      let lazyRoute = await route.lazy();
+      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, lazyRoutePromise2);
+    return {
+      lazyRoutePromise: lazyRoutePromise2,
+      lazyHandlerPromise: lazyRoutePromise2
+    };
+  }
+  let lazyKeys = Object.keys(route.lazy);
+  let lazyPropertyPromises = [];
+  let lazyHandlerPromise = void 0;
+  for (let key of lazyKeys) {
+    let promise = loadLazyRouteProperty({
+      key,
+      route,
+      manifest,
+      mapRouteProperties: mapRouteProperties2
+    });
+    if (promise) {
+      lazyPropertyPromises.push(promise);
+      if (key === type) {
+        lazyHandlerPromise = promise;
+      }
     }
   }
-  routeToUpdate.unstable_lazyMiddleware = void 0;
+  let lazyRoutePromise = Promise.all(lazyPropertyPromises).then(() => {
+  });
+  return {
+    lazyRoutePromise,
+    lazyHandlerPromise
+  };
 }
-function loadLazyMiddlewareForMatches(matches, manifest) {
-  let promises = matches.map(
-    (m) => m.route.unstable_lazyMiddleware ? loadLazyMiddleware(m.route, manifest) : void 0
-  ).filter(Boolean);
+function isNonNullable(value) {
+  return value !== void 0;
+}
+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(isNonNullable);
   return promises.length > 0 ? Promise.all(promises) : void 0;
 }
 async function defaultDataStrategy(args) {
@@ -3013,28 +3117,33 @@ 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 lazyRoutePromises = matches.map(
+    (m) => loadLazyRoute(m.route, type, manifest, mapRouteProperties2)
   );
   if (loadMiddlewarePromise) {
     await loadMiddlewarePromise;
   }
   let dsMatches = matches.map((match, i) => {
-    let loadRoutePromise = loadRouteDefinitionsPromises[i];
+    let { lazyRoutePromise, lazyHandlerPromise } = lazyRoutePromises[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)) {
         shouldLoad = true;
       }
-      return shouldLoad ? callLoaderOrAction(
+      return shouldLoad ? callLoaderOrAction({
         type,
         request,
         match,
-        loadRoutePromise,
+        lazyHandlerPromise,
+        lazyRoutePromise,
         handlerOverride,
         scopedContext
-      ) : Promise.resolve({ type: "data" /* data */, result: void 0 });
+      }) : Promise.resolve({ type: "data" /* data */, result: void 0 });
     };
     return {
       ...match,
@@ -3049,13 +3158,24 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
     fetcherKey,
     context: scopedContext
   });
+  let allLazyRoutePromises = lazyRoutePromises.flatMap(
+    (promiseMap) => Object.values(promiseMap).filter(isNonNullable)
+  );
   try {
-    await Promise.all(loadRouteDefinitionsPromises);
+    await Promise.all(allLazyRoutePromises);
   } catch (e) {
   }
   return results;
 }
-async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, scopedContext) {
+async function callLoaderOrAction({
+  type,
+  request,
+  match,
+  lazyHandlerPromise,
+  lazyRoutePromise,
+  handlerOverride,
+  scopedContext
+}) {
   let result;
   let onReject;
   let runHandler = (handler) => {
@@ -3092,7 +3212,7 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
   };
   try {
     let handler = match.route[type];
-    if (loadRoutePromise) {
+    if (lazyHandlerPromise || lazyRoutePromise) {
       if (handler) {
         let handlerError;
         let [value] = await Promise.all([
@@ -3102,17 +3222,19 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
           runHandler(handler).catch((e) => {
             handlerError = e;
           }),
-          loadRoutePromise
+          // Ensure all lazy route promises are resolved before continuing
+          lazyHandlerPromise,
+          lazyRoutePromise
         ]);
         if (handlerError !== void 0) {
           throw handlerError;
         }
         result = value;
       } else {
-        await loadRoutePromise;
+        await lazyHandlerPromise;
         handler = match.route[type];
         if (handler) {
-          result = await runHandler(handler);
+          [result] = await Promise.all([runHandler(handler), lazyRoutePromise]);
         } else if (type === "action") {
           let url = new URL(request.url);
           let pathname = url.pathname + url.search;
@@ -5210,22 +5332,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(() => {
@@ -5234,86 +5340,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(
@@ -5401,7 +5505,7 @@ var URL_LIMIT = 7680;
 function isFogOfWarEnabled(ssr) {
   return ssr === true;
 }
-function getPartialManifest(manifest, router2) {
+function getPartialManifest({ sri, ...manifest }, router2) {
   let routeIds = new Set(router2.state.matches.map((m) => m.route.id));
   let segments = router2.state.location.pathname.split("/").filter(Boolean);
   let paths = ["/"];
@@ -5422,7 +5526,8 @@ function getPartialManifest(manifest, router2) {
   );
   return {
     ...manifest,
-    routes: initialRoutes
+    routes: initialRoutes,
+    sri: sri ? true : void 0
   };
 }
 function getPatchRoutesOnNavigationFunction(manifest, routeModules, ssr, isSpaMode, basename) {
@@ -5709,32 +5814,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);
 }
@@ -5790,6 +5916,18 @@ var ssrInfo = null;
 var router = null;
 function initSsrInfo() {
   if (!ssrInfo && window.__reactRouterContext && window.__reactRouterManifest && window.__reactRouterRouteModules) {
+    if (window.__reactRouterManifest.sri === true) {
+      const importMap = document.querySelector("script[rr-importmap]");
+      if (importMap?.textContent) {
+        try {
+          window.__reactRouterManifest.sri = JSON.parse(
+            importMap.textContent
+          ).integrity;
+        } catch (err) {
+          console.error("Failed to parse import map", err);
+        }
+      }
+    }
     ssrInfo = {
       context: window.__reactRouterContext,
       manifest: window.__reactRouterManifest,

package/dist/development/dom-export.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v7.4.1
+ * react-router v7.5.0-pre.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -25,7 +25,7 @@ import {
   matchRoutes,
   shouldHydrateRouteLoader,
   useFogOFWarDiscovery
-} from "./chunk-XJI4KG32.mjs";
+} from "./chunk-5BSZVSUP.mjs";
 
 // lib/dom-export/dom-router-provider.tsx
 import * as React from "react";
@@ -40,6 +40,18 @@ var ssrInfo = null;
 var router = null;
 function initSsrInfo() {
   if (!ssrInfo && window.__reactRouterContext && window.__reactRouterManifest && window.__reactRouterRouteModules) {
+    if (window.__reactRouterManifest.sri === true) {
+      const importMap = document.querySelector("script[rr-importmap]");
+      if (importMap?.textContent) {
+        try {
+          window.__reactRouterManifest.sri = JSON.parse(
+            importMap.textContent
+          ).integrity;
+        } catch (err) {
+          console.error("Failed to parse import map", err);
+        }
+      }
+    }
     ssrInfo = {
       context: window.__reactRouterContext,
       manifest: window.__reactRouterManifest,