react-router 7.7.1 → 7.8.0-pre.1

package/dist/development/{chunk-K7YFBME3.js → chunk-NGF2R4G7.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.1
+ * react-router v7.8.0-pre.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -367,6 +367,10 @@ function unstable_createContext(defaultValue) {
 }
 var _map;
 var unstable_RouterContextProvider = class {
+  /**
+   * Create a new `unstable_RouterContextProvider` instance
+   * @param init An optional initial context map to populate the provider with
+   */
   constructor(init) {
     __privateAdd(this, _map, /* @__PURE__ */ new Map());
     if (init) {
@@ -375,6 +379,14 @@ var unstable_RouterContextProvider = class {
       }
     }
   }
+  /**
+   * Access a value from the context. If no value has been set for the context,
+   * it will return the context's `defaultValue` if provided, or throw an error
+   * if no `defaultValue` was set.
+   * @param context The context to get the value for
+   * @returns The value for the context, or the context's `defaultValue` if no
+   * value was set
+   */
   get(context) {
     if (__privateGet(this, _map).has(context)) {
       return __privateGet(this, _map).get(context);
@@ -384,6 +396,14 @@ var unstable_RouterContextProvider = class {
     }
     throw new Error("No value found for context");
   }
+  /**
+   * Set a value for the context. If the context already has a value set, this
+   * will overwrite it.
+   *
+   * @param context The context to set the value for
+   * @param value The value to set for the context
+   * @returns {void}
+   */
   set(context, value) {
     __privateGet(this, _map).set(context, value);
   }
@@ -489,6 +509,7 @@ function convertRouteMatchToUiMatch(match, loaderData) {
     pathname,
     params,
     data: loaderData[route.id],
+    loaderData: loaderData[route.id],
     handle: route.handle
   };
 }
@@ -1434,9 +1455,7 @@ function createRouter(init) {
       pendingNavigationController.signal,
       opts && opts.submission
     );
-    let scopedContext = new unstable_RouterContextProvider(
-      init.unstable_getContext ? await init.unstable_getContext() : void 0
-    );
+    let scopedContext = init.unstable_getContext ? await init.unstable_getContext() : new unstable_RouterContextProvider();
     let pendingActionResult;
     if (opts && opts.pendingError) {
       pendingActionResult = [
@@ -1703,7 +1722,7 @@ function createRouter(init) {
       pendingActionResult
     );
     pendingNavigationLoadId = ++incrementingLoadId;
-    if (!init.dataStrategy && !dsMatches.some((m) => m.shouldLoad) && revalidatingFetchers.length === 0) {
+    if (!init.dataStrategy && !dsMatches.some((m) => m.shouldLoad) && !dsMatches.some((m) => m.route.unstable_middleware) && revalidatingFetchers.length === 0) {
       let updatedFetchers2 = markFetchRedirectsDone();
       completeNavigation(
         location,
@@ -1857,9 +1876,7 @@ function createRouter(init) {
       setFetcherError(key, routeId, error, { flushSync });
       return;
     }
-    let scopedContext = new unstable_RouterContextProvider(
-      init.unstable_getContext ? await init.unstable_getContext() : void 0
-    );
+    let scopedContext = init.unstable_getContext ? await init.unstable_getContext() : new unstable_RouterContextProvider();
     let preventScrollReset = (opts && opts.preventScrollReset) === true;
     if (submission && isMutationMethod(submission.formMethod)) {
       await handleFetcherAction(
@@ -2710,20 +2727,13 @@ function createStaticHandler(routes, opts) {
     skipLoaderErrorBubbling,
     skipRevalidation,
     dataStrategy,
-    unstable_stream: stream,
-    unstable_respond: respond
+    unstable_generateMiddlewareResponse: generateMiddlewareResponse
   } = {}) {
     let url = new URL(request.url);
     let method = request.method;
     let location = createLocation("", createPath(url), null, "default");
     let matches = matchRoutes(dataRoutes, location, basename);
     requestContext = requestContext != null ? requestContext : new unstable_RouterContextProvider();
-    let respondOrStreamStaticContext = (ctx) => {
-      return stream ? stream(
-        requestContext,
-        () => Promise.resolve(ctx)
-      ) : respond ? respond(ctx) : ctx;
-    };
     if (!isValidMethod(method) && method !== "HEAD") {
       let error = getInternalRouterError(405, { method });
       let { matches: methodNotAllowedMatches, route } = getShortCircuitMatches(dataRoutes);
@@ -2740,7 +2750,7 @@ function createStaticHandler(routes, opts) {
         loaderHeaders: {},
         actionHeaders: {}
       };
-      return respondOrStreamStaticContext(staticContext);
+      return generateMiddlewareResponse ? generateMiddlewareResponse(() => Promise.resolve(staticContext)) : staticContext;
     } else if (!matches) {
       let error = getInternalRouterError(404, { pathname: location.pathname });
       let { matches: notFoundMatches, route } = getShortCircuitMatches(dataRoutes);
@@ -2757,11 +2767,9 @@ function createStaticHandler(routes, opts) {
         loaderHeaders: {},
         actionHeaders: {}
       };
-      return respondOrStreamStaticContext(staticContext);
+      return generateMiddlewareResponse ? generateMiddlewareResponse(() => Promise.resolve(staticContext)) : staticContext;
     }
-    if (stream || respond && matches.some(
-      (m) => m.route.unstable_middleware || typeof m.route.lazy === "object" && m.route.lazy.unstable_middleware
-    )) {
+    if (generateMiddlewareResponse) {
       invariant(
         requestContext instanceof unstable_RouterContextProvider,
         "When using middleware in `staticHandler.query()`, any provided `requestContext` must be an instance of `unstable_RouterContextProvider`"
@@ -2773,7 +2781,7 @@ function createStaticHandler(routes, opts) {
           mapRouteProperties
         );
         let renderedStaticContext;
-        let response = await runMiddlewarePipeline(
+        let response = await runServerMiddlewarePipeline(
           {
             request,
             matches,
@@ -2782,45 +2790,27 @@ function createStaticHandler(routes, opts) {
             // this to the proper type knowing it's not an `AppLoadContext`
             context: requestContext
           },
-          true,
           async () => {
-            if (stream) {
-              let res2 = await stream(
-                requestContext,
-                async (revalidationRequest) => {
-                  let result3 = await queryImpl(
-                    revalidationRequest,
-                    location,
-                    matches,
-                    requestContext,
-                    dataStrategy || null,
-                    skipLoaderErrorBubbling === true,
-                    null,
-                    filterMatchesToLoad || null,
-                    skipRevalidation === true
-                  );
-                  return isResponse(result3) ? result3 : { location, basename, ...result3 };
+            let res = await generateMiddlewareResponse(
+              async (revalidationRequest) => {
+                let result2 = await queryImpl(
+                  revalidationRequest,
+                  location,
+                  matches,
+                  requestContext,
+                  dataStrategy || null,
+                  skipLoaderErrorBubbling === true,
+                  null,
+                  filterMatchesToLoad || null,
+                  skipRevalidation === true
+                );
+                if (isResponse(result2)) {
+                  return result2;
                 }
-              );
-              return res2;
-            }
-            invariant(respond, "Expected respond to be defined");
-            let result2 = await queryImpl(
-              request,
-              location,
-              matches,
-              requestContext,
-              dataStrategy || null,
-              skipLoaderErrorBubbling === true,
-              null,
-              filterMatchesToLoad || null,
-              skipRevalidation === true
+                renderedStaticContext = { location, basename, ...result2 };
+                return renderedStaticContext;
+              }
             );
-            if (isResponse(result2)) {
-              return result2;
-            }
-            renderedStaticContext = { location, basename, ...result2 };
-            let res = await respond(renderedStaticContext);
             return res;
           },
           async (error, routeId) => {
@@ -2837,7 +2827,9 @@ function createStaticHandler(routes, opts) {
                 error,
                 skipLoaderErrorBubbling ? routeId : findNearestBoundary(matches, routeId).route.id
               );
-              return respondOrStreamStaticContext(staticContext);
+              return generateMiddlewareResponse(
+                () => Promise.resolve(staticContext)
+              );
             } else {
               let boundaryRouteId = skipLoaderErrorBubbling ? routeId : findNearestBoundary(
                 matches,
@@ -2858,7 +2850,9 @@ function createStaticHandler(routes, opts) {
                 actionHeaders: {},
                 loaderHeaders: {}
               };
-              return respondOrStreamStaticContext(staticContext);
+              return generateMiddlewareResponse(
+                () => Promise.resolve(staticContext)
+              );
             }
           }
         );
@@ -2891,7 +2885,7 @@ function createStaticHandler(routes, opts) {
     routeId,
     requestContext,
     dataStrategy,
-    unstable_respond: respond
+    unstable_generateMiddlewareResponse: generateMiddlewareResponse
   } = {}) {
     let url = new URL(request.url);
     let method = request.method;
@@ -2912,15 +2906,13 @@ function createStaticHandler(routes, opts) {
     } else if (!match) {
       throw getInternalRouterError(404, { pathname: location.pathname });
     }
-    if (respond && matches.some(
-      (m) => m.route.unstable_middleware || typeof m.route.lazy === "object" && m.route.lazy.unstable_middleware
-    )) {
+    if (generateMiddlewareResponse) {
       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, mapRouteProperties);
-      let response = await runMiddlewarePipeline(
+      let response = await runServerMiddlewarePipeline(
         {
           request,
           matches,
@@ -2929,37 +2921,34 @@ function createStaticHandler(routes, opts) {
           // this to the proper type knowing it's not an `AppLoadContext`
           context: requestContext
         },
-        true,
         async () => {
-          let result2 = await queryImpl(
-            request,
-            location,
-            matches,
-            requestContext,
-            dataStrategy || null,
-            false,
-            match,
-            null,
-            false
+          let res = await generateMiddlewareResponse(
+            async (innerRequest) => {
+              let result2 = await queryImpl(
+                innerRequest,
+                location,
+                matches,
+                requestContext,
+                dataStrategy || null,
+                false,
+                match,
+                null,
+                false
+              );
+              let processed = handleQueryResult(result2);
+              return isResponse(processed) ? processed : typeof processed === "string" ? new Response(processed) : Response.json(processed);
+            }
           );
-          if (isResponse(result2)) {
-            return respond(result2);
-          }
-          let error2 = result2.errors ? Object.values(result2.errors)[0] : void 0;
-          if (error2 !== void 0) {
-            throw error2;
-          }
-          let value = result2.actionData ? Object.values(result2.actionData)[0] : Object.values(result2.loaderData)[0];
-          return typeof value === "string" ? new Response(value) : Response.json(value);
+          return res;
         },
-        (error2) => {
-          if (isResponse(error2)) {
-            return respond(error2);
+        (error) => {
+          if (isRouteErrorResponse(error)) {
+            return Promise.resolve(errorResponseToResponse(error));
           }
-          return new Response(String(error2), {
-            status: 500,
-            statusText: "Unexpected Server Error"
-          });
+          if (isResponse(error)) {
+            return Promise.resolve(error);
+          }
+          throw error;
         }
       );
       return response;
@@ -2975,20 +2964,23 @@ function createStaticHandler(routes, opts) {
       null,
       false
     );
-    if (isResponse(result)) {
-      return result;
-    }
-    let error = result.errors ? Object.values(result.errors)[0] : void 0;
-    if (error !== void 0) {
-      throw error;
-    }
-    if (result.actionData) {
-      return Object.values(result.actionData)[0];
-    }
-    if (result.loaderData) {
-      return Object.values(result.loaderData)[0];
+    return handleQueryResult(result);
+    function handleQueryResult(result2) {
+      if (isResponse(result2)) {
+        return result2;
+      }
+      let error = result2.errors ? Object.values(result2.errors)[0] : void 0;
+      if (error !== void 0) {
+        throw error;
+      }
+      if (result2.actionData) {
+        return Object.values(result2.actionData)[0];
+      }
+      if (result2.loaderData) {
+        return Object.values(result2.loaderData)[0];
+      }
+      return void 0;
     }
-    return void 0;
   }
   async function queryImpl(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, filterMatchesToLoad, skipRevalidation) {
     invariant(
@@ -3928,45 +3920,118 @@ async function defaultDataStrategyWithMiddleware(args) {
   if (!args.matches.some((m) => m.route.unstable_middleware)) {
     return defaultDataStrategy(args);
   }
-  return runMiddlewarePipeline(
+  return runClientMiddlewarePipeline(
     args,
-    false,
     () => defaultDataStrategy(args),
     (error, routeId) => ({ [routeId]: { type: "error", result: error } })
   );
 }
-async function runMiddlewarePipeline(args, propagateResult, handler, errorHandler) {
+async function runServerMiddlewarePipeline(args, handler, errorHandler) {
   let { matches, request, params, context } = args;
-  let middlewareState = {
-    handlerResult: void 0
+  let tuples = matches.flatMap(
+    (m) => m.route.unstable_middleware ? m.route.unstable_middleware.map((fn) => [m.route.id, fn]) : []
+  );
+  let result = await callServerRouteMiddleware(
+    { request, params, context },
+    tuples,
+    handler,
+    errorHandler
+  );
+  if (isResponse(result)) {
+    return result;
+  }
+  invariant(false, `Expected a Response to be returned from route middleware`);
+}
+async function callServerRouteMiddleware(args, middlewares, handler, errorHandler, idx = 0) {
+  let { request } = args;
+  if (request.signal.aborted) {
+    if (request.signal.reason) {
+      throw request.signal.reason;
+    }
+    throw new Error(
+      `Request aborted without an \`AbortSignal.reason\`: ${request.method} ${request.url}`
+    );
+  }
+  let tuple = middlewares[idx];
+  if (!tuple) {
+    let result = await handler();
+    return result;
+  }
+  let [routeId, middleware] = tuple;
+  let nextCalled = false;
+  let nextResult = void 0;
+  let next = async () => {
+    if (nextCalled) {
+      throw new Error("You may only call `next()` once per middleware");
+    }
+    nextCalled = true;
+    try {
+      let result = await callServerRouteMiddleware(
+        args,
+        middlewares,
+        handler,
+        errorHandler,
+        idx + 1
+      );
+      if (isDataWithResponseInit(result)) {
+        result = dataWithResponseInitToResponse(result);
+      }
+      nextResult = result;
+      return nextResult;
+    } catch (e) {
+      nextResult = await errorHandler(
+        // Convert thrown data() values to ErrorResponses
+        isDataWithResponseInit(e) ? dataWithResponseInitToErrorResponse(e) : e,
+        routeId
+      );
+      return nextResult;
+    }
   };
   try {
-    let tuples = matches.flatMap(
-      (m) => m.route.unstable_middleware ? m.route.unstable_middleware.map((fn) => [m.route.id, fn]) : []
-    );
-    let result = await callRouteMiddleware(
-      { request, params, context },
-      tuples,
-      propagateResult,
-      middlewareState,
-      handler
+    let result = await middleware(
+      {
+        request: args.request,
+        params: args.params,
+        context: args.context
+      },
+      next
     );
-    return propagateResult ? result : middlewareState.handlerResult;
-  } catch (e) {
-    if (!middlewareState.middlewareError) {
-      throw e;
+    if (isDataWithResponseInit(result)) {
+      result = dataWithResponseInitToResponse(result);
     }
-    let result = await errorHandler(
-      middlewareState.middlewareError.error,
-      middlewareState.middlewareError.routeId
-    );
-    if (propagateResult || !middlewareState.handlerResult) {
+    if (nextCalled) {
+      return typeof result === "undefined" ? nextResult : result;
+    } else if (isResponse(result)) {
       return result;
+    } else {
+      nextResult = await next();
+      return nextResult;
     }
-    return Object.assign(middlewareState.handlerResult, result);
+  } catch (e) {
+    let response = await errorHandler(
+      // Convert thrown data() values to ErrorResponses
+      isDataWithResponseInit(e) ? dataWithResponseInitToErrorResponse(e) : e,
+      routeId
+    );
+    return response;
   }
 }
-async function callRouteMiddleware(args, middlewares, propagateResult, middlewareState, handler, idx = 0) {
+async function runClientMiddlewarePipeline(args, handler, errorHandler) {
+  let { matches, request, params, context } = args;
+  let tuples = matches.flatMap(
+    (m) => m.route.unstable_middleware ? m.route.unstable_middleware.map((fn) => [m.route.id, fn]) : []
+  );
+  let handlerResult = {};
+  await callClientRouteMiddleware(
+    { request, params, context },
+    tuples,
+    handler,
+    errorHandler,
+    handlerResult
+  );
+  return handlerResult;
+}
+async function callClientRouteMiddleware(args, middlewares, handler, errorHandler, handlerResult = {}, idx = 0) {
   let { request } = args;
   if (request.signal.aborted) {
     if (request.signal.reason) {
@@ -3978,28 +4043,30 @@ async function callRouteMiddleware(args, middlewares, propagateResult, middlewar
   }
   let tuple = middlewares[idx];
   if (!tuple) {
-    middlewareState.handlerResult = await handler();
-    return middlewareState.handlerResult;
+    let result = await handler();
+    Object.assign(handlerResult, result);
+    return;
   }
   let [routeId, middleware] = tuple;
   let nextCalled = false;
-  let nextResult = void 0;
   let next = async () => {
     if (nextCalled) {
       throw new Error("You may only call `next()` once per middleware");
     }
     nextCalled = true;
-    let result = await callRouteMiddleware(
-      args,
-      middlewares,
-      propagateResult,
-      middlewareState,
-      handler,
-      idx + 1
-    );
-    if (propagateResult) {
-      nextResult = result;
-      return nextResult;
+    try {
+      let result = await callClientRouteMiddleware(
+        args,
+        middlewares,
+        handler,
+        errorHandler,
+        handlerResult,
+        idx + 1
+      );
+      Object.assign(handlerResult, result);
+    } catch (e) {
+      let result = await errorHandler(e, routeId);
+      Object.assign(handlerResult, result);
     }
   };
   try {
@@ -4011,22 +4078,18 @@ async function callRouteMiddleware(args, middlewares, propagateResult, middlewar
       },
       next
     );
-    if (nextCalled) {
-      if (result === void 0) {
-        return nextResult;
-      } else {
-        return result;
-      }
-    } else {
-      return next();
+    if (typeof result !== "undefined") {
+      console.warn(
+        "client middlewares are not intended to return values, the value will be ignored",
+        result
+      );
     }
-  } catch (error) {
-    if (!middlewareState.middlewareError) {
-      middlewareState.middlewareError = { routeId, error };
-    } else if (middlewareState.middlewareError.error !== error) {
-      middlewareState.middlewareError = { routeId, error };
+    if (!nextCalled) {
+      await next();
     }
-    throw error;
+  } catch (error) {
+    let result = await errorHandler(error, routeId);
+    Object.assign(handlerResult, result);
   }
 }
 function getDataStrategyMatchLazyPromises(mapRouteProperties, manifest, request, match, lazyRoutePropertiesToSkip) {
@@ -4137,9 +4200,8 @@ async function callDataStrategyImpl(dataStrategyImpl, request, matches, fetcherK
     );
   } : (cb) => {
     let typedDataStrategyArgs = dataStrategyArgs;
-    return runMiddlewarePipeline(
+    return runClientMiddlewarePipeline(
       typedDataStrategyArgs,
-      false,
       () => cb({
         ...typedDataStrategyArgs,
         fetcherKey,
@@ -4477,11 +4539,12 @@ function processLoaderData(state, matches, results, pendingActionResult, revalid
   );
   revalidatingFetchers.filter((f) => !f.matches || f.matches.some((m) => m.shouldLoad)).forEach((rf) => {
     let { key, match, controller } = rf;
-    let result = fetcherResults[key];
-    invariant(result, "Did not find corresponding fetcher result");
     if (controller && controller.signal.aborted) {
       return;
-    } else if (isErrorResult(result)) {
+    }
+    let result = fetcherResults[key];
+    invariant(result, "Did not find corresponding fetcher result");
+    if (isErrorResult(result)) {
       let boundaryMatch = findNearestBoundary(state.matches, _optionalChain([match, 'optionalAccess', _59 => _59.route, 'access', _60 => _60.id]));
       if (!(errors && errors[boundaryMatch.route.id])) {
         errors = {
@@ -4611,6 +4674,28 @@ function isHashChangeOnly(a, b) {
   }
   return false;
 }
+function dataWithResponseInitToResponse(data2) {
+  return new Response(
+    typeof data2.data === "string" ? data2.data : JSON.stringify(data2.data),
+    data2.init || void 0
+  );
+}
+function dataWithResponseInitToErrorResponse(data2) {
+  return new ErrorResponseImpl(
+    _nullishCoalesce(_optionalChain([data2, 'access', _61 => _61.init, 'optionalAccess', _62 => _62.status]), () => ( 500)),
+    _nullishCoalesce(_optionalChain([data2, 'access', _63 => _63.init, 'optionalAccess', _64 => _64.statusText]), () => ( "Internal Server Error")),
+    data2.data
+  );
+}
+function errorResponseToResponse(error) {
+  return new Response(
+    typeof error.data === "string" ? error.data : JSON.stringify(error.data),
+    {
+      status: error.status,
+      statusText: error.statusText
+    }
+  );
+}
 function isDataStrategyResult(result) {
   return result != null && typeof result === "object" && "type" in result && "result" in result && (result.type === "data" /* data */ || result.type === "error" /* error */);
 }
@@ -5637,7 +5722,7 @@ function getTurboStreamSingleFetchDataStrategy(getRouter, manifest, routeModules
       return {
         hasLoader: manifestRoute.hasLoader,
         hasClientLoader: manifestRoute.hasClientLoader,
-        hasShouldRevalidate: Boolean(_optionalChain([routeModule, 'optionalAccess', _61 => _61.shouldRevalidate]))
+        hasShouldRevalidate: Boolean(_optionalChain([routeModule, 'optionalAccess', _65 => _65.shouldRevalidate]))
       };
     },
     fetchAndDecodeViaTurboStream,
@@ -5804,6 +5889,12 @@ async function bubbleMiddlewareErrors(singleFetchPromise, matches, routesParams,
           let routeResult = fetchedData.routes[match.route.id];
           if ("error" in routeResult) {
             middlewareError = routeResult.error;
+            if (_optionalChain([results, 'access', _66 => _66[match.route.id], 'optionalAccess', _67 => _67.result]) == null) {
+              results[match.route.id] = {
+                type: "error",
+                result: middlewareError
+              };
+            }
             break;
           }
         }
@@ -5911,7 +6002,7 @@ async function fetchAndDecodeViaTurboStream(args, basename, targetRoutes) {
       }
     } else {
       let typed = decoded.value;
-      let routeId = _optionalChain([targetRoutes, 'optionalAccess', _62 => _62[0]]);
+      let routeId = _optionalChain([targetRoutes, 'optionalAccess', _68 => _68[0]]);
       invariant2(routeId, "No routeId found for single fetch call decoding");
       if ("redirect" in typed) {
         data2 = { redirect: typed };
@@ -6222,7 +6313,7 @@ Please change the parent <Route path="${parentPath}"> to <Route path="${parentPa
   if (locationArg) {
     let parsedLocationArg = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
     invariant(
-      parentPathnameBase === "/" || _optionalChain([parsedLocationArg, 'access', _63 => _63.pathname, 'optionalAccess', _64 => _64.startsWith, 'call', _65 => _65(parentPathnameBase)]),
+      parentPathnameBase === "/" || _optionalChain([parsedLocationArg, 'access', _69 => _69.pathname, 'optionalAccess', _70 => _70.startsWith, 'call', _71 => _71(parentPathnameBase)]),
       `When overriding the location using \`<Routes location>\` or \`useRoutes(routes, location)\`, the location pathname must begin with the portion of the URL pathname that was matched by all parent routes. The current pathname base is "${parentPathnameBase}" but pathname "${parsedLocationArg.pathname}" was given in the \`location\` prop.`
     );
     location = parsedLocationArg;
@@ -6370,10 +6461,10 @@ function _renderMatches(matches, parentMatches = [], dataRouterState = null, fut
     }
   }
   let renderedMatches = matches;
-  let errors = _optionalChain([dataRouterState, 'optionalAccess', _66 => _66.errors]);
+  let errors = _optionalChain([dataRouterState, 'optionalAccess', _72 => _72.errors]);
   if (errors != null) {
     let errorIndex = renderedMatches.findIndex(
-      (m) => m.route.id && _optionalChain([errors, 'optionalAccess', _67 => _67[m.route.id]]) !== void 0
+      (m) => m.route.id && _optionalChain([errors, 'optionalAccess', _73 => _73[m.route.id]]) !== void 0
     );
     invariant(
       errorIndex >= 0,
@@ -6550,15 +6641,15 @@ function useRouteError() {
   if (error !== void 0) {
     return error;
   }
-  return _optionalChain([state, 'access', _68 => _68.errors, 'optionalAccess', _69 => _69[routeId]]);
+  return _optionalChain([state, 'access', _74 => _74.errors, 'optionalAccess', _75 => _75[routeId]]);
 }
 function useAsyncValue() {
   let value = React3.useContext(AwaitContext);
-  return _optionalChain([value, 'optionalAccess', _70 => _70._data]);
+  return _optionalChain([value, 'optionalAccess', _76 => _76._data]);
 }
 function useAsyncError() {
   let value = React3.useContext(AwaitContext);
-  return _optionalChain([value, 'optionalAccess', _71 => _71._error]);
+  return _optionalChain([value, 'optionalAccess', _77 => _77._error]);
 }
 var blockerId = 0;
 function useBlocker(shouldBlock) {
@@ -6670,7 +6761,7 @@ function getKeyedLinksForMatches(matches, routeModules, manifest) {
     let route = manifest.routes[match.route.id];
     return [
       route && route.css ? route.css.map((href) => ({ rel: "stylesheet", href })) : [],
-      _optionalChain([module, 'optionalAccess', _72 => _72.links, 'optionalCall', _73 => _73()]) || []
+      _optionalChain([module, 'optionalAccess', _78 => _78.links, 'optionalCall', _79 => _79()]) || []
     ];
   }).flat(2);
   let preloads = getModuleLinkHrefs(matches, manifest);
@@ -6771,7 +6862,7 @@ function getNewMatchesForLinks(page, nextMatches, currentMatches, manifest, loca
       // param change, /users/123 -> /users/456
       currentMatches[index].pathname !== match.pathname || // splat param changed, which is not present in match.path
       // e.g. /files/images/avatar.jpg -> files/finances.xls
-      _optionalChain([currentMatches, 'access', _74 => _74[index], 'access', _75 => _75.route, 'access', _76 => _76.path, 'optionalAccess', _77 => _77.endsWith, 'call', _78 => _78("*")]) && currentMatches[index].params["*"] !== match.params["*"]
+      _optionalChain([currentMatches, 'access', _80 => _80[index], 'access', _81 => _81.route, 'access', _82 => _82.path, 'optionalAccess', _83 => _83.endsWith, 'call', _84 => _84("*")]) && currentMatches[index].params["*"] !== match.params["*"]
     );
   };
   if (mode === "assets") {
@@ -6794,7 +6885,7 @@ function getNewMatchesForLinks(page, nextMatches, currentMatches, manifest, loca
             location.pathname + location.search + location.hash,
             window.origin
           ),
-          currentParams: _optionalChain([currentMatches, 'access', _79 => _79[0], 'optionalAccess', _80 => _80.params]) || {},
+          currentParams: _optionalChain([currentMatches, 'access', _85 => _85[0], 'optionalAccess', _86 => _86.params]) || {},
           nextUrl: new URL(page, window.origin),
           nextParams: match.params,
           defaultShouldRevalidate: true
@@ -7066,10 +7157,10 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
         )
       });
       let hasInitialData = initialState && initialState.loaderData && route.id in initialState.loaderData;
-      let initialData = hasInitialData ? _optionalChain([initialState, 'optionalAccess', _81 => _81.loaderData, 'optionalAccess', _82 => _82[route.id]]) : void 0;
+      let initialData = hasInitialData ? _optionalChain([initialState, 'optionalAccess', _87 => _87.loaderData, 'optionalAccess', _88 => _88[route.id]]) : void 0;
       let hasInitialError = initialState && initialState.errors && route.id in initialState.errors;
-      let initialError = hasInitialError ? _optionalChain([initialState, 'optionalAccess', _83 => _83.errors, 'optionalAccess', _84 => _84[route.id]]) : void 0;
-      let isHydrationRequest = needsRevalidation == null && (_optionalChain([routeModule, 'access', _85 => _85.clientLoader, 'optionalAccess', _86 => _86.hydrate]) === true || !route.hasLoader);
+      let initialError = hasInitialError ? _optionalChain([initialState, 'optionalAccess', _89 => _89.errors, 'optionalAccess', _90 => _90[route.id]]) : void 0;
+      let isHydrationRequest = needsRevalidation == null && (_optionalChain([routeModule, 'access', _91 => _91.clientLoader, 'optionalAccess', _92 => _92.hydrate]) === true || !route.hasLoader);
       dataRoute.loader = async ({ request, params, context }, singleFetch) => {
         try {
           let result = await prefetchStylesAndCallHandler(async () => {
@@ -7366,7 +7457,7 @@ function getPatchRoutesOnNavigationFunction(manifest, routeModules, ssr, routeDi
 function useFogOFWarDiscovery(router, manifest, routeModules, ssr, routeDiscovery, isSpaMode) {
   React6.useEffect(() => {
     if (!isFogOfWarEnabled(routeDiscovery, ssr) || // @ts-expect-error - TS doesn't know about this yet
-    _optionalChain([window, 'access', _87 => _87.navigator, 'optionalAccess', _88 => _88.connection, 'optionalAccess', _89 => _89.saveData]) === true) {
+    _optionalChain([window, 'access', _93 => _93.navigator, 'optionalAccess', _94 => _94.connection, 'optionalAccess', _95 => _95.saveData]) === true) {
       return;
     }
     function registerElement(el) {
@@ -7428,12 +7519,14 @@ function getManifestPath(_manifestPath, basename) {
 }
 var MANIFEST_VERSION_STORAGE_KEY = "react-router-manifest-version";
 async function fetchAndApplyManifestPatches(paths, errorReloadPath, manifest, routeModules, ssr, isSpaMode, basename, manifestPath, patchRoutes, signal) {
+  const searchParams = new URLSearchParams();
+  paths.sort().forEach((path) => searchParams.append("p", path));
+  searchParams.set("version", manifest.version);
   let url = new URL(
     getManifestPath(manifestPath, basename),
     window.location.origin
   );
-  paths.sort().forEach((path) => url.searchParams.append("p", path));
-  url.searchParams.set("version", manifest.version);
+  url.search = searchParams.toString();
   if (url.toString().length > URL_LIMIT) {
     nextPaths.clear();
     return;
@@ -7467,7 +7560,7 @@ async function fetchAndApplyManifestPatches(paths, errorReloadPath, manifest, ro
     sessionStorage.removeItem(MANIFEST_VERSION_STORAGE_KEY);
     serverPatches = await res.json();
   } catch (e) {
-    if (_optionalChain([signal, 'optionalAccess', _90 => _90.aborted])) return;
+    if (_optionalChain([signal, 'optionalAccess', _96 => _96.aborted])) return;
     throw e;
   }
   let knownRoutes = new Set(Object.keys(manifest.routes));
@@ -7611,7 +7704,7 @@ function getActiveMatches(matches, errors, isSpaMode) {
   return matches;
 }
 var CRITICAL_CSS_DATA_ATTRIBUTE = "data-react-router-critical-css";
-function Links() {
+function Links({ nonce }) {
   let { isSpaMode, manifest, routeModules, criticalCss } = useFrameworkContext();
   let { errors, matches: routerMatches } = useDataRouterStateContext();
   let matches = getActiveMatches(routerMatches, errors, isSpaMode);
@@ -7630,10 +7723,11 @@ function Links() {
     {
       ...{ [CRITICAL_CSS_DATA_ATTRIBUTE]: "" },
       rel: "stylesheet",
-      href: criticalCss.href
+      href: criticalCss.href,
+      nonce
     }
   ) : null, keyedLinks.map(
-    ({ key, link }) => isPageLinkDescriptor(link) ? /* @__PURE__ */ React7.createElement(PrefetchPageLinks, { key, ...link }) : /* @__PURE__ */ React7.createElement("link", { key, ...link })
+    ({ key, link }) => isPageLinkDescriptor(link) ? /* @__PURE__ */ React7.createElement(PrefetchPageLinks, { key, nonce, ...link }) : /* @__PURE__ */ React7.createElement("link", { key, nonce, ...link })
   ));
 }
 function PrefetchPageLinks({ page, ...linkProps }) {
@@ -7707,7 +7801,7 @@ function PrefetchPageLinksImpl({
       if (!manifestRoute || !manifestRoute.hasLoader) {
         return;
       }
-      if (!newMatchesForData.some((m2) => m2.route.id === m.route.id) && m.route.id in loaderData && _optionalChain([routeModules, 'access', _91 => _91[m.route.id], 'optionalAccess', _92 => _92.shouldRevalidate])) {
+      if (!newMatchesForData.some((m2) => m2.route.id === m.route.id) && m.route.id in loaderData && _optionalChain([routeModules, 'access', _97 => _97[m.route.id], 'optionalAccess', _98 => _98.shouldRevalidate])) {
         foundOptOutRoute = true;
       } else if (manifestRoute.hasClientLoader) {
         foundOptOutRoute = true;
@@ -7744,7 +7838,7 @@ function PrefetchPageLinksImpl({
   return /* @__PURE__ */ React7.createElement(React7.Fragment, null, dataHrefs.map((href) => /* @__PURE__ */ React7.createElement("link", { key: href, rel: "prefetch", as: "fetch", href, ...linkProps })), moduleHrefs.map((href) => /* @__PURE__ */ React7.createElement("link", { key: href, rel: "modulepreload", href, ...linkProps })), keyedPrefetchLinks.map(({ key, link }) => (
     // these don't spread `linkProps` because they are full link descriptors
     // already with their own props
-    /* @__PURE__ */ React7.createElement("link", { key, ...link })
+    /* @__PURE__ */ React7.createElement("link", { key, nonce: linkProps.nonce, ...link })
   )));
 }
 function Meta() {
@@ -7773,6 +7867,7 @@ function Meta() {
     let match = {
       id: routeId,
       data: data2,
+      loaderData: data2,
       meta: [],
       params: _match.params,
       pathname: _match.pathname,
@@ -7780,9 +7875,10 @@ function Meta() {
       error
     };
     matches[i] = match;
-    if (_optionalChain([routeModule, 'optionalAccess', _93 => _93.meta])) {
+    if (_optionalChain([routeModule, 'optionalAccess', _99 => _99.meta])) {
       routeMeta = typeof routeModule.meta === "function" ? routeModule.meta({
         data: data2,
+        loaderData: data2,
         params,
         location,
         matches,
@@ -7875,7 +7971,7 @@ function Scripts(scriptProps) {
     }
     let streamScript = "window.__reactRouterContext.stream = new ReadableStream({start(controller){window.__reactRouterContext.streamController = controller;}}).pipeThrough(new TextEncoderStream());";
     let contextScript = staticContext ? `window.__reactRouterContext = ${serverHandoffString};${streamScript}` : " ";
-    let routeModulesScript = !isStatic ? " " : `${_optionalChain([manifest, 'access', _94 => _94.hmr, 'optionalAccess', _95 => _95.runtime]) ? `import ${JSON.stringify(manifest.hmr.runtime)};` : ""}${!enableFogOfWar ? `import ${JSON.stringify(manifest.url)}` : ""};
+    let routeModulesScript = !isStatic ? " " : `${_optionalChain([manifest, 'access', _100 => _100.hmr, 'optionalAccess', _101 => _101.runtime]) ? `import ${JSON.stringify(manifest.hmr.runtime)};` : ""}${!enableFogOfWar ? `import ${JSON.stringify(manifest.url)}` : ""};
 ${matches.map((match, routeIndex) => {
       let routeVarName = `route${routeIndex}`;
       let manifestEntry = manifest.routes[match.route.id];
@@ -8105,7 +8201,7 @@ function BoundaryShell({
   children
 }) {
   let { routeModules } = useFrameworkContext();
-  if (_optionalChain([routeModules, 'access', _96 => _96.root, 'optionalAccess', _97 => _97.Layout]) && !isOutsideRemixApp) {
+  if (_optionalChain([routeModules, 'access', _102 => _102.root, 'optionalAccess', _103 => _103.Layout]) && !isOutsideRemixApp) {
     return children;
   }
   return /* @__PURE__ */ React8.createElement("html", { lang: "en" }, /* @__PURE__ */ React8.createElement("head", null, /* @__PURE__ */ React8.createElement("meta", { charSet: "utf-8" }), /* @__PURE__ */ React8.createElement(