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

package/dist/index.mjs

@@ -1,5 +1,5 @@
 /**
- * React Router v7.0.0-pre.1
+ * React Router v7.0.0-pre.2
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -43,32 +43,69 @@ function _objectWithoutPropertiesLoose(source, excluded) {
 ////////////////////////////////////////////////////////////////////////////////
 //#region Types and Constants
 ////////////////////////////////////////////////////////////////////////////////
+
 /**
  * Actions represent the type of change to a location value.
  */
-var Action;
-(function (Action) {
-  /**
-   * A POP indicates a change to an arbitrary index in the history stack, such
-   * as a back or forward navigation. It does not describe the direction of the
-   * navigation, only that the current index changed.
-   *
-   * Note: This is the default action for newly created history objects.
-   */
+let Action = /*#__PURE__*/function (Action) {
   Action["Pop"] = "POP";
-  /**
-   * A PUSH indicates a new entry being added to the history stack, such as when
-   * a link is clicked and a new page loads. When this happens, all subsequent
-   * entries in the stack are lost.
-   */
   Action["Push"] = "PUSH";
-  /**
-   * A REPLACE indicates the entry at the current index in the history stack
-   * being replaced by a new one.
-   */
   Action["Replace"] = "REPLACE";
-})(Action || (Action = {}));
+  return Action;
+}({});
+
+/**
+ * The pathname, search, and hash values of a URL.
+ */
+
+// TODO: (v7) Change the Location generic default from `any` to `unknown` and
+// remove Remix `useLocation` wrapper.
+
+/**
+ * An entry in a history stack. A location contains information about the
+ * URL path, as well as possibly some arbitrary state and a key.
+ */
+
+/**
+ * A change to the current location.
+ */
+
+/**
+ * A function that receives notifications about location changes.
+ */
+
+/**
+ * Describes a location that is the destination of some navigation used in
+ * {@link Link}, {@link useNavigate}, etc.
+ */
+
+/**
+ * A history is an interface to the navigation stack. The history serves as the
+ * source of truth for the current location, as well as provides a set of
+ * methods that may be used to change it.
+ *
+ * It is similar to the DOM's `window.history` object, but with a smaller, more
+ * focused API.
+ */
+
 const PopStateEventType = "popstate";
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Memory History
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A user-supplied object that describes a location. Used when providing
+ * entries to `createMemoryHistory` via its `initialEntries` option.
+ */
+
+/**
+ * A memory history stores locations in memory. This is useful in stateful
+ * environments where there is no web browser, such as node tests or React
+ * Native.
+ */
+
 /**
  * Memory history stores the current location in memory. It is designed for use
  * in stateful non-browser environments like tests and React Native.
@@ -173,6 +210,20 @@ function createMemoryHistory(options) {
   };
   return history;
 }
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Browser History
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A browser history stores the current location in regular URLs in a web
+ * browser environment. This is the standard for most web apps and provides the
+ * cleanest URLs the browser's address bar.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory
+ */
+
 /**
  * Browser history stores the location in regular URLs. This is the standard for
  * most web apps, but it requires some configuration on the server to ensure you
@@ -203,6 +254,24 @@ function createBrowserHistory(options) {
   }
   return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);
 }
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Hash History
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A hash history stores the current location in the fragment identifier portion
+ * of the URL in a web browser environment.
+ *
+ * This is ideal for apps that do not control the server for some reason
+ * (because the fragment identifier is never sent to the server), including some
+ * shared hosting environments that do not provide fine-grained controls over
+ * which pages are served at which URLs.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory
+ */
+
 /**
  * Hash history stores the location in window.location.hash. This makes it ideal
  * for situations where you don't want to send the location to the server for
@@ -220,7 +289,8 @@ function createHashHistory(options) {
       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
     // leading slash so all of our path-matching behaves the same as if it would
@@ -253,6 +323,16 @@ function createHashHistory(options) {
   }
   return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);
 }
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region UTILS
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * @private
+ */
+
 function invariant$2(value, message) {
   if (value === false || value === null || typeof value === "undefined") {
     throw new Error(message);
@@ -272,8 +352,9 @@ function warning(cond, message) {
   }
 }
 function createKey$1() {
-  return Math.random().toString(36).substr(2, 8);
+  return Math.random().toString(36).substring(2, 10);
 }
+
 /**
  * For browser-based histories, we combine the state and key into an object
  */
@@ -284,6 +365,7 @@ function getHistoryState(location, index) {
     idx: index
   };
 }
+
 /**
  * Creates a Location object with a unique key from the given Path
  */
@@ -305,6 +387,7 @@ function createLocation(current, to, state, key) {
   });
   return location;
 }
+
 /**
  * Creates a string URL path from the given pathname, search, and hash components.
  *
@@ -320,6 +403,7 @@ function createPath(_ref) {
   if (hash && hash !== "#") pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
   return pathname;
 }
+
 /**
  * Parses a string URL path into its separate pathname, search, and hash components.
  *
@@ -330,13 +414,13 @@ function parsePath(path) {
   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;
@@ -391,6 +475,7 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
     index = getIndex() + 1;
     let historyState = getHistoryState(location, index);
     let url = history.createHref(location);
+
     // try...catch because iOS limits us to 100 pushState calls :/
     try {
       globalHistory.pushState(historyState, "", url);
@@ -482,18 +567,165 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
   };
   return history;
 }
+
 //#endregion
 
-var ResultType;
-(function (ResultType) {
+/**
+ * Map of routeId -> data returned from a loader/action/error
+ */
+
+let ResultType = /*#__PURE__*/function (ResultType) {
   ResultType["data"] = "data";
   ResultType["redirect"] = "redirect";
   ResultType["error"] = "error";
-})(ResultType || (ResultType = {}));
+  return ResultType;
+}({});
+
+/**
+ * Successful result from a loader or action
+ */
+
+/**
+ * Redirect result from a loader or action
+ */
+
+/**
+ * Unsuccessful result from a loader or action
+ */
+
+/**
+ * Result from a loader or action - potentially successful or unsuccessful
+ */
+
+/**
+ * Users can specify either lowercase or uppercase form methods on `<Form>`,
+ * useSubmit(), `<fetcher.Form>`, etc.
+ */
+
+/**
+ * Active navigation/fetcher form methods are exposed in uppercase on the
+ * RouterState. This is to align with the normalization done via fetch().
+ */
+
+// Thanks https://github.com/sindresorhus/type-fest!
+
+/**
+ * @private
+ * Internal interface to pass around for action submissions, not intended for
+ * external consumption
+ */
+
+/**
+ * @private
+ * Arguments passed to route loader/action functions.  Same for now but we keep
+ * this as a private implementation detail in case they diverge in the future.
+ */
+
+/**
+ * Arguments passed to loader functions
+ */
+
+/**
+ * Arguments passed to action functions
+ */
+
+/**
+ * Loaders and actions can return anything except `undefined` (`null` is a
+ * valid return value if there is no data to return).  Responses are preferred
+ * and will ease any future migration to Remix
+ */
+
+/**
+ * Route loader function signature
+ */
+
+/**
+ * Route action function signature
+ */
+
+/**
+ * Arguments passed to shouldRevalidate function
+ */
+
+/**
+ * Route shouldRevalidate function signature.  This runs after any submission
+ * (navigation or fetcher), so we flatten the navigation/fetcher submission
+ * onto the arguments.  It shouldn't matter whether it came from a navigation
+ * or a fetcher, what really matters is the URLs and the formData since loaders
+ * have to re-run based on the data models that were potentially mutated.
+ */
+
+/**
+ * Result from a loader or action called via dataStrategy
+ */
+
+/**
+ * Function provided by the framework-aware layers to set any framework-specific
+ * properties from framework-agnostic properties
+ */
+
+/**
+ * Keys we cannot change from within a lazy() function. We spread all other keys
+ * onto the route. Either they're meaningful to the router, or they'll get
+ * ignored.
+ */
+
 const immutableRouteKeys = new Set(["lazy", "caseSensitive", "path", "id", "index", "children"]);
+
+/**
+ * lazy() function to load a route definition, which can add non-matching
+ * related properties to a route
+ */
+
+/**
+ * Base RouteObject with common props shared by all types of routes
+ */
+
+/**
+ * Index routes must not have children
+ */
+
+/**
+ * Non-index routes may have children, but cannot have index
+ */
+
+/**
+ * A route object represents a logical route, with (optionally) its child
+ * routes organized in a tree-like structure.
+ */
+
+/**
+ * A data route object, which is just a RouteObject with a required unique ID
+ */
+
+// Recursive helper for finding path parameters in the absence of wildcards
+
+/**
+ * Examples:
+ * "/a/b/*" -> "*"
+ * ":a" -> "a"
+ * "/a/:b" -> "b"
+ * "/a/blahblahblah:b" -> "b"
+ * "/:a/:b" -> "a" | "b"
+ * "/:a/b/:c/*" -> "a" | "c" | "*"
+ */
+
+// Attempt to parse the given string segment. If it fails, then just return the
+// plain string type as a default fallback. Otherwise, return the union of the
+// parsed string literals that were referenced as dynamic segments in the route.
+
+/**
+ * The parameters that were parsed from the URL path.
+ */
+
+/**
+ * A RouteMatch contains info about how a route matched a URL.
+ */
+
 function isIndexRoute(route) {
   return route.index === true;
 }
+
 // Walk the route tree generating unique IDs where necessary, so we are working
 // solely with AgnosticDataRouteObject's within the Router
 function convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath, manifest) {
@@ -527,6 +759,7 @@ function convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath, manif
     }
   });
 }
+
 /**
  * Matches the given routes to a location and returns the match data.
  *
@@ -596,6 +829,7 @@ function flattenRoutes(routes, branches, parentsMeta, parentPath) {
     }
     let path = joinPaths([parentPath, meta.relativePath]);
     let routesMeta = parentsMeta.concat(meta);
+
     // Add the children before adding this route to the array, so we traverse the
     // route tree depth-first and child routes appear before their parents in
     // the "flattened" version.
@@ -606,6 +840,7 @@ function flattenRoutes(routes, branches, parentsMeta, parentPath) {
       route.index !== true) ? process.env.NODE_ENV !== "production" ? invariant$2(false, "Index routes must not have child routes. Please remove " + ("all child routes from route path \"" + path + "\".")) : invariant$2(false) : void 0;
       flattenRoutes(route.children, branches, routesMeta, path);
     }
+
     // Routes without a path shouldn't ever match by themselves unless they are
     // index routes, so don't add them to the list of possible branches.
     if (route.path == null && !route.index) {
@@ -630,6 +865,7 @@ function flattenRoutes(routes, branches, parentsMeta, parentPath) {
   });
   return branches;
 }
+
 /**
  * Computes all combinations of optional path segments for a given path,
  * excluding combinations that are ambiguous and of lower priority.
@@ -648,6 +884,7 @@ function explodeOptionalSegments(path) {
   let segments = path.split("/");
   if (segments.length === 0) return [];
   let [first, ...rest] = segments;
+
   // Optional path segments are denoted by a trailing `?`
   let isOptional = first.endsWith("?");
   // Compute the corresponding required segment: `foo?` -> `foo`
@@ -659,6 +896,7 @@ function explodeOptionalSegments(path) {
   }
   let restExploded = explodeOptionalSegments(rest.join("/"));
   let result = [];
+
   // All child paths with the prefix.  Do this for all children before the
   // optional version for all children, so we get consistent ordering where the
   // parent optional aspect is preferred as required.  Otherwise, we can get
@@ -667,10 +905,12 @@ function explodeOptionalSegments(path) {
   // then /:one.  By always including the parent as required _for all children_
   // first, we avoid this issue
   result.push(...restExploded.map(subpath => subpath === "" ? required : [required, subpath].join("/")));
+
   // Then, if this is an optional value, add all child versions without
   if (isOptional) {
     result.push(...restExploded);
   }
+
   // for absolute paths, ensure `/` instead of empty segment
   return result.map(exploded => path.startsWith("/") && exploded === "" ? "/" : exploded);
 }
@@ -752,6 +992,7 @@ function matchRouteBranch(branch, pathname, allowPartial) {
   }
   return matches;
 }
+
 /**
  * Returns a path with params interpolated.
  *
@@ -766,11 +1007,13 @@ function generatePath(originalPath, params) {
     process.env.NODE_ENV !== "production" ? warning(false, "Route path \"" + path + "\" will be treated as if it were " + ("\"" + path.replace(/\*$/, "/*") + "\" because the `*` character must ") + "always follow a `/` in the pattern. To get rid of this warning, " + ("please change the route path to \"" + path.replace(/\*$/, "/*") + "\".")) : void 0;
     path = path.replace(/\*$/, "/*");
   }
+
   // ensure `/` is added at the beginning if the path is absolute
   const prefix = path.startsWith("/") ? "/" : "";
   const stringify = p => p == null ? "" : typeof p === "string" ? p : String(p);
   const segments = path.split(/\/+/).map((segment, index, array) => {
     const isLastSegment = index === array.length - 1;
+
     // only apply the splat if it's the last segment
     if (isLastSegment && segment === "*") {
       const star = "*";
@@ -784,6 +1027,7 @@ function generatePath(originalPath, params) {
       !(optional === "?" || param != null) ? process.env.NODE_ENV !== "production" ? invariant$2(false, "Missing \":" + key + "\" param") : invariant$2(false) : void 0;
       return stringify(param);
     }
+
     // Remove any optional markers from optional static segments
     return segment.replace(/\?$/g, "");
   })
@@ -791,6 +1035,15 @@ function generatePath(originalPath, params) {
   .filter(segment => !!segment);
   return prefix + segments.join("/");
 }
+
+/**
+ * A PathPattern is used to match on some portion of a URL pathname.
+ */
+
+/**
+ * A PathMatch contains info about how a PathPattern matched on a URL pathname.
+ */
+
 /**
  * Performs pattern matching on a URL pathname and returns information about
  * the match.
@@ -886,6 +1139,7 @@ function decodePath(value) {
     return value;
   }
 }
+
 /**
  * @private
  */
@@ -894,6 +1148,7 @@ function stripBasename(pathname, basename) {
   if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {
     return null;
   }
+
   // We want to leave trailing slash behavior in the user's control, so if they
   // specify a basename with a trailing slash, we should support it
   let startIndex = basename.endsWith("/") ? basename.length - 1 : basename.length;
@@ -904,6 +1159,7 @@ function stripBasename(pathname, basename) {
   }
   return pathname.slice(startIndex) || "/";
 }
+
 /**
  * Returns a resolved path object relative to the given pathname.
  *
@@ -941,6 +1197,7 @@ function resolvePathname(relativePath, fromPathname) {
 function getInvalidPathError(char, field, dest, path) {
   return "Cannot include a '" + char + "' character in a manually specified " + ("`to." + field + "` field [" + JSON.stringify(path) + "].  Please separate it out to the ") + ("`to." + dest + "` field. Alternatively you may provide the full path as ") + "a string in <Link to=\"...\"> and the router will parse it for you.";
 }
+
 /**
  * @private
  *
@@ -967,14 +1224,17 @@ function getInvalidPathError(char, field, dest, path) {
 function getPathContributingMatches(matches) {
   return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);
 }
+
 // Return the array of pathnames for the current route matches - used to
 // generate the routePathnames input for resolveTo()
 function getResolveToMatches(matches) {
   let pathMatches = getPathContributingMatches(matches);
+
   // Use the full pathname for the leaf match so we include splat values for "." links
   // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329
   return pathMatches.map((match, idx) => idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase);
 }
+
 /**
  * @private
  */
@@ -994,6 +1254,7 @@ function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
   let isEmptyPath = toArg === "" || to.pathname === "";
   let toPathname = isEmptyPath ? "/" : to.pathname;
   let from;
+
   // Routing is relative to the current pathname if explicitly requested.
   //
   // If a pathname is explicitly provided in `to`, it should be relative to the
@@ -1007,6 +1268,7 @@ function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
     from = locationPathname;
   } else {
     let routePathnameIndex = routePathnames.length - 1;
+
     // With relative="route" (the default), each leading .. segment means
     // "go up one route" instead of "go up one URL segment".  This is a key
     // difference from how <a href> works and a major reason we call this a
@@ -1022,6 +1284,7 @@ function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
     from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
   }
   let path = resolvePath(to, from);
+
   // Ensure the pathname has a trailing slash if the original "to" had one
   let hasExplicitTrailingSlash = toPathname && toPathname !== "/" && toPathname.endsWith("/");
   // Or if this was a link to the current path which has a trailing slash
@@ -1031,43 +1294,26 @@ function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
   }
   return path;
 }
+
 /**
  * @private
  */
 const joinPaths = paths => paths.join("/").replace(/\/\/+/g, "/");
