react-router 7.7.0 → 7.7.1-pre.0

package/dist/development/index.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v7.7.0
+ * react-router v7.7.1-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -31,7 +31,7 @@ import {
   isSession,
   routeRSCServerRequest,
   setDevServerHooks
-} from "./chunk-T3VM44WY.mjs";
+} from "./chunk-KFHXRAUZ.mjs";
 import {
   Action,
   Await,
@@ -140,7 +140,7 @@ import {
   withComponentProps,
   withErrorBoundaryProps,
   withHydrateFallbackProps
-} from "./chunk-EF7DTUVF.mjs";
+} from "./chunk-FSG5FGWQ.mjs";
 export {
   Await,
   BrowserRouter,

package/dist/development/lib/types/internal.d.mts

@@ -1,4 +1,4 @@
-import { n as RouteModule, o as LinkDescriptor, c as Location, p as Pretty, q as MetaDescriptor, G as GetLoaderData, r as ServerDataFunctionArgs, s as unstable_MiddlewareNextFunction, t as ClientDataFunctionArgs, v as ServerDataFrom, w as Normalize, x as GetActionData } from '../../route-data-DjzmHYNR.mjs';
+import { n as RouteModule, o as LinkDescriptor, c as Location, p as Pretty, q as MetaDescriptor, G as GetLoaderData, r as ServerDataFunctionArgs, s as unstable_MiddlewareNextFunction, t as ClientDataFunctionArgs, v as ServerDataFrom, w as Normalize, x as GetActionData } from '../../route-data-CqEmXQub.mjs';
 import { R as RouteFiles, P as Pages } from '../../register-DiOIlEq5.mjs';
 import 'react';
 

package/dist/development/lib/types/internal.d.ts

@@ -1,4 +1,4 @@
-import { R as RouteModule, L as LinkDescriptor, a as Location, P as Pretty, M as MetaDescriptor, G as GetLoaderData, S as ServerDataFunctionArgs, u as unstable_MiddlewareNextFunction, C as ClientDataFunctionArgs, b as ServerDataFrom, N as Normalize, c as GetActionData } from '../../routeModules-g5PTiDfO.js';
+import { R as RouteModule, L as LinkDescriptor, a as Location, P as Pretty, M as MetaDescriptor, G as GetLoaderData, S as ServerDataFunctionArgs, u as unstable_MiddlewareNextFunction, C as ClientDataFunctionArgs, b as ServerDataFrom, N as Normalize, c as GetActionData } from '../../routeModules-BR2FO0ix.js';
 import { R as RouteFiles, P as Pages } from '../../register-DiOIlEq5.js';
 import 'react';
 

package/dist/development/lib/types/internal.js

@@ -1,5 +1,5 @@
 "use strict";/**
- * react-router v7.7.0
+ * react-router v7.7.1-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/development/lib/types/internal.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v7.7.0
+ * react-router v7.7.1-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/{production/route-data-DjzmHYNR.d.mts → development/route-data-CqEmXQub.d.mts}

@@ -448,14 +448,56 @@ interface DataStrategyMatch extends AgnosticRouteMatch<string, AgnosticDataRoute
         handler: Promise<void> | undefined;
         route: Promise<void> | undefined;
     };
+    /**
+     * A boolean value indicating whether this route handler should be called in this pass.
+     *
+     * The `matches` array always includes _all_ matched routes even when only _some_
+     * route handlers need to be called so that things like middleware can be implemented.
+     *
+     * `shouldLoad` is usually only interesting if you are skipping the route handler
+     * entirely and implementing custom handler logic - since it lets you determine
+     * if that custom logic should run for this route or not.
+     *
+     * For example:
+     *  - If you are on `/parent/child/a` and you navigate to `/parent/child/b` -
+     *    you'll get an array of three matches (`[parent, child, b]`), but only `b`
+     *    will have `shouldLoad=true` because the data for `parent` and `child` is
+     *    already loaded
+     *  - If you are on `/parent/child/a` and you submit to `a`'s `action`, then only
+     *    `a` will have `shouldLoad=true` for the action execution of `dataStrategy`
+     *  - After the `action`, `dataStrategy` will be called again for the `loader`
+     *    revalidation, and all matches will have `shouldLoad=true` (assuming no custom
+     *   `shouldRevalidate` implementations)
+     */
     shouldLoad: boolean;
     unstable_shouldRevalidateArgs: ShouldRevalidateFunctionArgs | null;
     unstable_shouldCallHandler(defaultShouldRevalidate?: boolean): boolean;
+    /**
+     * An async function that will resolve any `route.lazy` implementations and
+     * execute the route's handler (if necessary), returning a `DataStrategyResult`
+     *
+     * - Calling `match.resolve` does not mean you're calling the `loader`/`action`
+     *   (the "handler") - `resolve` will only call the `handler` internally if
+     *   needed _and_ if you don't pass your own `handlerOverride` function parameter
+     * - It is safe to call `match.resolve` for all matches, even if they have
+     *   `shouldLoad=false`, and it will no-op if no loading is required
+     * - You should generally always call `match.resolve()` for `shouldLoad:true`
+     *   routes to ensure that any `route.lazy` implementations are processed
+     * - See the examples below for how to implement custom handler execution via
+     *   `match.resolve`
+     */
     resolve: (handlerOverride?: (handler: (ctx?: unknown) => DataFunctionReturnValue) => DataFunctionReturnValue) => Promise<DataStrategyResult>;
 }
 interface DataStrategyFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
