react-router 7.0.0-pre.1 → 7.0.0-pre.2

package/dist/umd/react-router.development.js

@@ -1,5 +1,5 @@
 /**
- * React Router v7.0.0-pre.1
+ * React Router v7.0.0-pre.2
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -310,7 +310,7 @@
         pathname = "/",
         search = "",
         hash = ""
-      } = parsePath(window.location.hash.substr(1));
+      } = parsePath(window.location.hash.substring(1));
 
       // Hash URL should always have a leading / just like window.location.pathname
       // does, so if an app ends up at a route like /#something then we add a
@@ -373,7 +373,7 @@
     }
   }
   function createKey$1() {
-    return Math.random().toString(36).substr(2, 8);
+    return Math.random().toString(36).substring(2, 10);
   }
 
   /**
@@ -435,13 +435,13 @@
     if (path) {
       let hashIndex = path.indexOf("#");
       if (hashIndex >= 0) {
-        parsedPath.hash = path.substr(hashIndex);
-        path = path.substr(0, hashIndex);
+        parsedPath.hash = path.substring(hashIndex);
+        path = path.substring(0, hashIndex);
       }
       let searchIndex = path.indexOf("?");
       if (searchIndex >= 0) {
-        parsedPath.search = path.substr(searchIndex);
-        path = path.substr(0, searchIndex);
+        parsedPath.search = path.substring(searchIndex);
+        path = path.substring(0, searchIndex);
       }
       if (path) {
         parsedPath.pathname = path;
@@ -1335,28 +1335,6 @@
    * @private
    */
   const normalizeHash = hash => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
-
-  /**
-   * This is a shortcut for creating `application/json` responses. Converts `data`
-   * to JSON and sets the `Content-Type` header.
-   *
-   * @category Utils
-   */
-  const json$1 = function json(data, init) {
-    if (init === void 0) {
-      init = {};
-    }
-    let responseInit = typeof init === "number" ? {
-      status: init
-    } : init;
-    let headers = new Headers(responseInit.headers);
-    if (!headers.has("Content-Type")) {
-      headers.set("Content-Type", "application/json; charset=utf-8");
-    }
-    return new Response(JSON.stringify(data), _extends({}, responseInit, {
-      headers
-    }));
-  };
   class DataWithResponseInit {
     constructor(data, init) {
       this.type = "DataWithResponseInit";
@@ -1376,6 +1354,10 @@
       status: init
     } : init);
   }