+
 /**
  * @private
  */
 const normalizePathname = pathname => pathname.replace(/\/+$/, "").replace(/^\/*/, "/");
+
 /**
  * @private
  */
 const normalizeSearch = search => !search || search === "?" ? "" : search.startsWith("?") ? search : "?" + search;
+
 /**
  * @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";
@@ -1075,6 +1321,7 @@ class DataWithResponseInit {
     this.init = init || null;
   }
 }
+
 /**
  * Create "responses" that contain `status`/`headers` without forcing
  * serialization into an actual `Response` - used by Remix single fetch
@@ -1086,6 +1333,10 @@ function data(data, init) {
     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".
@@ -1110,6 +1361,7 @@ const redirect = function redirect(url, init) {
     headers
   }));
 };
+
 /**
  * A redirect response that will force a document reload to the new location.
  * Sets the status code and the `Location` header.
@@ -1122,6 +1374,7 @@ const redirectDocument = (url, init) => {
   response.headers.set("X-Remix-Reload-Document", "true");
   return response;
 };
+
 /**
  * A redirect response that will perform a `history.replaceState` instead of a
  * `history.pushState` for client-side navigation redirects.
@@ -1159,6 +1412,7 @@ class ErrorResponseImpl {
     }
   }
 }
+
 /**
  * Check if the given error is an ErrorResponse generated from a 4xx/5xx
  * Response thrown from an action/loader
@@ -1169,11 +1423,109 @@ function isRouteErrorResponse(error) {
   return error != null && typeof error.status === "number" && typeof error.statusText === "string" && typeof error.internal === "boolean" && "data" in error;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+//#region Types and Constants
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A Router instance manages all navigation and data loading/mutations
+ */
+
+/**
+ * State maintained internally by the router.  During a navigation, all states
+ * reflect the the "old" location unless otherwise noted.
+ */
+
+/**
+ * Data that can be passed into hydrate a Router from SSR
+ */
+
+/**
+ * Future flags to toggle new feature behavior
+ */
+
+/**
+ * Initialization options for createRouter
+ */
+
+/**
+ * State returned from a server-side query() call
+ */
+
+/**
+ * A StaticHandler instance manages a singular SSR navigation/fetch event
+ */
+
+/**
+ * Subscriber function signature for changes to router state
+ */
+
+/**
+ * Function signature for determining the key to be used in scroll restoration
+ * for a given location
+ */
+
+/**
+ * Function signature for determining the current scroll position
+ */
+
+/**
+  - "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.
+ */
+
+// Allowed for any navigation or fetch
+
+// Only allowed for navigations
+
+// Only allowed for submission navigations
+
+/**
+ * Options for a navigate() call for a normal (non-submission) navigation
+ */
+
+/**
+ * Options for a navigate() call for a submission navigation
+ */
+
+/**
+ * Options to pass to navigate() for a navigation
+ */
+
+/**
+ * Options for a fetch() load
+ */
+
+/**
+ * Options for a fetch() submission
+ */
+
+/**
+ * Options to pass to fetch()
+ */
+
+/**
+ * Potential states for state.navigation
+ */
+
+/**
+ * Potential states for fetchers
+ */
+
+/**
+ * Cached info for active fetcher.load() instances so they can participate
+ * in revalidation
+ */
+
+/**
+ * Identified fetcher.load() calls that need to be revalidated
+ */
+
 const validMutationMethodsArr = ["POST", "PUT", "PATCH", "DELETE"];
 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",
@@ -1206,13 +1558,17 @@ const defaultMapRouteProperties = route => ({
   hasErrorBoundary: Boolean(route.hasErrorBoundary)
 });
 const TRANSITIONS_STORAGE_KEY = "remix-router-transitions";
+
 // Flag used on new `loaderData` to indicate that we do not want to preserve
 // any prior loader data from the throwing route in `mergeLoaderData`
 const ResetLoaderDataSymbol = Symbol("ResetLoaderData");
+
 //#endregion
+
 ////////////////////////////////////////////////////////////////////////////////
 //#region createRouter
 ////////////////////////////////////////////////////////////////////////////////
+
 /**
  * Create a router and listen to history POP navigations
  */
@@ -1221,6 +1577,7 @@ function createRouter(init) {
   const isBrowser = typeof routerWindow !== "undefined" && typeof routerWindow.document !== "undefined" && typeof routerWindow.document.createElement !== "undefined";
   !(init.routes.length > 0) ? process.env.NODE_ENV !== "production" ? invariant$2(false, "You must provide a non-empty routes array to createRouter") : invariant$2(false) : void 0;
   let mapRouteProperties = init.mapRouteProperties || defaultMapRouteProperties;
+
   // Routes keyed by ID
   let manifest = {};
   // Routes in tree format for matching
@@ -1229,6 +1586,7 @@ function createRouter(init) {
   let basename = init.basename || "/";
   let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;
   let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;
+
   // Config driven behavior flags
   let future = _extends({}, init.future);
   // Cleanup function for history
@@ -1265,6 +1623,7 @@ function createRouter(init) {
       [route.id]: error
     };
   }
+
   // In SPA apps, if the user provided a patchRoutesOnNavigation implementation and
   // our initial match is a splat route, clear them out so we run through lazy
   // discovery on hydration in case there's a more accurate lazy route match.
@@ -1281,6 +1640,7 @@ function createRouter(init) {
   if (!initialMatches) {
     initialized = false;
     initialMatches = [];
+
     // If partial hydration and fog of war is enabled, we will be running
     // `patchRoutesOnNavigation` during hydration so include any partial matches as
     // the initial matches so we can properly render `HydrateFallback`'s
@@ -1326,57 +1686,77 @@ function createRouter(init) {
     fetchers: new Map(),
     blockers: new Map()
   };
+
   // -- Stateful internal variables to manage navigations --
   // Current navigation in progress (to be committed in completeNavigation)
   let pendingAction = Action.Pop;
+
   // Should the current navigation prevent the scroll reset if scroll cannot
   // be restored?
   let pendingPreventScrollReset = false;
+
   // AbortController for the active navigation
   let pendingNavigationController;
+
   // Should the current navigation enable document.startViewTransition?
   let pendingViewTransitionEnabled = false;
+
   // Store applied view transitions so we can apply them on POP
   let appliedViewTransitions = new Map();
+
   // Cleanup function for persisting applied transitions to sessionStorage
   let removePageHideEventListener = null;
+
   // We use this to avoid touching history in completeNavigation if a
   // revalidation is entirely uninterrupted
   let isUninterruptedRevalidation = false;
+
   // Use this internal flag to force revalidation of all loaders:
   //  - submissions (completed or interrupted)
   //  - useRevalidator()
   //  - X-Remix-Revalidate (from redirect)
   let isRevalidationRequired = false;
+
   // Use this internal array to capture fetcher loads that were cancelled by an
   // action navigation and require revalidation
   let cancelledFetcherLoads = new Set();
+
   // AbortControllers for any in-flight fetchers
   let fetchControllers = new Map();
+
   // Track loads based on the order in which they started
   let incrementingLoadId = 0;
+
   // Track the outstanding pending navigation data load to be compared against
   // the globally incrementing load when a fetcher load lands after a completed
   // navigation
   let pendingNavigationLoadId = -1;
+
   // Fetchers that triggered data reloads as a result of their actions
   let fetchReloadIds = new Map();
+
   // Fetchers that triggered redirect navigations
   let fetchRedirectIds = new Set();
+
   // Most recent href/match for fetcher.load calls for fetchers
   let fetchLoadMatches = new Map();
+
   // Ref-count mounted fetchers so we know when it's ok to clean them up
   let activeFetchers = new Map();
+
   // Fetchers queued for deletion because they've been removed from the UI.
   // These will be officially deleted after they return to idle
   let fetchersQueuedForDeletion = new Set();
+
   // Store blocker functions in a separate Map outside of router state since
   // we don't need to update UI state if they change
   let blockerFunctions = new Map();
+
   // Flag to ignore the next history update, so we can revert the URL change on
   // a POP navigation that was blocked by the user without touching router state
   let unblockBlockerHistoryUpdate = undefined;
   let pendingRevalidationDfd = null;
+
   // Initialize the router, all side effects should be kicked off from here.
   // Implemented as a Fluent API for ease of:
   //   let router = createRouter(init).initialize();
@@ -1408,6 +1788,7 @@ function createRouter(init) {
           unblockBlockerHistoryUpdate = resolve;
         });
         init.history.go(delta * -1);
+
         // Put the blocker into a blocked state
         updateBlocker(blockerKey, {
           state: "blocked",
@@ -1444,6 +1825,7 @@ function createRouter(init) {
       routerWindow.addEventListener("pagehide", _saveAppliedTransitions);
       removePageHideEventListener = () => routerWindow.removeEventListener("pagehide", _saveAppliedTransitions);
     }
+
     // Kick off initial data load if needed.  Use Pop to avoid modifying history
     // Note we don't do any handling of lazy here.  For SPA's it'll get handled
     // in the normal navigation flow.  For SSR it's expected that lazy modules are
@@ -1456,6 +1838,7 @@ function createRouter(init) {
     }
     return router;
   }
+
   // Clean up a router and it's side effects
   function dispose() {
     if (unlistenHistory) {
@@ -1469,17 +1852,20 @@ function createRouter(init) {
     state.fetchers.forEach((_, key) => deleteFetcher(key));
     state.blockers.forEach((_, key) => deleteBlocker(key));
   }
+
   // Subscribe to state updates for the router
   function subscribe(fn) {
     subscribers.add(fn);
     return () => subscribers.delete(fn);
   }
+
   // Update our state and notify the calling context of the change
   function updateState(newState, opts) {
     if (opts === void 0) {
       opts = {};
     }
     state = _extends({}, state, newState);
+
     // Cleanup for all fetchers that have returned to idle since we only
     // care about in-flight fetchers
     // - If it's been unmounted then we can completely delete it
@@ -1497,6 +1883,7 @@ function createRouter(init) {
         }
       }
     });
+
     // Iterate over a local copy so that if flushSync is used and we end up
     // removing and adding a new subscriber due to the useCallback dependencies,
     // we don't get ourselves into a loop calling the new subscriber immediately
@@ -1505,10 +1892,12 @@ function createRouter(init) {
       viewTransitionOpts: opts.viewTransitionOpts,
       flushSync: opts.flushSync === true
     }));
+
     // Cleanup internally now that we've called our subscribers/updated state
     unmountedFetchers.forEach(key => deleteFetcher(key));
     mountedFetchers.forEach(key => state.fetchers.delete(key));
   }
+
   // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION
   // and setting state.[historyAction/location/matches] to the new route.
   // - Location is a required param
@@ -1540,8 +1929,10 @@ function createRouter(init) {
       // Clear actionData on any other completed navigations
       actionData = null;
     }
+
     // Always preserve any existing loaderData from re-used routes
     let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;
+
     // On a successful navigation we can assume we got through all blockers
     // so we can start fresh
     let blockers = state.blockers;
@@ -1549,9 +1940,11 @@ function createRouter(init) {
       blockers = new Map(blockers);
       blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));
     }
+
     // Always respect the user flag.  Otherwise don't reset on mutation
     // submission navigations unless they redirect
     let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;
+
     // Commit any in-flight routes at the end of the HMR revalidation "navigation"
     if (inFlightDataRoutes) {
       dataRoutes = inFlightDataRoutes;
@@ -1563,6 +1956,7 @@ function createRouter(init) {
       init.history.replace(location, location.state);
     }
     let viewTransitionOpts;
+
     // On POP, enable transitions if they were enabled on the original navigation
     if (pendingAction === Action.Pop) {
       // Forward takes precedence so they behave like the original navigation
@@ -1610,6 +2004,7 @@ function createRouter(init) {
       viewTransitionOpts,
       flushSync: flushSync === true
     });
+
     // Reset stateful navigation vars
     pendingAction = Action.Pop;
     pendingPreventScrollReset = false;
@@ -1619,6 +2014,7 @@ function createRouter(init) {
     (_pendingRevalidationD = pendingRevalidationDfd) == null ? void 0 : _pendingRevalidationD.resolve();
     pendingRevalidationDfd = null;
   }
+
   // Trigger a navigation event, which can either be a numerical POP or a PUSH
   // replace with an optional submission
   async function navigate(to, opts) {
@@ -1634,6 +2030,7 @@ function createRouter(init) {
     } = normalizeNavigateOptions(false, normalizedPath, opts);
     let currentLocation = state.location;
     let nextLocation = createLocation(state.location, path, opts && opts.state);
+
     // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded
     // URL from window.location, so we need to encode it here so the behavior
     // remains the same as POP and non-data-router usages.  new URL() does all
@@ -1694,6 +2091,7 @@ function createRouter(init) {
       flushSync
     });
   }
+
   // Revalidate all current loaders.  If a navigation is in progress or if this
   // is interrupted by a navigation, allow this to "succeed" by calling all
   // loaders during the next loader round
@@ -1713,15 +2111,18 @@ function createRouter(init) {
     updateState({
       revalidation: "loading"
     });
+
     // Capture this here for the edge-case that we have a fully synchronous
     // startNavigation which would resolve and null out pendingRevalidationDfd
     // before we return from this function
     let promise = pendingRevalidationDfd.promise;
+
     // If we're currently submitting an action, we don't need to start a new
     // navigation, we'll just let the follow up loader execution call all loaders
     if (state.navigation.state === "submitting") {
       return promise;
     }
+
     // If we're currently in an idle state, start a new navigation for the current
     // action/location and mark it as uninterrupted, which will skip the history
     // update in completeNavigation
@@ -1731,6 +2132,7 @@ function createRouter(init) {
       });
       return promise;
     }
+
     // Otherwise, if we're currently in a loading state, just start a new
     // navigation to the navigation.location but do not trigger an uninterrupted
     // revalidation so that history correctly updates once the navigation completes
@@ -1741,6 +2143,7 @@ function createRouter(init) {
     });
     return promise;
   }
+
   // Start a navigation to the given action/location.  Can optionally provide a
   // overrideNavigation which will override the normalLoad in the case of a redirect
   // navigation
@@ -1752,6 +2155,7 @@ function createRouter(init) {
     pendingNavigationController = null;
     pendingAction = historyAction;
     isUninterruptedRevalidation = (opts && opts.startUninterruptedRevalidation) === true;
+
     // Save the current scroll position every time we start a new navigation,
     // and track whether we should reset scroll on completion
     saveScrollPosition(state.location, state.matches);
@@ -1765,6 +2169,7 @@ function createRouter(init) {
     if (fogOfWar.active && fogOfWar.matches) {
       matches = fogOfWar.matches;
     }
+
     // Short circuit with a 404 on the root error boundary if we match nothing
     if (!matches) {
       let {
@@ -1783,6 +2188,7 @@ function createRouter(init) {
       });
       return;
     }
+
     // Short circuit if it's only a hash change and not a revalidation or
     // mutation submission.
     //
@@ -1797,6 +2203,7 @@ function createRouter(init) {
       });
       return;
     }
+
     // Create a controller/Request for this navigation
     pendingNavigationController = new AbortController();
     let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);
@@ -1819,6 +2226,7 @@ function createRouter(init) {
       if (actionResult.shortCircuited) {
         return;
       }
+
       // If we received a 404 from handleAction, it's because we couldn't lazily
       // discover the destination route so we don't want to call loaders
       if (actionResult.pendingActionResult) {
@@ -1841,9 +2249,11 @@ function createRouter(init) {
       flushSync = false;
       // No need to do fog of war matching again on loader execution
       fogOfWar.active = false;
+
       // Create a GET request for the loaders
       request = createClientSideRequest(init.history, request.url, request.signal);
     }
+
     // Call loaders
     let {
       shortCircuited,
@@ -1854,6 +2264,7 @@ function createRouter(init) {
     if (shortCircuited) {
       return;
     }
+
     // Clean up now that the action/loaders have completed.  Don't clean up if
     // we short circuited because pendingNavigationController will have already
     // been assigned to a new controller for the next navigation
@@ -1865,6 +2276,7 @@ function createRouter(init) {
       errors
     }));
   }
+
   // Call the action matched by the leaf route for this navigation and handle
   // redirects/errors
   async function handleAction(request, location, submission, matches, isFogOfWar, opts) {
@@ -1872,6 +2284,7 @@ function createRouter(init) {
       opts = {};
     }
     interruptActiveLoads();
+
     // Put us in a submitting state
     let navigation = getSubmittingNavigation(location, submission);
     updateState({
@@ -1911,6 +2324,7 @@ function createRouter(init) {
         matches = discoverResult.matches;
       }
     }
+
     // Call our action and get the result
     let result;
     let actionMatch = getTargetMatch(matches, location);
@@ -1955,6 +2369,7 @@ function createRouter(init) {
       // Store off the pending error - we use it to determine which loaders
       // to call and will commit it when we complete the navigation
       let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);
+
       // By default, all submissions to the current location are REPLACE
       // navigations, but if the action threw an error that'll be rendered in
       // an errorElement, we fall back to PUSH so that the user can use the
@@ -1973,14 +2388,17 @@ function createRouter(init) {
       pendingActionResult: [actionMatch.route.id, result]
     };
   }
+
   // Call all applicable loaders for the given matches, handling redirects,
   // errors, etc.
   async function handleLoaders(request, location, matches, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult) {
     // Figure out the right navigation we want to use for data loading
     let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);
+
     // If this was a redirect from an action we don't have a "submission" but
     // we have it on the loading navigation so use that if available
     let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);
+
     // If this is an uninterrupted revalidation, we remain in our current idle
     // state.  If not, we need to switch to our loading state and load data,
     // preserving any new action data or existing action data (in the case of
@@ -1988,6 +2406,7 @@ function createRouter(init) {
     // Also (with "partial hydration"), don't update the state for the initial
     // data load since it's not a "navigation"
     let shouldUpdateNavigationState = !isUninterruptedRevalidation && !initialHydration;
+
     // When fog of war is enabled, we enter our `loading` state earlier so we
     // can discover new routes during the `loading` state.  We skip this if
     // we've already run actions since we would have done our matching already.
@@ -2038,6 +2457,7 @@ function createRouter(init) {
     let routesToUse = inFlightDataRoutes || dataRoutes;
     let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, initialHydration === true, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult);
     pendingNavigationLoadId = ++incrementingLoadId;
+
     // Short circuit if we have no loaders to run
     if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {
       let updatedFetchers = markFetchRedirectsDone();
@@ -2083,6 +2503,7 @@ function createRouter(init) {
         fetchControllers.set(rf.key, rf.controller);
       }
     });
+
     // Proxy navigation abort through to revalidation fetchers
     let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(f => abortFetcher(f.key));
     if (pendingNavigationController) {
@@ -2097,6 +2518,7 @@ function createRouter(init) {
         shortCircuited: true
       };
     }
+
     // Clean up _after_ loaders have completed.  Don't clean up if we short
     // circuited because fetchControllers would have been aborted and
     // reassigned to new controllers for the next navigation
@@ -2104,6 +2526,7 @@ function createRouter(init) {
       pendingNavigationController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
     }
     revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key));
+
     // If any loaders returned a redirect Response, start a new REPLACE navigation
     let redirect = findRedirect(loaderResults);
     if (redirect) {
@@ -2127,11 +2550,13 @@ function createRouter(init) {
         shortCircuited: true
       };
     }
+
     // Process and commit output from loaders
     let {
       loaderData,
       errors
     } = processLoaderData(state, matches, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults);
+
     // Preserve SSR errors during partial hydration
     if (initialHydration && state.errors) {
       errors = _extends({}, state.errors, errors);
@@ -2171,6 +2596,7 @@ function createRouter(init) {
     });
     return new Map(state.fetchers);
   }
+
   // Trigger a fetcher load/submit for the given fetcher key
   async function fetch(key, routeId, href, opts) {
     abortFetcher(key);
@@ -2207,6 +2633,7 @@ function createRouter(init) {
       await handleFetcherAction(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);
       return;
     }
+
     // Store off the match so we can call it's shouldRevalidate on subsequent
     // revalidations
     fetchLoadMatches.set(key, {
@@ -2215,6 +2642,7 @@ function createRouter(init) {
     });
     await handleFetcherLoader(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);
   }
+
   // Call the action for the matched fetcher.submit(), and then handle redirects,
   // errors, and revalidation
   async function handleFetcherAction(key, routeId, path, match, requestMatches, isFogOfWar, flushSync, preventScrollReset, submission) {
@@ -2237,6 +2665,7 @@ function createRouter(init) {
     if (!isFogOfWar && detectAndHandle405Error(match)) {
       return;
     }
+
     // Put this fetcher into it's submitting state
     let existingFetcher = state.fetchers.get(key);
     updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {
@@ -2268,6 +2697,7 @@ function createRouter(init) {
         }
       }
     }
+
     // Call the action for the fetcher
     fetchControllers.set(key, abortController);
     let originatingLoadId = incrementingLoadId;
@@ -2281,6 +2711,7 @@ function createRouter(init) {
       }
       return;
     }
+
     // We don't want errors bubbling up to the UI or redirects processed for
     // unmounted fetchers so we just revert them to idle
     if (fetchersQueuedForDeletion.has(key)) {
@@ -2308,12 +2739,14 @@ function createRouter(init) {
           });
         }
       }
+
       // Process any non-redirect errors thrown
       if (isErrorResult(actionResult)) {
         setFetcherError(key, routeId, actionResult.error);
         return;
       }
     }
+
     // Start the data load for current matches, or the next location if we're
     // in the middle of a navigation
     let nextLocation = state.navigation.location || state.location;
@@ -2326,6 +2759,7 @@ function createRouter(init) {
     let loadFetcher = getLoadingFetcher(submission, actionResult.data);
     state.fetchers.set(key, loadFetcher);
     let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, false, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, [match.route.id, actionResult]);
+
     // Put all revalidating fetchers into the loading state, except for the
     // current fetcher which we want to keep in it's current loading state which
     // contains it's action submission info + action data
@@ -2371,11 +2805,13 @@ function createRouter(init) {
         preventScrollReset
       });
     }
+
     // Process and commit output from loaders
     let {
       loaderData,
       errors
     } = processLoaderData(state, matches, loaderResults, undefined, revalidatingFetchers, fetcherResults);
+
     // Since we let revalidations complete even if the submitting fetcher was
     // deleted, only put it back to idle if it hasn't been deleted
     if (state.fetchers.has(key)) {
@@ -2383,6 +2819,7 @@ function createRouter(init) {
       state.fetchers.set(key, doneFetcher);
     }
     abortStaleFetchLoads(loadId);
+
     // If we are currently in a navigation loading state and this fetcher is
     // more recent than the navigation, we want the newer data so abort the
     // navigation and complete it with the fetcher data
@@ -2407,6 +2844,7 @@ function createRouter(init) {
       isRevalidationRequired = false;
     }
   }
+
   // Call the matched loader for fetcher.load(), handling redirects, errors, etc.
   async function handleFetcherLoader(key, routeId, path, match, matches, isFogOfWar, flushSync, preventScrollReset, submission) {
     let existingFetcher = state.fetchers.get(key);
@@ -2436,11 +2874,13 @@ function createRouter(init) {
         match = getTargetMatch(matches, path);
       }
     }
+
     // Call the loader for this fetcher route match
     fetchControllers.set(key, abortController);
     let originatingLoadId = incrementingLoadId;
     let results = await callDataStrategy("loader", state, fetchRequest, [match], matches, key);
     let result = results[match.route.id];