+    /**
+     * Matches for this route extended with Data strategy APIs
+     */
     matches: DataStrategyMatch[];
     unstable_runClientMiddleware: (cb: DataStrategyFunction<Context>) => Promise<Record<string, DataStrategyResult>>;
+    /**
+     * The key of the fetcher we are calling `dataStrategy` for, otherwise `null`
+     * for navigational executions
+     */
     fetcherKey: string | null;
 }
 /**
@@ -1092,8 +1134,12 @@ interface GetScrollPositionFunction {
     (): number;
 }
 /**
-  - "route": relative to the route hierarchy so `..` means remove all segments of the current route even if it has many. For example, a `route("posts/:id")` would have both `:id` and `posts` removed from the url.
-  - "path": relative to the pathname so `..` means remove one segment of the pathname. For example, a `route("posts/:id")` would have only `:id` removed from the url.
+ * - "route": relative to the route hierarchy so `..` means remove all segments
+ * of the current route even if it has many. For example, a `route("posts/:id")`
+ * would have both `:id` and `posts` removed from the url.
+ * - "path": relative to the pathname so `..` means remove one segment of the
+ * pathname. For example, a `route("posts/:id")` would have only `:id` removed
+ * from the url.
  */
 type RelativeRoutingType = "route" | "path";
 type BaseNavigateOrFetchOptions = {

package/dist/{production/routeModules-g5PTiDfO.d.ts → development/routeModules-BR2FO0ix.d.ts}

@@ -448,14 +448,56 @@ interface DataStrategyMatch extends AgnosticRouteMatch<string, AgnosticDataRoute
         handler: Promise<void> | undefined;
         route: Promise<void> | undefined;
     };
+    /**
+     * A boolean value indicating whether this route handler should be called in this pass.
+     *
+     * The `matches` array always includes _all_ matched routes even when only _some_
+     * route handlers need to be called so that things like middleware can be implemented.
+     *
+     * `shouldLoad` is usually only interesting if you are skipping the route handler
+     * entirely and implementing custom handler logic - since it lets you determine
+     * if that custom logic should run for this route or not.
+     *
+     * For example:
+     *  - If you are on `/parent/child/a` and you navigate to `/parent/child/b` -
+     *    you'll get an array of three matches (`[parent, child, b]`), but only `b`
+     *    will have `shouldLoad=true` because the data for `parent` and `child` is
+     *    already loaded
+     *  - If you are on `/parent/child/a` and you submit to `a`'s `action`, then only
+     *    `a` will have `shouldLoad=true` for the action execution of `dataStrategy`
+     *  - After the `action`, `dataStrategy` will be called again for the `loader`
+     *    revalidation, and all matches will have `shouldLoad=true` (assuming no custom
+     *   `shouldRevalidate` implementations)
+     */
     shouldLoad: boolean;
     unstable_shouldRevalidateArgs: ShouldRevalidateFunctionArgs | null;
     unstable_shouldCallHandler(defaultShouldRevalidate?: boolean): boolean;