+
+  // This is now only used by the Await component and will eventually probably
+  // go away in favor of the format used by `React.use`
+
   /**
    * A redirect response. Sets the status code and the `Location` header.
    * Defaults to "302 Found".
@@ -1564,7 +1546,7 @@
   const validMutationMethods = new Set(validMutationMethodsArr);
   const validRequestMethodsArr = ["GET", ...validMutationMethodsArr];
   const validRequestMethods = new Set(validRequestMethodsArr);
-  const redirectStatusCodes$1 = new Set([301, 302, 303, 307, 308]);
+  const redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
   const redirectPreserveMethodStatusCodes = new Set([307, 308]);
   const IDLE_NAVIGATION = {
     state: "idle",
@@ -3083,7 +3065,7 @@
         return dataResults;
       }
       for (let [routeId, result] of Object.entries(results)) {
-        if (isRedirectDataStrategyResultResult(result)) {
+        if (isRedirectDataStrategyResult(result)) {
           let response = result.result;
           dataResults[routeId] = {
             type: ResultType.redirect,
@@ -3096,8 +3078,6 @@
       return dataResults;
     }
     async function callLoadersAndMaybeResolveData(state, matches, matchesToLoad, fetchersToLoad, request) {
-      state.matches;
-
       // Kick off loaders and fetchers in parallel
       let loaderResultsPromise = callDataStrategy("loader", state, request, matchesToLoad, matches, null);
       let fetcherResultsPromise = Promise.all(fetchersToLoad.map(async f => {
@@ -3609,7 +3589,7 @@
         };
       }
       let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, skipLoaderErrorBubbling === true, null);
-      if (isResponse$2(result)) {
+      if (isResponse(result)) {
         return result;
       }
 
@@ -3682,7 +3662,7 @@
         });
       }
       let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, false, match);
-      if (isResponse$2(result)) {
+      if (isResponse(result)) {
         return result;
       }
       let error = result.errors ? Object.values(result.errors)[0] : undefined;
@@ -3711,7 +3691,7 @@
           return result;
         }
         let result = await loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch);
-        return isResponse$2(result) ? result : _extends({}, result, {
+        return isResponse(result) ? result : _extends({}, result, {
           actionData: null,
           actionHeaders: {}
         });
@@ -3719,7 +3699,7 @@
         // If the user threw/returned a Response in callLoaderOrAction for a
         // `queryRoute` call, we throw the `DataStrategyResult` to bail out early
         // and then return or throw the raw Response here accordingly
-        if (isDataStrategyResult(e) && isResponse$2(e.result)) {
+        if (isDataStrategyResult(e) && isResponse(e.result)) {
           if (e.type === ResultType.error) {
             throw e.result;
           }
@@ -3727,7 +3707,7 @@
         }
         // Redirects are always returned since they don't propagate to catch
         // boundaries
-        if (isRedirectResponse$1(e)) {
+        if (isRedirectResponse(e)) {
           return e;
         }
         throw e;
@@ -3881,12 +3861,12 @@
           return;
         }
         let result = results[match.route.id];
-        if (isRedirectDataStrategyResultResult(result)) {
+        if (isRedirectDataStrategyResult(result)) {
           let response = result.result;
           // Throw redirects and let the server handle them with an HTTP redirect
           throw normalizeRelativeRoutingRedirectResponse(response, request, match.route.id, matches, basename);
         }
-        if (isResponse$2(result.result) && isRouteRequest) {
+        if (isResponse(result.result) && isRouteRequest) {
           // For SSR single-route requests, we want to hand Responses back
           // directly without unwrapping
           throw result;
@@ -4597,7 +4577,7 @@
       result,
       type
     } = dataStrategyResult;
-    if (isResponse$2(result)) {
+    if (isResponse(result)) {
       let data;
       try {
         let contentType = result.headers.get("Content-Type");
@@ -5009,8 +4989,8 @@
   function isDataStrategyResult(result) {
     return result != null && typeof result === "object" && "type" in result && "result" in result && (result.type === ResultType.data || result.type === ResultType.error);
   }
-  function isRedirectDataStrategyResultResult(result) {
-    return isResponse$2(result.result) && redirectStatusCodes$1.has(result.result.status);
+  function isRedirectDataStrategyResult(result) {
+    return isResponse(result.result) && redirectStatusCodes.has(result.result.status);
   }
   function isErrorResult(result) {
     return result.type === ResultType.error;
@@ -5021,16 +5001,14 @@
   function isDataWithResponseInit(value) {
     return typeof value === "object" && value != null && "type" in value && "data" in value && "init" in value && value.type === "DataWithResponseInit";
   }
-  function isResponse$2(value) {
+  function isResponse(value) {
     return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
   }
-  function isRedirectResponse$1(result) {
-    if (!isResponse$2(result)) {
-      return false;
-    }
-    let status = result.status;
-    let location = result.headers.get("Location");
-    return status >= 300 && status <= 399 && location != null;
+  function isRedirectStatusCode(statusCode) {
+    return redirectStatusCodes.has(statusCode);
+  }
+  function isRedirectResponse(result) {
+    return isResponse(result) && isRedirectStatusCode(result.status) && result.headers.has("Location");
   }
   function isValidMethod(method) {
     return validRequestMethods.has(method.toUpperCase());
@@ -6473,8 +6451,8 @@
     let setState = React__namespace.useCallback((newState, _ref2) => {
       let {
         deletedFetchers,
-        flushSync: flushSync,
-        viewTransitionOpts: viewTransitionOpts
+        flushSync,
+        viewTransitionOpts
       } = _ref2;
       deletedFetchers.forEach(key => fetcherData.current.delete(key));
       newState.fetchers.forEach((fetcher, key) => {
@@ -7376,7 +7354,56 @@
    * @see https://remix.run/route/meta
    */
 