+
     // We can delete this so long as we weren't aborted by our our own fetcher
     // re-load which would have put _new_ controller is in fetchControllers
     if (fetchControllers.get(key) === abortController) {
@@ -2449,12 +2889,14 @@ function createRouter(init) {
     if (fetchRequest.signal.aborted) {
       return;
     }
+
     // We don't want errors bubbling up or redirects followed for unmounted
     // fetchers, so short circuit here if it was removed from the UI
     if (fetchersQueuedForDeletion.has(key)) {
       updateFetcherState(key, getDoneFetcher(undefined));
       return;
     }
+
     // If the loader threw a redirect Response, start a new REPLACE navigation
     if (isRedirectResult(result)) {
       if (pendingNavigationLoadId > originatingLoadId) {
@@ -2470,14 +2912,17 @@ function createRouter(init) {
         return;
       }
     }
+
     // Process any non-redirect errors thrown
     if (isErrorResult(result)) {
       setFetcherError(key, routeId, result.error);
       return;
     }
+
     // Put the fetcher back into an idle state
     updateFetcherState(key, getDoneFetcher(result.data));
   }
+
   /**
    * Utility function to handle redirects returned from an action or loader.
    * Normally, a redirect "replaces" the navigation that triggered it.  So, for
@@ -2535,10 +2980,12 @@ function createRouter(init) {
         return;
       }
     }
+
     // There's no need to abort on redirects, since we don't detect the
     // redirect until the action/loaders have settled
     pendingNavigationController = null;
     let redirectNavigationType = replace === true || redirect.response.headers.has("X-Remix-Replace") ? Action.Replace : Action.Push;
+
     // Use the incoming submission if provided, fallback on the active one in
     // state.navigation
     let {
@@ -2549,6 +2996,7 @@ function createRouter(init) {
     if (!submission && !fetcherSubmission && formMethod && formAction && formEncType) {
       submission = getSubmissionFromNavigation(state.navigation);
     }
+
     // If this was a 307/308 submission we want to preserve the HTTP method and
     // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the
     // redirected location
@@ -2576,6 +3024,7 @@ function createRouter(init) {
       });
     }
   }
+
   // Utility wrapper for calling dataStrategy client-side without having to
   // pass around the manifest, mapRouteProperties, etc.
   async function callDataStrategy(type, state, request, matchesToLoad, matches, fetcherKey) {
@@ -2595,7 +3044,7 @@ function createRouter(init) {
       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,
@@ -2608,7 +3057,6 @@ function createRouter(init) {
     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 => {
@@ -2640,6 +3088,7 @@ function createRouter(init) {
   function interruptActiveLoads() {
     // Every interruption triggers a revalidation
     isRevalidationRequired = true;
+
     // Abort in-flight fetcher loads
     fetchLoadMatches.forEach((_, key) => {
       if (fetchControllers.has(key)) {
@@ -2766,9 +3215,11 @@ function createRouter(init) {
     state.blockers.delete(key);
     blockerFunctions.delete(key);
   }
+
   // Utility function to update blockers, ensuring valid state transitions
   function updateBlocker(key, newBlocker) {
     let blocker = state.blockers.get(key) || IDLE_BLOCKER;
+
     // Poor mans state machine :)
     // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM
     !(blocker.state === "unblocked" && newBlocker.state === "blocked" || blocker.state === "blocked" && newBlocker.state === "blocked" || blocker.state === "blocked" && newBlocker.state === "proceeding" || blocker.state === "blocked" && newBlocker.state === "unblocked" || blocker.state === "proceeding" && newBlocker.state === "unblocked") ? process.env.NODE_ENV !== "production" ? invariant$2(false, "Invalid blocker state transition: " + blocker.state + " -> " + newBlocker.state) : invariant$2(false) : void 0;
@@ -2787,6 +3238,7 @@ function createRouter(init) {
     if (blockerFunctions.size === 0) {
       return;
     }
+
     // We ony support a single active blocker at the moment since we don't have
     // any compelling use cases for multi-blocker yet
     if (blockerFunctions.size > 1) {
@@ -2800,6 +3252,7 @@ function createRouter(init) {
       // it and can let this navigation continue
       return;
     }
+
     // At this point, we know we're unblocked/blocked so we need to check the
     // user-provided blocker function
     if (blockerFunction({
@@ -2825,12 +3278,14 @@ function createRouter(init) {
       error
     };
   }
+
   // Opt in to capturing and reporting scroll positions during navigations,
   // used by the <ScrollRestoration> component
   function enableScrollRestoration(positions, getPosition, getKey) {
     savedScrollPositions = positions;
     getScrollPosition = getPosition;
     getScrollRestorationKey = getKey || null;
+
     // Perform initial hydration scroll restoration, since we miss the boat on
     // the initial updateState() because we've not yet rendered <ScrollRestoration/>
     // and therefore have no savedScrollPositions available
@@ -2949,6 +3404,7 @@ function createRouter(init) {
         };
       }
       let newPartialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
+
       // Avoid loops if the second pass results in the same partial matches
       if (!newPartialMatches || partialMatches.length === newPartialMatches.length && partialMatches.every((m, i) => m.route.id === newPartialMatches[i].route.id)) {
         return {
@@ -2967,6 +3423,7 @@ function createRouter(init) {
     let isNonHMR = inFlightDataRoutes == null;
     let routesToUse = inFlightDataRoutes || dataRoutes;
     patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties);
+
     // If we are not in the middle of an HMR revalidation and we changed the
     // routes, provide a new identity and trigger a reflow via `updateState`
     // to re-run memoized `router.routes` dependencies.
@@ -3016,12 +3473,19 @@ function createRouter(init) {
   };
   return router;
 }
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region createStaticHandler
+////////////////////////////////////////////////////////////////////////////////
+
 function createStaticHandler$1(routes, opts) {
   !(routes.length > 0) ? process.env.NODE_ENV !== "production" ? invariant$2(false, "You must provide a non-empty routes array to createStaticHandler") : invariant$2(false) : void 0;
   let manifest = {};
   let basename = (opts ? opts.basename : null) || "/";
   let mapRouteProperties = (opts == null ? void 0 : opts.mapRouteProperties) || defaultMapRouteProperties;
   let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, undefined, manifest);
+
   /**
    * The query() method is intended for document requests, in which we want to
    * call an optional action and potentially multiple loaders for all nested
@@ -3058,6 +3522,7 @@ function createStaticHandler$1(routes, opts) {
     let method = request.method;
     let location = createLocation("", createPath(url), null, "default");
     let matches = matchRoutes(dataRoutes, location, basename);
+
     // SSR supports HEAD requests while SPA doesn't
     if (!isValidMethod(method) && method !== "HEAD") {
       let error = getInternalRouterError(405, {
@@ -3103,9 +3568,10 @@ function createStaticHandler$1(routes, opts) {
       };
     }
     let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, skipLoaderErrorBubbling === true, null);
-    if (isResponse$2(result)) {
+    if (isResponse(result)) {
       return result;
     }
+
     // When returning StaticHandlerContext, we patch back in the location here
     // since we need it for React Context.  But this helps keep our submit and
     // loadRouteData operating on a Request instead of a Location
@@ -3114,6 +3580,7 @@ function createStaticHandler$1(routes, opts) {
       basename
     }, result);
   }
+
   /**
    * The queryRoute() method is intended for targeted route requests, either
    * for fetch ?_data requests or resource route requests.  In this case, we
@@ -3150,6 +3617,7 @@ function createStaticHandler$1(routes, opts) {
     let method = request.method;
     let location = createLocation("", createPath(url), null, "default");
     let matches = matchRoutes(dataRoutes, location, basename);
+
     // SSR supports HEAD requests while SPA doesn't
     if (!isValidMethod(method) && method !== "HEAD" && method !== "OPTIONS") {
       throw getInternalRouterError(405, {
@@ -3173,7 +3641,7 @@ function createStaticHandler$1(routes, opts) {
       });
     }
     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;
@@ -3184,6 +3652,7 @@ function createStaticHandler$1(routes, opts) {
       // preserve the "error" state outside of queryImpl.
       throw error;
     }
+
     // Pick off the right state value to return
     if (result.actionData) {
       return Object.values(result.actionData)[0];
@@ -3201,7 +3670,7 @@ function createStaticHandler$1(routes, opts) {
         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: {}
       });
@@ -3209,7 +3678,7 @@ function createStaticHandler$1(routes, opts) {
       // 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;
         }
@@ -3217,7 +3686,7 @@ function createStaticHandler$1(routes, opts) {
       }
       // Redirects are always returned since they don't propagate to catch
       // boundaries
-      if (isRedirectResponse$1(e)) {
+      if (isRedirectResponse(e)) {
         return e;
       }
       throw e;
@@ -3277,6 +3746,7 @@ function createStaticHandler$1(routes, opts) {
         actionHeaders: {}
       };
     }
+
     // Create a GET request for the loaders
     let loaderRequest = new Request(request.url, {
       headers: request.headers,
@@ -3288,6 +3758,7 @@ function createStaticHandler$1(routes, opts) {
       // to call and will commit it when we complete the navigation
       let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);
       let context = await loadRouteData(loaderRequest, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null, [boundaryMatch.route.id, result]);
+
       // action status codes take precedence over loader status codes
       return _extends({}, context, {
         statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,
@@ -3312,6 +3783,7 @@ function createStaticHandler$1(routes, opts) {
   }
   async function loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, pendingActionResult) {
     let isRouteRequest = routeMatch != null;
+
     // Short circuit if we have no loaders to run (queryRoute())
     if (isRouteRequest && !(routeMatch != null && routeMatch.route.loader) && !(routeMatch != null && routeMatch.route.lazy)) {
       throw getInternalRouterError(400, {
@@ -3322,6 +3794,7 @@ function createStaticHandler$1(routes, opts) {
     }
     let requestMatches = routeMatch ? [routeMatch] : pendingActionResult && isErrorResult(pendingActionResult[1]) ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]) : matches;
     let matchesToLoad = requestMatches.filter(m => m.route.loader || m.route.lazy);
+
     // Short circuit if we have no loaders to run (query())
     if (matchesToLoad.length === 0) {
       return {
@@ -3341,8 +3814,10 @@ function createStaticHandler$1(routes, opts) {
     if (request.signal.aborted) {
       throwStaticHandlerAbortedError(request, isRouteRequest);
     }
+
     // Process and commit output from loaders
     let context = processRouteLoaderData(matches, results, pendingActionResult, true, skipLoaderErrorBubbling);
+
     // Add a null for any non-loader matches for proper revalidation on the client
     let executedLoaders = new Set(matchesToLoad.map(match => match.route.id));
     matches.forEach(match => {
@@ -3354,6 +3829,7 @@ function createStaticHandler$1(routes, opts) {
       matches
     });
   }
+
   // Utility wrapper for calling dataStrategy server-side without having to
   // pass around the manifest, mapRouteProperties, etc.
   async function callDataStrategy(type, request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy) {
@@ -3364,12 +3840,12 @@ function createStaticHandler$1(routes, opts) {
         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;
@@ -3384,10 +3860,13 @@ function createStaticHandler$1(routes, opts) {
     queryRoute
   };
 }
+
 //#endregion
+
 ////////////////////////////////////////////////////////////////////////////////
 //#region Helpers
 ////////////////////////////////////////////////////////////////////////////////
+
 /**
  * Given an existing StaticHandlerContext and an error thrown at render time,
  * provide an updated StaticHandlerContext suitable for a second SSR render
@@ -3431,8 +3910,10 @@ function normalizeTo(location, matches, basename, to, fromRouteId, relative) {
     contextualMatches = matches;
     activeRouteMatch = matches[matches.length - 1];
   }
+
   // Resolve the relative path
   let path = resolveTo(to ? to : ".", getResolveToMatches(contextualMatches), stripBasename(location.pathname, basename) || location.pathname, relative === "path");
+
   // When `to` is not specified we inherit search/hash from the current
   // location, unlike when to="." and we just inherit the path.
   // See https://github.com/remix-run/remix/issues/927
@@ -3440,6 +3921,7 @@ function normalizeTo(location, matches, basename, to, fromRouteId, relative) {
     path.search = location.search;
     path.hash = location.hash;
   }
+
   // Account for `?index` params when routing to the current location
   if ((to == null || to === "" || to === ".") && activeRouteMatch) {
     let nakedIndex = hasNakedIndexQuery(path.search);
@@ -3456,6 +3938,7 @@ function normalizeTo(location, matches, basename, to, fromRouteId, relative) {
       path.search = qs ? "?" + qs : "";
     }
   }
+
   // If we're operating within a basename, prepend it to the pathname.  If
   // this is a root navigation, then just use the raw basename which allows
   // the basename to have full control over the presence of a trailing slash
@@ -3465,6 +3948,7 @@ function normalizeTo(location, matches, basename, to, fromRouteId, relative) {
   }
   return createPath(path);
 }
+
 // Normalize navigation options by converting formMethod=GET formData objects to
 // URLSearchParams so they behave identically to links with query params
 function normalizeNavigateOptions(isFetcher, path, opts) {
@@ -3488,6 +3972,7 @@ function normalizeNavigateOptions(isFetcher, path, opts) {
       type: "invalid-body"
     })
   });
+
   // Create a Submission on non-GET navigations
   let rawFormMethod = opts.formMethod || "get";
   let formMethod = rawFormMethod.toUpperCase();
@@ -3575,6 +4060,7 @@ function normalizeNavigateOptions(isFetcher, path, opts) {
       submission
     };
   }
+
   // Flatten submission onto URLSearchParams for GET submissions
   let parsedPath = parsePath(path);
   // On GET navigation submissions we can drop the ?index param from the
@@ -3589,6 +4075,7 @@ function normalizeNavigateOptions(isFetcher, path, opts) {
     submission
   };
 }
+
 // Filter out all routes at/below any caught error as they aren't going to
 // render so we don't need to load them
 function getLoaderMatchesUntilBoundary(matches, boundaryId, includeBoundary) {
@@ -3605,6 +4092,7 @@ function getMatchesToLoad(history, state, matches, submission, location, initial
   let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : undefined;
   let currentUrl = history.createURL(state.location);
   let nextUrl = history.createURL(location);
+
   // Pick navigation matches that are net-new or qualify for revalidation
   let boundaryMatches = matches;
   if (initialHydration && state.errors) {
@@ -3619,6 +4107,7 @@ function getMatchesToLoad(history, state, matches, submission, location, initial
     // boundary
     boundaryMatches = getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]);
   }
+
   // Don't revalidate loaders by default after action 4xx/5xx responses
   // when the flag is enabled.  They can still opt-into revalidation via
   // `shouldRevalidate` via `actionResult`
@@ -3638,10 +4127,12 @@ function getMatchesToLoad(history, state, matches, submission, location, initial
     if (initialHydration) {
       return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);
     }
+
     // Always call the loader on new route instances
     if (isNewLoader(state.loaderData, state.matches[index], match)) {
       return true;
     }
+
     // This is the default implementation for when we revalidate.  If the route
     // provides it's own implementation, then we give them full control but
     // provide this value so they can leverage it if needed after they check
@@ -3663,6 +4154,7 @@ function getMatchesToLoad(history, state, matches, submission, location, initial
       currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)
     }));
   });
+
   // Pick fetcher.loads that need to be revalidated
   let revalidatingFetchers = [];
   fetchLoadMatches.forEach((f, key) => {
@@ -3675,6 +4167,7 @@ function getMatchesToLoad(history, state, matches, submission, location, initial
       return;
     }
     let fetcherMatches = matchRoutes(routesToUse, f.path, basename);
+
     // If the fetcher path no longer matches, push it in with null matches so
     // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is
     // currently only a use-case for Remix HMR where the route tree can change
@@ -3690,6 +4183,7 @@ function getMatchesToLoad(history, state, matches, submission, location, initial
       });
       return;
     }
+
     // Revalidating fetchers are decoupled from the route matches since they
     // load from a static href.  They revalidate based on explicit revalidation
     // (submission, useRevalidator, or X-Remix-Revalidate)
@@ -3740,20 +4234,24 @@ function shouldLoadRouteOnHydration(route, loaderData, errors) {
   if (route.lazy) {
     return true;
   }
+
   // No loader, nothing to initialize
   if (!route.loader) {
     return false;
   }
   let hasData = loaderData != null && loaderData[route.id] !== undefined;
   let hasError = errors != null && errors[route.id] !== undefined;
+
   // Don't run if we error'd during SSR
   if (!hasData && hasError) {
     return false;
   }
+
   // Explicitly opting-in to running on hydration
   if (typeof route.loader === "function" && route.loader.hydrate === true) {
     return true;
   }
+
   // Otherwise, run if we're not yet initialized with anything
   return !hasData && !hasError;
 }
@@ -3763,9 +4261,11 @@ function isNewLoader(currentLoaderData, currentMatch, match) {
   !currentMatch ||
   // [a, b] -> [a, c]
   match.route.id !== currentMatch.route.id;
+
   // Handle the case that we don't have data for a re-used route, potentially
   // from a prior error
   let isMissingData = !currentLoaderData.hasOwnProperty(match.route.id);
+
   // Always load if this is a net-new route or we don't yet have data
   return isNew || isMissingData;
 }
@@ -3801,6 +4301,7 @@ function patchRoutesImpl(routeId, children, routesToUse, manifest, mapRoutePrope
   } else {
     childrenToPatch = routesToUse;
   }
+
   // Don't patch in routes we already know about so that `patch` is idempotent
   // to simplify user-land code. This is useful because we re-call the
   // `patchRoutesOnNavigation` function for matched routes with params.
@@ -3813,15 +4314,18 @@ function isSameRoute(newRoute, existingRoute) {
   if ("id" in newRoute && "id" in existingRoute && newRoute.id === existingRoute.id) {
     return true;
   }
+
   // Second is by pathing differences
   if (!(newRoute.index === existingRoute.index && newRoute.path === existingRoute.path && newRoute.caseSensitive === existingRoute.caseSensitive)) {
     return false;
   }
+
   // Pathless layout routes are trickier since we need to check children.
   // If they have no children then they're the same as far as we can tell
   if ((!newRoute.children || newRoute.children.length === 0) && (!existingRoute.children || existingRoute.children.length === 0)) {
     return true;
   }
+
   // Otherwise, we look to see if every child in the new route is already
   // represented in the existing route's children
   return newRoute.children.every((aChild, i) => {
@@ -3829,6 +4333,7 @@ function isSameRoute(newRoute, existingRoute) {
     return (_existingRoute$childr = existingRoute.children) == null ? void 0 : _existingRoute$childr.some(bChild => isSameRoute(aChild, bChild));
   });
 }
+
 /**
  * Execute route.lazy() methods to lazily load route modules (loader, action,
  * shouldRevalidate) and update the routeManifest in place which shares objects
@@ -3839,6 +4344,7 @@ async function loadLazyRouteModule(route, mapRouteProperties, manifest) {
     return;
   }
   let lazyRoute = await route.lazy();
+
   // If the lazy route function was executed and removed by another parallel
   // call then we can return - first lazy() to finish wins because the return
   // value of lazy is expected to be static
@@ -3847,6 +4353,7 @@ async function loadLazyRouteModule(route, mapRouteProperties, manifest) {
   }
   let routeToUpdate = manifest[route.id];
   !routeToUpdate ? process.env.NODE_ENV !== "production" ? invariant$2(false, "No route found in manifest") : invariant$2(false) : void 0;
+
   // Update the route in place.  This should be safe because there's no way
   // we could yet be sitting on this route as we can't get there without
   // resolving lazy() first.
@@ -3867,9 +4374,11 @@ async function loadLazyRouteModule(route, mapRouteProperties, manifest) {
       routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];
     }
   }
+
   // Mutate the route with the provided updates.  Do this first so we pass
   // the updated version to mapRouteProperties
   Object.assign(routeToUpdate, routeUpdates);
+
   // Mutate the `hasErrorBoundary` property on the route based on the route
   // updates and remove the `lazy` function so we don't resolve the lazy
   // route again.
@@ -3877,6 +4386,7 @@ async function loadLazyRouteModule(route, mapRouteProperties, manifest) {
     lazy: undefined
   }));
 }
+
 // Default implementation of `dataStrategy` which fetches all loaders in parallel
 async function defaultDataStrategy(_ref4) {
   let {
@@ -3911,6 +4421,7 @@ async function callDataStrategyImpl(dataStrategyImpl, type, state, request, matc
       resolve
     });
   });
+
   // Send all matches here to allow for a middleware-type implementation.
   // handler will be a no-op for unneeded routes and we filter those results
   // back out below.
@@ -3921,6 +4432,7 @@ async function callDataStrategyImpl(dataStrategyImpl, type, state, request, matc
     fetcherKey,
     context: requestContext
   });
+
   // Wait for all routes to load here but 'swallow the error since we want
   // it to bubble up from the `await loadRoutePromise` in `callLoaderOrAction` -
   // called from `match.resolve()`
@@ -3931,6 +4443,7 @@ async function callDataStrategyImpl(dataStrategyImpl, type, state, request, matc
   }
   return results;
 }
+
 // Default logic for calling a loader/action is the user has no specified a dataStrategy
 async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, staticContext) {
   let result;
@@ -3971,6 +4484,7 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
   };
   try {
     let handler = match.route[type];
+
     // If we have a route.lazy promise, await that first
     if (loadRoutePromise) {
       if (handler) {
@@ -4042,7 +4556,7 @@ async function convertDataStrategyResultToDataResult(dataStrategyResult) {
     result,
     type
   } = dataStrategyResult;
-  if (isResponse$2(result)) {
+  if (isResponse(result)) {
     let data;
     try {
       let contentType = result.headers.get("Content-Type");
@@ -4089,6 +4603,7 @@ async function convertDataStrategyResultToDataResult(dataStrategyResult) {
           statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status
         };
       }
+
       // Convert thrown data() to ErrorResponse instances
       result = new ErrorResponseImpl(((_result$init2 = result.init) == null ? void 0 : _result$init2.status) || 500, undefined, result.data);
     }
@@ -4112,6 +4627,7 @@ async function convertDataStrategyResultToDataResult(dataStrategyResult) {
     data: result
   };
 }
+
 // Support relative routing in internal redirects
 function normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename) {
   let location = response.headers.get("Location");
@@ -4135,6 +4651,7 @@ function normalizeRedirectLocation(location, currentUrl, basename) {
   }
   return location;
 }
+
 // Utility method for creating the Request instances for loaders/actions during
 // client-side navigations and fetches.  During SSR we will always have a
 // Request instance from the static handler (query/queryRoute)
@@ -4199,6 +4716,7 @@ function processRouteLoaderData(matches, results, pendingActionResult, isStaticH
   let foundError = false;
   let loaderHeaders = {};
   let pendingError = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : undefined;
+
   // Process loader results into state.loaderData/state.errors
   matches.forEach(match => {
     if (!(match.route.id in results)) {
@@ -4228,10 +4746,12 @@ function processRouteLoaderData(matches, results, pendingActionResult, isStaticH
           errors[boundaryMatch.route.id] = error;
         }
       }
+
       // Clear our any prior loaderData for the throwing route
       if (!isStaticHandler) {
         loaderData[id] = ResetLoaderDataSymbol;
       }
+
       // Once we find our first (highest) error, we set the status code and
       // prevent deeper status codes from overriding
       if (!foundError) {
@@ -4253,6 +4773,7 @@ function processRouteLoaderData(matches, results, pendingActionResult, isStaticH
       }
     }
   });
+
   // If we didn't consume the pending action error (i.e., all loaders
   // resolved), then consume it here.  Also clear out any loaderData for the
   // throwing route
@@ -4274,6 +4795,7 @@ function processLoaderData(state, matches, results, pendingActionResult, revalid
     loaderData,
     errors
   } = processRouteLoaderData(matches, results, pendingActionResult);
+
   // Process results from our revalidating fetchers
   revalidatingFetchers.forEach(rf => {
     let {
@@ -4283,6 +4805,7 @@ function processLoaderData(state, matches, results, pendingActionResult, revalid
     } = rf;
     let result = fetcherResults[key];
     !result ? process.env.NODE_ENV !== "production" ? invariant$2(false, "Did not find corresponding fetcher result") : invariant$2(false) : void 0;
+
     // Process fetcher non-redirect errors
     if (controller && controller.signal.aborted) {
       // Nothing to do for aborted fetchers
@@ -4319,6 +4842,7 @@ function mergeLoaderData(loaderData, newLoaderData, matches, errors) {
     merged[k] = v;
     return merged;
   }, {});
+
   // Preserve existing `loaderData` for routes not included in `newLoaderData` and
   // where a loader wasn't removed by HMR
   for (let match of matches) {
@@ -4346,6 +4870,7 @@ function getActionDataForCommit(pendingActionResult) {
     }
   };
 }
+
 // Find the nearest error boundary, looking upwards from the leaf route (or the
 // route specified by routeId) for the closest ancestor error boundary,
 // defaulting to the root match
@@ -4401,6 +4926,7 @@ function getInternalRouterError(status, _temp5) {
   }
   return new ErrorResponseImpl(status || 500, statusText, new Error(errorMessage), true);
 }
+
 // Find any returned redirect errors, starting from the lowest match
 function findRedirect(results) {
   let entries = Object.entries(results);
@@ -4434,6 +4960,7 @@ function isHashChangeOnly(a, b) {
     // /page#hash -> /page#other
     return true;
   }
+
   // If the hash is removed the browser will re-perform a request to the server
   // /page#hash -> /page
   return false;
@@ -4441,8 +4968,8 @@ function isHashChangeOnly(a, b) {
 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;
@@ -4453,16 +4980,14 @@ function isRedirectResult(result) {
 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());
@@ -4673,6 +5198,9 @@ function createDeferred$1() {
 }
 //#endregion
 
+// Create react-specific types from the agnostic types in @remix-run/router to
+// export from react-router
+
 const DataRouterContext = /*#__PURE__*/React.createContext(null);
 DataRouterContext.displayName = "DataRouter";
 const DataRouterStateContext = /*#__PURE__*/React.createContext(null);
@@ -4681,10 +5209,24 @@ const ViewTransitionContext = /*#__PURE__*/React.createContext({
   isTransitioning: false
 });
 ViewTransitionContext.displayName = "ViewTransition";
+
+// TODO: (v7) Change the useFetcher data from `any` to `unknown`
+
 const FetchersContext = /*#__PURE__*/React.createContext(new Map());
 FetchersContext.displayName = "Fetchers";
 const AwaitContext = /*#__PURE__*/React.createContext(null);
 AwaitContext.displayName = "Await";
+
+/**
+ * A Navigator is a "location changer"; it's how you get to different locations.
+ *
+ * Every history instance conforms to the Navigator interface, but the
+ * distinction is useful primarily when it comes to the low-level `<Router>` API
+ * where both the location and a navigator must be provided separately in order
+ * to avoid "tearing" that may occur in a suspense-enabled app if the action
+ * and/or location were to be read directly from the history instance.
+ */
+
 const NavigationContext = /*#__PURE__*/React.createContext(null);
 NavigationContext.displayName = "Navigation";
 const LocationContext = /*#__PURE__*/React.createContext(null);
@@ -4731,6 +5273,7 @@ function useHref(to, _temp) {
     relative
   });
   let joinedPathname = pathname;
+
   // If we're operating within a basename, prepend it to the pathname prior
   // to creating the href.  If this is a root navigation, then just use the raw
   // basename which allows the basename to have full control over the presence
@@ -4744,6 +5287,7 @@ function useHref(to, _temp) {
     hash
   });
 }