+    /**
+     * An async function that will resolve any `route.lazy` implementations and
+     * execute the route's handler (if necessary), returning a `DataStrategyResult`
+     *
+     * - Calling `match.resolve` does not mean you're calling the `loader`/`action`
+     *   (the "handler") - `resolve` will only call the `handler` internally if
+     *   needed _and_ if you don't pass your own `handlerOverride` function parameter
+     * - It is safe to call `match.resolve` for all matches, even if they have
+     *   `shouldLoad=false`, and it will no-op if no loading is required
+     * - You should generally always call `match.resolve()` for `shouldLoad:true`
+     *   routes to ensure that any `route.lazy` implementations are processed
+     * - See the examples below for how to implement custom handler execution via
+     *   `match.resolve`
+     */
     resolve: (handlerOverride?: (handler: (ctx?: unknown) => DataFunctionReturnValue) => DataFunctionReturnValue) => Promise<DataStrategyResult>;
 }
 interface DataStrategyFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
+    /**
+     * Matches for this route extended with Data strategy APIs
+     */
     matches: DataStrategyMatch[];
     unstable_runClientMiddleware: (cb: DataStrategyFunction<Context>) => Promise<Record<string, DataStrategyResult>>;
+    /**
+     * The key of the fetcher we are calling `dataStrategy` for, otherwise `null`
+     * for navigational executions
+     */
     fetcherKey: string | null;
 }
 /**
@@ -1092,8 +1134,12 @@ interface GetScrollPositionFunction {
     (): number;
 }
 /**
-  - "route": relative to the route hierarchy so `..` means remove all segments of the current route even if it has many. For example, a `route("posts/:id")` would have both `:id` and `posts` removed from the url.
-  - "path": relative to the pathname so `..` means remove one segment of the pathname. For example, a `route("posts/:id")` would have only `:id` removed from the url.
+ * - "route": relative to the route hierarchy so `..` means remove all segments
+ * of the current route even if it has many. For example, a `route("posts/:id")`
+ * would have both `:id` and `posts` removed from the url.
+ * - "path": relative to the pathname so `..` means remove one segment of the
+ * pathname. For example, a `route("posts/:id")` would have only `:id` removed
+ * from the url.
  */
 type RelativeRoutingType = "route" | "path";
 type BaseNavigateOrFetchOptions = {

package/dist/production/{browser-CcxeZJcQ.d.mts → browser-7LYX59NK.d.mts}

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import * as React from 'react';
-import { u as unstable_RouterContextProvider, i as ActionFunction, C as ClientActionFunction, j as ClientLoaderFunction, k as HeadersFunction, l as LinksFunction, m as LoaderFunction, M as MetaFunction, S as ShouldRevalidateFunction, c as Location, h as Params } from './route-data-DjzmHYNR.mjs';
+import { u as unstable_RouterContextProvider, i as ActionFunction, C as ClientActionFunction, j as ClientLoaderFunction, k as HeadersFunction, l as LinksFunction, m as LoaderFunction, M as MetaFunction, S as ShouldRevalidateFunction, c as Location, h as Params } from './route-data-CqEmXQub.mjs';
 
 type ServerContext = {
     redirect?: Response;
@@ -104,6 +104,67 @@ type DecodeReplyFunction = (reply: FormData | string, { temporaryReferences }: {
     temporaryReferences: unknown;
 }) => Promise<unknown[]>;
 type LoadServerActionFunction = (id: string) => Promise<Function>;
+/**
+ * Matches the given routes to a Request and returns a RSC Response encoding an
+ * `RSCPayload` for consumption by a RSC enabled client router.
+ *
+ * @example
+ * import {
+ *   createTemporaryReferenceSet,
+ *   decodeAction,
+ *   decodeReply,
+ *   loadServerAction,
+ *   renderToReadableStream,
+ * } from "@vitejs/plugin-rsc/rsc";
+ * import { unstable_matchRSCServerRequest as matchRSCServerRequest } from "react-router";
+ *
+ * matchRSCServerRequest({
+ *   createTemporaryReferenceSet,
+ *   decodeAction,
+ *   decodeFormState,
+ *   decodeReply,
+ *   loadServerAction,
+ *   request,
+ *   routes: routes(),
+ *   generateResponse(match) {
+ *     return new Response(
+ *       renderToReadableStream(match.payload),
+ *       {
+ *         status: match.statusCode,
+ *         headers: match.headers,
+ *       }
+ *     );
+ *   },
+ * });
+ *
+ * @name unstable_matchRSCServerRequest
+ * @public
+ * @category RSC
+ * @mode data
+ * @param opts Options
+ * @param opts.basename The basename to use when matching the request.
+ * @param opts.decodeAction Your `react-server-dom-xyz/server`'s `decodeAction`
+ * function, responsible for loading a server action.
+ * @param opts.decodeReply Your `react-server-dom-xyz/server`'s `decodeReply`
+ * function, used to decode the server function's arguments and bind them to the
+ * implementation for invocation by the router.
+ * @param opts.decodeFormState A function responsible for decoding form state for
+ * progressively enhanceable forms with `useActionState` using your
+ * `react-server-dom-xyz/server`'s `decodeFormState`.
+ * @param opts.generateResponse A function responsible for using your
+ * `renderToReadableStream` to generate a Response encoding the `RSCPayload`.
+ * @param opts.loadServerAction Your `react-server-dom-xyz/server`'s
+ * `loadServerAction` function, used to load a server action by ID.
+ * @param opts.request The request to match against.
+ * @param opts.requestContext An instance of `unstable_RouterContextProvider`
+ * that should be created per request, to be passed to loaders, actions and middleware.
+ * @param opts.routes Your route definitions.
+ * @param opts.createTemporaryReferenceSet A function that returns a temporary
+ * reference set for the request, used to track temporary references in the RSC stream.
+ * @param opts.onError An optional error handler that will be called with any
+ * errors that occur during the request processing.
+ * @returns A Response that contains the RSC data for hydration.
+ */
 declare function matchRSCServerRequest({ createTemporaryReferenceSet, basename, decodeReply, requestContext, loadServerAction, decodeAction, decodeFormState, onError, request, routes, generateResponse, }: {
     createTemporaryReferenceSet: () => unknown;
     basename?: string;
@@ -125,6 +186,41 @@ declare global {
         __FLIGHT_DATA: any[];
     }
 }
+/**
+ * Get the prerendered RSC stream for hydration. Usually passed directly to your
+ * `react-server-dom-xyz/client`'s `createFromReadableStream`.
+ *
+ * @example
+ * import { startTransition, StrictMode } from "react";
+ * import { hydrateRoot } from "react-dom/client";
+ * import {
+ *   unstable_getRSCStream as getRSCStream,
+ *   unstable_RSCHydratedRouter as RSCHydratedRouter,
+ * } from "react-router";
+ * import type { unstable_RSCPayload as RSCPayload } from "react-router";
+ *
+ * createFromReadableStream(getRSCStream()).then(
+ *   (payload: RSCServerPayload) => {
+ *     startTransition(async () => {
+ *       hydrateRoot(
+ *         document,
+ *         <StrictMode>
+ *           <RSCHydratedRouter ...props />
+ *         </StrictMode>,
+ *         {
+ *           // Options
+ *         }
+ *       );
+ *     });
+ *   }
+ * );
+ *
+ * @name unstable_getRSCStream
+ * @public
+ * @category RSC
+ * @mode data
+ * @returns A `ReadableStream` that contains the RSC data for hydration.
+ */
 declare function getRSCStream(): ReadableStream<any>;
 
 export { type DecodeActionFunction as D, type LoadServerActionFunction as L, type RSCPayload as R, type DecodeFormStateFunction as a, type DecodeReplyFunction as b, type RSCManifestPayload as c, type RSCMatch as d, type RSCRenderPayload as e, type RSCRouteManifest as f, getRSCStream as g, type RSCRouteMatch as h, type RSCRouteConfigEntry as i, type RSCRouteConfig as j, matchRSCServerRequest as m };

package/dist/production/{chunk-5KHO4FML.js → chunk-BPUKNCMM.js}

@@ -1,5 +1,5 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }/**
- * react-router v7.7.0
+ * react-router v7.7.1-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -2305,9 +2305,7 @@ function createRouter(init) {
           )
         };
       } else {
-        dataResults[routeId] = await convertDataStrategyResultToDataResult(
-          result
-        );
+        dataResults[routeId] = await convertDataStrategyResultToDataResult(result);
       }
     }
     return dataResults;
@@ -4163,7 +4161,10 @@ async function callDataStrategyImpl(dataStrategyImpl, request, matches, fetcherK
   });
   try {
     await Promise.all(
-      matches.flatMap((m) => [_optionalChain([m, 'access', _43 => _43._lazyPromises, 'optionalAccess', _44 => _44.handler]), _optionalChain([m, 'access', _45 => _45._lazyPromises, 'optionalAccess', _46 => _46.route])])
+      matches.flatMap((m) => [
+        _optionalChain([m, 'access', _43 => _43._lazyPromises, 'optionalAccess', _44 => _44.handler]),
+        _optionalChain([m, 'access', _45 => _45._lazyPromises, 'optionalAccess', _46 => _46.route])
+      ])
     );
   } catch (e) {
   }
@@ -5478,8 +5479,10 @@ function encode(input, options) {
                     lastSentIndex++;
                   } else if (id2 < 0) {
                     controller.enqueue(
-                      textEncoder.encode(`${TYPE_ERROR}${deferredId}:${id2}
-`)
+                      textEncoder.encode(
+                        `${TYPE_ERROR}${deferredId}:${id2}
+`
+                      )
                     );
                   } else {
                     const values = encoder.stringified.slice(lastSentIndex + 1).join(",");
@@ -6406,68 +6409,71 @@ function _renderMatches(matches, parentMatches = [], dataRouterState = null, fut
       }
     }
   }
-  return renderedMatches.reduceRight((outlet, match, index) => {
-    let error;
-    let shouldRenderHydrateFallback = false;
-    let errorElement = null;
-    let hydrateFallbackElement = null;
-    if (dataRouterState) {
-      error = errors && match.route.id ? errors[match.route.id] : void 0;
-      errorElement = match.route.errorElement || defaultErrorElement;
-      if (renderFallback) {
-        if (fallbackIndex < 0 && index === 0) {
-          warningOnce(
-            "route-fallback",
-            false,
-            "No `HydrateFallback` element provided to render during initial hydration"
-          );
-          shouldRenderHydrateFallback = true;
-          hydrateFallbackElement = null;
-        } else if (fallbackIndex === index) {
-          shouldRenderHydrateFallback = true;
-          hydrateFallbackElement = match.route.hydrateFallbackElement || null;
+  return renderedMatches.reduceRight(
+    (outlet, match, index) => {
+      let error;
+      let shouldRenderHydrateFallback = false;
+      let errorElement = null;
+      let hydrateFallbackElement = null;
+      if (dataRouterState) {
+        error = errors && match.route.id ? errors[match.route.id] : void 0;
+        errorElement = match.route.errorElement || defaultErrorElement;
+        if (renderFallback) {
+          if (fallbackIndex < 0 && index === 0) {
+            warningOnce(
+              "route-fallback",
+              false,
+              "No `HydrateFallback` element provided to render during initial hydration"
+            );
+            shouldRenderHydrateFallback = true;
+            hydrateFallbackElement = null;
+          } else if (fallbackIndex === index) {
+            shouldRenderHydrateFallback = true;
+            hydrateFallbackElement = match.route.hydrateFallbackElement || null;
+          }
         }
       }
-    }
-    let matches2 = parentMatches.concat(renderedMatches.slice(0, index + 1));
-    let getChildren = () => {
-      let children;
-      if (error) {
-        children = errorElement;
-      } else if (shouldRenderHydrateFallback) {
-        children = hydrateFallbackElement;
-      } else if (match.route.Component) {
-        children = /* @__PURE__ */ React3.createElement(match.route.Component, null);
-      } else if (match.route.element) {
-        children = match.route.element;
-      } else {
-        children = outlet;
-      }
-      return /* @__PURE__ */ React3.createElement(
-        RenderedRoute,
+      let matches2 = parentMatches.concat(renderedMatches.slice(0, index + 1));
+      let getChildren = () => {
+        let children;
+        if (error) {
+          children = errorElement;
+        } else if (shouldRenderHydrateFallback) {
+          children = hydrateFallbackElement;
+        } else if (match.route.Component) {
+          children = /* @__PURE__ */ React3.createElement(match.route.Component, null);
+        } else if (match.route.element) {
+          children = match.route.element;
+        } else {
+          children = outlet;
+        }
+        return /* @__PURE__ */ React3.createElement(
+          RenderedRoute,
+          {
+            match,
+            routeContext: {
+              outlet,
+              matches: matches2,
+              isDataRoute: dataRouterState != null
+            },
+            children
+          }
+        );
+      };
+      return dataRouterState && (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? /* @__PURE__ */ React3.createElement(
+        RenderErrorBoundary,
         {
-          match,
-          routeContext: {
-            outlet,
-            matches: matches2,
-            isDataRoute: dataRouterState != null
-          },
-          children
+          location: dataRouterState.location,
+          revalidation: dataRouterState.revalidation,
+          component: errorElement,
+          error,
+          children: getChildren(),
+          routeContext: { outlet: null, matches: matches2, isDataRoute: true }
         }
-      );
-    };
-    return dataRouterState && (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? /* @__PURE__ */ React3.createElement(
-      RenderErrorBoundary,
-      {
-        location: dataRouterState.location,
-        revalidation: dataRouterState.revalidation,
-        component: errorElement,
-        error,
-        children: getChildren(),
-        routeContext: { outlet: null, matches: matches2, isDataRoute: true }
-      }
-    ) : getChildren();
-  }, null);
+      ) : getChildren();
+    },
+    null
+  );
 }
 function getDataRouterConsoleError(hookName) {
   return `${hookName} must be used within a data router.  See https://reactrouter.com/en/main/routers/picking-a-router.`;
@@ -7630,10 +7636,7 @@ function Links() {
     ({ key, link }) => isPageLinkDescriptor(link) ? /* @__PURE__ */ React7.createElement(PrefetchPageLinks, { key, ...link }) : /* @__PURE__ */ React7.createElement("link", { key, ...link })
   ));
 }