-  // Loose copy from @react-router/server-runtime to avoid circular imports
+  /**
+   * A function that returns an array of data objects to use for rendering
+   * metadata HTML tags in a route. These tags are not rendered on descendant
+   * routes in the route hierarchy. In other words, they will only be rendered on
+   * the route in which they are exported.
+   *
+   * @param Loader - The type of the current route's loader function
+   * @param MatchLoaders - Mapping from a parent route's filepath to its loader
+   * function type
+   *
+   * Note that parent route filepaths are relative to the `app/` directory.
+   *
+   * For example, if this meta function is for `/sales/customers/$customerId`:
+   *
+   * ```ts
+   * // app/root.tsx
+   * const loader = () => ({ hello: "world" })
+   * export type Loader = typeof loader
+   *
+   * // app/routes/sales.tsx
+   * const loader = () => ({ salesCount: 1074 })
+   * export type Loader = typeof loader
+   *
+   * // app/routes/sales/customers.tsx
+   * const loader = () => ({ customerCount: 74 })
+   * export type Loader = typeof loader
+   *
+   * // app/routes/sales/customers/$customersId.tsx
+   * import type { Loader as RootLoader } from "../../../root"
+   * import type { Loader as SalesLoader } from "../../sales"
+   * import type { Loader as CustomersLoader } from "../../sales/customers"
+   *
+   * const loader = () => ({ name: "Customer name" })
+   *
+   * const meta: MetaFunction<typeof loader, {
+   *  "root": RootLoader,
+   *  "routes/sales": SalesLoader,
+   *  "routes/sales/customers": CustomersLoader,
+   * }> = ({ data, matches }) => {
+   *   const { name } = data
+   *   //      ^? string
+   *   const { customerCount } = matches.find((match) => match.id === "routes/sales/customers").data
+   *   //      ^? number
+   *   const { salesCount } = matches.find((match) => match.id === "routes/sales").data
+   *   //      ^? number
+   *   const { hello } = matches.find((match) => match.id === "root").data
+   *   //      ^? "world"
+   * }
+   * ```
+   */
 
   /**
    * A React component that is rendered for a route.
@@ -7433,7 +7460,7 @@
     let descriptors = matches.map(match => {
       let module = routeModules[match.route.id];
       let route = manifest.routes[match.route.id];
-      return [route.css ? route.css.map(href => ({
+      return [route && route.css ? route.css.map(href => ({
         rel: "stylesheet",
         href
       })) : [], (module == null || module.links == null ? void 0 : module.links()) || []];
@@ -7512,8 +7539,12 @@
   }
   async function getKeyedPrefetchLinks(matches, manifest, routeModules) {
     let links = await Promise.all(matches.map(async match => {
-      let mod = await loadRouteModule(manifest.routes[match.route.id], routeModules);
-      return mod.links ? mod.links() : [];
+      let route = manifest.routes[match.route.id];
+      if (route) {
+        let mod = await loadRouteModule(route, routeModules);
+        return mod.links ? mod.links() : [];
+      }
+      return [];
     }));
     return dedupeLinkDescriptors(links.flat(1).filter(isHtmlLinkDescriptor).filter(link => link.rel === "stylesheet" || link.rel === "preload").map(link => link.rel === "stylesheet" ? _extends({}, link, {
       rel: "prefetch",
@@ -7525,7 +7556,6 @@
 
   // This is ridiculously identical to transition.ts `filterMatchesToLoad`
   function getNewMatchesForLinks(page, nextMatches, currentMatches, manifest, location, mode) {
-    let path = parsePathPatch(page);
     let isNew = (match, index) => {
       if (!currentMatches[index]) return true;
       return match.route.id !== currentMatches[index].route.id;
@@ -7540,43 +7570,45 @@
         ((_currentMatches$index = currentMatches[index].route.path) == null ? void 0 : _currentMatches$index.endsWith("*")) && currentMatches[index].params["*"] !== match.params["*"]
       );
     };
+    if (mode === "assets") {
+      return nextMatches.filter((match, index) => isNew(match, index) || matchPathChanged(match, index));
+    }
 
-    // NOTE: keep this mostly up-to-date w/ the transition data diff, but this
+    // NOTE: keep this mostly up-to-date w/ the router data diff, but this
     // version doesn't care about submissions
-    let newMatches = mode === "data" && location.search !== path.search ?
-    // this is really similar to stuff in transition.ts, maybe somebody smarter
+    // TODO: this is really similar to stuff in router.ts, maybe somebody smarter
     // than me (or in less of a hurry) can share some of it. You're the best.
-    nextMatches.filter((match, index) => {
-      let manifestRoute = manifest.routes[match.route.id];
-      if (!manifestRoute.hasLoader) {
-        return false;
-      }
-      if (isNew(match, index) || matchPathChanged(match, index)) {
-        return true;
-      }
-      if (match.route.shouldRevalidate) {
-        var _currentMatches$;
-        let routeChoice = match.route.shouldRevalidate({
-          currentUrl: new URL(location.pathname + location.search + location.hash, window.origin),
-          currentParams: ((_currentMatches$ = currentMatches[0]) == null ? void 0 : _currentMatches$.params) || {},
-          nextUrl: new URL(page, window.origin),
-          nextParams: match.params,
-          defaultShouldRevalidate: true
-        });
-        if (typeof routeChoice === "boolean") {
-          return routeChoice;
+    if (mode === "data") {
+      return nextMatches.filter((match, index) => {
+        let manifestRoute = manifest.routes[match.route.id];
+        if (!manifestRoute || !manifestRoute.hasLoader) {
+          return false;
         }
-      }
-      return true;
-    }) : nextMatches.filter((match, index) => {
-      let manifestRoute = manifest.routes[match.route.id];
-      return (mode === "assets" || manifestRoute.hasLoader) && (isNew(match, index) || matchPathChanged(match, index));
-    });
-    return newMatches;
+        if (isNew(match, index) || matchPathChanged(match, index)) {
+          return true;
+        }
+        if (match.route.shouldRevalidate) {
+          var _currentMatches$;
+          let routeChoice = match.route.shouldRevalidate({
+            currentUrl: new URL(location.pathname + location.search + location.hash, window.origin),
+            currentParams: ((_currentMatches$ = currentMatches[0]) == null ? void 0 : _currentMatches$.params) || {},
+            nextUrl: new URL(page, window.origin),
+            nextParams: match.params,
+            defaultShouldRevalidate: true
+          });
+          if (typeof routeChoice === "boolean") {
+            return routeChoice;
+          }
+        }
+        return true;
+      });
+    }
+    return [];
   }
   function getModuleLinkHrefs(matches, manifestPatch) {
     return dedupeHrefs(matches.map(match => {
       let route = manifestPatch.routes[match.route.id];
+      if (!route) return [];
       let hrefs = [route.module];
       if (route.imports) {
         hrefs = hrefs.concat(route.imports);
@@ -7591,6 +7623,7 @@
   function getCurrentPageModulePreloadHrefs(matches, manifest) {
     return dedupeHrefs(matches.map(match => {
       let route = manifest.routes[match.route.id];
+      if (!route) return [];
       let hrefs = [route.module];
       if (route.imports) {
         hrefs = hrefs.concat(route.imports);
@@ -7629,13 +7662,6 @@
     }, []);
   }
 
-  // https://github.com/remix-run/history/issues/897
-  function parsePathPatch(href) {
-    let path = parsePath(href);
-    if (path.search === undefined) path.search = "";
-    return path;
-  }
-
   // Detect if this browser supports <link rel="preload"> (or has it enabled).
   // Originally added to handle the firefox `network.preload` config:
   //   https://bugzilla.mozilla.org/show_bug.cgi?id=1847811
@@ -7673,13 +7699,6 @@
     };
   }
 
-  /**
-   * Data for a route that was returned from a `loader()`.
-   */
-
-  function isResponse$1(value) {
-    return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
-  }
   async function createRequestInit(request) {
     let init = {
       signal: request.signal
@@ -7818,7 +7837,7 @@
       });
       return result;
     });