+
 /**
  * Returns true if this component is a descendant of a Router, useful to ensure
  * a component is used within a Router.
@@ -4753,6 +5297,7 @@ function useHref(to, _temp) {
 function useInRouterContext() {
   return React.useContext(LocationContext) != null;
 }
+
 /**
   Returns the current {@link Location}. This can be useful if you'd like to perform some side effect whenever it changes.
 
@@ -4782,6 +5327,7 @@ function useLocation() {
   "useLocation() may be used only in the context of a <Router> component.") : invariant$2(false) : void 0;
   return React.useContext(LocationContext).location;
 }
+
 /**
  * Returns the current navigation action which describes how the router came to
  * the current location, either by a pop, push, or replace on the history stack.
@@ -4791,6 +5337,7 @@ function useLocation() {
 function useNavigationType() {
   return React.useContext(LocationContext).navigationType;
 }
+
 /**
  * Returns a PathMatch object if the given pattern matches the current URL.
  * This is useful for components that need to know "active" state, e.g.
@@ -4807,7 +5354,13 @@ function useMatch(pattern) {
   } = useLocation();
   return React.useMemo(() => matchPath(pattern, decodePath(pathname)), [pathname, pattern]);
 }
+
+/**
+ * The interface for the navigate() function returned from useNavigate().
+ */
+
 const navigateEffectWarning = "You should call navigate() in a React.useEffect(), not when " + "your component is first rendered.";
+
 // Mute warnings for calls to useNavigate in SSR environments
 function useIsomorphicLayoutEffect(cb) {
   let isStatic = React.useContext(NavigationContext).static;
@@ -4818,6 +5371,7 @@ function useIsomorphicLayoutEffect(cb) {
     React.useLayoutEffect(cb);
   }
 }
+
 /**
   Returns a function that lets you navigate programmatically in the browser in response to user interactions or effects.
 
@@ -4873,6 +5427,7 @@ function useNavigateUnstable() {
       options = {};
     }
     process.env.NODE_ENV !== "production" ? warning(activeRef.current, navigateEffectWarning) : void 0;
+
     // Short circuit here since if this happens on first render the navigate
     // is useless because we haven't wired up our history listener yet
     if (!activeRef.current) return;
@@ -4881,6 +5436,7 @@ function useNavigateUnstable() {
       return;
     }
     let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, options.relative === "path");
+
     // If we're operating within a basename, prepend it to the pathname prior
     // to handing off to history (but only if we're not in a data router,
     // otherwise it'll prepend the basename inside of the router).
@@ -4895,6 +5451,7 @@ function useNavigateUnstable() {
   return navigate;
 }
 const OutletContext = /*#__PURE__*/React.createContext(null);
+
 /**
  * Returns the parent route {@link OutletProps.context | `<Outlet context>`}.
  *
@@ -4903,6 +5460,7 @@ const OutletContext = /*#__PURE__*/React.createContext(null);
 function useOutletContext() {
   return React.useContext(OutletContext);
 }
+
 /**
  * Returns the element for the child route at this level of the route
  * hierarchy. Used internally by `<Outlet>` to render child routes.
@@ -4918,6 +5476,7 @@ function useOutlet(context) {
   }
   return outlet;
 }
+
 /**
   Returns an object of key/value pairs of the dynamic params from the current URL that were matched by the routes. Child routes inherit all params from their parent routes.
 
@@ -4941,6 +5500,7 @@ function useParams() {
   let routeMatch = matches[matches.length - 1];
   return routeMatch ? routeMatch.params : {};
 }
+
 /**
   Resolves the pathname of the given `to` value against the current location. Similar to {@link useHref}, but returns a {@link Path} instead of a string.
 
@@ -4971,6 +5531,7 @@ function useResolvedPath(to, _temp2) {
   let routePathnamesJson = JSON.stringify(getResolveToMatches(matches));
   return React.useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, relative === "path"), [to, routePathnamesJson, locationPathname, relative]);
 }
+
 /**
   Hook version of {@link Routes | `<Routes>`} that uses objects instead of components. These objects have the same properties as the component props.
 
@@ -5005,6 +5566,7 @@ function useResolvedPath(to, _temp2) {
 function useRoutes(routes, locationArg) {
   return useRoutesImpl(routes, locationArg);
 }
+
 /**
  * Internal implementation with accept optional param for RouterProvider usage
  *
@@ -5097,6 +5659,7 @@ function useRoutesImpl(routes, locationArg, dataRouterState, future) {
     // Re-encode pathnames that were decoded inside matchRoutes
     navigator.encodeLocation ? navigator.encodeLocation(match.pathnameBase).pathname : match.pathnameBase])
   })), parentMatches, dataRouterState);
+
   // When a user passes in a `locationArg`, the associated routes need to
   // be wrapped in a new `LocationContext.Provider` in order for `useLocation`
   // to use the scoped location instead of the global location.
@@ -5177,6 +5740,7 @@ class RenderErrorBoundary extends React.Component {
         revalidation: props.revalidation
       };
     }
+
     // If we're not changing locations, preserve the location but still surface
     // any new errors that may come through. We retain the existing error, we do
     // this because the error provided from the app state may be cleared without
@@ -5191,12 +5755,12 @@ class RenderErrorBoundary extends React.Component {
     console.error("React Router caught the following error during render", error, errorInfo);
   }
   render() {
-    return this.state.error !== undefined ? ( /*#__PURE__*/React.createElement(RouteContext.Provider, {
+    return this.state.error !== undefined ? /*#__PURE__*/React.createElement(RouteContext.Provider, {
       value: this.props.routeContext
     }, /*#__PURE__*/React.createElement(RouteErrorContext.Provider, {
       value: this.state.error,
       children: this.props.component
-    }))) : this.props.children;
+    })) : this.props.children;
   }
 }
 function RenderedRoute(_ref) {
@@ -5206,6 +5770,7 @@ function RenderedRoute(_ref) {
     children
   } = _ref;
   let dataRouterContext = React.useContext(DataRouterContext);
+
   // Track how deep we got in our render pass to emulate SSR componentDidCatch
   // in a DataStaticRouter
   if (dataRouterContext && dataRouterContext.static && dataRouterContext.staticContext && (match.route.errorElement || match.route.ErrorBoundary)) {
@@ -5244,6 +5809,7 @@ function _renderMatches(matches, parentMatches, dataRouterState, future) {
     }
   }
   let renderedMatches = matches;
+
   // If we have data errors, trim matches to the highest error boundary
   let errors = (_dataRouterState = dataRouterState) == null ? void 0 : _dataRouterState.errors;
   if (errors != null) {
@@ -5251,6 +5817,7 @@ function _renderMatches(matches, parentMatches, dataRouterState, future) {
     !(errorIndex >= 0) ? process.env.NODE_ENV !== "production" ? invariant$2(false, "Could not find a matching route for errors on route IDs: " + Object.keys(errors).join(",")) : invariant$2(false) : void 0;
     renderedMatches = renderedMatches.slice(0, Math.min(renderedMatches.length, errorIndex + 1));
   }
+
   // If we're in a partial hydration mode, detect if we need to render down to
   // a given HydrateFallback while we load the rest of the hydration data
   let renderFallback = false;
@@ -5336,7 +5903,7 @@ function _renderMatches(matches, parentMatches, dataRouterState, future) {
     // Only wrap in an error boundary within data router usages when we have an
     // ErrorBoundary/errorElement on this route.  Otherwise let it bubble up to
     // an ancestor ErrorBoundary/errorElement
-    return dataRouterState && (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? ( /*#__PURE__*/React.createElement(RenderErrorBoundary, {
+    return dataRouterState && (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? /*#__PURE__*/React.createElement(RenderErrorBoundary, {
       location: dataRouterState.location,
       revalidation: dataRouterState.revalidation,
       component: errorElement,
@@ -5347,17 +5914,16 @@ function _renderMatches(matches, parentMatches, dataRouterState, future) {
         matches,
         isDataRoute: true
       }
-    })) : getChildren();
+    }) : getChildren();
   }, null);
 }
-var DataRouterHook$1;
-(function (DataRouterHook) {
+var DataRouterHook$1 = /*#__PURE__*/function (DataRouterHook) {
   DataRouterHook["UseBlocker"] = "useBlocker";
   DataRouterHook["UseRevalidator"] = "useRevalidator";
   DataRouterHook["UseNavigateStable"] = "useNavigate";
-})(DataRouterHook$1 || (DataRouterHook$1 = {}));
-var DataRouterStateHook$1;
-(function (DataRouterStateHook) {
+  return DataRouterHook;
+}(DataRouterHook$1 || {});
+var DataRouterStateHook$1 = /*#__PURE__*/function (DataRouterStateHook) {
   DataRouterStateHook["UseBlocker"] = "useBlocker";
   DataRouterStateHook["UseLoaderData"] = "useLoaderData";
   DataRouterStateHook["UseActionData"] = "useActionData";
@@ -5368,7 +5934,8 @@ var DataRouterStateHook$1;
   DataRouterStateHook["UseRevalidator"] = "useRevalidator";
   DataRouterStateHook["UseNavigateStable"] = "useNavigate";
   DataRouterStateHook["UseRouteId"] = "useRouteId";
-})(DataRouterStateHook$1 || (DataRouterStateHook$1 = {}));
+  return DataRouterStateHook;
+}(DataRouterStateHook$1 || {});
 function getDataRouterConsoleError$1(hookName) {
   return hookName + " must be used within a data router.  See https://reactrouter.com/en/main/routers/picking-a-router.";
 }
@@ -5387,6 +5954,7 @@ function useRouteContext(hookName) {
   !route ? process.env.NODE_ENV !== "production" ? invariant$2(false, getDataRouterConsoleError$1(hookName)) : invariant$2(false) : void 0;
   return route;
 }
+
 // Internal version with hookName-aware debugging
 function useCurrentRouteId(hookName) {
   let route = useRouteContext(hookName);
@@ -5394,12 +5962,14 @@ function useCurrentRouteId(hookName) {
   !thisRoute.route.id ? process.env.NODE_ENV !== "production" ? invariant$2(false, hookName + " can only be used on routes that contain a unique \"id\"") : invariant$2(false) : void 0;
   return thisRoute.route.id;
 }
+
 /**
  * Returns the ID for the nearest contextual route
  */
 function useRouteId() {
   return useCurrentRouteId(DataRouterStateHook$1.UseRouteId);
 }
+
 /**
   Returns the current navigation, defaulting to an "idle" navigation when no navigation is in progress. You can use this to render pending UI (like a global spinner) or read FormData from a form navigation.
 
@@ -5420,6 +5990,7 @@ function useNavigation() {
   let state = useDataRouterState$1(DataRouterStateHook$1.UseNavigation);
   return state.navigation;
 }
+
 /**
   Revalidate the data on the page for reasons outside of normal data mutations like window focus or polling on an interval.
 
@@ -5455,6 +6026,7 @@ function useRevalidator() {
     state: state.revalidation
   }), [dataRouterContext.router, state.revalidation]);
 }
+
 /**
  * Returns the active route matches, useful for accessing loaderData for
  * parent/child routes or the route "handle" property
@@ -5468,6 +6040,7 @@ function useMatches() {
   } = useDataRouterState$1(DataRouterStateHook$1.UseMatches);
   return React.useMemo(() => matches.map(m => convertRouteMatchToUiMatch(m, loaderData)), [matches, loaderData]);
 }
+
 /**
   Returns the data from the closest route {@link LoaderFunction | loader} or {@link ClientLoaderFunction | client loader}.
 
@@ -5491,6 +6064,7 @@ function useLoaderData() {
   let routeId = useCurrentRouteId(DataRouterStateHook$1.UseLoaderData);
   return state.loaderData[routeId];
 }
+
 /**
   Returns the loader data for a given route by route ID.
 
@@ -5522,6 +6096,7 @@ function useRouteLoaderData(routeId) {
   let state = useDataRouterState$1(DataRouterStateHook$1.UseRouteLoaderData);
   return state.loaderData[routeId];
 }
+
 /**
   Returns the action data from the most recent POST navigation form submission or `undefined` if there hasn't been one.
 
@@ -5552,6 +6127,7 @@ function useActionData() {
   let routeId = useCurrentRouteId(DataRouterStateHook$1.UseLoaderData);
   return state.actionData ? state.actionData[routeId] : undefined;
 }
+
 /**
   Accesses the error thrown during an {@link ActionFunction | action}, {@link LoaderFunction | loader}, or component render to be used in a route module Error Boundary.
 
@@ -5569,14 +6145,17 @@ function useRouteError() {
   let error = React.useContext(RouteErrorContext);
   let state = useDataRouterState$1(DataRouterStateHook$1.UseRouteError);
   let routeId = useCurrentRouteId(DataRouterStateHook$1.UseRouteError);
+
   // If this was a render error, we put it in a RouteError context inside
   // of RenderErrorBoundary
   if (error !== undefined) {
     return error;
   }
+
   // Otherwise look for errors from our data router state
   return (_state$errors = state.errors) == null ? void 0 : _state$errors[routeId];
 }
+
 /**
   Returns the resolved promise value from the closest {@link Await | `<Await>`}.
 
@@ -5598,6 +6177,7 @@ function useAsyncValue() {
   let value = React.useContext(AwaitContext);
   return value == null ? void 0 : value._data;
 }
+
 /**
   Returns the rejection value from the closest {@link Await | `<Await>`}.
 
@@ -5625,6 +6205,7 @@ function useAsyncError() {
   return value == null ? void 0 : value._error;
 }
 let blockerId = 0;
+
 /**
  * Allow the application to block navigations within the SPA and present the
  * user a confirmation dialog to confirm the navigation.  Mostly used to avoid
@@ -5647,6 +6228,7 @@ function useBlocker(shouldBlock) {
     if (basename === "/") {
       return shouldBlock(arg);
     }
+
     // If they provided us a function and we've got an active basename, strip
     // it from the locations we expose to the user to match the behavior of
     // useLocation
@@ -5665,6 +6247,7 @@ function useBlocker(shouldBlock) {
       historyAction
     });
   }, [basename, shouldBlock]);
+
   // This effect is in charge of blocker key assignment and deletion (which is
   // tightly coupled to the key)
   React.useEffect(() => {
@@ -5672,6 +6255,7 @@ function useBlocker(shouldBlock) {
     setBlockerKey(key);
     return () => router.deleteBlocker(key);
   }, [router]);
+
   // This effect handles assigning the blockerFunction.  This is to handle
   // unstable blocker function identities, and happens only after the prior
   // effect so we don't get an orphaned blockerFunction in the router with a
@@ -5681,10 +6265,12 @@ function useBlocker(shouldBlock) {
       router.getBlocker(blockerKey, blockerFunction);
     }
   }, [router, blockerKey, blockerFunction]);
+
   // Prefer the blocker from `state` not `router.state` since DataRouterContext
   // is memoized so this ensures we update on blocker state updates
   return blockerKey && state.blockers.has(blockerKey) ? state.blockers.get(blockerKey) : IDLE_BLOCKER;
 }
+
 /**
  * Stable version of useNavigate that is used when we are in the context of
  * a RouterProvider.
@@ -5705,6 +6291,7 @@ function useNavigateStable() {
       options = {};
     }
     process.env.NODE_ENV !== "production" ? warning(activeRef.current, navigateEffectWarning) : void 0;
+
     // Short circuit here since if this happens on first render the navigate
     // is useless because we haven't wired up our router subscriber yet
     if (!activeRef.current) return;
@@ -5778,6 +6365,7 @@ function mapRouteProperties(route) {
   }
   return updates;
 }
+
 /**
  * @category Routers
  */
@@ -5797,6 +6385,10 @@ function createMemoryRouter(routes, opts) {
   }).initialize();
 }
 class Deferred {
+  // @ts-expect-error - no initializer
+
+  // @ts-expect-error - no initializer
+
   constructor() {
     this.status = "pending";
     this.promise = new Promise((resolve, reject) => {
@@ -5815,6 +6407,9 @@ class Deferred {
     });
   }
 }
+
+// Copied from react-dom types
+
 /**
  * Given a Remix Router instance, render the appropriate UI
  */
@@ -5835,8 +6430,8 @@ function RouterProvider(_ref) {
   let setState = React.useCallback((newState, _ref2) => {
     let {
       deletedFetchers,
-      flushSync: flushSync,
-      viewTransitionOpts: viewTransitionOpts
+      flushSync,
+      viewTransitionOpts
     } = _ref2;
     deletedFetchers.forEach(key => fetcherData.current.delete(key));
     newState.fetchers.forEach((fetcher, key) => {
@@ -5847,6 +6442,7 @@ function RouterProvider(_ref) {
     warnOnce(flushSync === false || reactDomFlushSyncImpl != null, "You provided the `flushSync` option to a router update, " + "but you are not using the `<RouterProvider>` from `react-router/dom` " + "so `ReactDOM.flushSync()` is unavailable.  Please update your app " + 'to `import { RouterProvider } from "react-router/dom"` and ensure ' + "you have `react-dom` installed as a dependency to use the " + "`flushSync` option.");
     let isViewTransitionAvailable = router.window != null && router.window.document != null && typeof router.window.document.startViewTransition === "function";
     warnOnce(viewTransitionOpts == null || isViewTransitionAvailable, "You provided the `viewTransition` option to a router update, " + "but you do not appear to be running in a DOM environment as " + "`window.startViewTransition` is not available.");
+
     // If this isn't a view transition or it's not available in this browser,
     // just update and be done with it
     if (!viewTransitionOpts || !isViewTransitionAvailable) {
@@ -5857,6 +6453,7 @@ function RouterProvider(_ref) {
       }
       return;
     }
+
     // flushSync + startViewTransition
     if (reactDomFlushSyncImpl && flushSync) {
       // Flush through the context to mark DOM elements as transition=ing
@@ -5873,10 +6470,12 @@ function RouterProvider(_ref) {
           nextLocation: viewTransitionOpts.nextLocation
         });
       });
+
       // Update the DOM
       let t = router.window.document.startViewTransition(() => {
         reactDomFlushSyncImpl(() => setStateImpl(newState));
       });
+
       // Clean up after the animation completes
       t.finished.finally(() => {
         reactDomFlushSyncImpl(() => {
@@ -5891,6 +6490,7 @@ function RouterProvider(_ref) {
       reactDomFlushSyncImpl(() => setTransition(t));
       return;
     }
+
     // startTransition + startViewTransition
     if (transition) {
       // Interrupting an in-progress transition, cancel and let everything flush
@@ -5913,9 +6513,11 @@ function RouterProvider(_ref) {
       });
     }
   }, [router.window, reactDomFlushSyncImpl, transition, renderDfd]);
+
   // Need to use a layout effect here so we are subscribed early enough to
   // pick up on any render-driven redirects/navigations (useEffect/<Navigate>)
   React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);
+
   // When we start a view transition, create a Deferred we can use for the
   // eventual "completed" render
   React.useEffect(() => {
@@ -5923,6 +6525,7 @@ function RouterProvider(_ref) {
       setRenderDfd(new Deferred());
     }
   }, [vtContext]);
+
   // Once the deferred is created, kick off startViewTransition() to update the
   // DOM and then wait on the Deferred to resolve (indicating the DOM update has
   // happened)
@@ -5945,6 +6548,7 @@ function RouterProvider(_ref) {
       setTransition(transition);
     }
   }, [pendingState, renderDfd, router.window]);
+
   // When the new location finally renders and is committed to the DOM, this
   // effect will run to resolve the transition
   React.useEffect(() => {
@@ -5952,6 +6556,7 @@ function RouterProvider(_ref) {
       renderDfd.resolve();
     }
   }, [renderDfd, transition, state.location, pendingState]);
+
   // If we get interrupted with a new navigation during a transition, we skip
   // the active transition, let it cleanup, then kick it off again here
   React.useEffect(() => {
@@ -5989,6 +6594,7 @@ function RouterProvider(_ref) {
     static: false,
     basename
   }), [router, navigator, basename]);
+
   // The fragment and {null} here are important!  We need them to keep React 18's
   // useId happy when we are server-rendering since we may have a <script> here
   // containing the hydrated server-side staticContext (from StaticRouterProvider).
@@ -6014,6 +6620,7 @@ function RouterProvider(_ref) {
     state: state
   })))))), null);
 }