-function PrefetchPageLinks({
-  page,
-  ...dataLinkProps
-}) {
+function PrefetchPageLinks({ page, ...linkProps }) {
   let { router } = useDataRouterContext2();
   let matches = React7.useMemo(
     () => matchRoutes(router.routes, page, router.basename),
@@ -7642,7 +7645,7 @@ function PrefetchPageLinks({
   if (!matches) {
     return null;
   }
-  return /* @__PURE__ */ React7.createElement(PrefetchPageLinksImpl, { page, matches, ...dataLinkProps });
+  return /* @__PURE__ */ React7.createElement(PrefetchPageLinksImpl, { page, matches, ...linkProps });
 }
 function useKeyedPrefetchLinks(matches) {
   let { manifest, routeModules } = useFrameworkContext();
@@ -7846,7 +7849,7 @@ function isValidMetaTag(tagName) {
   return typeof tagName === "string" && /^(meta|link)$/.test(tagName);
 }
 var isHydrated = false;
-function Scripts(props) {
+function Scripts(scriptProps) {
   let {
     manifest,
     serverHandoffString,
@@ -7932,7 +7935,7 @@ import(${JSON.stringify(manifest.entry.module)});`;
     return /* @__PURE__ */ React7.createElement(React7.Fragment, null, /* @__PURE__ */ React7.createElement(
       "script",
       {
-        ...props,
+        ...scriptProps,
         suppressHydrationWarning: true,
         dangerouslySetInnerHTML: createHtml(contextScript),
         type: void 0
@@ -7940,7 +7943,7 @@ import(${JSON.stringify(manifest.entry.module)});`;
     ), /* @__PURE__ */ React7.createElement(
       "script",
       {
-        ...props,
+        ...scriptProps,
         suppressHydrationWarning: true,
         dangerouslySetInnerHTML: createHtml(routeModulesScript),
         type: "module",
@@ -7977,7 +7980,7 @@ import(${JSON.stringify(manifest.entry.module)});`;
     {
       rel: "modulepreload",
       href: manifest.url,
-      crossOrigin: props.crossOrigin,
+      crossOrigin: scriptProps.crossOrigin,
       integrity: sri[manifest.url],
       suppressHydrationWarning: true
     }
@@ -7986,7 +7989,7 @@ import(${JSON.stringify(manifest.entry.module)});`;
     {
       rel: "modulepreload",
       href: manifest.entry.module,
-      crossOrigin: props.crossOrigin,
+      crossOrigin: scriptProps.crossOrigin,
       integrity: sri[manifest.entry.module],
       suppressHydrationWarning: true
     }
@@ -7996,7 +7999,7 @@ import(${JSON.stringify(manifest.entry.module)});`;
       key: path,
       rel: "modulepreload",
       href: path,
-      crossOrigin: props.crossOrigin,
+      crossOrigin: scriptProps.crossOrigin,
       integrity: sri[path],
       suppressHydrationWarning: true
     }