-    if (isResponse$1(result.result) || isRouteErrorResponse(result.result)) {
+    if (isResponse(result.result) || isRouteErrorResponse(result.result)) {
       return {
         [actionMatch.route.id]: result
       };
@@ -7863,6 +7882,7 @@
     let results = {};
     let resolvePromise = Promise.all(matches.map(async (m, i) => m.resolve(async handler => {
       routeDfds[i].resolve();
+      let manifestRoute = manifest.routes[m.route.id];
       if (!m.shouldLoad) {
         var _routeModules$m$route;
         // If we're not yet initialized and this is the initial load, respect
@@ -7875,7 +7895,7 @@
         // Otherwise, we opt out if we currently have data, a `loader`, and a
         // `shouldRevalidate` function.  This implies that the user opted out
         // via `shouldRevalidate`
-        if (m.route.id in router.state.loaderData && manifest.routes[m.route.id].hasLoader && (_routeModules$m$route = routeModules[m.route.id]) != null && _routeModules$m$route.shouldRevalidate) {
+        if (m.route.id in router.state.loaderData && manifestRoute && manifestRoute.hasLoader && (_routeModules$m$route = routeModules[m.route.id]) != null && _routeModules$m$route.shouldRevalidate) {
           foundOptOutRoute = true;
           return;
         }
@@ -7883,8 +7903,8 @@
 
       // When a route has a client loader, it opts out of the singular call and
       // calls it's server loader via `serverLoader()` using a `?_routes` param
-      if (manifest.routes[m.route.id].hasClientLoader) {
-        if (manifest.routes[m.route.id].hasLoader) {
+      if (manifestRoute && manifestRoute.hasClientLoader) {
+        if (manifestRoute.hasLoader) {
           foundOptOutRoute = true;
         }
         try {
@@ -7903,7 +7923,7 @@
       }
 
       // Load this route on the server if it has a loader
-      if (manifest.routes[m.route.id].hasLoader) {
+      if (manifestRoute && manifestRoute.hasLoader) {
         routesParams.add(m.route.id);
       }
 
@@ -8295,20 +8315,18 @@
     }));
   }
 
-  // NOTE: make sure to change the Route in server-runtime if you change this
-
-  // NOTE: make sure to change the EntryRoute in server-runtime if you change this
-
   // Create a map of routes by parentId to use recursively instead of
   // repeatedly filtering the manifest.
   function groupRoutesByParentId$1(manifest) {
     let routes = {};
     Object.values(manifest).forEach(route => {
-      let parentId = route.parentId || "";
-      if (!routes[parentId]) {
-        routes[parentId] = [];
+      if (route) {
+        let parentId = route.parentId || "";
+        if (!routes[parentId]) {
+          routes[parentId] = [];
+        }
+        routes[parentId].push(route);
       }
-      routes[parentId].push(route);
     });
     return routes;
   }
@@ -8448,7 +8466,7 @@
         // Use critical path modules directly
         Object.assign(dataRoute, _extends({}, dataRoute, getRouteComponents(route, routeModule, isSpaMode), {
           handle: routeModule.handle,
-          shouldRevalidate: needsRevalidation ? wrapShouldRevalidateForHdr(route.id, routeModule.shouldRevalidate, needsRevalidation) : routeModule.shouldRevalidate
+          shouldRevalidate: getShouldRevalidateFunction(routeModule, route.id, needsRevalidation)
         }));
         let hasInitialData = initialState && initialState.loaderData && route.id in initialState.loaderData;
         let initialData = hasInitialData ? initialState == null || (_initialState$loaderD = initialState.loaderData) == null ? void 0 : _initialState$loaderD[route.id] : undefined;
@@ -8567,16 +8585,13 @@
               }
             }));
           }
-          if (needsRevalidation) {
-            lazyRoute.shouldRevalidate = wrapShouldRevalidateForHdr(route.id, mod.shouldRevalidate, needsRevalidation);
-          }
           return _extends({}, lazyRoute.loader ? {
             loader: lazyRoute.loader
           } : {}, lazyRoute.action ? {
             action: lazyRoute.action
           } : {}, {
             hasErrorBoundary: lazyRoute.hasErrorBoundary,
-            shouldRevalidate: lazyRoute.shouldRevalidate,
+            shouldRevalidate: getShouldRevalidateFunction(lazyRoute, route.id, needsRevalidation),
             handle: lazyRoute.handle,
             // No need to wrap these in layout since the root route is never
             // loaded via route.lazy()
@@ -8590,6 +8605,22 @@
       return dataRoute;
     });
   }
+  function getShouldRevalidateFunction(route, routeId, needsRevalidation) {
+    // During HDR we force revalidation for updated routes
+    if (needsRevalidation) {
+      return wrapShouldRevalidateForHdr(routeId, route.shouldRevalidate, needsRevalidation);
+    }
+
+    // Single fetch revalidates by default, so override the RR default value which
+    // matches the multi-fetch behavior with `true`
+    if (route.shouldRevalidate) {
+      let fn = route.shouldRevalidate;
+      return opts => fn(_extends({}, opts, {
+        defaultShouldRevalidate: true
+      }));
+    }
+    return route.shouldRevalidate;
+  }
 
   // When an HMR / HDR update happens we opt out of all user-defined
   // revalidation logic and force a revalidation on the first call
@@ -8791,9 +8822,12 @@
 
     // Patch routes we don't know about yet into the manifest
     let knownRoutes = new Set(Object.keys(manifest.routes));
-    let patches = Object.values(serverPatches).reduce((acc, route) => !knownRoutes.has(route.id) ? Object.assign(acc, {
-      [route.id]: route
-    }) : acc, {});
+    let patches = Object.values(serverPatches).reduce((acc, route) => {
+      if (route && !knownRoutes.has(route.id)) {
+        acc[route.id] = route;
+      }
+      return acc;
+    }, {});
     Object.assign(manifest.routes, patches);
 
     // Track discovered paths so we don't have to fetch them again
@@ -8803,7 +8837,7 @@
     // in their new children
     let parentIds = new Set();
     Object.values(patches).forEach(patch => {
-      if (!patch.parentId || !patches[patch.parentId]) {
+      if (patch && (!patch.parentId || !patches[patch.parentId])) {
         parentIds.add(patch.parentId);
       }
     });
@@ -8833,9 +8867,6 @@
   const _excluded$2 = ["page"],
     _excluded2$1 = ["page", "matches"],
     _excluded3$1 = ["tagName"];
-
-  // TODO: Temporary shim until we figure out the way to handle typings in v7
-
   function useDataRouterContext$1() {
     let context = React__namespace.useContext(DataRouterContext);
     !context ? invariant$1(false, "You must render this element inside a <DataRouterContext.Provider> element")  : void 0;
@@ -9098,12 +9129,13 @@
       let foundOptOutRoute = false;
       nextMatches.forEach(m => {
         var _routeModules$m$route;
-        if (!manifest.routes[m.route.id].hasLoader) {
+        let manifestRoute = manifest.routes[m.route.id];
+        if (!manifestRoute || !manifestRoute.hasLoader) {
           return;
         }
         if (!newMatchesForData.some(m2 => m2.route.id === m.route.id) && m.route.id in loaderData && (_routeModules$m$route = routeModules[m.route.id]) != null && _routeModules$m$route.shouldRevalidate) {
           foundOptOutRoute = true;
-        } else if (manifest.routes[m.route.id].hasClientLoader) {
+        } else if (manifestRoute.hasClientLoader) {
           foundOptOutRoute = true;
         } else {
           routesParams.add(m.route.id);
@@ -9374,7 +9406,7 @@
     }, []);
     let routePreloads = matches.map(match => {
       let route = manifest.routes[match.route.id];
-      return (route.imports || []).concat([route.module]);
+      return route ? (route.imports || []).concat([route.module]) : [];
     }).flat(1);
     let preloads = isHydrated ? [] : manifest.entry.imports.concat(routePreloads);
     return isHydrated ? null : /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, !enableFogOfWar ? /*#__PURE__*/React__namespace.createElement("link", {
@@ -9414,7 +9446,6 @@
     _excluded2 = ["aria-current", "caseSensitive", "className", "end", "style", "to", "viewTransition", "children"],
     _excluded3 = ["discover", "fetcherKey", "navigate", "reloadDocument", "replace", "state", "method", "action", "onSubmit", "relative", "preventScrollReset", "viewTransition"],
     _excluded4 = ["getKey", "storageKey"];
-
   ////////////////////////////////////////////////////////////////////////////////
   //#region Global Stuff
   ////////////////////////////////////////////////////////////////////////////////
@@ -11092,7 +11123,7 @@
       // route opted into clientLoader hydration and either:
       // * gave us a HydrateFallback
       // * or doesn't have a server loader and we have no data to render
-      if (route && shouldHydrateRouteLoader(manifestRoute, route, context.isSpaMode) && (route.HydrateFallback || !manifestRoute.hasLoader)) {
+      if (route && manifestRoute && shouldHydrateRouteLoader(manifestRoute, route, context.isSpaMode) && (route.HydrateFallback || !manifestRoute.hasLoader)) {
         delete context.staticHandlerContext.loaderData[routeId];
       }
     }
@@ -11309,7 +11340,17 @@
       async parse(cookieHeader, parseOptions) {
         if (!cookieHeader) return null;
         let cookies = cookie.parse(cookieHeader, _extends({}, options, parseOptions));
-        return name in cookies ? cookies[name] === "" ? "" : await decodeCookieValue(cookies[name], secrets) : null;
+        if (name in cookies) {
+          let value = cookies[name];
+          if (typeof value === "string" && value !== "") {
+            let decoded = await decodeCookieValue(value, secrets);
+            return decoded;
+          } else {
+            return "";
+          }
+        } else {
+          return null;
+        }
       },
       async serialize(value, serializeOptions) {
         return cookie.serialize(name, value === "" ? "" : await encodeCookieValue(value, secrets), _extends({}, options, serializeOptions));
@@ -11416,7 +11457,10 @@
 
   function createEntryRouteModules(manifest) {
     return Object.keys(manifest).reduce((memo, routeId) => {
-      memo[routeId] = manifest[routeId].module;
+      let route = manifest[routeId];
+      if (route) {
+        memo[routeId] = route.module;
+      }
       return memo;
     }, {});
   }
@@ -11540,32 +11584,6 @@
     }));
   }
 
-  // must be a type since this is a subtype of response
-  // interfaces must conform to the types they extend
-
-  /**
-   * This is a shortcut for creating `application/json` responses. Converts `data`
-   * to JSON and sets the `Content-Type` header.
-   *
-   * @see https://remix.run/utils/json
-   */
-  const json = function json(data, init) {
-    if (init === void 0) {
-      init = {};
-    }
-    return json$1(data, init);
-  };
-  function isResponse(value) {
-    return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
-  }
-  const redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
-  function isRedirectStatusCode(statusCode) {
-    return redirectStatusCodes.has(statusCode);
-  }
-  function isRedirectResponse(response) {
-    return isRedirectStatusCode(response.status);
-  }
-
   /**
    * An object of unknown type for route loaders and actions provided by the
    * server's `getLoadContext()` function.  This is defined as an empty interface
@@ -11573,10 +11591,6 @@
    * globally: https://www.typescriptlang.org/docs/handbook/declaration-merging.html
    */
 
-  /**
-   * Data for a route that was returned from a `loader()`.
-   */
-
   // Need to use RR's version here to permit the optional context even
   // though we know it'll always be provided in remix
   async function callRouteHandler(handler, args) {
@@ -11639,23 +11653,21 @@
 
   function invariant(value, message) {
     if (value === false || value === null || typeof value === "undefined") {
-      console.error("The following error is a bug in Remix; please open an issue! https://github.com/remix-run/remix/issues/new");
+      console.error("The following error is a bug in React Router; please open an issue! https://github.com/remix-run/react-router/issues/new/choose");
       throw new Error(message);
     }
   }
 
-  // NOTE: make sure to change the Route in remix-react/react-router-dev if you change this
-
-  // NOTE: make sure to change the EntryRoute in react-router/react-router-dev if you change this
-
   function groupRoutesByParentId(manifest) {
     let routes = {};
     Object.values(manifest).forEach(route => {
-      let parentId = route.parentId || "";
-      if (!routes[parentId]) {
-        routes[parentId] = [];
+      if (route) {
+        let parentId = route.parentId || "";
+        if (!routes[parentId]) {
+          routes[parentId] = [];
+        }
+        routes[parentId].push(route);
       }
-      routes[parentId].push(route);
     });
     return routes;
   }
@@ -11788,13 +11800,15 @@
       let {
         id
       } = match.route;
-      let routeModule = build.routes[id].module;
+      let route = build.routes[id];
+      !route ? invariant(false, "Route with id \"" + id + "\" not found in build")  : void 0;
+      let routeModule = route.module;
       let loaderHeaders = context.loaderHeaders[id] || new Headers();
       let actionHeaders = context.actionHeaders[id] || new Headers();
 
       // Only expose errorHeaders to the leaf headers() function to
       // avoid duplication via parentHeaders
-      let includeErrorHeaders = errorHeaders != undefined && idx === matches.length - 1;
+      let includeErrorHeaders = errorHeaders != null && idx === matches.length - 1;
       // Only prepend cookies from errorHeaders at the leaf renderable route
       // when it's not the same as loaderHeaders/actionHeaders to avoid
       // duplicate cookies
@@ -12226,15 +12240,18 @@
         if (matches) {
           for (let match of matches) {
             let routeId = match.route.id;
-            patches[routeId] = build.assets.routes[routeId];
+            let route = build.assets.routes[routeId];
+            if (route) {
+              patches[routeId] = route;
+            }
           }
         }
       }
-      return json(patches, {
+      return Response.json(patches, {
         headers: {
           "Cache-Control": "public, max-age=31536000, immutable"
         }
-      }); // Override the TypedResponse stuff from json()
+      });
     }
     return new Response("Invalid Request", {
       status: 400
@@ -12413,7 +12430,7 @@
     }
   }
   function errorResponseToJson(errorResponse, serverMode) {
-    return json$1(serializeError(
+    return Response.json(serializeError(
     // @ts-expect-error This is "private" from users but intended for internal use
     errorResponse.error || new Error("Unexpected Server Error"), serverMode), {
       status: errorResponse.status,
@@ -12770,7 +12787,6 @@
   exports.isCookie = isCookie;
   exports.isRouteErrorResponse = isRouteErrorResponse;
   exports.isSession = isSession;
-  exports.json = json$1;
   exports.matchPath = matchPath;
   exports.matchRoutes = matchRoutes;
   exports.parsePath = parsePath;