+
 // Memoize to avoid re-renders when updating `ViewTransitionContext`
 const MemoizedDataRoutes = /*#__PURE__*/React.memo(DataRoutes$1);
 function DataRoutes$1(_ref3) {
@@ -6024,6 +6631,11 @@ function DataRoutes$1(_ref3) {
   } = _ref3;
   return useRoutesImpl(routes, undefined, state);
 }
+
+/**
+ * @category Types
+ */
+
 /**
  * A `<Router>` that stores all entries in memory.
  *
@@ -6061,6 +6673,11 @@ function MemoryRouter(_ref4) {
     navigator: history
   });
 }
+
+/**
+ * @category Types
+ */
+
 /**
  * A component-based version of {@link useNavigate} to use in a [`React.Component
  * Class`](https://reactjs.org/docs/react-component.html) where hooks are not
@@ -6091,6 +6708,7 @@ function Navigate(_ref5) {
     pathname: locationPathname
   } = useLocation();
   let navigate = useNavigate();
+
   // Resolve the path outside of the effect so that when effects run twice in
   // StrictMode they navigate to the same place
   let path = resolveTo(to, getResolveToMatches(matches), locationPathname, relative === "path");
@@ -6104,6 +6722,11 @@ function Navigate(_ref5) {
   }, [navigate, jsonPath, relative, replace, state]);
   return null;
 }
+
+/**
+ * @category Types
+ */
+
 /**
   Renders the matching child route of a parent route or nothing if no child route matches.
 
@@ -6125,6 +6748,19 @@ function Navigate(_ref5) {
 function Outlet(props) {
   return useOutlet(props.context);
 }
+
+/**
+ * @category Types
+ */
+
+/**
+ * @category Types
+ */
+
+/**
+ * @category Types
+ */
+
 /**
  * Configures an element to render when a pattern matches the current location.
  * It must be rendered within a {@link Routes} element. Note that these routes
@@ -6136,6 +6772,11 @@ function Outlet(props) {
 function Route(_props) {
   process.env.NODE_ENV !== "production" ? invariant$2(false, "A <Route> is only ever to be used as the child of <Routes> element, " + "never rendered directly. Please wrap your <Route> in a <Routes>.") : invariant$2(false) ;
 }
+
+/**
+ * @category Types
+ */
+
 /**
  * Provides location context for the rest of the app.
  *
@@ -6155,6 +6796,7 @@ function Router(_ref6) {
     static: staticProp = false
   } = _ref6;
   !!useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant$2(false, "You cannot render a <Router> inside another <Router>." + " You should never have more than one in your app.") : invariant$2(false) : void 0;
+
   // Preserve trailing slashes on basename, so we can let the user control
   // the enforcement of trailing slashes throughout the app
   let basename = basenameProp.replace(/^\/*/, "/");
@@ -6201,6 +6843,11 @@ function Router(_ref6) {
     value: locationContext
   }));
 }
+
+/**
+ * @category Types
+ */
+
 /**
  Renders a branch of {@link Route | `<Routes>`} that best matches the current
  location. Note that these routes do not participate in data loading, actions,
@@ -6225,6 +6872,11 @@ function Routes(_ref7) {
   } = _ref7;
   return useRoutes(createRoutesFromChildren(children), location);
 }
+
+/**
+ * @category Types
+ */
+
 /**
 Used to render promise values with automatic error handling.
 
@@ -6277,12 +6929,12 @@ function Await(_ref8) {
     errorElement: errorElement
   }, /*#__PURE__*/React.createElement(ResolveAwait, null, children));
 }
-var AwaitRenderStatus;
-(function (AwaitRenderStatus) {
+var AwaitRenderStatus = /*#__PURE__*/function (AwaitRenderStatus) {
   AwaitRenderStatus[AwaitRenderStatus["pending"] = 0] = "pending";
   AwaitRenderStatus[AwaitRenderStatus["success"] = 1] = "success";
   AwaitRenderStatus[AwaitRenderStatus["error"] = 2] = "error";
-})(AwaitRenderStatus || (AwaitRenderStatus = {}));
+  return AwaitRenderStatus;
+}(AwaitRenderStatus || {});
 class AwaitErrorBoundary extends React.Component {
   constructor(props) {
     super(props);
@@ -6361,10 +7013,12 @@ class AwaitErrorBoundary extends React.Component {
         children: children
       });
     }
+
     // Throw to the suspense boundary
     throw promise;
   }
 }
+
 /**
  * @private
  * Indirection to leverage useAsyncValue for a render-prop API on `<Await>`
@@ -6377,9 +7031,11 @@ function ResolveAwait(_ref9) {
   let toRender = typeof children === "function" ? children(data) : children;
   return /*#__PURE__*/React.createElement(React.Fragment, null, toRender);
 }
+
 ///////////////////////////////////////////////////////////////////////////////
 // UTILS
 ///////////////////////////////////////////////////////////////////////////////
+
 /**
  * Creates a route config from a React "children" object, which is usually
  * either a `<Route>` element or an array of them. Used internally by
@@ -6431,6 +7087,7 @@ function createRoutesFromChildren(children, parentPath) {
   });
   return routes;
 }
+
 /**
  * Renders the result of `matchRoutes()` into a React element.
  *
@@ -6518,6 +7175,9 @@ function getSearchParamsForLocation(locationSearch, defaultSearchParams) {
   }
   return searchParams;
 }
+
+// Thanks https://github.com/sindresorhus/type-fest!
+
 // One-time check for submitter support
 let _formDataSupportsSubmitter = null;
 function isFormDataSubmitterSupported() {
@@ -6533,6 +7193,19 @@ function isFormDataSubmitterSupported() {
   }
   return _formDataSupportsSubmitter;
 }
+
+/**
+ * Submit options shared by both navigations and fetchers
+ */
+
+/**
+ * Submit options available to fetchers
+ */
+
+/**
+ * Submit options available to navigations
+ */
+
 const supportedFormEncTypes = new Set(["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"]);
 function getFormEncType(encType) {
   if (encType != null && !supportedFormEncTypes.has(encType)) {
@@ -6561,7 +7234,9 @@ function getFormSubmissionInfo(target, basename) {
     if (form == null) {
       throw new Error("Cannot submit a <button> or <input type=\"submit\"> without a <form>");
     }
+
     // <button>/<input type="submit"> may override attributes of <form>
+
     // When grabbing the action from the element, it will have had the basename
     // prefixed to ensure non-JS scenarios work, so strip it since we'll
     // re-prefix in the router
@@ -6569,8 +7244,10 @@ function getFormSubmissionInfo(target, basename) {
     action = attr ? stripBasename(attr, basename) : null;
     method = target.getAttribute("formmethod") || form.getAttribute("method") || defaultMethod;
     encType = getFormEncType(target.getAttribute("formenctype")) || getFormEncType(form.getAttribute("enctype")) || defaultEncType;
+
     // Build a FormData object populated from a form and submitter
     formData = new FormData(form, target);
+
     // If this browser doesn't support the `FormData(el, submitter)` format,
     // then tack on the submitter value at the end.  This is a lightweight
     // solution that is not 100% spec compliant.  For complete support in older
@@ -6597,6 +7274,7 @@ function getFormSubmissionInfo(target, basename) {
     encType = defaultEncType;
     body = target;
   }
+
   // Send body for <Form encType="text/plain" so we encode it into text
   if (formData && encType === "text/plain") {
     body = formData;
@@ -6617,6 +7295,105 @@ function invariant$1(value, message) {
   }
 }
 
+/**
+ * A function that handles data mutations for a route on the client
+ */
+
+/**
+ * Arguments passed to a route `clientAction` function
+ */
+
+/**
+ * A function that loads data for a route on the client
+ */
+
+/**
+ * Arguments passed to a route `clientLoader` function
+ */
+
+/**
+ * ErrorBoundary to display for this route
+ */
+
+/**
+ * `<Route HydrateFallback>` component to render on initial loads
+ * when client loaders are present
+ */
+
+/**
+ * Optional, root-only `<Route Layout>` component to wrap the root content in.
+ * Useful for defining the <html>/<head>/<body> document shell shared by the
+ * Component, HydrateFallback, and ErrorBoundary
+ */
+
+/**
+ * A function that defines `<link>` tags to be inserted into the `<head>` of
+ * the document on route transitions.
+ *
+ * @see https://remix.run/route/meta
+ */
+
+/**
+ * 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.
+ */
+
+/**
+ * An arbitrary object that is associated with a route.
+ *
+ * @see https://remix.run/route/handle
+ */
+
 async function loadRouteModule(route, routeModulesCache) {
   if (route.id in routeModulesCache) {
     return routeModulesCache[route.id];
@@ -6634,6 +7411,7 @@ async function loadRouteModule(route, routeModulesCache) {
     // - Or, the asset trying to be imported has an error (usually in vite dev
     //   mode), so the best we can do here is log the error for visibility
     //   (via `Preserve log`) and reload
+
     // Log the error so it can be accessed via the `Preserve Log` setting
     console.error("Error loading route module `" + route.module + "`, reloading page...");
     console.error(error);
@@ -6661,7 +7439,7 @@ function getKeyedLinksForMatches(matches, routeModules, manifest) {
   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()) || []];
@@ -6691,6 +7469,7 @@ async function prefetchStyleLinks(route, routeModule) {
       }));
     }
   }
+
   // don't block for non-matching media queries, or for stylesheets that are
   // already in the DOM (active route revalidations)
   let matchingLinks = styleLinks.filter(link => (!link.media || window.matchMedia(link.media).matches) && !document.querySelector("link[rel=\"stylesheet\"][href=\"" + link.href + "\"]"));
@@ -6719,6 +7498,7 @@ async function prefetchStyleLink(descriptor) {
     document.head.appendChild(link);
   });
 }
+
 ////////////////////////////////////////////////////////////////////////////////
 function isPageLinkDescriptor(object) {
   return object != null && typeof object.page === "string";
@@ -6727,6 +7507,7 @@ function isHtmlLinkDescriptor(object) {
   if (object == null) {
     return false;
   }
+
   // <link> may not have an href if <link rel="preload"> is used with imageSrcSet + imageSizes
   // https://github.com/remix-run/remix/issues/184
   // https://html.spec.whatwg.org/commit-snapshots/cb4f5ff75de5f4cbd7013c4abad02f21c77d4d1c/#attr-link-imagesrcset
@@ -6737,8 +7518,12 @@ function isHtmlLinkDescriptor(object) {
 }
 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",
@@ -6747,9 +7532,9 @@ async function getKeyedPrefetchLinks(matches, manifest, routeModules) {
     rel: "prefetch"
   })));
 }
+
 // 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;
@@ -6764,42 +7549,45 @@ function getNewMatchesForLinks(page, nextMatches, currentMatches, manifest, loca
       ((_currentMatches$index = currentMatches[index].route.path) == null ? void 0 : _currentMatches$index.endsWith("*")) && currentMatches[index].params["*"] !== match.params["*"]
     );
   };
-  // NOTE: keep this mostly up-to-date w/ the transition data diff, but this
+  if (mode === "assets") {
+    return nextMatches.filter((match, index) => isNew(match, index) || matchPathChanged(match, index));
+  }
+
+  // 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);
@@ -6807,12 +7595,14 @@ function getModuleLinkHrefs(matches, manifestPatch) {
     return hrefs;
   }).flat(1));
 }
+
 // The `<Script>` will render rel=modulepreload for the current page, we don't
 // need to include them in a page prefetch, this gives us the list to remove
 // while deduping.
 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);
@@ -6850,12 +7640,7 @@ function dedupeLinkDescriptors(descriptors, preloads) {
     return deduped;
   }, []);
 }
-// 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
@@ -6872,8 +7657,10 @@ function isPreloadSupported() {
 
 // This escapeHtml utility is based on https://github.com/zertosh/htmlescape
 // License: https://github.com/zertosh/htmlescape/blob/0527ca7156a524d256101bb310a9f970f63078ad/LICENSE
+
 // We've chosen to inline the utility here to reduce the number of npm dependencies we have,
 // slightly decrease the code size compared the original package and make it esm compatible.
+
 const ESCAPE_LOOKUP$2 = {
   "&": "\\u0026",
   ">": "\\u003e",
@@ -6891,9 +7678,6 @@ function createHtml(html) {
   };
 }
 
-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
@@ -6901,6 +7685,7 @@ async function createRequestInit(request) {
   if (request.method !== "GET") {
     init.method = request.method;
     let contentType = request.headers.get("Content-Type");
+
     // Check between word boundaries instead of startsWith() due to the last
     // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type
     if (contentType && /\bapplication\/json\b/.test(contentType)) {
@@ -6967,12 +7752,12 @@ function StreamTransfer(_ref) {
     done,
     value
   } = promise.result;
-  let scriptTag = value ? ( /*#__PURE__*/React.createElement("script", {
+  let scriptTag = value ? /*#__PURE__*/React.createElement("script", {
     nonce: nonce,
     dangerouslySetInnerHTML: {
       __html: "window.__reactRouterContext.streamController.enqueue(" + escapeHtml$1(JSON.stringify(value)) + ");"
     }
-  })) : null;
+  }) : null;
   if (done) {
     return /*#__PURE__*/React.createElement(React.Fragment, null, scriptTag, /*#__PURE__*/React.createElement("script", {
       nonce: nonce,
@@ -7001,14 +7786,17 @@ function getSingleFetchDataStrategy$1(manifest, routeModules, getRouter) {
     if (request.method !== "GET") {
       return singleFetchActionStrategy(request, matches);
     }
+
     // Fetcher loads are singular calls to one loader
     if (fetcherKey) {
       return singleFetchLoaderFetcherStrategy(request, matches);
     }
+
     // Navigational loads are more complex...
     return singleFetchLoaderNavigationStrategy(manifest, routeModules, getRouter(), request, matches);
   };
 }
+
 // Actions are simple since they're singular calls to the server for both
 // navigations and fetchers)
 async function singleFetchActionStrategy(request, matches) {
@@ -7028,11 +7816,12 @@ async function singleFetchActionStrategy(request, matches) {
     });
     return result;
   });
-  if (isResponse$1(result.result) || isRouteErrorResponse(result.result)) {
+  if (isResponse(result.result) || isRouteErrorResponse(result.result)) {
     return {
       [actionMatch.route.id]: result
     };
   }
+
   // For non-responses, proxy along the statusCode via data()
   // (most notably for skipping action error revalidation)
   return {
@@ -7042,30 +7831,37 @@ async function singleFetchActionStrategy(request, matches) {
     }
   };
 }
+
 // Loaders are trickier since we only want to hit the server once, so we
 // create a singular promise for all server-loader routes to latch onto.
 async function singleFetchLoaderNavigationStrategy(manifest, routeModules, router, request, matches) {
   // Track which routes need a server load - in case we need to tack on a
   // `_routes` param
   let routesParams = new Set();
+
   // We only add `_routes` when one or more routes opts out of a load via
   // `shouldRevalidate` or `clientLoader`
   let foundOptOutRoute = false;
+
   // Deferreds for each route so we can be sure they've all loaded via
   // `match.resolve()`, and a singular promise that can tell us all routes
   // have been resolved
   let routeDfds = matches.map(() => createDeferred());
   let routesLoadedPromise = Promise.all(routeDfds.map(d => d.promise));
+
   // Deferred that we'll use for the call to the server that each match can
   // await and parse out it's specific result
   let singleFetchDfd = createDeferred();
+
   // Base URL and RequestInit for calls to the server
   let url = stripIndexParam$1(singleFetchUrl(request.url));
   let init = await createRequestInit(request);
+
   // We'll build up this results object as we loop through matches
   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
@@ -7074,18 +7870,20 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, route
       if (!router.state.initialized) {
         return;
       }
+
       // 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;
       }
     }
+
     // 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 {
@@ -7102,10 +7900,12 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, route
       }
       return;
     }
+
     // 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);
     }
+
     // Lump this match in with the others on a singular promise
     try {
       let result = await handler(async () => {
@@ -7123,8 +7923,10 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, route
       };
     }
   })));
+
   // Wait for all routes to resolve above before we make the HTTP call
   await routesLoadedPromise;
+
   // We can skip the server call:
   // - On initial hydration - only clientLoaders can pass through via `clientLoader.hydrate`
   // - If there are no routes to fetch from the server
@@ -7151,6 +7953,7 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, route
   await resolvePromise;
   return results;
 }
+
 // Fetcher loader calls are much simpler than navigational loader calls
 async function singleFetchLoaderFetcherStrategy(request, matches) {
   let fetcherMatch = matches.find(m => m.shouldLoad);
@@ -7202,6 +8005,7 @@ function singleFetchUrl(reqUrl) {
 }
 async function fetchAndDecode(url, init) {
   let res = await fetch(url, init);
+
   // If this 404'd without hitting the running server (most likely in a
   // pre-rendered app using a CDN), then bubble a standard 404 ErrorResponse
   if (res.status === 404 && !res.headers.has("X-Remix-Response")) {
@@ -7224,6 +8028,7 @@ async function fetchAndDecode(url, init) {
     throw new Error("Unable to decode turbo-stream response");
   }
 }
+
 // Note: If you change this function please change the corresponding
 // encodeViaTurboStream function in server-runtime
 function decodeViaTurboStream(body, global) {
@@ -7360,6 +8165,7 @@ class RemixErrorBoundary extends React.Component {
         location: props.location
       };
     }
+
     // If we're not changing locations, preserve the location but still surface
     // any new errors that may come through. We retain the existing error, we do
     // this because the error provided from the app state may be cleared without
@@ -7380,6 +8186,7 @@ class RemixErrorBoundary extends React.Component {
     }
   }
 }
+
 /**
  * When app's don't provide a root level ErrorBoundary, we default to this.
  */
@@ -7437,16 +8244,19 @@ function BoundaryShell(_ref2) {
   let {
     routeModules
   } = useFrameworkContext();
+
   // Generally speaking, when the root route has a Layout we want to use that
   // as the app shell instead of the default `BoundaryShell` wrapper markup below.
   // This is true for `loader`/`action` errors, most render errors, and
   // `HydrateFallback` scenarios.
+
   // However, render errors thrown from the `Layout` present a bit of an issue
   // because if the `Layout` itself throws during the `ErrorBoundary` pass and
   // we bubble outside the `RouterProvider` to the wrapping `RemixErrorBoundary`,
   // by returning only `children` here we'll be trying to append a `<div>` to
   // the `document` and the DOM will throw, putting React into an error/hydration
   // loop.
+
   // Instead, if we're ever rendering from the outermost `RemixErrorBoundary`
   // during hydration that wraps `RouterProvider`, then we can't trust the
   // `Layout` and should fallback to the default app shell so we're always
@@ -7489,11 +8299,13 @@ function RemixRootDefaultHydrateFallback() {
 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;
 }
@@ -7506,15 +8318,15 @@ function getRouteComponents(route, routeModule, isSpaMode) {
   }) : undefined;
   if (route.id === "root" && routeModule.Layout) {
     return _extends({}, Component ? {
-      element: ( /*#__PURE__*/React.createElement(routeModule.Layout, null, /*#__PURE__*/React.createElement(Component, null)))
+      element: /*#__PURE__*/React.createElement(routeModule.Layout, null, /*#__PURE__*/React.createElement(Component, null))
     } : {
       Component
     }, ErrorBoundary ? {
-      errorElement: ( /*#__PURE__*/React.createElement(routeModule.Layout, null, /*#__PURE__*/React.createElement(ErrorBoundary, null)))
+      errorElement: /*#__PURE__*/React.createElement(routeModule.Layout, null, /*#__PURE__*/React.createElement(ErrorBoundary, null))
     } : {
       ErrorBoundary
     }, HydrateFallback ? {
-      hydrateFallbackElement: ( /*#__PURE__*/React.createElement(routeModule.Layout, null, /*#__PURE__*/React.createElement(HydrateFallback, null)))
+      hydrateFallbackElement: /*#__PURE__*/React.createElement(routeModule.Layout, null, /*#__PURE__*/React.createElement(HydrateFallback, null))
     } : {
       HydrateFallback
     });
@@ -7633,7 +8445,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
       // 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;
@@ -7658,6 +8470,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
               params,
               async serverLoader() {
                 preventInvalidServerHandlerCall("loader", route, isSpaMode);
+
                 // On the first call, resolve with the server result
                 if (isHydrationRequest) {
                   if (hasInitialData) {
@@ -7667,6 +8480,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
                     throw initialError;
                   }
                 }
+
                 // Call the server loader for client-side navigations
                 return fetchServerLoader(singleFetch);
               }
@@ -7679,6 +8493,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
           isHydrationRequest = false;
         }
       };
+
       // Let React Router know whether to run this on hydration
       dataRoute.loader.hydrate = shouldHydrateRouteLoader(route, routeModule, isSpaMode);
       dataRoute.action = (_ref2, singleFetch) => {
@@ -7726,6 +8541,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
           });
         };
       }
+
       // Load all other modules via route.lazy()
       dataRoute.lazy = async () => {
         let mod = await loadRouteModuleWithBlockingLinks(route, routeModulesCache);
@@ -7748,16 +8564,13 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
             }
           }));
         }
-        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()
@@ -7771,6 +8584,23 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
     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
 function wrapShouldRevalidateForHdr(routeId, routeShouldRevalidate, needsRevalidation) {
@@ -7786,6 +8616,7 @@ function wrapShouldRevalidateForHdr(routeId, routeShouldRevalidate, needsRevalid
 async function loadRouteModuleWithBlockingLinks(route, routeModules) {
   let routeModule = await loadRouteModule(route, routeModules);
   await prefetchStyleLinks(route, routeModule);
+
   // Include all `browserSafeRouteExports` fields, except `HydrateFallback`
   // since those aren't used on lazily loaded routes
   return {
@@ -7799,6 +8630,7 @@ async function loadRouteModuleWithBlockingLinks(route, routeModules) {
     shouldRevalidate: routeModule.shouldRevalidate
   };
 }
+
 // Our compiler generates the default export as `{}` when no default is provided,
 // which can lead us to trying to use that as a Component in RR and calling
 // createElement on it.  Patching here as a quick fix and hoping it's no longer
@@ -7816,10 +8648,12 @@ function shouldHydrateRouteLoader(route, routeModule, isSpaMode) {
 
 // Currently rendered links that may need prefetching
 const nextPaths = new Set();
+
 // FIFO queue of previously discovered routes to prevent re-calling on
 // subsequent navigations to the same path
 const discoveredPathsMaxSize = 1000;
 const discoveredPaths = new Set();
+
 // 7.5k to come in under the ~8k limit for most browsers
 // https://stackoverflow.com/a/417184
 const URL_LIMIT = 7680;
@@ -7831,8 +8665,10 @@ function getPartialManifest(manifest, router) {
   let routeIds = new Set(router.state.matches.map(m => m.route.id));
   let segments = router.state.location.pathname.split("/").filter(Boolean);
   let paths = ["/"];
+
   // We've already matched to the last segment
   segments.pop();
+
   // Traverse each path for our parents and match in case they have pathless/index
   // children we need to include in the initial manifest
   while (segments.length > 0) {
@@ -7874,6 +8710,7 @@ function useFogOFWarDiscovery(router, manifest, routeModules, isSpaMode) {
     if (!isFogOfWarEnabled(isSpaMode) || ((_navigator$connection = navigator.connection) == null ? void 0 : _navigator$connection.saveData) === true) {
       return;
     }
+
     // Register a link href for patching
     function registerElement(el) {
       let path = el.tagName === "FORM" ? el.getAttribute("action") : el.getAttribute("href");
@@ -7885,6 +8722,7 @@ function useFogOFWarDiscovery(router, manifest, routeModules, isSpaMode) {
         nextPaths.add(url.pathname);
       }
     }
+
     // Register and fetch patches for all initially-rendered links/forms
     async function fetchPatches() {
       let lazyPaths = Array.from(nextPaths.keys()).filter(path => {
@@ -7903,9 +8741,11 @@ function useFogOFWarDiscovery(router, manifest, routeModules, isSpaMode) {
         console.error("Failed to fetch manifest patches", e);
       }
     }
+
     // Register and fetch patches for all initially-rendered links
     document.body.querySelectorAll("a[data-discover], form[data-discover]").forEach(el => registerElement(el));
     fetchPatches();
+
     // Setup a MutationObserver to fetch all subsequently rendered links/form
     let debouncedFetchPatches = debounce(fetchPatches, 100);
     function isElement(node) {
@@ -7943,6 +8783,7 @@ async function fetchAndApplyManifestPatches(paths, manifest, routeModules, isSpa
   let url = new URL(manifestPath, window.location.origin);
   paths.sort().forEach(path => url.searchParams.append("p", path));
   url.searchParams.set("version", manifest.version);
+
   // If the URL is nearing the ~8k limit on GET requests, skip this optimization
   // step and just let discovery happen on link click.  We also wipe out the
   // nextPaths Set here so we can start filling it with fresh links
@@ -7957,19 +8798,25 @@ async function fetchAndApplyManifestPatches(paths, manifest, routeModules, isSpa
     throw new Error(await res.text());
   }
   let serverPatches = await res.json();
+
   // 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
   paths.forEach(p => addToFifoQueue(p, discoveredPaths));
+
   // Identify all parentIds for which we have new children to add and patch
   // 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);
     }
   });
@@ -7982,6 +8829,7 @@ function addToFifoQueue(path, queue) {
   }
   queue.add(path);
 }
+
 // Thanks Josh!
 // https://www.joshwcomeau.com/snippets/javascript/debounce/
 function debounce(callback, wait) {
@@ -8008,8 +8856,10 @@ function useDataRouterStateContext() {
   !context ? process.env.NODE_ENV !== "production" ? invariant$1(false, "You must render this element inside a <DataRouterStateContext.Provider> element") : invariant$1(false) : void 0;
   return context;
 }
+
 ////////////////////////////////////////////////////////////////////////////////
 // FrameworkContext
+
 const FrameworkContext = /*#__PURE__*/React.createContext(undefined);
 FrameworkContext.displayName = "FrameworkContext";
 function useFrameworkContext() {
@@ -8017,6 +8867,26 @@ function useFrameworkContext() {
   !context ? process.env.NODE_ENV !== "production" ? invariant$1(false, "You must render this element inside a <HydratedRouter> element") : invariant$1(false) : void 0;
   return context;
 }
+
+////////////////////////////////////////////////////////////////////////////////
+// Public API
+
+/**
+ * Defines the discovery behavior of the link:
+ *
+ * - "render" - default, discover the route when the link renders
+ * - "none" - don't eagerly discover, only discover if the link is clicked
+ */
+
+/**
+ * Defines the prefetching behavior of the link:
+ *
+ * - "none": Never fetched
+ * - "intent": Fetched when the user focuses or hovers the link
+ * - "render": Fetched when the link is rendered
+ * - "viewport": Fetched when the link is in the viewport
+ */
+
 function usePrefetchBehavior(prefetch, theirElementProps) {
   let frameworkContext = React.useContext(FrameworkContext);
   let [maybePrefetch, setMaybePrefetch] = React.useState(false);
@@ -8065,6 +8935,7 @@ function usePrefetchBehavior(prefetch, theirElementProps) {
     setMaybePrefetch(false);
     setShouldPrefetch(false);
   };
+
   // No prefetching if not using SSR
   if (!frameworkContext) {
     return [false, ref, {}];
@@ -8072,6 +8943,7 @@ function usePrefetchBehavior(prefetch, theirElementProps) {
   if (prefetch !== "intent") {
     return [shouldPrefetch, ref, {}];
   }
+
   // When using prefetch="intent" we need to attach focus/hover listeners
   return [shouldPrefetch, ref, {
     onFocus: composeEventHandlers(onFocus, setIntent),
@@ -8089,6 +8961,7 @@ function composeEventHandlers(theirHandler, ourHandler) {
     }
   };
 }
+
 // Return the matches actively being displayed:
 // - In SPA Mode we only SSR/hydrate the root match, and include all matches
 //   after hydration. This lets the router handle initial match loads via lazy().
@@ -8104,6 +8977,7 @@ function getActiveMatches(matches, errors, isSpaMode) {
   }
   return matches;
 }
+
 /**
   Renders all of the `<link>` tags created by route module {@link LinksFunction} export. You should render it inside the `<head>` of your document.
 
@@ -8137,22 +9011,23 @@ function Links() {
   } = useDataRouterStateContext();
   let matches = getActiveMatches(routerMatches, errors, isSpaMode);
   let keyedLinks = React.useMemo(() => getKeyedLinksForMatches(matches, routeModules, manifest), [matches, routeModules, manifest]);
-  return /*#__PURE__*/React.createElement(React.Fragment, null, criticalCss ? ( /*#__PURE__*/React.createElement("style", {
+  return /*#__PURE__*/React.createElement(React.Fragment, null, criticalCss ? /*#__PURE__*/React.createElement("style", {
     dangerouslySetInnerHTML: {
       __html: criticalCss
     }
-  })) : null, keyedLinks.map(_ref => {
+  }) : null, keyedLinks.map(_ref => {
     let {
       key,
       link
     } = _ref;
-    return isPageLinkDescriptor(link) ? ( /*#__PURE__*/React.createElement(PrefetchPageLinks, _extends({
+    return isPageLinkDescriptor(link) ? /*#__PURE__*/React.createElement(PrefetchPageLinks, _extends({
       key: key
-    }, link))) : ( /*#__PURE__*/React.createElement("link", _extends({
+    }, link)) : /*#__PURE__*/React.createElement("link", _extends({
       key: key
-    }, link)));
+    }, link));
   }));
 }
+
 /**
   Renders `<link rel=prefetch|modulepreload>` tags for modules and data of another page to enable an instant navigation to that page. {@link LinkProps.prefetch | `<Link prefetch>`} uses this internally, but you can render it to prefetch a page for any other reason.
 
@@ -8226,18 +9101,20 @@ function PrefetchPageLinksImpl(_ref3) {
       // since it would always trigger a prefetch of the existing loaders
       return [];
     }
+
     // Single-fetch is harder :)
     // This parallels the logic in the single fetch data strategy
     let routesParams = new Set();
     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);
@@ -8256,19 +9133,20 @@ function PrefetchPageLinksImpl(_ref3) {
     return [url.pathname + url.search];
   }, [loaderData, location, manifest, newMatchesForData, nextMatches, page, routeModules]);
   let moduleHrefs = React.useMemo(() => getModuleLinkHrefs(newMatchesForAssets, manifest), [newMatchesForAssets, manifest]);
+
   // needs to be a hook with async behavior because we need the modules, not
   // just the manifest like the other links in here.
   let keyedPrefetchLinks = useKeyedPrefetchLinks(newMatchesForAssets);
-  return /*#__PURE__*/React.createElement(React.Fragment, null, dataHrefs.map(href => ( /*#__PURE__*/React.createElement("link", _extends({
+  return /*#__PURE__*/React.createElement(React.Fragment, null, dataHrefs.map(href => /*#__PURE__*/React.createElement("link", _extends({
     key: href,
     rel: "prefetch",
     as: "fetch",
     href: href
-  }, linkProps)))), moduleHrefs.map(href => ( /*#__PURE__*/React.createElement("link", _extends({
+  }, linkProps))), moduleHrefs.map(href => /*#__PURE__*/React.createElement("link", _extends({
     key: href,
     rel: "modulepreload",
     href: href
-  }, linkProps)))), keyedPrefetchLinks.map(_ref4 => {
+  }, linkProps))), keyedPrefetchLinks.map(_ref4 => {
     let {
       key,
       link
@@ -8283,6 +9161,7 @@ function PrefetchPageLinksImpl(_ref3) {
     );
   }));
 }
+
 /**
   Renders all the `<meta>` tags created by route module {@link MetaFunction} exports. You should render it inside the `<head>` of your HTML.
 
@@ -8390,10 +9269,10 @@ function Meta() {
       delete metaProps.charset;
     }
     if ("charSet" in metaProps && metaProps.charSet != null) {
-      return typeof metaProps.charSet === "string" ? ( /*#__PURE__*/React.createElement("meta", {
+      return typeof metaProps.charSet === "string" ? /*#__PURE__*/React.createElement("meta", {
         key: "charSet",
         charSet: metaProps.charSet
-      })) : null;
+      }) : null;
     }
     if ("script:ld+json" in metaProps) {
       try {
@@ -8417,11 +9296,24 @@ function Meta() {
 function isValidMetaTag(tagName) {
   return typeof tagName === "string" && /^(meta|link)$/.test(tagName);
 }
+
 /**
  * Tracks whether hydration is finished, so scripts can be skipped
  * during client-side updates.
  */
 let isHydrated = false;
+
+/**
+  A couple common attributes:
+
+  - `<Scripts crossOrigin>` for hosting your static assets on a different server than your app.
+  - `<Scripts nonce>` to support a [content security policy for scripts](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src) with [nonce-sources](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/Sources#sources) for your `<script>` tags.
+
+  You cannot pass through attributes such as `async`, `defer`, `src`, `type`, `noModule` because they are managed by React Router internally.
+
+  @category Types
+ */
+
 /**
   Renders the client runtime of your app. It should be rendered inside the `<body>` of the document.
 
@@ -8460,6 +9352,7 @@ function Scripts(props) {
     matches: routerMatches
   } = useDataRouterStateContext();
   let enableFogOfWar = isFogOfWarEnabled(isSpaMode);
+
   // Let <ServerRouter> know that we hydrated and we should render the single
   // fetch streaming scripts
   if (renderMeta) {
@@ -8492,23 +9385,23 @@ function Scripts(props) {
   }, []);
   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.createElement(React.Fragment, null, !enableFogOfWar ? ( /*#__PURE__*/React.createElement("link", {
+  return isHydrated ? null : /*#__PURE__*/React.createElement(React.Fragment, null, !enableFogOfWar ? /*#__PURE__*/React.createElement("link", {
     rel: "modulepreload",
     href: manifest.url,
     crossOrigin: props.crossOrigin
-  })) : null, /*#__PURE__*/React.createElement("link", {
+  }) : null, /*#__PURE__*/React.createElement("link", {
     rel: "modulepreload",
     href: manifest.entry.module,
     crossOrigin: props.crossOrigin
-  }), dedupe(preloads).map(path => ( /*#__PURE__*/React.createElement("link", {
+  }), dedupe(preloads).map(path => /*#__PURE__*/React.createElement("link", {
     key: path,
     rel: "modulepreload",
     href: path,
     crossOrigin: props.crossOrigin
-  }))), initialScripts));
+  })), initialScripts);
 }
 function dedupe(array) {
   return [...new Set(array)];
@@ -8535,7 +9428,9 @@ const _excluded$1 = ["onClick", "discover", "prefetch", "relative", "reloadDocum
 ////////////////////////////////////////////////////////////////////////////////
 //#region Global Stuff
 ////////////////////////////////////////////////////////////////////////////////
+
 const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
+
 // HEY YOU! DON'T TOUCH THIS VARIABLE!
 //
 // It is replaced with the proper version at build time via a babel plugin in
@@ -8553,6 +9448,12 @@ try {
 } catch (e) {
   // no-op
 }
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Routers
+////////////////////////////////////////////////////////////////////////////////
+
 /**
  * @category Routers
  */
@@ -8571,6 +9472,7 @@ function createBrowserRouter(routes, opts) {
     window: opts == null ? void 0 : opts.window
   }).initialize();
 }
+
 /**
  * @category Routers
  */
@@ -8638,6 +9540,17 @@ function deserializeErrors$1(errors) {
   }
   return serialized;
 }
+
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Components
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * @category Types
+ */
+
 /**
  * A `<Router>` for use in web browsers. Provides the cleanest URLs.
  *
@@ -8673,6 +9586,11 @@ function BrowserRouter(_ref) {
     navigator: history
   });
 }
+
+/**
+ * @category Types
+ */
+
 /**
  * A `<Router>` for use in web browsers. Stores the location in the hash
  * portion of the URL so it is not sent to the server.
@@ -8709,6 +9627,11 @@ function HashRouter(_ref2) {
     navigator: history
   });
 }
+
+/**
+ * @category Types
+ */
+
 /**
  * A `<Router>` that accepts a pre-instantiated history object. It's important
  * to note that using your own history object is highly discouraged and may add
@@ -8741,7 +9664,13 @@ function HistoryRouter(_ref3) {
   });
 }
 HistoryRouter.displayName = "unstable_HistoryRouter";
+
+/**
+ * @category Types
+ */
+
 const ABSOLUTE_URL_REGEX$1 = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+
 /**
   A progressively enhanced `<a href>` wrapper to enable navigation with client-side routing.
 
@@ -8780,12 +9709,14 @@ const Link = /*#__PURE__*/React.forwardRef(function LinkWithRef(_ref4, forwarded
     basename
   } = React.useContext(NavigationContext);
   let isAbsolute = typeof to === "string" && ABSOLUTE_URL_REGEX$1.test(to);
+
   // Rendered into <a href> for absolute URLs
   let absoluteHref;
   let isExternal = false;
   if (typeof to === "string" && isAbsolute) {
     // Render the absolute href server- and client-side
     absoluteHref = to;
+
     // Only check for external origins client-side
     if (isBrowser) {
       try {
@@ -8804,6 +9735,7 @@ const Link = /*#__PURE__*/React.forwardRef(function LinkWithRef(_ref4, forwarded
       }
     }
   }
+
   // Rendered into <a href> for relative URLs
   let href = useHref(to, {
     relative
@@ -8833,11 +9765,51 @@ const Link = /*#__PURE__*/React.forwardRef(function LinkWithRef(_ref4, forwarded
     target: target,
     "data-discover": !isAbsolute && discover === "render" ? "true" : undefined
   }));
-  return shouldPrefetch && !isAbsolute ? ( /*#__PURE__*/React.createElement(React.Fragment, null, link, /*#__PURE__*/React.createElement(PrefetchPageLinks, {
+  return shouldPrefetch && !isAbsolute ? /*#__PURE__*/React.createElement(React.Fragment, null, link, /*#__PURE__*/React.createElement(PrefetchPageLinks, {
     page: href
-  }))) : link;
+  })) : link;
 });
 Link.displayName = "Link";
+
+/**
+  The object passed to {@link NavLink} `children`, `className`, and `style` prop callbacks to render and style the link based on its state.
+
+  ```
+  // className
+  <NavLink
+    to="/messages"
+    className={({ isActive, isPending }) =>
+      isPending ? "pending" : isActive ? "active" : ""
+    }
+  >
+    Messages
+  </NavLink>
+
+  // style
+  <NavLink
+    to="/messages"
+    style={({ isActive, isPending }) => {
+      return {
+        fontWeight: isActive ? "bold" : "",
+        color: isPending ? "red" : "black",
+      }
+    )}
+  />
+
+  // children
+  <NavLink to="/tasks">
+    {({ isActive, isPending }) => (
+      <span className={isActive ? "active" : ""}>Tasks</span>
+    )}
+  </NavLink>
+  ```
+
+ */
+
+/**
+ * @category Types
+ */
+
 /**
   Wraps {@link Link | `<Link>`} with additional props for styling active and pending states.
 
@@ -8900,6 +9872,7 @@ const NavLink = /*#__PURE__*/React.forwardRef(function NavLinkWithRef(_ref5, ref
   if (nextLocationPathname && basename) {
     nextLocationPathname = stripBasename(nextLocationPathname, basename) || nextLocationPathname;
   }
+
   // If the `to` has a trailing slash, look at that exact spot.  Otherwise,
   // we're looking for a slash _after_ what's in `to`.  For example:
   //
@@ -8936,6 +9909,21 @@ const NavLink = /*#__PURE__*/React.forwardRef(function NavLinkWithRef(_ref5, ref
   }), typeof children === "function" ? children(renderProps) : children);
 });
 NavLink.displayName = "NavLink";
+
+/**
+ * Form props shared by navigations and fetchers
+ */
+
+/**
+ * Form props available to fetchers
+ * @category Types
+ */
+
+/**
+ * Form props available to navigations
+ * @category Types
+ */
+
 /**
 
 A progressively enhanced HTML [`<form>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form) that submits data to actions via `fetch`, activating pending states in `useNavigation` which enables advanced user interfaces beyond a basic HTML form. After a form's action completes, all data on the page is automatically revalidated to keep the UI in sync with the data.
@@ -9050,6 +10038,7 @@ function ScrollRestoration(_ref7) {
     getKey,
     storageKey
   });
+
   // In order to support `getKey`, we need to compute a "key" here so we can
   // hydrate that up so that SSR scroll restoration isn't waiting on React to
   // hydrate. *However*, our key on the server is not the same as our key on
@@ -9064,6 +10053,7 @@ function ScrollRestoration(_ref7) {
   // Nah, we only need this the first time for the SSR render
   // eslint-disable-next-line react-hooks/exhaustive-deps
   []);
+
   // In SPA Mode, there's nothing to restore on initial render since we didn't
   // render anything on the server
   if (!remixContext || remixContext.isSpaMode) {
@@ -9096,24 +10086,24 @@ function ScrollRestoration(_ref7) {
 }
 ScrollRestoration.displayName = "ScrollRestoration";
 //#endregion
+
 ////////////////////////////////////////////////////////////////////////////////
 //#region Hooks
 ////////////////////////////////////////////////////////////////////////////////
-var DataRouterHook;
-(function (DataRouterHook) {
+var DataRouterHook = /*#__PURE__*/function (DataRouterHook) {
   DataRouterHook["UseScrollRestoration"] = "useScrollRestoration";
   DataRouterHook["UseSubmit"] = "useSubmit";
   DataRouterHook["UseSubmitFetcher"] = "useSubmitFetcher";
   DataRouterHook["UseFetcher"] = "useFetcher";
   DataRouterHook["useViewTransitionState"] = "useViewTransitionState";
-})(DataRouterHook || (DataRouterHook = {}));
-var DataRouterStateHook;
-(function (DataRouterStateHook) {
+  return DataRouterHook;
+}(DataRouterHook || {});
+var DataRouterStateHook = /*#__PURE__*/function (DataRouterStateHook) {
   DataRouterStateHook["UseFetcher"] = "useFetcher";
   DataRouterStateHook["UseFetchers"] = "useFetchers";
   DataRouterStateHook["UseScrollRestoration"] = "useScrollRestoration";
-})(DataRouterStateHook || (DataRouterStateHook = {}));
-// Internal hooks
+  return DataRouterStateHook;
+}(DataRouterStateHook || {}); // Internal hooks
 function getDataRouterConsoleError(hookName) {
   return hookName + " must be used within a data router.  See https://reactrouter.com/en/main/routers/picking-a-router.";
 }
@@ -9127,7 +10117,9 @@ function useDataRouterState(hookName) {
   !state ? process.env.NODE_ENV !== "production" ? invariant$2(false, getDataRouterConsoleError(hookName)) : invariant$2(false) : void 0;
   return state;
 }
+
 // External hooks
+
 /**
  * Handles the click behavior for router `<Link>` components. This is useful if
  * you need to create custom `<Link>` components with the same click behavior we
@@ -9152,6 +10144,7 @@ function useLinkClickHandler(to, _temp) {
   return React.useCallback(event => {
     if (shouldProcessLinkClick(event, target)) {
       event.preventDefault();
+
       // If the URL hasn't changed, a regular <a> will do a replace instead of
       // a push, so do the same here unless the replace prop is explicitly set
       let replace = replaceProp !== undefined ? replaceProp : createPath(location) === createPath(path);
@@ -9165,6 +10158,7 @@ function useLinkClickHandler(to, _temp) {
     }
   }, [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative, viewTransition]);
 }
+
 /**
   Returns a tuple of the current URL's {@link URLSearchParams} and a function to update them. Setting the search params causes a navigation.
 
@@ -9197,8 +10191,47 @@ function useSearchParams(defaultInit) {
   }, [navigate, searchParams]);
   return [searchParams, setSearchParams];
 }
+
+/**
+  Sets new search params and causes a navigation when called.
+
+  ```tsx
+  <button
+    onClick={() => {
+      const params = new URLSearchParams();
+      params.set("someKey", "someValue");
+      setSearchParams(params, {
+        preventScrollReset: true,
+      });
+    }}
+  />
+  ```
+
+  It also supports a function for setting new search params.
+
+  ```tsx
+  <button
+    onClick={() => {
+      setSearchParams((prev) => {
+        prev.set("someKey", "someValue");
+        return prev;
+      });
+    }}
+  />
+  ```
+ */
+
+/**
+ * Submits a HTML `<form>` to the server without reloading the page.
+ */
+
+/**
+ * Submits a fetcher `<form>` to the server without reloading the page.
+ */
+
 let fetcherId = 0;
 let getUniqueFetcherId = () => "__" + String(++fetcherId) + "__";
+
 /**
   The imperative version of {@link Form | `<Form>`} that lets you submit a form from code instead of a user interaction.
 
@@ -9264,6 +10297,7 @@ function useSubmit() {
     }
   }, [router, basename, currentRouteId]);
 }
+
 // v7: Eventually we should deprecate this entirely in favor of using the
 // router method directly?
 /**
@@ -9304,6 +10338,7 @@ action, _temp2) {
   let path = _extends({}, useResolvedPath(action ? action : ".", {
     relative
   }));
+
   // If no action was specified, browsers will persist current search params
   // when determining the path, so match that behavior
   // https://github.com/remix-run/remix/issues/927
@@ -9312,6 +10347,7 @@ action, _temp2) {
     // Safe to write to this directly here since if action was undefined, we
     // would have called useResolvedPath(".") which will never include a search
     path.search = location.search;
+
     // When grabbing search params from the URL, remove any included ?index param
     // since it might not apply to our contextual route.  We add it back based
     // on match.route.index below
@@ -9328,6 +10364,7 @@ action, _temp2) {
   if ((!action || action === ".") && match.route.index) {
     path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
   }
+
   // If we're operating within a basename, prepend it to the pathname prior
   // to creating the form action.  If this is a root navigation, then just use
   // the raw basename which allows the basename to have full control over the
@@ -9337,7 +10374,17 @@ action, _temp2) {
   }
   return createPath(path);
 }
+
+/**
+The return value of `useFetcher` that keeps track of the state of a fetcher.
+
+```tsx
+let fetcher = useFetcher();
+```
+ */
+
 // TODO: (v7) Change the useFetcher generic default from `any` to `unknown`
+
 /**
   Useful for creating complex, dynamic user interfaces that require multiple, concurrent data interactions without causing a navigation.
 
@@ -9385,17 +10432,20 @@ function useFetcher(_temp3) {
   !fetcherData ? process.env.NODE_ENV !== "production" ? invariant$2(false, "useFetcher must be used inside a FetchersContext") : invariant$2(false) : void 0;
   !route ? process.env.NODE_ENV !== "production" ? invariant$2(false, "useFetcher must be used inside a RouteContext") : invariant$2(false) : void 0;
   !(routeId != null) ? process.env.NODE_ENV !== "production" ? invariant$2(false, "useFetcher can only be used on routes that contain a unique \"id\"") : invariant$2(false) : void 0;
+
   // Fetcher key handling
   let defaultKey = React.useId();
   let [fetcherKey, setFetcherKey] = React.useState(key || defaultKey);
   if (key && key !== fetcherKey) {
     setFetcherKey(key);
   }
+
   // Registration/cleanup
   React.useEffect(() => {
     router.getFetcher(fetcherKey);
     return () => router.deleteFetcher(fetcherKey);
   }, [router, fetcherKey]);
+
   // Fetcher additions
   let load = React.useCallback(async (href, opts) => {
     !routeId ? process.env.NODE_ENV !== "production" ? invariant$2(false, "No routeId available for fetcher.load()") : invariant$2(false) : void 0;
@@ -9419,6 +10469,7 @@ function useFetcher(_temp3) {
     FetcherForm.displayName = "fetcher.Form";
     return FetcherForm;
   }, [fetcherKey]);
+
   // Exposed FetcherWithComponents
   let fetcher = state.fetchers.get(fetcherKey) || IDLE_FETCHER;
   let data = fetcherData.get(fetcherKey);
@@ -9431,6 +10482,7 @@ function useFetcher(_temp3) {
   }), [FetcherForm, submit, load, fetcher, data]);
   return fetcherWithComponents;
 }
+
 /**
   Returns an array of all in-flight fetchers. This is useful for components throughout the app that didn't create the fetchers but want to use their submissions to participate in optimistic UI.
 
@@ -9474,6 +10526,7 @@ function getScrollRestorationKey(location, matches, basename, getKey) {
   }
   return key;
 }
+
 /**
  * When rendered inside a RouterProvider, will restore scroll positions on navigations
  */
@@ -9495,6 +10548,7 @@ function useScrollRestoration(_temp4) {
   let location = useLocation();
   let matches = useMatches();
   let navigation = useNavigation();
+
   // Trigger manual scroll restoration while we're active
   React.useEffect(() => {
     window.history.scrollRestoration = "manual";
@@ -9502,6 +10556,7 @@ function useScrollRestoration(_temp4) {
       window.history.scrollRestoration = "auto";
     };
   }, []);
+
   // Save positions on pagehide
   usePageHide(React.useCallback(() => {
     if (navigation.state === "idle") {
@@ -9515,6 +10570,7 @@ function useScrollRestoration(_temp4) {
     }
     window.history.scrollRestoration = "auto";
   }, [navigation.state, getKey, basename, location, matches, storageKey]));
+
   // Read in any saved scroll locations
   if (typeof document !== "undefined") {
     // eslint-disable-next-line react-hooks/rules-of-hooks
@@ -9528,12 +10584,14 @@ function useScrollRestoration(_temp4) {
         // no-op, use default empty object
       }
     }, [storageKey]);
+
     // Enable scroll restoration in the router
     // eslint-disable-next-line react-hooks/rules-of-hooks
     React.useLayoutEffect(() => {
       let disableScrollRestoration = router == null ? void 0 : router.enableScrollRestoration(savedScrollPositions, () => window.scrollY, getKey ? (location, matches) => getScrollRestorationKey(location, matches, basename, getKey) : undefined);
       return () => disableScrollRestoration && disableScrollRestoration();
     }, [router, basename, getKey]);
+
     // Restore scrolling when state.restoreScrollPosition changes
     // eslint-disable-next-line react-hooks/rules-of-hooks
     React.useLayoutEffect(() => {
@@ -9541,11 +10599,13 @@ function useScrollRestoration(_temp4) {
       if (restoreScrollPosition === false) {
         return;
       }
+
       // been here before, scroll to it
       if (typeof restoreScrollPosition === "number") {
         window.scrollTo(0, restoreScrollPosition);
         return;
       }
+
       // try to scroll to the hash
       if (location.hash) {
         let el = document.getElementById(decodeURIComponent(location.hash.slice(1)));
@@ -9554,15 +10614,18 @@ function useScrollRestoration(_temp4) {
           return;
         }
       }
+
       // Don't reset if this navigation opted out
       if (preventScrollReset === true) {
         return;
       }
+
       // otherwise go to the top on new locations
       window.scrollTo(0, 0);
     }, [location, restoreScrollPosition, preventScrollReset]);
   }
 }
+
 /**
  * Setup a callback to be fired on the window's `beforeunload` event.
  *
@@ -9582,6 +10645,7 @@ function useBeforeUnload(callback, options) {
     };
   }, [callback, capture]);
 }
+
 /**
  * Setup a callback to be fired on the window's `pagehide` event. This is
  * useful for saving some data to `window.localStorage` just before the page
@@ -9604,6 +10668,7 @@ function usePageHide(callback, options) {
     };
   }, [callback, capture]);
 }
+
 /**
   Wrapper around useBlocker to show a window.confirm prompt to users instead of building a custom UI with {@link useBlocker}.
 
@@ -9665,6 +10730,7 @@ function usePrompt(_ref9) {
     }
   }, [blocker, when]);
 }
+
 /**
   This hook returns `true` when there is an active [View Transition](https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API) to the specified location. This can be used to apply finer-grained styles to elements to further customize the view transition. This requires that view transitions have been enabled for the given navigation via {@link LinkProps.viewTransition} (or the `Form`, `submit`, or `navigate` call)
 
@@ -9688,6 +10754,7 @@ function useViewTransitionState(to, opts) {
   }
   let currentPath = stripBasename(vtContext.currentLocation.pathname, basename) || vtContext.currentLocation.pathname;
   let nextPath = stripBasename(vtContext.nextLocation.pathname, basename) || vtContext.nextLocation.pathname;
+
   // Transition is active if we're going to or coming from the indicated
   // destination.  This ensures that other PUSH navigations that reverse
   // an indicated transition apply.  I.e., on the list view you have:
@@ -9703,6 +10770,7 @@ function useViewTransitionState(to, opts) {
   // (even though this isn't strictly a POP reverse)
   return matchPath(path.pathname, nextPath) != null || matchPath(path.pathname, currentPath) != null;
 }
+
 //#endregion
 
 /**
@@ -9797,13 +10865,13 @@ function StaticRouterProvider(_ref2) {
     routes: router.routes,
     future: router.future,
     state: state
-  })))))), hydrateScript ? ( /*#__PURE__*/React.createElement("script", {
+  })))))), hydrateScript ? /*#__PURE__*/React.createElement("script", {
     suppressHydrationWarning: true,
     nonce: nonce,
     dangerouslySetInnerHTML: {
       __html: hydrateScript
     }
-  })) : null);
+  }) : null);
 }
 function DataRoutes(_ref3) {
   let {
@@ -9867,6 +10935,7 @@ function createStaticHandler(routes, opts) {
     mapRouteProperties
   }));
 }
+
 /**
  * @category Routers
  */
@@ -9876,6 +10945,7 @@ function createStaticRouter(routes, context, opts) {
   }
   let manifest = {};
   let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, undefined, manifest);
+
   // Because our context matches may be from a framework-agnostic set of
   // routes passed to createStaticHandler(), we update them here with our
   // newly created/enhanced data routes
@@ -9978,6 +11048,7 @@ function encodeLocation(to) {
   };
 }
 const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+
 // This utility is based on https://github.com/zertosh/htmlescape
 // License: https://github.com/zertosh/htmlescape/blob/0527ca7156a524d256101bb310a9f970f63078ad/LICENSE
 const ESCAPE_LOOKUP$1 = {
@@ -10016,6 +11087,7 @@ function ServerRouter(_ref) {
     serverHandoffString
   } = context;
   let routes = createServerRoutes(manifest.routes, routeModules, context.future, context.isSpaMode);
+
   // Create a shallow clone of `loaderData` we can mutate for partial hydration.
   // When a route exports a `clientLoader` and a `HydrateFallback`, we want to
   // render the fallback on the server so we clear our the `loaderData` during SSR.
@@ -10030,7 +11102,7 @@ function ServerRouter(_ref) {
     // 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];
     }
   }
@@ -10053,13 +11125,13 @@ function ServerRouter(_ref) {
     router: router,
     context: context.staticHandlerContext,
     hydrate: false
-  }))), context.serverHandoffStream ? ( /*#__PURE__*/React.createElement(React.Suspense, null, /*#__PURE__*/React.createElement(StreamTransfer, {
+  }))), context.serverHandoffStream ? /*#__PURE__*/React.createElement(React.Suspense, null, /*#__PURE__*/React.createElement(StreamTransfer, {
     context: context,
     identifier: 0,
     reader: context.serverHandoffStream.getReader(),
     textDecoder: new TextDecoder(),
     nonce: nonce
-  }))) : null);
+  })) : null);
 }
 
 /**
@@ -10093,6 +11165,7 @@ function createRoutesStub(routes, context) {
         routeModules: {},
         isSpaMode: false
       };
+
       // Update the routes to include context in the loader/action and populate
       // the manifest and routeModules during the walk
       let patched = processRoutes(
@@ -10116,6 +11189,7 @@ function processRoutes(routes, context, manifest, routeModules, parentId) {
     if (!route.id) {
       throw new Error("Expected a route.id in @remix-run/testing processRoutes() function");
     }
+
     // Patch in the Remix context to loaders/actions
     let {
       loader,
@@ -10137,6 +11211,7 @@ function processRoutes(routes, context, manifest, routeModules, parentId) {
       handle: route.handle,
       shouldRevalidate: route.shouldRevalidate
     };
+
     // Add the EntryRoute to the manifest
     let entryRoute = {
       id: route.id,
@@ -10154,6 +11229,7 @@ function processRoutes(routes, context, manifest, routeModules, parentId) {
       module: "build/stub-path-to-module.js" // any need for this?
     };
     manifest.routes[newRoute.id] = entryRoute;
+
     // Add the route to routeModules
     routeModules[route.id] = {
       default: route.Component || Outlet,
@@ -10201,6 +11277,18 @@ function byteStringToUint8Array(byteString) {
 }
 
 const _excluded = ["secrets"];
+
+/**
+ * A HTTP cookie.
+ *
+ * A Cookie is a logical container for metadata about a HTTP cookie; its name
+ * and options. But it doesn't contain a value. Instead, it has `parse()` and
+ * `serialize()` methods that allow a single instance to be reused for
+ * parsing/encoding multiple different values.
+ *
+ * @see https://remix.run/utils/cookies#cookie-api
+ */
+
 /**
  * Creates a logical container for managing a browser cookie from the server.
  */
@@ -10231,7 +11319,17 @@ const createCookie = function createCookie(name, cookieOptions) {
     async parse(cookieHeader, parseOptions) {
       if (!cookieHeader) return null;
       let cookies = 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 serialize(name, value === "" ? "" : await encodeCookieValue(value, secrets), _extends({}, options, serializeOptions));
@@ -10275,6 +11373,7 @@ function decodeData(value) {
     return {};
   }
 }
+
 // See: https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.escape.js
 function myEscape(value) {
   let str = value.toString();
@@ -10301,6 +11400,7 @@ function hex(code, length) {
   while (result.length < length) result = "0" + result;
   return result;
 }
+
 // See: https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/es.unescape.js
 function myUnescape(value) {
   let str = value.toString();
@@ -10336,7 +11436,10 @@ function warnOnceAboutExpiresCookie(name, expires) {
 
 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;
   }, {});
 }
@@ -10344,12 +11447,12 @@ function createEntryRouteModules(manifest) {
 /**
  * The mode to use when running the server.
  */
-var ServerMode;
-(function (ServerMode) {
+let ServerMode = /*#__PURE__*/function (ServerMode) {
   ServerMode["Development"] = "development";
   ServerMode["Production"] = "production";
   ServerMode["Test"] = "test";
-})(ServerMode || (ServerMode = {}));
+  return ServerMode;
+}({});
 function isServerMode(value) {
   return value === ServerMode.Development || value === ServerMode.Production || value === ServerMode.Test;
 }
@@ -10395,6 +11498,7 @@ function isServerMode(value) {
  * because it came first, and that just wouldn't be fair to let errors cut in
  * line.
  */
+
 function sanitizeError(error, serverMode) {
   if (error instanceof Error && serverMode !== ServerMode.Development) {
     let sanitized = new Error("Unexpected Server Error");
@@ -10411,6 +11515,10 @@ function sanitizeErrors(errors, serverMode) {
     });
   }, {});
 }
+
+// must be type alias due to inference issues on interfaces
+// https://github.com/microsoft/TypeScript/issues/15300
+
 function serializeError(error, serverMode) {
   let sanitized = sanitizeError(error, serverMode);
   return {
@@ -10456,27 +11564,11 @@ function matchServerRoutes(routes, pathname, basename) {
 }
 
 /**
- * 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
+ * An object of unknown type for route loaders and actions provided by the
+ * server's `getLoadContext()` function.  This is defined as an empty interface
+ * specifically so apps can leverage declaration merging to augment this type
+ * globally: https://www.typescriptlang.org/docs/handbook/declaration-merging.html
  */
-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);
-}
 
 // Need to use RR's version here to permit the optional context even
 // though we know it'll always be provided in remix
@@ -10486,12 +11578,14 @@ async function callRouteHandler(handler, args) {
     params: args.params,
     context: args.context
   });
+
   // If they returned a redirect via data(), re-throw it as a Response
   if (isDataWithResponseInit(result) && result.init && result.init.status && isRedirectStatusCode(result.init.status)) {
     throw new Response(null, result.init);
   }
   return result;
 }
+
 // TODO: Document these search params better
 // and stop stripping these in V2. These break
 // support for running in a SW and also expose
@@ -10538,7 +11632,7 @@ function stripRoutesParam(request) {
 
 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);
   }
 }
@@ -10546,14 +11640,17 @@ function invariant(value, message) {
 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;
 }
+
 // Create a map of routes by parentId to use recursively instead of
 // repeatedly filtering the manifest.
 function createRoutes(manifest, parentId, routesByParentId) {
@@ -10567,6 +11664,7 @@ function createRoutes(manifest, parentId, routesByParentId) {
     children: createRoutes(manifest, route.id, routesByParentId)
   }));
 }
+
 // Convert the Remix ServerManifest into DataRouteObject's for use with
 // createStaticHandler
 function createStaticHandlerDataRoutes(manifest, future, parentId, routesByParentId) {
@@ -10621,8 +11719,10 @@ function createStaticHandlerDataRoutes(manifest, future, parentId, routesByParen
 
 // This escapeHtml utility is based on https://github.com/zertosh/htmlescape
 // License: https://github.com/zertosh/htmlescape/blob/0527ca7156a524d256101bb310a9f970f63078ad/LICENSE
+
 // We've chosen to inline the utility here to reduce the number of npm dependencies we have,
 // slightly decrease the code size compared the original package and make it esm compatible.
+
 const ESCAPE_LOOKUP = {
   "&": "\\u0026",
   ">": "\\u003e",
@@ -10679,16 +11779,20 @@ function getDocumentHeaders(build, context) {
     let {
       id
     } = match.route;
-    let routeModule = build.routes[id].module;
+    let route = build.routes[id];
+    !route ? process.env.NODE_ENV !== "production" ? invariant(false, "Route with id \"" + id + "\" not found in build") : invariant(false) : 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
     let includeErrorCookies = includeErrorHeaders && errorHeaders !== loaderHeaders && errorHeaders !== actionHeaders;
+
     // Use the parent headers for any route without a `headers` export
     if (routeModule.headers == null) {
       let headers = new Headers(parentHeaders);
@@ -10705,6 +11809,7 @@ function getDocumentHeaders(build, context) {
       actionHeaders,
       errorHeaders: includeErrorHeaders ? errorHeaders : undefined
     }) : routeModule.headers : undefined);
+
     // Automatically preserve Set-Cookie headers from bubbled responses,
     // loaders, errors, and parent routes
     if (includeErrorCookies) {
@@ -10746,6 +11851,7 @@ function getSingleFetchDataStrategy(_temp) {
     if (isActionDataRequest && request.method === "GET") {
       return {};
     }
+
     // Only run opt-in loaders when fine-grained revalidation is enabled
     let matchesToLoad = loadRouteIds ? matches.filter(m => loadRouteIds.includes(m.route.id)) : matches;
     let results = await Promise.all(matchesToLoad.map(match => match.resolve()));
@@ -10771,6 +11877,7 @@ async function singleFetchAction(build, serverMode, staticHandler, request, hand
         isActionDataRequest: true
       })
     });
+
     // Unlike `handleDataRequest`, when singleFetch is enabled, query does
     // let non-Response return values through
     if (isResponse(result)) {
@@ -10789,6 +11896,7 @@ async function singleFetchAction(build, serverMode, staticHandler, request, hand
         status: SINGLE_FETCH_REDIRECT_STATUS
       };
     }
+
     // Sanitize errors outside of development environments
     if (context.errors) {
       Object.values(context.errors).forEach(err => {
@@ -10861,6 +11969,7 @@ async function singleFetchLoaders(build, serverMode, staticHandler, request, han
         status: SINGLE_FETCH_REDIRECT_STATUS
       };
     }
+
     // Sanitize errors outside of development environments
     if (context.errors) {
       Object.values(context.errors).forEach(err => {
@@ -10871,6 +11980,7 @@ async function singleFetchLoaders(build, serverMode, staticHandler, request, han
       });
       context.errors = sanitizeErrors(context.errors, serverMode);
     }
+
     // Aggregate results based on the matches we intended to load since we get
     // `null` values back in `context.loaderData` for routes we didn't load
     let results = {};
@@ -10929,6 +12039,7 @@ function getSingleFetchRedirect(status, headers, basename) {
     replace: headers.has("X-Remix-Replace")
   };
 }
+
 // Note: If you change this function please change the corresponding
 // decodeViaTurboStream function in server-runtime
 function encodeViaTurboStream(data, requestSignal, streamTimeout, serverMode) {
@@ -11038,6 +12149,7 @@ const createRequestHandler = (build, mode) => {
         request
       });
     };
+
     // Manifest request for fog of war
     let manifestUrl = (((_build$basename = _build.basename) != null ? _build$basename : "/") + "/__manifest").replace(/\/+/g, "/");
     if (url.pathname === manifestUrl) {
@@ -11107,15 +12219,18 @@ async function handleManifestRequest(build, routes, url) {
       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
@@ -11127,10 +12242,12 @@ async function handleSingleFetchRequest(serverMode, build, staticHandler, reques
     headers,
     status
   } = request.method !== "GET" ? await singleFetchAction(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) : await singleFetchLoaders(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError);
+
   // Mark all successful responses with a header so we can identify in-flight
   // network errors that are missing this header
   let resultHeaders = new Headers(headers);
   resultHeaders.set("X-Remix-Response", "yes");
+
   // 304 responses should not have a body
   if (status === 304) {
     return new Response(null, {
@@ -11138,6 +12255,7 @@ async function handleSingleFetchRequest(serverMode, build, staticHandler, reques
       headers: resultHeaders
     });
   }
+
   // We use a less-descriptive `text/x-script` here instead of something like
   // `text/x-turbo` to enable compression when deployed via Cloudflare.  See:
   //  - https://github.com/remix-run/remix/issues/9884
@@ -11164,6 +12282,7 @@ async function handleDocumentRequest(serverMode, build, staticHandler, request,
     return context;
   }
   let headers = getDocumentHeaders(build, context);
+
   // 304 responses should not have a body or a content-type
   if (context.statusCode === 304) {
     return new Response(null, {
@@ -11171,6 +12290,7 @@ async function handleDocumentRequest(serverMode, build, staticHandler, request,
       headers
     });
   }
+
   // Sanitize errors outside of development environments
   if (context.errors) {
     Object.values(context.errors).forEach(err => {
@@ -11181,6 +12301,7 @@ async function handleDocumentRequest(serverMode, build, staticHandler, request,
     });
     context.errors = sanitizeErrors(context.errors, serverMode);
   }
+
   // Server UI state to send to the client.
   // - When single fetch is enabled, this is streamed down via `serverHandoffStream`
   // - Otherwise it's stringified into `serverHandoffString`
@@ -11212,6 +12333,7 @@ async function handleDocumentRequest(serverMode, build, staticHandler, request,
   } catch (error) {
     handleError(error);
     let errorForSecondRender = error;
+
     // If they threw a response, unwrap it into an ErrorResponse like we would
     // have for a loader/action
     if (isResponse(error)) {
@@ -11222,12 +12344,15 @@ async function handleDocumentRequest(serverMode, build, staticHandler, request,
         // If we can't unwrap the response - just leave it as-is
       }
     }
+
     // Get a new StaticHandlerContext that contains the error at the right boundary
     context = getStaticContextFromError(staticHandler.dataRoutes, context, errorForSecondRender);
+
     // Sanitize errors outside of development environments
     if (context.errors) {
       context.errors = sanitizeErrors(context.errors, serverMode);
     }
+
     // Get a new entryContext for the second render pass
     // Server UI state to send to the client.
     // - When single fetch is enabled, this is streamed down via `serverHandoffStream`
@@ -11284,7 +12409,7 @@ async function handleResourceRequest(serverMode, build, staticHandler, routeId,
   }
 }
 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,
@@ -11299,6 +12424,7 @@ function returnLastResortErrorResponse(error, serverMode) {
   if (serverMode !== ServerMode.Production) {
     message += "\n\n" + String(error);
   }
+
   // Good grief folks, get your act together 😂!
   return new Response(message, {
     status: 500,
@@ -11314,6 +12440,16 @@ function unwrapResponse(response) {
   return contentType && /\bapplication\/json\b/.test(contentType) ? response.body == null ? null : response.json() : response.text();
 }
 
+/**
+ * An object of name/value pairs to be used in the session.
+ */
+
+/**
+ * Session persists data across HTTP requests.
+ *
+ * @see https://remix.run/utils/sessions#session-api
+ */
+
 function flash(name) {
   return "__flash_" + name + "__";
 }
@@ -11372,6 +12508,25 @@ const createSession = function createSession(initialData, id) {
 const isSession = object => {
   return object != null && typeof object.id === "string" && typeof object.data !== "undefined" && typeof object.has === "function" && typeof object.get === "function" && typeof object.set === "function" && typeof object.flash === "function" && typeof object.unset === "function";
 };
+
+/**
+ * SessionStorage stores session data between HTTP requests and knows how to
+ * parse and create cookies.
+ *
+ * A SessionStorage creates Session objects using a `Cookie` header as input.
+ * Then, later it generates the `Set-Cookie` header to be used in the response.
+ */
+
+/**
+ * SessionIdStorageStrategy is designed to allow anyone to easily build their
+ * own SessionStorage using `createSessionStorage(strategy)`.
+ *
+ * This strategy describes a common scenario where the session id is stored in
+ * a cookie but the actual session data is stored elsewhere, usually in a
+ * database or on disk. A set of create, read, update, and delete operations
+ * are provided for managing the session data.
+ */
+
 /**
  * Creates a SessionStorage object using a SessionIdStorageStrategy.
  *
@@ -11486,6 +12641,7 @@ function createMemorySessionStorage(_temp) {
         if (!expires || expires > new Date()) {
           return data;
         }
+
         // Remove expired session data.
         if (expires) map.delete(id);
       }
@@ -11539,5 +12695,5 @@ function deserializeErrors(errors) {
   return serialized;
 }
 
-export { Await, BrowserRouter, Form, HashRouter, IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, Link, Links, MemoryRouter, Meta, NavLink, Navigate, Action as NavigationType, Outlet, PrefetchPageLinks, Route, Router, RouterProvider, Routes, Scripts, ScrollRestoration, ServerRouter, StaticRouter, StaticRouterProvider, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, ErrorResponseImpl as UNSAFE_ErrorResponseImpl, FetchersContext as UNSAFE_FetchersContext, FrameworkContext as UNSAFE_FrameworkContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RemixErrorBoundary as UNSAFE_RemixErrorBoundary, RouteContext as UNSAFE_RouteContext, ServerMode as UNSAFE_ServerMode, SingleFetchRedirectSymbol as UNSAFE_SingleFetchRedirectSymbol, ViewTransitionContext as UNSAFE_ViewTransitionContext, createBrowserHistory as UNSAFE_createBrowserHistory, createClientRoutes as UNSAFE_createClientRoutes, createClientRoutesWithHMRRevalidationOptOut as UNSAFE_createClientRoutesWithHMRRevalidationOptOut, createRouter as UNSAFE_createRouter, decodeViaTurboStream as UNSAFE_decodeViaTurboStream, deserializeErrors as UNSAFE_deserializeErrors, getPatchRoutesOnNavigationFunction as UNSAFE_getPatchRoutesOnNavigationFunction, getSingleFetchDataStrategy$1 as UNSAFE_getSingleFetchDataStrategy, invariant$2 as UNSAFE_invariant, mapRouteProperties as UNSAFE_mapRouteProperties, shouldHydrateRouteLoader as UNSAFE_shouldHydrateRouteLoader, useFogOFWarDiscovery as UNSAFE_useFogOFWarDiscovery, useScrollRestoration as UNSAFE_useScrollRestoration, createBrowserRouter, createCookie, createCookieSessionStorage, createHashRouter, createMemoryRouter, createMemorySessionStorage, createPath, createRequestHandler, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, createRoutesStub, createSearchParams, createSession, createSessionStorage, createStaticHandler, createStaticRouter, data, generatePath, isCookie, isRouteErrorResponse, isSession, json$1 as json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, replace, resolvePath, HistoryRouter as unstable_HistoryRouter, setDevServerHooks as unstable_setDevServerHooks, usePrompt as unstable_usePrompt, useActionData, useAsyncError, useAsyncValue, useBeforeUnload, useBlocker, useFetcher, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes, useSearchParams, useSubmit, useViewTransitionState };
+export { Await, BrowserRouter, Form, HashRouter, IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, Link, Links, MemoryRouter, Meta, NavLink, Navigate, Action as NavigationType, Outlet, PrefetchPageLinks, Route, Router, RouterProvider, Routes, Scripts, ScrollRestoration, ServerRouter, StaticRouter, StaticRouterProvider, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, ErrorResponseImpl as UNSAFE_ErrorResponseImpl, FetchersContext as UNSAFE_FetchersContext, FrameworkContext as UNSAFE_FrameworkContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RemixErrorBoundary as UNSAFE_RemixErrorBoundary, RouteContext as UNSAFE_RouteContext, ServerMode as UNSAFE_ServerMode, SingleFetchRedirectSymbol as UNSAFE_SingleFetchRedirectSymbol, ViewTransitionContext as UNSAFE_ViewTransitionContext, createBrowserHistory as UNSAFE_createBrowserHistory, createClientRoutes as UNSAFE_createClientRoutes, createClientRoutesWithHMRRevalidationOptOut as UNSAFE_createClientRoutesWithHMRRevalidationOptOut, createRouter as UNSAFE_createRouter, decodeViaTurboStream as UNSAFE_decodeViaTurboStream, deserializeErrors as UNSAFE_deserializeErrors, getPatchRoutesOnNavigationFunction as UNSAFE_getPatchRoutesOnNavigationFunction, getSingleFetchDataStrategy$1 as UNSAFE_getSingleFetchDataStrategy, invariant$2 as UNSAFE_invariant, mapRouteProperties as UNSAFE_mapRouteProperties, shouldHydrateRouteLoader as UNSAFE_shouldHydrateRouteLoader, useFogOFWarDiscovery as UNSAFE_useFogOFWarDiscovery, useScrollRestoration as UNSAFE_useScrollRestoration, createBrowserRouter, createCookie, createCookieSessionStorage, createHashRouter, createMemoryRouter, createMemorySessionStorage, createPath, createRequestHandler, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, createRoutesStub, createSearchParams, createSession, createSessionStorage, createStaticHandler, createStaticRouter, data, generatePath, isCookie, isRouteErrorResponse, isSession, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, replace, resolvePath, HistoryRouter as unstable_HistoryRouter, setDevServerHooks as unstable_setDevServerHooks, usePrompt as unstable_usePrompt, useActionData, useAsyncError, useAsyncValue, useBeforeUnload, useBlocker, useFetcher, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes, useSearchParams, useSubmit, useViewTransitionState };
 //# sourceMappingURL=index.mjs.map