@remix-run/router 1.6.2 → 1.6.3-pre.0

package/dist/router.cjs.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.6.2
+ * @remix-run/router v1.6.3-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -16,14 +16,12 @@ function _extends() {
   _extends = Object.assign ? Object.assign.bind() : function (target) {
     for (var i = 1; i < arguments.length; i++) {
       var source = arguments[i];
-
       for (var key in source) {
         if (Object.prototype.hasOwnProperty.call(source, key)) {
           target[key] = source[key];
         }
       }
     }
-
     return target;
   };
   return _extends.apply(this, arguments);
@@ -37,17 +35,41 @@ function _extends() {
  * Actions represent the type of change to a location value.
  */
 exports.Action = void 0;
+
 /**
  * The pathname, search, and hash values of a URL.
  */
-
 (function (Action) {
   Action["Pop"] = "POP";
   Action["Push"] = "PUSH";
   Action["Replace"] = "REPLACE";
 })(exports.Action || (exports.Action = {}));
+/**
+ * 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, either via
+ * `history.push` or `history.replace`. May be either a URL or the pieces of a
+ * URL path.
+ */
+/**
+ * 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
 
-const PopStateEventType = "popstate"; //#endregion
 ////////////////////////////////////////////////////////////////////////////////
 //#region Memory History
 ////////////////////////////////////////////////////////////////////////////////
@@ -56,7 +78,11 @@ const PopStateEventType = "popstate"; //#endregion
  * 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.
@@ -65,60 +91,47 @@ function createMemoryHistory(options) {
   if (options === void 0) {
     options = {};
   }
-
   let {
     initialEntries = ["/"],
     initialIndex,
     v5Compat = false
   } = options;
   let entries; // Declare so we can access from createMemoryLocation
-
   entries = initialEntries.map((entry, index) => createMemoryLocation(entry, typeof entry === "string" ? null : entry.state, index === 0 ? "default" : undefined));
   let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);
   let action = exports.Action.Pop;
   let listener = null;
-
   function clampIndex(n) {
     return Math.min(Math.max(n, 0), entries.length - 1);
   }
-
   function getCurrentLocation() {
     return entries[index];
   }
-
   function createMemoryLocation(to, state, key) {
     if (state === void 0) {
       state = null;
     }
-
     let location = createLocation(entries ? getCurrentLocation().pathname : "/", to, state, key);
     warning(location.pathname.charAt(0) === "/", "relative pathnames are not supported in memory history: " + JSON.stringify(to));
     return location;
   }
-
   function createHref(to) {
     return typeof to === "string" ? to : createPath(to);
   }
-
   let history = {
     get index() {
       return index;
     },
-
     get action() {
       return action;
     },
-
     get location() {
       return getCurrentLocation();
     },
-
     createHref,
-
     createURL(to) {
       return new URL(createHref(to), "http://localhost");
     },
-
     encodeLocation(to) {
       let path = typeof to === "string" ? parsePath(to) : to;
       return {
@@ -127,13 +140,11 @@ function createMemoryHistory(options) {
         hash: path.hash || ""
       };
     },
-
     push(to, state) {
       action = exports.Action.Push;
       let nextLocation = createMemoryLocation(to, state);
       index += 1;
       entries.splice(index, entries.length, nextLocation);
-
       if (v5Compat && listener) {
         listener({
           action,
@@ -142,12 +153,10 @@ function createMemoryHistory(options) {
         });
       }
     },
-
     replace(to, state) {
       action = exports.Action.Replace;
       let nextLocation = createMemoryLocation(to, state);
       entries[index] = nextLocation;
-
       if (v5Compat && listener) {
         listener({
           action,
@@ -156,13 +165,11 @@ function createMemoryHistory(options) {
         });
       }
     },
-
     go(delta) {
       action = exports.Action.Pop;
       let nextIndex = clampIndex(index + delta);
       let nextLocation = entries[nextIndex];
       index = nextIndex;
-
       if (listener) {
         listener({
           action,
@@ -171,17 +178,17 @@ function createMemoryHistory(options) {
         });
       }
     },
-
     listen(fn) {
       listener = fn;
       return () => {
         listener = null;
       };
     }
-
   };
   return history;
-} //#endregion
+}
+//#endregion
+
 ////////////////////////////////////////////////////////////////////////////////
 //#region Browser History
 ////////////////////////////////////////////////////////////////////////////////
@@ -193,7 +200,6 @@ function createMemoryHistory(options) {
  *
  * @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
@@ -205,7 +211,6 @@ function createBrowserHistory(options) {
   if (options === void 0) {
     options = {};
   }
-
   function createBrowserLocation(window, globalHistory) {
     let {
       pathname,
@@ -216,16 +221,17 @@ function createBrowserHistory(options) {
       pathname,
       search,
       hash
-    }, // state defaults to `null` because `window.history.state` does
+    },
+    // state defaults to `null` because `window.history.state` does
     globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || "default");
   }
-
   function createBrowserHref(window, to) {
     return typeof to === "string" ? to : createPath(to);
   }
-
   return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);
-} //#endregion
+}
+//#endregion
+
 ////////////////////////////////////////////////////////////////////////////////
 //#region Hash History
 ////////////////////////////////////////////////////////////////////////////////
@@ -241,7 +247,6 @@ function createBrowserHistory(options) {
  *
  * @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
@@ -254,7 +259,6 @@ function createHashHistory(options) {
   if (options === void 0) {
     options = {};
   }
-
   function createHashLocation(window, globalHistory) {
     let {
       pathname = "/",
@@ -265,29 +269,27 @@ function createHashHistory(options) {
       pathname,
       search,
       hash
-    }, // state defaults to `null` because `window.history.state` does
+    },
+    // state defaults to `null` because `window.history.state` does
     globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || "default");
   }
-
   function createHashHref(window, to) {
     let base = window.document.querySelector("base");
     let href = "";
-
     if (base && base.getAttribute("href")) {
       let url = window.location.href;
       let hashIndex = url.indexOf("#");
       href = hashIndex === -1 ? url : url.slice(0, hashIndex);
     }
-
     return href + "#" + (typeof to === "string" ? to : createPath(to));
   }
-
   function validateHashLocation(location, to) {
     warning(location.pathname.charAt(0) === "/", "relative pathnames are not supported in hash history.push(" + JSON.stringify(to) + ")");
   }
-
   return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);
-} //#endregion
+}
+//#endregion
+
 ////////////////////////////////////////////////////////////////////////////////
 //#region UTILS
 ////////////////////////////////////////////////////////////////////////////////
@@ -295,7 +297,6 @@ function createHashHistory(options) {
 /**
  * @private
  */
-
 function invariant(value, message) {
   if (value === false || value === null || typeof value === "undefined") {
     throw new Error(message);
@@ -305,26 +306,24 @@ function warning(cond, message) {
   if (!cond) {
     // eslint-disable-next-line no-console
     if (typeof console !== "undefined") console.warn(message);
-
     try {
       // Welcome to debugging history!
       //
       // This error is thrown as a convenience so you can more easily
       // find the source for a warning that appears in the console by
       // enabling "pause on exceptions" in your JavaScript debugger.
-      throw new Error(message); // eslint-disable-next-line no-empty
+      throw new Error(message);
+      // eslint-disable-next-line no-empty
     } catch (e) {}
   }
 }
-
 function createKey() {
   return Math.random().toString(36).substr(2, 8);
 }
+
 /**
  * For browser-based histories, we combine the state and key into an object
  */
-
-
 function getHistoryState(location, index) {
   return {
     usr: location.state,
@@ -332,16 +331,14 @@ function getHistoryState(location, index) {
     idx: index
   };
 }
+
 /**
  * Creates a Location object with a unique key from the given Path
  */
-
-
 function createLocation(current, to, state, key) {
   if (state === void 0) {
     state = null;
   }
-
   let location = _extends({
     pathname: typeof current === "string" ? current : current.pathname,
     search: "",
@@ -354,13 +351,12 @@ function createLocation(current, to, state, key) {
     // keep as is for the time being and just let any incoming keys take precedence
     key: to && to.key || key || createKey()
   });
-
   return location;
 }
+
 /**
  * Creates a string URL path from the given pathname, search, and hash components.
  */
-
 function createPath(_ref) {
   let {
     pathname = "/",
@@ -371,41 +367,33 @@ 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.
  */
-
 function parsePath(path) {
   let parsedPath = {};
-
   if (path) {
     let hashIndex = path.indexOf("#");
-
     if (hashIndex >= 0) {
       parsedPath.hash = path.substr(hashIndex);
       path = path.substr(0, hashIndex);
     }
-
     let searchIndex = path.indexOf("?");
-
     if (searchIndex >= 0) {
       parsedPath.search = path.substr(searchIndex);
       path = path.substr(0, searchIndex);
     }
-
     if (path) {
       parsedPath.pathname = path;
     }
   }
-
   return parsedPath;
 }
-
 function getUrlBasedHistory(getLocation, createHref, validateLocation, options) {
   if (options === void 0) {
     options = {};
   }
-
   let {
     window = document.defaultView,
     v5Compat = false
@@ -413,30 +401,27 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
   let globalHistory = window.history;
   let action = exports.Action.Pop;
   let listener = null;
-  let index = getIndex(); // Index should only be null when we initialize. If not, it's because the
+  let index = getIndex();
+  // Index should only be null when we initialize. If not, it's because the
   // user called history.pushState or history.replaceState directly, in which
   // case we should log a warning as it will result in bugs.
-
   if (index == null) {
     index = 0;
     globalHistory.replaceState(_extends({}, globalHistory.state, {
       idx: index
     }), "");
   }
-
   function getIndex() {
     let state = globalHistory.state || {
       idx: null
     };
     return state.idx;
   }
-
   function handlePop() {
     action = exports.Action.Pop;
     let nextIndex = getIndex();
     let delta = nextIndex == null ? null : nextIndex - index;
     index = nextIndex;
-
     if (listener) {
       listener({
         action,
@@ -445,23 +430,29 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
       });
     }
   }
-
   function push(to, state) {
     action = exports.Action.Push;
     let location = createLocation(history.location, to, state);
     if (validateLocation) validateLocation(location, to);
     index = getIndex() + 1;
     let historyState = getHistoryState(location, index);
-    let url = history.createHref(location); // try...catch because iOS limits us to 100 pushState calls :/
+    let url = history.createHref(location);
 
+    // try...catch because iOS limits us to 100 pushState calls :/
     try {
       globalHistory.pushState(historyState, "", url);
     } catch (error) {
+      // If the exception is because `state` can't be serialized, let that throw
+      // outwards just like a replace call would so the dev knows the cause
+      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps
+      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal
+      if (error instanceof DOMException && error.name === "DataCloneError") {
+        throw error;
+      }
       // They are going to lose state here, but there is no real
       // way to warn them about it since the page will refresh...
       window.location.assign(url);
     }
-
     if (v5Compat && listener) {
       listener({
         action,
@@ -470,7 +461,6 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
       });
     }
   }
-
   function replace(to, state) {
     action = exports.Action.Replace;
     let location = createLocation(history.location, to, state);
@@ -479,7 +469,6 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
     let historyState = getHistoryState(location, index);
     let url = history.createHref(location);
     globalHistory.replaceState(historyState, "", url);
-
     if (v5Compat && listener) {
       listener({
         action,
@@ -488,7 +477,6 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
       });
     }
   }
-
   function createURL(to) {
     // window.location.origin is "null" (the literal string value) in Firefox
     // under certain conditions, notably when serving from a local HTML file
@@ -498,21 +486,17 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
     invariant(base, "No window.location.(origin|href) available to create URL for href: " + href);
     return new URL(href, base);
   }
-
   let history = {
     get action() {
       return action;
     },
-
     get location() {
       return getLocation(window, globalHistory);
     },
-
     listen(fn) {
       if (listener) {
         throw new Error("A history only accepts one active listener");
       }
-
       window.addEventListener(PopStateEventType, handlePop);
       listener = fn;
       return () => {
@@ -520,13 +504,10 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
         listener = null;
       };
     },
-
     createHref(to) {
       return createHref(window, to);
     },
-
     createURL,
-
     encodeLocation(to) {
       // Encode a Location the same way window.location would
       let url = createURL(to);
@@ -536,66 +517,176 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
         hash: url.hash
       };
     },
-
     push,
     replace,
-
     go(n) {
       return globalHistory.go(n);
     }
-
   };
   return history;
-} //#endregion
+}
+
+//#endregion
 
 /**
  * Map of routeId -> data returned from a loader/action/error
  */
 
 let ResultType;
+
 /**
  * Successful result from a loader or action
  */
-
 (function (ResultType) {
   ResultType["data"] = "data";
   ResultType["deferred"] = "deferred";
   ResultType["redirect"] = "redirect";
   ResultType["error"] = "error";
 })(ResultType || (ResultType = {}));
-
+/**
+ * Successful defer() 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 lowercase on the
+ * RouterState
+ */
+/**
+ * In v7, active navigation/fetcher form methods are exposed in uppercase on the
+ * RouterState.  This is to align with the normalization done via fetch().
+ */
+/**
+ * @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
+ */
+/**
+ * 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.
+ */
+/**
+ * Function provided by the framework-aware layers to set `hasErrorBoundary`
+ * from the framework-aware `errorElement` prop
+ *
+ * @deprecated Use `mapRouteProperties` instead
+ */
+/**
+ * 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
-
+}
 
+// 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) {
   if (parentPath === void 0) {
     parentPath = [];
   }
-
   if (manifest === void 0) {
     manifest = {};
   }
-
   return routes.map((route, index) => {
     let treePath = [...parentPath, index];
     let id = typeof route.id === "string" ? route.id : treePath.join("-");
     invariant(route.index !== true || !route.children, "Cannot specify children on an index route");
     invariant(!manifest[id], "Found a route id collision on id \"" + id + "\".  Route " + "id's must be globally unique within Data Router usages");
-
     if (isIndexRoute(route)) {
       let indexRoute = _extends({}, route, mapRouteProperties(route), {
         id
       });
-
       manifest[id] = indexRoute;
       return indexRoute;
     } else {
@@ -603,41 +694,35 @@ function convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath, manif
         id,
         children: undefined
       });
-
       manifest[id] = pathOrLayoutRoute;
-
       if (route.children) {
         pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties, treePath, manifest);
       }
-
       return pathOrLayoutRoute;
     }
   });
 }
+
 /**
  * Matches the given routes to a location and returns the match data.
  *
  * @see https://reactrouter.com/utils/match-routes
  */
-
 function matchRoutes(routes, locationArg, basename) {
   if (basename === void 0) {
     basename = "/";
   }
-
   let location = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
   let pathname = stripBasename(location.pathname || "/", basename);
-
   if (pathname == null) {
     return null;
   }
-
   let branches = flattenRoutes(routes);
   rankRouteBranches(branches);
   let matches = null;
-
   for (let i = 0; matches == null && i < branches.length; ++i) {
-    matches = matchRouteBranch(branches[i], // Incoming pathnames are generally encoded from either window.location
+    matches = matchRouteBranch(branches[i],
+    // Incoming pathnames are generally encoded from either window.location
     // or from router.navigate, but we want to match against the unencoded
     // paths in the route definitions.  Memory router locations won't be
     // encoded here but there also shouldn't be anything to decode so this
@@ -645,23 +730,18 @@ function matchRoutes(routes, locationArg, basename) {
     // history-aware.
     safelyDecodeURI(pathname));
   }
-
   return matches;
 }
-
 function flattenRoutes(routes, branches, parentsMeta, parentPath) {
   if (branches === void 0) {
     branches = [];
   }
-
   if (parentsMeta === void 0) {
     parentsMeta = [];
   }
-
   if (parentPath === void 0) {
     parentPath = "";
   }
-
   let flattenRoute = (route, index, relativePath) => {
     let meta = {
       relativePath: relativePath === undefined ? route.path || "" : relativePath,
@@ -669,40 +749,37 @@ function flattenRoutes(routes, branches, parentsMeta, parentPath) {
       childrenIndex: index,
       route
     };
-
     if (meta.relativePath.startsWith("/")) {
       invariant(meta.relativePath.startsWith(parentPath), "Absolute route path \"" + meta.relativePath + "\" nested under path " + ("\"" + parentPath + "\" is not valid. An absolute child route path ") + "must start with the combined path of all its parent routes.");
       meta.relativePath = meta.relativePath.slice(parentPath.length);
     }
-
     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
+    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.
-
     if (route.children && route.children.length > 0) {
-      invariant( // Our types know better, but runtime JS may not!
+      invariant(
+      // Our types know better, but runtime JS may not!
       // @ts-expect-error
       route.index !== true, "Index routes must not have child routes. Please remove " + ("all child routes from route path \"" + path + "\"."));
       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.
-
+    }
 
+    // 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) {
       return;
     }
-
     branches.push({
       path,
       score: computeScore(path, route.index),
       routesMeta
     });
   };
-
   routes.forEach((route, index) => {
     var _route$path;
-
     // coarse-grain check for optional params
     if (route.path === "" || !((_route$path = route.path) != null && _route$path.includes("?"))) {
       flattenRoute(route, index);
@@ -714,6 +791,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.
@@ -728,82 +806,74 @@ function flattenRoutes(routes, branches, parentsMeta, parentPath) {
  * - `/one/three/:four/:five`
  * - `/one/:two/three/:four/:five`
  */
-
-
 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`
+  let [first, ...rest] = segments;
 
+  // Optional path segments are denoted by a trailing `?`
+  let isOptional = first.endsWith("?");
+  // Compute the corresponding required segment: `foo?` -> `foo`
   let required = first.replace(/\?$/, "");
-
   if (rest.length === 0) {
     // Intepret empty string as omitting an optional segment
     // `["one", "", "three"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`
     return isOptional ? [required, ""] : [required];
   }
-
   let restExploded = explodeOptionalSegments(rest.join("/"));
-  let result = []; // All child paths with the prefix.  Do this for all children before the
+  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
   // child sections interspersed where deeper optional segments are higher than
   // parent optional segments, where for example, /:two would explodes _earlier_
   // 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("/")));
 
-  result.push(...restExploded.map(subpath => subpath === "" ? required : [required, subpath].join("/"))); // Then if this is an optional value, add all child versions without
-
+  // 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
-
+  }
 
+  // for absolute paths, ensure `/` instead of empty segment
   return result.map(exploded => path.startsWith("/") && exploded === "" ? "/" : exploded);
 }
-
 function rankRouteBranches(branches) {
   branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first
   : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));
 }
-
 const paramRe = /^:\w+$/;
 const dynamicSegmentValue = 3;
 const indexRouteValue = 2;
 const emptySegmentValue = 1;
 const staticSegmentValue = 10;
 const splatPenalty = -2;
-
 const isSplat = s => s === "*";
-
 function computeScore(path, index) {
   let segments = path.split("/");
   let initialScore = segments.length;
-
   if (segments.some(isSplat)) {
     initialScore += splatPenalty;
   }
-
   if (index) {
     initialScore += indexRouteValue;
   }
-
   return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === "" ? emptySegmentValue : staticSegmentValue), initialScore);
 }
-
 function compareIndexes(a, b) {
   let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);
-  return siblings ? // If two routes are siblings, we should try to match the earlier sibling
+  return siblings ?
+  // If two routes are siblings, we should try to match the earlier sibling
   // first. This allows people to have fine-grained control over the matching
   // behavior by simply putting routes with identical paths in the order they
   // want them tried.
-  a[a.length - 1] - b[b.length - 1] : // Otherwise, it doesn't really make sense to rank non-siblings by index,
+  a[a.length - 1] - b[b.length - 1] :
+  // Otherwise, it doesn't really make sense to rank non-siblings by index,
   // so they sort equally.
   0;
 }
-
 function matchRouteBranch(branch, pathname) {
   let {
     routesMeta
@@ -811,7 +881,6 @@ function matchRouteBranch(branch, pathname) {
   let matchedParams = {};
   let matchedPathname = "/";
   let matches = [];
-
   for (let i = 0; i < routesMeta.length; ++i) {
     let meta = routesMeta[i];
     let end = i === routesMeta.length - 1;
@@ -831,72 +900,70 @@ function matchRouteBranch(branch, pathname) {
       pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),
       route
     });
-
     if (match.pathnameBase !== "/") {
       matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
     }
   }
-
   return matches;
 }
+
 /**
  * Returns a path with params interpolated.
  *
  * @see https://reactrouter.com/utils/generate-path
  */
-
-
 function generatePath(originalPath, params) {
   if (params === void 0) {
     params = {};
   }
-
   let path = originalPath;
-
   if (path.endsWith("*") && path !== "*" && !path.endsWith("/*")) {
     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(/\*$/, "/*") + "\"."));
     path = path.replace(/\*$/, "/*");
-  } // ensure `/` is added at the beginning if the path is absolute
-
+  }
 
+  // ensure `/` is added at the beginning if the path is absolute
   const prefix = path.startsWith("/") ? "/" : "";
   const segments = path.split(/\/+/).map((segment, index, array) => {
-    const isLastSegment = index === array.length - 1; // only apply the splat if it's the last segment
+    const isLastSegment = index === array.length - 1;
 
+    // only apply the splat if it's the last segment
     if (isLastSegment && segment === "*") {
       const star = "*";
-      const starParam = params[star]; // Apply the splat
+      const starParam = params[star];
 
+      // Apply the splat
       return starParam;
     }
-
     const keyMatch = segment.match(/^:(\w+)(\??)$/);
-
     if (keyMatch) {
       const [, key, optional] = keyMatch;
       let param = params[key];
-
       if (optional === "?") {
         return param == null ? "" : param;
       }
-
       if (param == null) {
         invariant(false, "Missing \":" + key + "\" param");
       }
-
       return param;
-    } // Remove any optional markers from optional static segments
-
+    }
 
+    // Remove any optional markers from optional static segments
     return segment.replace(/\?$/g, "");
-  }) // Remove empty segments
+  })
+  // Remove empty segments
   .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.
@@ -911,7 +978,6 @@ function matchPath(pattern, pathname) {
       end: true
     };
   }
-
   let [matcher, paramNames] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);
   let match = pathname.match(matcher);
   if (!match) return null;
@@ -925,7 +991,6 @@ function matchPath(pattern, pathname) {
       let splatValue = captureGroups[index] || "";
       pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
     }
-
     memo[paramName] = safelyDecodeURIComponent(captureGroups[index] || "", paramName);
     return memo;
   }, {});
@@ -936,16 +1001,13 @@ function matchPath(pattern, pathname) {
     pattern
   };
 }
-
 function compilePath(path, caseSensitive, end) {
   if (caseSensitive === void 0) {
     caseSensitive = false;
   }
-
   if (end === void 0) {
     end = true;
   }
-
   warning(path === "*" || !path.endsWith("*") || path.endsWith("/*"), "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(/\*$/, "/*") + "\"."));
   let paramNames = [];
   let regexpSource = "^" + path.replace(/\/*\*?$/, "") // Ignore trailing / and /*, we'll handle it below
@@ -955,7 +1017,6 @@ function compilePath(path, caseSensitive, end) {
     paramNames.push(paramName);
     return "/([^\\/]+)";
   });
-
   if (path.endsWith("*")) {
     paramNames.push("*");
     regexpSource += path === "*" || path === "/*" ? "(.*)$" // Already matched the initial /, just match the rest
@@ -973,11 +1034,9 @@ function compilePath(path, caseSensitive, end) {
     // /user-preferences since `-` counts as a word boundary.
     regexpSource += "(?:(?=\\/|$))";
   } else ;
-
   let matcher = new RegExp(regexpSource, caseSensitive ? undefined : "i");
   return [matcher, paramNames];
 }
-
 function safelyDecodeURI(value) {
   try {
     return decodeURI(value);
@@ -986,7 +1045,6 @@ function safelyDecodeURI(value) {
     return value;
   }
 }
-
 function safelyDecodeURIComponent(value, paramName) {
   try {
     return decodeURIComponent(value);
@@ -995,41 +1053,36 @@ function safelyDecodeURIComponent(value, paramName) {
     return value;
   }
 }
+
 /**
  * @private
  */
-
-
 function stripBasename(pathname, basename) {
   if (basename === "/") return pathname;
-
   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
-
+  }
 
+  // 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;
   let nextChar = pathname.charAt(startIndex);
-
   if (nextChar && nextChar !== "/") {
     // pathname does not start with basename/
     return null;
   }
-
   return pathname.slice(startIndex) || "/";
 }
+
 /**
  * Returns a resolved path object relative to the given pathname.
  *
  * @see https://reactrouter.com/utils/resolve-path
  */
-
 function resolvePath(to, fromPathname) {
   if (fromPathname === void 0) {
     fromPathname = "/";
   }
-
   let {
     pathname: toPathname,
     search = "",
@@ -1042,7 +1095,6 @@ function resolvePath(to, fromPathname) {
     hash: normalizeHash(hash)
   };
 }
-
 function resolvePathname(relativePath, fromPathname) {
   let segments = fromPathname.replace(/\/+$/, "").split("/");
   let relativeSegments = relativePath.split("/");
@@ -1056,10 +1108,10 @@ function resolvePathname(relativePath, fromPathname) {
   });
   return segments.length > 1 ? segments.join("/") : "/";
 }
-
 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
  *
@@ -1083,22 +1135,18 @@ function getInvalidPathError(char, field, dest, path) {
  *     </Route>
  *   </Route>
  */
-
-
 function getPathContributingMatches(matches) {
   return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);
 }
+
 /**
  * @private
  */
-
 function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
   if (isPathRelative === void 0) {
     isPathRelative = false;
   }
-
   let to;
-
   if (typeof toArg === "string") {
     to = parsePath(toArg);
   } else {
@@ -1107,10 +1155,11 @@ function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
     invariant(!to.pathname || !to.pathname.includes("#"), getInvalidPathError("#", "pathname", "hash", to));
     invariant(!to.search || !to.search.includes("#"), getInvalidPathError("#", "search", "hash", to));
   }
-
   let isEmptyPath = toArg === "" || to.pathname === "";
   let toPathname = isEmptyPath ? "/" : to.pathname;
-  let from; // Routing is relative to the current pathname if explicitly requested.
+  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
   // route context. This is explained in `Note on `<Link to>` values` in our
@@ -1119,71 +1168,66 @@ function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
   // `to` values that do not provide a pathname. `to` can simply be a search or
   // hash string, in which case we should assume that the navigation is relative
   // to the current location's pathname and *not* the route pathname.
-
   if (isPathRelative || toPathname == null) {
     from = locationPathname;
   } else {
     let routePathnameIndex = routePathnames.length - 1;
-
     if (toPathname.startsWith("..")) {
-      let toSegments = toPathname.split("/"); // Each leading .. segment means "go up one route" instead of "go up one
+      let toSegments = toPathname.split("/");
+
+      // 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 "to" value instead of a "href".
-
       while (toSegments[0] === "..") {
         toSegments.shift();
         routePathnameIndex -= 1;
       }
-
       to.pathname = toSegments.join("/");
-    } // If there are more ".." segments than parent routes, resolve relative to
-    // the root / URL.
-
+    }
 
+    // If there are more ".." segments than parent routes, resolve relative to
+    // the root / URL.
     from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
   }
+  let path = resolvePath(to, from);
 
-  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
-
+  // 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
   let hasCurrentTrailingSlash = (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");
-
   if (!path.pathname.endsWith("/") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {
     path.pathname += "/";
   }
-
   return path;
 }
+
 /**
  * @private
  */
-
 function getToPathname(to) {
   // Empty strings should be treated the same as / paths
   return to === "" || to.pathname === "" ? "/" : typeof to === "string" ? parsePath(to).pathname : to.pathname;
 }
+
 /**
  * @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.
@@ -1192,16 +1236,13 @@ const json = 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
   }));
@@ -1212,17 +1253,15 @@ class DeferredData {
     this.pendingKeysSet = new Set();
     this.subscribers = new Set();
     this.deferredKeys = [];
-    invariant(data && typeof data === "object" && !Array.isArray(data), "defer() only accepts plain objects"); // Set up an AbortController + Promise we can race against to exit early
-    // cancellation
+    invariant(data && typeof data === "object" && !Array.isArray(data), "defer() only accepts plain objects");
 
+    // Set up an AbortController + Promise we can race against to exit early
+    // cancellation
     let reject;
     this.abortPromise = new Promise((_, r) => reject = r);
     this.controller = new AbortController();
-
     let onAbort = () => reject(new AbortedDeferredError("Deferred data aborted"));
-
     this.unlistenAbortSignal = () => this.controller.signal.removeEventListener("abort", onAbort);
-
     this.controller.signal.addEventListener("abort", onAbort);
     this.data = Object.entries(data).reduce((acc, _ref) => {
       let [key, value] = _ref;
@@ -1230,34 +1269,31 @@ class DeferredData {
         [key]: this.trackPromise(key, value)
       });
     }, {});
-
     if (this.done) {
       // All incoming values were resolved
       this.unlistenAbortSignal();
     }
-
     this.init = responseInit;
   }
-
   trackPromise(key, value) {
     if (!(value instanceof Promise)) {
       return value;
     }
-
     this.deferredKeys.push(key);
-    this.pendingKeysSet.add(key); // We store a little wrapper promise that will be extended with
+    this.pendingKeysSet.add(key);
+
+    // We store a little wrapper promise that will be extended with
     // _data/_error props upon resolve/reject
+    let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, null, data), error => this.onSettle(promise, key, error));
 
-    let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, null, data), error => this.onSettle(promise, key, error)); // Register rejection listeners to avoid uncaught promise rejections on
+    // Register rejection listeners to avoid uncaught promise rejections on
     // errors or aborted deferred values
-
     promise.catch(() => {});
     Object.defineProperty(promise, "_tracked", {
       get: () => true
     });
     return promise;
   }
-
   onSettle(promise, key, error, data) {
     if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {
       this.unlistenAbortSignal();
@@ -1266,14 +1302,11 @@ class DeferredData {
       });
       return Promise.reject(error);
     }
-
     this.pendingKeysSet.delete(key);
-
     if (this.done) {
       // Nothing left to abort!
       this.unlistenAbortSignal();
     }
-
     if (error) {
       Object.defineProperty(promise, "_error", {
         get: () => error
@@ -1281,54 +1314,43 @@ class DeferredData {
       this.emit(false, key);
       return Promise.reject(error);
     }
-
     Object.defineProperty(promise, "_data", {
       get: () => data
     });
     this.emit(false, key);
     return data;
   }
-
   emit(aborted, settledKey) {
     this.subscribers.forEach(subscriber => subscriber(aborted, settledKey));
   }
-
   subscribe(fn) {
     this.subscribers.add(fn);
     return () => this.subscribers.delete(fn);
   }
-
   cancel() {
     this.controller.abort();
     this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));
     this.emit(true);
   }
-
   async resolveData(signal) {
     let aborted = false;
-
     if (!this.done) {
       let onAbort = () => this.cancel();
-
       signal.addEventListener("abort", onAbort);
       aborted = await new Promise(resolve => {
         this.subscribe(aborted => {
           signal.removeEventListener("abort", onAbort);
-
           if (aborted || this.done) {
             resolve(aborted);
           }
         });
       });
     }
-
     return aborted;
   }
-
   get done() {
     return this.pendingKeysSet.size === 0;
   }
-
   get unwrappedData() {
     invariant(this.data !== null && this.done, "Can only unwrap data on initialized and settled deferreds");
     return Object.entries(this.data).reduce((acc, _ref2) => {
@@ -1338,40 +1360,31 @@ class DeferredData {
       });
     }, {});
   }
-
   get pendingKeys() {
     return Array.from(this.pendingKeysSet);
   }
-
 }
-
 function isTrackedPromise(value) {
   return value instanceof Promise && value._tracked === true;
 }
-
 function unwrapTrackedPromise(value) {
   if (!isTrackedPromise(value)) {
     return value;
   }
-
   if (value._error) {
     throw value._error;
   }
-
   return value._data;
 }
-
 const defer = function defer(data, init) {
   if (init === void 0) {
     init = {};
   }
-
   let responseInit = typeof init === "number" ? {
     status: init
   } : init;
   return new DeferredData(data, responseInit);
 };
-
 /**
  * A redirect response. Sets the status code and the `Location` header.
  * Defaults to "302 Found".
@@ -1380,9 +1393,7 @@ const redirect = function redirect(url, init) {
   if (init === void 0) {
     init = 302;
   }
-
   let responseInit = init;
-
   if (typeof responseInit === "number") {
     responseInit = {
       status: responseInit
@@ -1390,28 +1401,25 @@ const redirect = function redirect(url, init) {
   } else if (typeof responseInit.status === "undefined") {
     responseInit.status = 302;
   }
-
   let headers = new Headers(responseInit.headers);
   headers.set("Location", url);
   return new Response(null, _extends({}, responseInit, {
     headers
   }));
 };
+
 /**
  * @private
  * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies
  */
-
 class ErrorResponse {
   constructor(status, statusText, data, internal) {
     if (internal === void 0) {
       internal = false;
     }
-
     this.status = status;
     this.statusText = statusText || "";
     this.internal = internal;
-
     if (data instanceof Error) {
       this.data = data.toString();
       this.error = data;
@@ -1419,24 +1427,82 @@ class ErrorResponse {
       this.data = data;
     }
   }
-
 }
+
 /**
  * Check if the given error is an ErrorResponse generated from a 4xx/5xx
  * Response thrown from an action/loader
  */
-
 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
+ */
+/**
+ * Options for a navigate() call for a Link navigation
+ */
+/**
+ * Options for a navigate() call for a Form navigation
+ */
+/**
+ * Options to pass to navigate() for either a Link or Form navigation
+ */
+/**
+ * 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
+ */
+/**
+ * Wrapper object to allow us to throw any response out from callLoaderOrAction
+ * for queryRouter while preserving whether or not it was thrown or returned
+ * from the loader/action
+ */
 const validMutationMethodsArr = ["post", "put", "patch", "delete"];
 const validMutationMethods = new Set(validMutationMethodsArr);
 const validRequestMethodsArr = ["get", ...validMutationMethodsArr];
@@ -1466,12 +1532,12 @@ const IDLE_BLOCKER = {
   location: undefined
 };
 const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
-const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
-const isServer = !isBrowser;
-
 const defaultMapRouteProperties = route => ({
   hasErrorBoundary: Boolean(route.hasErrorBoundary)
-}); //#endregion
+});
+
+//#endregion
+
 ////////////////////////////////////////////////////////////////////////////////
 //#region createRouter
 ////////////////////////////////////////////////////////////////////////////////
@@ -1479,57 +1545,54 @@ const defaultMapRouteProperties = route => ({
 /**
  * Create a router and listen to history POP navigations
  */
-
-
 function createRouter(init) {
+  const routerWindow = init.window ? init.window : typeof window !== "undefined" ? window : undefined;
+  const isBrowser = typeof routerWindow !== "undefined" && typeof routerWindow.document !== "undefined" && typeof routerWindow.document.createElement !== "undefined";
+  const isServer = !isBrowser;
   invariant(init.routes.length > 0, "You must provide a non-empty routes array to createRouter");
   let mapRouteProperties;
-
   if (init.mapRouteProperties) {
     mapRouteProperties = init.mapRouteProperties;
   } else if (init.detectErrorBoundary) {
     // If they are still using the deprecated version, wrap it with the new API
     let detectErrorBoundary = init.detectErrorBoundary;
-
     mapRouteProperties = route => ({
       hasErrorBoundary: detectErrorBoundary(route)
     });
   } else {
     mapRouteProperties = defaultMapRouteProperties;
-  } // Routes keyed by ID
-
-
-  let manifest = {}; // Routes in tree format for matching
+  }
 
+  // Routes keyed by ID
+  let manifest = {};
+  // Routes in tree format for matching
   let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties, undefined, manifest);
   let inFlightDataRoutes;
-  let basename = init.basename || "/"; // Config driven behavior flags
-
+  let basename = init.basename || "/";
+  // Config driven behavior flags
   let future = _extends({
     v7_normalizeFormMethod: false,
     v7_prependBasename: false
-  }, init.future); // Cleanup function for history
-
-
-  let unlistenHistory = null; // Externally-provided functions to call on all state changes
-
-  let subscribers = new Set(); // Externally-provided object to hold scroll restoration locations during routing
-
-  let savedScrollPositions = null; // Externally-provided function to get scroll restoration keys
-
-  let getScrollRestorationKey = null; // Externally-provided function to get current scroll position
-
-  let getScrollPosition = null; // One-time flag to control the initial hydration scroll restoration.  Because
+  }, init.future);
+  // Cleanup function for history
+  let unlistenHistory = null;
+  // Externally-provided functions to call on all state changes
+  let subscribers = new Set();
+  // Externally-provided object to hold scroll restoration locations during routing
+  let savedScrollPositions = null;
+  // Externally-provided function to get scroll restoration keys
+  let getScrollRestorationKey = null;
+  // Externally-provided function to get current scroll position
+  let getScrollPosition = null;
+  // One-time flag to control the initial hydration scroll restoration.  Because
   // we don't get the saved positions from <ScrollRestoration /> until _after_
   // the initial render, we need to manually trigger a separate updateState to
   // send along the restoreScrollPosition
   // Set to true if we have `hydrationData` since we assume we were SSR'd and that
   // SSR did the initial scroll restoration.
-
   let initialScrollRestored = init.hydrationData != null;
   let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);
   let initialErrors = null;
-
   if (initialMatches == null) {
     // If we do not match a user-provided-route, fall back to the root
     // to allow the error boundary to take over
@@ -1545,10 +1608,11 @@ function createRouter(init) {
       [route.id]: error
     };
   }
-
-  let initialized = // All initialMatches need to be loaded before we're ready.  If we have lazy
+  let initialized =
+  // All initialMatches need to be loaded before we're ready.  If we have lazy
   // functions around still then we'll need to run them in initialize()
-  !initialMatches.some(m => m.route.lazy) && ( // And we have to either have no loaders or have been provided hydrationData
+  !initialMatches.some(m => m.route.lazy) && (
+  // And we have to either have no loaders or have been provided hydrationData
   !initialMatches.some(m => m.route.loader) || init.hydrationData != null);
   let router;
   let state = {
@@ -1566,57 +1630,74 @@ function createRouter(init) {
     errors: init.hydrationData && init.hydrationData.errors || initialErrors,
     fetchers: new Map(),
     blockers: new Map()
-  }; // -- Stateful internal variables to manage navigations --
+  };
+
+  // -- Stateful internal variables to manage navigations --
   // Current navigation in progress (to be committed in completeNavigation)
+  let pendingAction = exports.Action.Pop;
 
-  let pendingAction = exports.Action.Pop; // Should the current navigation prevent the scroll reset if scroll cannot
+  // Should the current navigation prevent the scroll reset if scroll cannot
   // be restored?
+  let pendingPreventScrollReset = false;
 
-  let pendingPreventScrollReset = false; // AbortController for the active navigation
+  // AbortController for the active navigation
+  let pendingNavigationController;
 
-  let pendingNavigationController; // We use this to avoid touching history in completeNavigation if a
+  // We use this to avoid touching history in completeNavigation if a
   // revalidation is entirely uninterrupted
+  let isUninterruptedRevalidation = false;
 
-  let isUninterruptedRevalidation = false; // Use this internal flag to force revalidation of all loaders:
+  // Use this internal flag to force revalidation of all loaders:
   //  - submissions (completed or interrupted)
   //  - useRevalidator()
   //  - X-Remix-Revalidate (from redirect)
+  let isRevalidationRequired = false;
 
-  let isRevalidationRequired = false; // Use this internal array to capture routes that require revalidation due
+  // Use this internal array to capture routes that require revalidation due
   // to a cancelled deferred on action submission
+  let cancelledDeferredRoutes = [];
 
-  let cancelledDeferredRoutes = []; // Use this internal array to capture fetcher loads that were cancelled by an
+  // Use this internal array to capture fetcher loads that were cancelled by an
   // action navigation and require revalidation
+  let cancelledFetcherLoads = [];
 
-  let cancelledFetcherLoads = []; // AbortControllers for any in-flight fetchers
+  // AbortControllers for any in-flight fetchers
+  let fetchControllers = new Map();
 
-  let fetchControllers = new Map(); // Track loads based on the order in which they started
+  // Track loads based on the order in which they started
+  let incrementingLoadId = 0;
 
-  let incrementingLoadId = 0; // Track the outstanding pending navigation data load to be compared against
+  // 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;
 
-  let pendingNavigationLoadId = -1; // Fetchers that triggered data reloads as a result of their actions
+  // Fetchers that triggered data reloads as a result of their actions
+  let fetchReloadIds = new Map();
 
-  let fetchReloadIds = new Map(); // Fetchers that triggered redirect navigations
+  // Fetchers that triggered redirect navigations
+  let fetchRedirectIds = new Set();
 
-  let fetchRedirectIds = new Set(); // Most recent href/match for fetcher.load calls for fetchers
+  // Most recent href/match for fetcher.load calls for fetchers
+  let fetchLoadMatches = new Map();
 
-  let fetchLoadMatches = new Map(); // Store DeferredData instances for active route matches.  When a
+  // Store DeferredData instances for active route matches.  When a
   // route loader returns defer() we stick one in here.  Then, when a nested
   // promise resolves we update loaderData.  If a new navigation starts we
   // cancel active deferreds for eliminated routes.
+  let activeDeferreds = new Map();
 
-  let activeDeferreds = new Map(); // Store blocker functions in a separate Map outside of router state since
+  // 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();
 
-  let blockerFunctions = new Map(); // Flag to ignore the next history update, so we can revert the URL change on
+  // 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 ignoreNextHistoryUpdate = false;
 
-  let ignoreNextHistoryUpdate = false; // Initialize the router, all side effects should be kicked off from here.
+  // 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();
-
   function initialize() {
     // If history informs us of a POP navigation, start the navigation but do not update
     // state.  We'll update our own state once the navigation completes
@@ -1626,98 +1707,90 @@ function createRouter(init) {
         location,
         delta
       } = _ref;
-
       // Ignore this event if it was just us resetting the URL from a
       // blocked POP navigation
       if (ignoreNextHistoryUpdate) {
         ignoreNextHistoryUpdate = false;
         return;
       }
-
       warning(blockerFunctions.size === 0 || delta != null, "You are trying to use a blocker on a POP navigation to a location " + "that was not created by @remix-run/router. This will fail silently in " + "production. This can happen if you are navigating outside the router " + "via `window.history.pushState`/`window.location.hash` instead of using " + "router navigation APIs.  This can also happen if you are using " + "createHashRouter and the user manually changes the URL.");
       let blockerKey = shouldBlockNavigation({
         currentLocation: state.location,
         nextLocation: location,
         historyAction
       });
-
       if (blockerKey && delta != null) {
         // Restore the URL to match the current UI, but don't update router state
         ignoreNextHistoryUpdate = true;
-        init.history.go(delta * -1); // Put the blocker into a blocked state
+        init.history.go(delta * -1);
 
+        // Put the blocker into a blocked state
         updateBlocker(blockerKey, {
           state: "blocked",
           location,
-
           proceed() {
             updateBlocker(blockerKey, {
               state: "proceeding",
               proceed: undefined,
               reset: undefined,
               location
-            }); // Re-do the same POP navigation we just blocked
-
+            });
+            // Re-do the same POP navigation we just blocked
             init.history.go(delta);
           },
-
           reset() {
             deleteBlocker(blockerKey);
             updateState({
               blockers: new Map(router.state.blockers)
             });
           }
-
         });
         return;
       }
-
       return startNavigation(historyAction, location);
-    }); // Kick off initial data load if needed.  Use Pop to avoid modifying history
+    });
+
+    // 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
     // resolved prior to router creation since we can't go into a fallbackElement
     // UI for SSR'd apps
-
     if (!state.initialized) {
       startNavigation(exports.Action.Pop, state.location);
     }
-
     return router;
-  } // Clean up a router and it's side effects
-
+  }
 
+  // Clean up a router and it's side effects
   function dispose() {
     if (unlistenHistory) {
       unlistenHistory();
     }
-
     subscribers.clear();
     pendingNavigationController && pendingNavigationController.abort();
     state.fetchers.forEach((_, key) => deleteFetcher(key));
     state.blockers.forEach((_, key) => deleteBlocker(key));
-  } // Subscribe to state updates for the router
-
+  }
 
+  // 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
-
+  }
 
+  // Update our state and notify the calling context of the change
   function updateState(newState) {
     state = _extends({}, state, newState);
     subscribers.forEach(subscriber => subscriber(state));
-  } // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION
+  }
+
+  // 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
   // - Navigation will always be set to IDLE_NAVIGATION
   // - Can pass any other state in newState
-
-
   function completeNavigation(location, newState) {
     var _location$state, _location$state2;
-
     // Deduce if we're in a loading/actionReload state:
     // - We have committed actionData in the store
     // - The current navigation was a mutation submission
@@ -1725,7 +1798,6 @@ function createRouter(init) {
     // - The location being loaded is not the result of a redirect
     let isActionReload = state.actionData != null && state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && state.navigation.state === "loading" && ((_location$state = location.state) == null ? void 0 : _location$state._isRedirect) !== true;
     let actionData;
-
     if (newState.actionData) {
       if (Object.keys(newState.actionData).length > 0) {
         actionData = newState.actionData;
@@ -1739,25 +1811,24 @@ function createRouter(init) {
     } else {
       // Clear actionData on any other completed navigations
       actionData = null;
-    } // Always preserve any existing loaderData from re-used routes
+    }
 
+    // Always preserve any existing loaderData from re-used routes
+    let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;
 
-    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
+    // On a successful navigation we can assume we got through all blockers
     // so we can start fresh
-
     for (let [key] of blockerFunctions) {
       deleteBlocker(key);
-    } // Always respect the user flag.  Otherwise don't reset on mutation
-    // submission navigations unless they redirect
-
+    }
 
+    // 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;
-
     if (inFlightDataRoutes) {
       dataRoutes = inFlightDataRoutes;
       inFlightDataRoutes = undefined;
     }
-
     updateState(_extends({}, newState, {
       // matches, errors, fetchers go through as-is
       actionData,
@@ -1771,30 +1842,28 @@ function createRouter(init) {
       preventScrollReset,
       blockers: new Map(state.blockers)
     }));
-
     if (isUninterruptedRevalidation) ; else if (pendingAction === exports.Action.Pop) ; else if (pendingAction === exports.Action.Push) {
       init.history.push(location, location.state);
     } else if (pendingAction === exports.Action.Replace) {
       init.history.replace(location, location.state);
-    } // Reset stateful navigation vars
-
+    }
 
+    // Reset stateful navigation vars
     pendingAction = exports.Action.Pop;
     pendingPreventScrollReset = false;
     isUninterruptedRevalidation = false;
     isRevalidationRequired = false;
     cancelledDeferredRoutes = [];
     cancelledFetcherLoads = [];
-  } // Trigger a navigation event, which can either be a numerical POP or a PUSH
-  // replace with an optional submission
-
+  }
 
+  // Trigger a navigation event, which can either be a numerical POP or a PUSH
+  // replace with an optional submission
   async function navigate(to, opts) {
     if (typeof to === "number") {
       init.history.go(to);
       return;
     }
-
     let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, to, opts == null ? void 0 : opts.fromRouteId, opts == null ? void 0 : opts.relative);
     let {
       path,
@@ -1802,16 +1871,16 @@ function createRouter(init) {
       error
     } = normalizeNavigateOptions(future.v7_normalizeFormMethod, 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
+    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
     // the same encoding we'd get from a history.pushState/window.location read
     // without having to touch history
-
     nextLocation = _extends({}, nextLocation, init.history.encodeLocation(nextLocation));
     let userReplace = opts && opts.replace != null ? opts.replace : undefined;
     let historyAction = exports.Action.Push;
-
     if (userReplace === true) {
       historyAction = exports.Action.Replace;
     } else if (userReplace === false) ; else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) {
@@ -1821,42 +1890,36 @@ function createRouter(init) {
       // action/loader this will be ignored and the redirect will be a PUSH
       historyAction = exports.Action.Replace;
     }
-
     let preventScrollReset = opts && "preventScrollReset" in opts ? opts.preventScrollReset === true : undefined;
     let blockerKey = shouldBlockNavigation({
       currentLocation,
       nextLocation,
       historyAction
     });
-
     if (blockerKey) {
       // Put the blocker into a blocked state
       updateBlocker(blockerKey, {
         state: "blocked",
         location: nextLocation,
-
         proceed() {
           updateBlocker(blockerKey, {
             state: "proceeding",
             proceed: undefined,
             reset: undefined,
             location: nextLocation
-          }); // Send the same navigation through
-
+          });
+          // Send the same navigation through
           navigate(to, opts);
         },
-
         reset() {
           deleteBlocker(blockerKey);
           updateState({
             blockers: new Map(state.blockers)
           });
         }
-
       });
       return;
     }
-
     return await startNavigation(historyAction, nextLocation, {
       submission,
       // Send through the formData serialization error if we have one so we can
@@ -1865,43 +1928,44 @@ function createRouter(init) {
       preventScrollReset,
       replace: opts && opts.replace
     });
-  } // Revalidate all current loaders.  If a navigation is in progress or if this
+  }
+
+  // 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
-
-
   function revalidate() {
     interruptActiveLoads();
     updateState({
       revalidation: "loading"
-    }); // 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 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;
-    } // If we're currently in an idle state, start a new navigation for the current
+    }
+
+    // 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
-
-
     if (state.navigation.state === "idle") {
       startNavigation(state.historyAction, state.location, {
         startUninterruptedRevalidation: true
       });
       return;
-    } // Otherwise, if we're currently in a loading state, just start a new
+    }
+
+    // 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
-
-
     startNavigation(pendingAction || state.historyAction, state.navigation.location, {
       overrideNavigation: state.navigation
     });
-  } // Start a navigation to the given action/location.  Can optionally provide a
+  }
+
+  // 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
-
-
   async function startNavigation(historyAction, location, opts) {
     // Abort any in-progress navigations and start a new one. Unset any ongoing
     // uninterrupted revalidations unless told otherwise, since we want this
@@ -1909,15 +1973,17 @@ function createRouter(init) {
     pendingNavigationController && pendingNavigationController.abort();
     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
+    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);
     pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
     let routesToUse = inFlightDataRoutes || dataRoutes;
     let loadingNavigation = opts && opts.overrideNavigation;
-    let matches = matchRoutes(routesToUse, location, basename); // Short circuit with a 404 on the root error boundary if we match nothing
+    let matches = matchRoutes(routesToUse, location, basename);
 
+    // Short circuit with a 404 on the root error boundary if we match nothing
     if (!matches) {
       let error = getInternalRouterError(404, {
         pathname: location.pathname
@@ -1925,8 +1991,8 @@ function createRouter(init) {
       let {
         matches: notFoundMatches,
         route
-      } = getShortCircuitMatches(routesToUse); // Cancel all pending deferred on 404s since we don't keep any routes
-
+      } = getShortCircuitMatches(routesToUse);
+      // Cancel all pending deferred on 404s since we don't keep any routes
       cancelActiveDeferreds();
       completeNavigation(location, {
         matches: notFoundMatches,
@@ -1936,26 +2002,26 @@ function createRouter(init) {
         }
       });
       return;
-    } // Short circuit if it's only a hash change and not a mutation submission.
-    // Ignore on initial page loads because since the initial load will always
-    // be "same hash".
-    // For example, on /page#hash and submit a <Form method="post"> which will
-    // default to a navigation to /page
-
+    }
 
-    if (state.initialized && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {
+    // Short circuit if it's only a hash change and not a revalidation or
+    // mutation submission.
+    //
+    // Ignore on initial page loads because since the initial load will always
+    // be "same hash".  For example, on /page#hash and submit a <Form method="post">
+    // which will default to a navigation to /page
+    if (state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {
       completeNavigation(location, {
         matches
       });
       return;
-    } // Create a controller/Request for this navigation
-
+    }
 
+    // Create a controller/Request for this navigation
     pendingNavigationController = new AbortController();
     let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);
     let pendingActionData;
     let pendingError;
-
     if (opts && opts.pendingError) {
       // If we have a pendingError, it means the user attempted a GET submission
       // with binary FormData so assign here and skip to handleLoaders.  That
@@ -1969,40 +2035,36 @@ function createRouter(init) {
       let actionOutput = await handleAction(request, location, opts.submission, matches, {
         replace: opts.replace
       });
-
       if (actionOutput.shortCircuited) {
         return;
       }
-
       pendingActionData = actionOutput.pendingActionData;
       pendingError = actionOutput.pendingActionError;
-
       let navigation = _extends({
         state: "loading",
         location
       }, opts.submission);
+      loadingNavigation = navigation;
 
-      loadingNavigation = navigation; // Create a GET request for the loaders
-
+      // Create a GET request for the loaders
       request = new Request(request.url, {
         signal: request.signal
       });
-    } // Call loaders
-
+    }
 
+    // Call loaders
     let {
       shortCircuited,
       loaderData,
       errors
     } = await handleLoaders(request, location, matches, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, pendingActionData, pendingError);
-
     if (shortCircuited) {
       return;
-    } // Clean up now that the action/loaders have completed.  Don't clean up if
+    }
+
+    // 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
-
-
     pendingNavigationController = null;
     completeNavigation(location, _extends({
       matches
@@ -2012,25 +2074,25 @@ function createRouter(init) {
       loaderData,
       errors
     }));
-  } // Call the action matched by the leaf route for this navigation and handle
-  // redirects/errors
-
+  }
 
+  // Call the action matched by the leaf route for this navigation and handle
+  // redirects/errors
   async function handleAction(request, location, submission, matches, opts) {
-    interruptActiveLoads(); // Put us in a submitting state
+    interruptActiveLoads();
 
+    // Put us in a submitting state
     let navigation = _extends({
       state: "submitting",
       location
     }, submission);
-
     updateState({
       navigation
-    }); // Call our action and get the result
+    });
 
+    // Call our action and get the result
     let result;
     let actionMatch = getTargetMatch(matches, location);
-
     if (!actionMatch.route.action && !actionMatch.route.lazy) {
       result = {
         type: ResultType.error,
@@ -2042,17 +2104,14 @@ function createRouter(init) {
       };
     } else {
       result = await callLoaderOrAction("action", request, actionMatch, matches, manifest, mapRouteProperties, basename);
-
       if (request.signal.aborted) {
         return {
           shortCircuited: true
         };
       }
     }
-
     if (isRedirectResult(result)) {
       let replace;
-
       if (opts && opts.replace != null) {
         replace = opts.replace;
       } else {
@@ -2061,7 +2120,6 @@ function createRouter(init) {
         // double back-buttons
         replace = result.location === state.location.pathname + state.location.search;
       }
-
       await startRedirectNavigation(state, result, {
         submission,
         replace
@@ -2070,19 +2128,18 @@ function createRouter(init) {
         shortCircuited: true
       };
     }
-
     if (isErrorResult(result)) {
       // 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 are REPLACE navigations, but if the
+      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);
+
+      // By default, all submissions 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 back button to get back to
       // the pre-submission form location to try again
-
       if ((opts && opts.replace) !== true) {
         pendingAction = exports.Action.Push;
       }
-
       return {
         // Send back an empty object we can use to clear out any prior actionData
         pendingActionData: {},
@@ -2091,26 +2148,23 @@ function createRouter(init) {
         }
       };
     }
-
     if (isDeferredResult(result)) {
       throw getInternalRouterError(400, {
         type: "defer-action"
       });
     }
-
     return {
       pendingActionData: {
         [actionMatch.route.id]: result.data
       }
     };
-  } // Call all applicable loaders for the given matches, handling redirects,
-  // errors, etc.
-
+  }
 
+  // Call all applicable loaders for the given matches, handling redirects,
+  // errors, etc.
   async function handleLoaders(request, location, matches, overrideNavigation, submission, fetcherSubmission, replace, pendingActionData, pendingError) {
     // Figure out the right navigation we want to use for data loading
     let loadingNavigation = overrideNavigation;
-
     if (!loadingNavigation) {
       let navigation = _extends({
         state: "loading",
@@ -2120,12 +2174,11 @@ function createRouter(init) {
         formEncType: undefined,
         formData: undefined
       }, submission);
-
       loadingNavigation = navigation;
-    } // 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
-
+    }
 
+    // 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 ? submission || fetcherSubmission : loadingNavigation.formMethod && loadingNavigation.formAction && loadingNavigation.formData && loadingNavigation.formEncType ? {
       formMethod: loadingNavigation.formMethod,
       formAction: loadingNavigation.formAction,
@@ -2133,12 +2186,14 @@ function createRouter(init) {
       formEncType: loadingNavigation.formEncType
     } : undefined;
     let routesToUse = inFlightDataRoutes || dataRoutes;
-    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, fetchLoadMatches, routesToUse, basename, pendingActionData, pendingError); // Cancel pending deferreds for no-longer-matched routes or routes we're
+    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, fetchLoadMatches, routesToUse, basename, pendingActionData, pendingError);
+
+    // Cancel pending deferreds for no-longer-matched routes or routes we're
     // about to reload.  Note that if this is an action reload we would have
     // already cancelled all pending deferreds so this would be a no-op
+    cancelActiveDeferreds(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId));
 
-    cancelActiveDeferreds(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId)); // Short circuit if we have no loaders to run
-
+    // Short circuit if we have no loaders to run
     if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {
       let updatedFetchers = markFetchRedirectsDone();
       completeNavigation(location, _extends({
@@ -2154,12 +2209,12 @@ function createRouter(init) {
       return {
         shortCircuited: true
       };
-    } // If this is an uninterrupted revalidation, we remain in our current idle
+    }
+
+    // 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
     // a revalidation interrupting an actionReload)
-
-
     if (!isUninterruptedRevalidation) {
       revalidatingFetchers.forEach(rf => {
         let fetcher = state.fetchers.get(rf.key);
@@ -2185,7 +2240,6 @@ function createRouter(init) {
         fetchers: new Map(state.fetchers)
       } : {}));
     }
-
     pendingNavigationLoadId = ++incrementingLoadId;
     revalidatingFetchers.forEach(rf => {
       if (rf.controller) {
@@ -2194,37 +2248,34 @@ function createRouter(init) {
         // triggered the revalidation
         fetchControllers.set(rf.key, rf.controller);
       }
-    }); // Proxy navigation abort through to revalidation fetchers
+    });
 
+    // Proxy navigation abort through to revalidation fetchers
     let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(f => abortFetcher(f.key));
-
     if (pendingNavigationController) {
       pendingNavigationController.signal.addEventListener("abort", abortPendingFetchRevalidations);
     }
-
     let {
       results,
       loaderResults,
       fetcherResults
     } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, request);
-
     if (request.signal.aborted) {
       return {
         shortCircuited: true
       };
-    } // Clean up _after_ loaders have completed.  Don't clean up if we short
+    }
+
+    // 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
-
-
     if (pendingNavigationController) {
       pendingNavigationController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
     }
+    revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key));
 
-    revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key)); // If any loaders returned a redirect Response, start a new REPLACE navigation
-
+    // If any loaders returned a redirect Response, start a new REPLACE navigation
     let redirect = findRedirect(results);
-
     if (redirect) {
       await startRedirectNavigation(state, redirect, {
         replace
@@ -2232,14 +2283,15 @@ function createRouter(init) {
       return {
         shortCircuited: true
       };
-    } // Process and commit output from loaders
-
+    }
 
+    // Process and commit output from loaders
     let {
       loaderData,
       errors
-    } = processLoaderData(state, matches, matchesToLoad, loaderResults, pendingError, revalidatingFetchers, fetcherResults, activeDeferreds); // Wire up subscribers to update loaderData as promises settle
+    } = processLoaderData(state, matches, matchesToLoad, loaderResults, pendingError, revalidatingFetchers, fetcherResults, activeDeferreds);
 
+    // Wire up subscribers to update loaderData as promises settle
     activeDeferreds.forEach((deferredData, routeId) => {
       deferredData.subscribe(aborted => {
         // Note: No need to updateState here since the TrackedPromise on
@@ -2260,56 +2312,50 @@ function createRouter(init) {
       fetchers: new Map(state.fetchers)
     } : {});
   }
-
   function getFetcher(key) {
     return state.fetchers.get(key) || IDLE_FETCHER;
-  } // Trigger a fetcher load/submit for the given fetcher key
-
+  }
 
+  // Trigger a fetcher load/submit for the given fetcher key
   function fetch(key, routeId, href, opts) {
     if (isServer) {
       throw new Error("router.fetch() was called during the server render, but it shouldn't be. " + "You are likely calling a useFetcher() method in the body of your component. " + "Try moving it to a useEffect or a callback.");
     }
-
     if (fetchControllers.has(key)) abortFetcher(key);
     let routesToUse = inFlightDataRoutes || dataRoutes;
     let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, routeId, opts == null ? void 0 : opts.relative);
     let matches = matchRoutes(routesToUse, normalizedPath, basename);
-
     if (!matches) {
       setFetcherError(key, routeId, getInternalRouterError(404, {
         pathname: normalizedPath
       }));
       return;
     }
-
     let {
       path,
       submission
     } = normalizeNavigateOptions(future.v7_normalizeFormMethod, true, normalizedPath, opts);
     let match = getTargetMatch(matches, path);
     pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
-
     if (submission && isMutationMethod(submission.formMethod)) {
       handleFetcherAction(key, routeId, path, match, matches, submission);
       return;
-    } // Store off the match so we can call it's shouldRevalidate on subsequent
-    // revalidations
-
+    }
 
+    // Store off the match so we can call it's shouldRevalidate on subsequent
+    // revalidations
     fetchLoadMatches.set(key, {
       routeId,
       path
     });
     handleFetcherLoader(key, routeId, path, match, matches, submission);
-  } // Call the action for the matched fetcher.submit(), and then handle redirects,
-  // errors, and revalidation
-
+  }
 
+  // Call the action for the matched fetcher.submit(), and then handle redirects,
+  // errors, and revalidation
   async function handleFetcherAction(key, routeId, path, match, requestMatches, submission) {
     interruptActiveLoads();
     fetchLoadMatches.delete(key);
-
     if (!match.route.action && !match.route.lazy) {
       let error = getInternalRouterError(405, {
         method: submission.formMethod,
@@ -2318,49 +2364,43 @@ function createRouter(init) {
       });
       setFetcherError(key, routeId, error);
       return;
-    } // Put this fetcher into it's submitting state
-
+    }
 
+    // Put this fetcher into it's submitting state
     let existingFetcher = state.fetchers.get(key);
-
     let fetcher = _extends({
       state: "submitting"
     }, submission, {
       data: existingFetcher && existingFetcher.data,
       " _hasFetcherDoneAnything ": true
     });
-
     state.fetchers.set(key, fetcher);
     updateState({
       fetchers: new Map(state.fetchers)
-    }); // Call the action for the fetcher
+    });
 
+    // Call the action for the fetcher
     let abortController = new AbortController();
     let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);
     fetchControllers.set(key, abortController);
     let actionResult = await callLoaderOrAction("action", fetchRequest, match, requestMatches, manifest, mapRouteProperties, basename);
-
     if (fetchRequest.signal.aborted) {
       // We can delete this so long as we weren't aborted by ou our own fetcher
       // re-submit which would have put _new_ controller is in fetchControllers
       if (fetchControllers.get(key) === abortController) {
         fetchControllers.delete(key);
       }
-
       return;
     }
-
     if (isRedirectResult(actionResult)) {
       fetchControllers.delete(key);
       fetchRedirectIds.add(key);
-
       let loadingFetcher = _extends({
         state: "loading"
       }, submission, {
         data: undefined,
         " _hasFetcherDoneAnything ": true
       });
-
       state.fetchers.set(key, loadingFetcher);
       updateState({
         fetchers: new Map(state.fetchers)
@@ -2369,22 +2409,21 @@ function createRouter(init) {
         submission,
         isFetchActionRedirect: true
       });
-    } // Process any non-redirect errors thrown
-
+    }
 
+    // Process any non-redirect errors thrown
     if (isErrorResult(actionResult)) {
       setFetcherError(key, routeId, actionResult.error);
       return;
     }
-
     if (isDeferredResult(actionResult)) {
       throw getInternalRouterError(400, {
         type: "defer-action"
       });
-    } // Start the data load for current matches, or the next location if we're
-    // in the middle of a navigation
-
+    }
 
+    // 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;
     let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);
     let routesToUse = inFlightDataRoutes || dataRoutes;
@@ -2392,22 +2431,21 @@ function createRouter(init) {
     invariant(matches, "Didn't find any matches after fetcher action");
     let loadId = ++incrementingLoadId;
     fetchReloadIds.set(key, loadId);
-
     let loadFetcher = _extends({
       state: "loading",
       data: actionResult.data
     }, submission, {
       " _hasFetcherDoneAnything ": true
     });
-
     state.fetchers.set(key, loadFetcher);
     let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, fetchLoadMatches, routesToUse, basename, {
       [match.route.id]: actionResult.data
     }, undefined // No need to send through errors since we short circuit above
-    ); // Put all revalidating fetchers into the loading state, except for the
+    );
+
+    // 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
-
     revalidatingFetchers.filter(rf => rf.key !== key).forEach(rf => {
       let staleKey = rf.key;
       let existingFetcher = state.fetchers.get(staleKey);
@@ -2421,7 +2459,6 @@ function createRouter(init) {
         " _hasFetcherDoneAnything ": true
       };
       state.fetchers.set(staleKey, revalidatingFetcher);
-
       if (rf.controller) {
         fetchControllers.set(staleKey, rf.controller);
       }
@@ -2429,49 +2466,50 @@ function createRouter(init) {
     updateState({
       fetchers: new Map(state.fetchers)
     });
-
     let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(rf => abortFetcher(rf.key));
-
     abortController.signal.addEventListener("abort", abortPendingFetchRevalidations);
     let {
       results,
       loaderResults,
       fetcherResults
     } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);
-
     if (abortController.signal.aborted) {
       return;
     }
-
     abortController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
     fetchReloadIds.delete(key);
     fetchControllers.delete(key);
     revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));
     let redirect = findRedirect(results);
-
     if (redirect) {
       return startRedirectNavigation(state, redirect);
-    } // Process and commit output from loaders
-
+    }
 
+    // Process and commit output from loaders
     let {
       loaderData,
       errors
     } = processLoaderData(state, state.matches, matchesToLoad, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);
-    let doneFetcher = {
-      state: "idle",
-      data: actionResult.data,
-      formMethod: undefined,
-      formAction: undefined,
-      formEncType: undefined,
-      formData: undefined,
-      " _hasFetcherDoneAnything ": true
-    };
-    state.fetchers.set(key, doneFetcher);
-    let didAbortFetchLoads = abortStaleFetchLoads(loadId); // If we are currently in a navigation loading state and this fetcher is
+
+    // 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)) {
+      let doneFetcher = {
+        state: "idle",
+        data: actionResult.data,
+        formMethod: undefined,
+        formAction: undefined,
+        formEncType: undefined,
+        formData: undefined,
+        " _hasFetcherDoneAnything ": true
+      };
+      state.fetchers.set(key, doneFetcher);
+    }
+    let didAbortFetchLoads = 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
-
     if (state.navigation.state === "loading" && loadId > pendingNavigationLoadId) {
       invariant(pendingAction, "Expected pending action");
       pendingNavigationController && pendingNavigationController.abort();
@@ -2488,17 +2526,17 @@ function createRouter(init) {
       updateState(_extends({
         errors,
         loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors)
-      }, didAbortFetchLoads ? {
+      }, didAbortFetchLoads || revalidatingFetchers.length > 0 ? {
         fetchers: new Map(state.fetchers)
       } : {}));
       isRevalidationRequired = false;
     }
-  } // Call the matched loader for fetcher.load(), handling redirects, errors, etc.
-
+  }
 
+  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.
   async function handleFetcherLoader(key, routeId, path, match, matches, submission) {
-    let existingFetcher = state.fetchers.get(key); // Put this fetcher into it's loading state
-
+    let existingFetcher = state.fetchers.get(key);
+    // Put this fetcher into it's loading state
     let loadingFetcher = _extends({
       state: "loading",
       formMethod: undefined,
@@ -2509,48 +2547,48 @@ function createRouter(init) {
       data: existingFetcher && existingFetcher.data,
       " _hasFetcherDoneAnything ": true
     });
-
     state.fetchers.set(key, loadingFetcher);
     updateState({
       fetchers: new Map(state.fetchers)
-    }); // Call the loader for this fetcher route match
+    });
 
+    // Call the loader for this fetcher route match
     let abortController = new AbortController();
     let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);
     fetchControllers.set(key, abortController);
-    let result = await callLoaderOrAction("loader", fetchRequest, match, matches, manifest, mapRouteProperties, basename); // Deferred isn't supported for fetcher loads, await everything and treat it
+    let result = await callLoaderOrAction("loader", fetchRequest, match, matches, manifest, mapRouteProperties, basename);
+
+    // Deferred isn't supported for fetcher loads, await everything and treat it
     // as a normal load.  resolveDeferredData will return undefined if this
     // fetcher gets aborted, so we just leave result untouched and short circuit
     // below if that happens
-
     if (isDeferredResult(result)) {
       result = (await resolveDeferredData(result, fetchRequest.signal, true)) || result;
-    } // 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
-
+    }
 
+    // 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) {
       fetchControllers.delete(key);
     }
-
     if (fetchRequest.signal.aborted) {
       return;
-    } // If the loader threw a redirect Response, start a new REPLACE navigation
-
+    }
 
+    // If the loader threw a redirect Response, start a new REPLACE navigation
     if (isRedirectResult(result)) {
       fetchRedirectIds.add(key);
       await startRedirectNavigation(state, result);
       return;
-    } // Process any non-redirect errors thrown
-
+    }
 
+    // Process any non-redirect errors thrown
     if (isErrorResult(result)) {
       let boundaryMatch = findNearestBoundary(state.matches, routeId);
-      state.fetchers.delete(key); // TODO: In remix, this would reset to IDLE_NAVIGATION if it was a catch -
+      state.fetchers.delete(key);
+      // TODO: In remix, this would reset to IDLE_NAVIGATION if it was a catch -
       // do we need to behave any differently with our non-redirect errors?
       // What if it was a non-redirect Response?
-
       updateState({
         fetchers: new Map(state.fetchers),
         errors: {
@@ -2559,9 +2597,9 @@ function createRouter(init) {
       });
       return;
     }
+    invariant(!isDeferredResult(result), "Unhandled fetcher deferred data");
 
-    invariant(!isDeferredResult(result), "Unhandled fetcher deferred data"); // Put the fetcher back into an idle state
-
+    // Put the fetcher back into an idle state
     let doneFetcher = {
       state: "idle",
       data: result.data,
@@ -2576,6 +2614,7 @@ function createRouter(init) {
       fetchers: new Map(state.fetchers)
     });
   }
+
   /**
    * Utility function to handle redirects returned from an action or loader.
    * Normally, a redirect "replaces" the navigation that triggered it.  So, for
@@ -2595,57 +2634,49 @@ function createRouter(init) {
    * actually touch history until we've processed redirects, so we just use
    * the history action from the original navigation (PUSH or REPLACE).
    */
-
-
   async function startRedirectNavigation(state, redirect, _temp) {
-    var _window;
-
     let {
       submission,
       replace,
       isFetchActionRedirect
     } = _temp === void 0 ? {} : _temp;
-
     if (redirect.revalidate) {
       isRevalidationRequired = true;
     }
-
     let redirectLocation = createLocation(state.location, redirect.location, // TODO: This can be removed once we get rid of useTransition in Remix v2
     _extends({
       _isRedirect: true
     }, isFetchActionRedirect ? {
       _isFetchActionRedirect: true
     } : {}));
-    invariant(redirectLocation, "Expected a location on the redirect navigation"); // Check if this an absolute external redirect that goes to a new origin
-
-    if (ABSOLUTE_URL_REGEX.test(redirect.location) && isBrowser && typeof ((_window = window) == null ? void 0 : _window.location) !== "undefined") {
+    invariant(redirectLocation, "Expected a location on the redirect navigation");
+    // Check if this an absolute external redirect that goes to a new origin
+    if (ABSOLUTE_URL_REGEX.test(redirect.location) && isBrowser) {
       let url = init.history.createURL(redirect.location);
       let isDifferentBasename = stripBasename(url.pathname, basename) == null;
-
-      if (window.location.origin !== url.origin || isDifferentBasename) {
+      if (routerWindow.location.origin !== url.origin || isDifferentBasename) {
         if (replace) {
-          window.location.replace(redirect.location);
+          routerWindow.location.replace(redirect.location);
         } else {
-          window.location.assign(redirect.location);
+          routerWindow.location.assign(redirect.location);
         }
-
         return;
       }
-    } // There's no need to abort on redirects, since we don't detect the
-    // redirect until the action/loaders have settled
-
+    }
 
+    // There's no need to abort on redirects, since we don't detect the
+    // redirect until the action/loaders have settled
     pendingNavigationController = null;
-    let redirectHistoryAction = replace === true ? exports.Action.Replace : exports.Action.Push; // Use the incoming submission if provided, fallback on the active one in
-    // state.navigation
+    let redirectHistoryAction = replace === true ? exports.Action.Replace : exports.Action.Push;
 
+    // Use the incoming submission if provided, fallback on the active one in
+    // state.navigation
     let {
       formMethod,
       formAction,
       formEncType,
       formData
     } = state.navigation;
-
     if (!submission && formMethod && formAction && formData && formEncType) {
       submission = {
         formMethod,
@@ -2653,11 +2684,11 @@ function createRouter(init) {
         formEncType,
         formData
       };
-    } // If this was a 307/308 submission we want to preserve the HTTP method and
+    }
+
+    // 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
-
-
     if (redirectPreserveMethodStatusCodes.has(redirect.status) && submission && isMutationMethod(submission.formMethod)) {
       await startNavigation(redirectHistoryAction, redirectLocation, {
         submission: _extends({}, submission, {
@@ -2699,7 +2730,6 @@ function createRouter(init) {
       });
     }
   }
-
   async function callLoadersAndMaybeResolveData(currentMatches, matches, matchesToLoad, fetchersToLoad, request) {
     // Call all navigation loaders and revalidating fetcher loaders in parallel,
     // then slice off the results into separate arrays so we can handle them
@@ -2726,14 +2756,15 @@ function createRouter(init) {
       fetcherResults
     };
   }
-
   function interruptActiveLoads() {
     // Every interruption triggers a revalidation
-    isRevalidationRequired = true; // Cancel pending route-level deferreds and mark cancelled routes for
-    // revalidation
+    isRevalidationRequired = true;
 
-    cancelledDeferredRoutes.push(...cancelActiveDeferreds()); // Abort in-flight fetcher loads
+    // Cancel pending route-level deferreds and mark cancelled routes for
+    // revalidation
+    cancelledDeferredRoutes.push(...cancelActiveDeferreds());
 
+    // Abort in-flight fetcher loads
     fetchLoadMatches.forEach((_, key) => {
       if (fetchControllers.has(key)) {
         cancelledFetcherLoads.push(key);
@@ -2741,7 +2772,6 @@ function createRouter(init) {
       }
     });
   }
-
   function setFetcherError(key, routeId, error) {
     let boundaryMatch = findNearestBoundary(state.matches, routeId);
     deleteFetcher(key);
@@ -2752,22 +2782,25 @@ function createRouter(init) {
       fetchers: new Map(state.fetchers)
     });
   }
-
   function deleteFetcher(key) {
-    if (fetchControllers.has(key)) abortFetcher(key);
+    let fetcher = state.fetchers.get(key);
+    // Don't abort the controller if this is a deletion of a fetcher.submit()
+    // in it's loading phase since - we don't want to abort the corresponding
+    // revalidation and want them to complete and land
+    if (fetchControllers.has(key) && !(fetcher && fetcher.state === "loading" && fetchReloadIds.has(key))) {
+      abortFetcher(key);
+    }
     fetchLoadMatches.delete(key);
     fetchReloadIds.delete(key);
     fetchRedirectIds.delete(key);
     state.fetchers.delete(key);
   }
-
   function abortFetcher(key) {
     let controller = fetchControllers.get(key);
     invariant(controller, "Expected fetch controller: " + key);
     controller.abort();
     fetchControllers.delete(key);
   }
-
   function markFetchersDone(keys) {
     for (let key of keys) {
       let fetcher = getFetcher(key);
@@ -2783,34 +2816,27 @@ function createRouter(init) {
       state.fetchers.set(key, doneFetcher);
     }
   }
-
   function markFetchRedirectsDone() {
     let doneKeys = [];
     let updatedFetchers = false;
-
     for (let key of fetchRedirectIds) {
       let fetcher = state.fetchers.get(key);
       invariant(fetcher, "Expected fetcher: " + key);
-
       if (fetcher.state === "loading") {
         fetchRedirectIds.delete(key);
         doneKeys.push(key);
         updatedFetchers = true;
       }
     }
-
     markFetchersDone(doneKeys);
     return updatedFetchers;
   }
-
   function abortStaleFetchLoads(landedId) {
     let yeetedKeys = [];
-
     for (let [key, id] of fetchReloadIds) {
       if (id < landedId) {
         let fetcher = state.fetchers.get(key);
         invariant(fetcher, "Expected fetcher: " + key);
-
         if (fetcher.state === "loading") {
           abortFetcher(key);
           fetchReloadIds.delete(key);
@@ -2818,67 +2844,59 @@ function createRouter(init) {
         }
       }
     }
-
     markFetchersDone(yeetedKeys);
     return yeetedKeys.length > 0;
   }
-
   function getBlocker(key, fn) {
     let blocker = state.blockers.get(key) || IDLE_BLOCKER;
-
     if (blockerFunctions.get(key) !== fn) {
       blockerFunctions.set(key, fn);
     }
-
     return blocker;
   }
-
   function deleteBlocker(key) {
     state.blockers.delete(key);
     blockerFunctions.delete(key);
-  } // Utility function to update blockers, ensuring valid state transitions
-
+  }
 
+  // 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
+    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
     invariant(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", "Invalid blocker state transition: " + blocker.state + " -> " + newBlocker.state);
     state.blockers.set(key, newBlocker);
     updateState({
       blockers: new Map(state.blockers)
     });
   }
-
   function shouldBlockNavigation(_ref2) {
     let {
       currentLocation,
       nextLocation,
       historyAction
     } = _ref2;
-
     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
-
+    }
 
+    // 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) {
       warning(false, "A router only supports one blocker at a time");
     }
-
     let entries = Array.from(blockerFunctions.entries());
     let [blockerKey, blockerFunction] = entries[entries.length - 1];
     let blocker = state.blockers.get(blockerKey);
-
     if (blocker && blocker.state === "proceeding") {
       // If the blocker is currently proceeding, we don't need to re-check
       // 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
-
+    }
 
+    // At this point, we know we're unblocked/blocked so we need to check the
+    // user-provided blocker function
     if (blockerFunction({
       currentLocation,
       nextLocation,
@@ -2887,7 +2905,6 @@ function createRouter(init) {
       return blockerKey;
     }
   }
-
   function cancelActiveDeferreds(predicate) {
     let cancelledRouteIds = [];
     activeDeferreds.forEach((dfd, routeId) => {
@@ -2901,37 +2918,33 @@ function createRouter(init) {
       }
     });
     return cancelledRouteIds;
-  } // Opt in to capturing and reporting scroll positions during navigations,
-  // used by the <ScrollRestoration> component
-
+  }
 
+  // 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 || (location => location.key);
 
-    getScrollRestorationKey = getKey || (location => location.key); // Perform initial hydration scroll restoration, since we miss the boat on
+    // 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
-
-
     if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {
       initialScrollRestored = true;
       let y = getSavedScrollPosition(state.location, state.matches);
-
       if (y != null) {
         updateState({
           restoreScrollPosition: y
         });
       }
     }
-
     return () => {
       savedScrollPositions = null;
       getScrollPosition = null;
       getScrollRestorationKey = null;
     };
   }
-
   function saveScrollPosition(location, matches) {
     if (savedScrollPositions && getScrollRestorationKey && getScrollPosition) {
       let userMatches = matches.map(m => createUseMatchesMatch(m, state.loaderData));
@@ -2939,39 +2952,31 @@ function createRouter(init) {
       savedScrollPositions[key] = getScrollPosition();
     }
   }
-
   function getSavedScrollPosition(location, matches) {
     if (savedScrollPositions && getScrollRestorationKey && getScrollPosition) {
       let userMatches = matches.map(m => createUseMatchesMatch(m, state.loaderData));
       let key = getScrollRestorationKey(location, userMatches) || location.key;
       let y = savedScrollPositions[key];
-
       if (typeof y === "number") {
         return y;
       }
     }
-
     return null;
   }
-
   function _internalSetRoutes(newRoutes) {
     manifest = {};
     inFlightDataRoutes = convertRoutesToDataRoutes(newRoutes, mapRouteProperties, undefined, manifest);
   }
-
   router = {
     get basename() {
       return basename;
     },
-
     get state() {
       return state;
     },
-
     get routes() {
       return dataRoutes;
     },
-
     initialize,
     subscribe,
     enableScrollRestoration,
@@ -2994,7 +2999,9 @@ function createRouter(init) {
     _internalSetRoutes
   };
   return router;
-} //#endregion
+}
+//#endregion
+
 ////////////////////////////////////////////////////////////////////////////////
 //#region createStaticHandler
 ////////////////////////////////////////////////////////////////////////////////
@@ -3005,21 +3012,19 @@ function createStaticHandler(routes, opts) {
   let manifest = {};
   let basename = (opts ? opts.basename : null) || "/";
   let mapRouteProperties;
-
   if (opts != null && opts.mapRouteProperties) {
     mapRouteProperties = opts.mapRouteProperties;
   } else if (opts != null && opts.detectErrorBoundary) {
     // If they are still using the deprecated version, wrap it with the new API
     let detectErrorBoundary = opts.detectErrorBoundary;
-
     mapRouteProperties = route => ({
       hasErrorBoundary: detectErrorBoundary(route)
     });
   } else {
     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
@@ -3039,7 +3044,6 @@ function createStaticHandler(routes, opts) {
    * propagate that out and return the raw Response so the HTTP server can
    * return it directly.
    */
-
   async function query(request, _temp2) {
     let {
       requestContext
@@ -3047,8 +3051,9 @@ function createStaticHandler(routes, opts) {
     let url = new URL(request.url);
     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
+    let matches = matchRoutes(dataRoutes, location, basename);
 
+    // SSR supports HEAD requests while SPA doesn't
     if (!isValidMethod(method) && method !== "HEAD") {
       let error = getInternalRouterError(405, {
         method
@@ -3094,21 +3099,20 @@ function createStaticHandler(routes, opts) {
         activeDeferreds: null
       };
     }
-
     let result = await queryImpl(request, location, matches, requestContext);
-
     if (isResponse(result)) {
       return result;
-    } // When returning StaticHandlerContext, we patch back in the location here
+    }
+
+    // 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
-
-
     return _extends({
       location,
       basename
     }, result);
   }
+
   /**
    * The queryRoute() method is intended for targeted route requests, either
    * for fetch ?_data requests or resource route requests.  In this case, we
@@ -3129,8 +3133,6 @@ function createStaticHandler(routes, opts) {
    * code.  Examples here are 404 and 405 errors that occur prior to reaching
    * any user-defined loaders.
    */
-
-
   async function queryRoute(request, _temp3) {
     let {
       routeId,
@@ -3139,8 +3141,9 @@ function createStaticHandler(routes, opts) {
     let url = new URL(request.url);
     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
+    let matches = matchRoutes(dataRoutes, location, basename);
 
+    // SSR supports HEAD requests while SPA doesn't
     if (!isValidMethod(method) && method !== "HEAD" && method !== "OPTIONS") {
       throw getInternalRouterError(405, {
         method
@@ -3150,9 +3153,7 @@ function createStaticHandler(routes, opts) {
         pathname: location.pathname
       });
     }
-
     let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);
-
     if (routeId && !match) {
       throw getInternalRouterError(403, {
         pathname: location.pathname,
@@ -3164,52 +3165,40 @@ function createStaticHandler(routes, opts) {
         pathname: location.pathname
       });
     }
-
     let result = await queryImpl(request, location, matches, requestContext, match);
-
     if (isResponse(result)) {
       return result;
     }
-
     let error = result.errors ? Object.values(result.errors)[0] : undefined;
-
     if (error !== undefined) {
       // If we got back result.errors, that means the loader/action threw
       // _something_ that wasn't a Response, but it's not guaranteed/required
       // to be an `instanceof Error` either, so we have to use throw here to
       // preserve the "error" state outside of queryImpl.
       throw error;
-    } // Pick off the right state value to return
-
+    }
 
+    // Pick off the right state value to return
     if (result.actionData) {
       return Object.values(result.actionData)[0];
     }
-
     if (result.loaderData) {
       var _result$activeDeferre;
-
       let data = Object.values(result.loaderData)[0];
-
       if ((_result$activeDeferre = result.activeDeferreds) != null && _result$activeDeferre[match.route.id]) {
         data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];
       }
-
       return data;
     }
-
     return undefined;
   }
-
   async function queryImpl(request, location, matches, requestContext, routeMatch) {
     invariant(request.signal, "query()/queryRoute() requests must contain an AbortController signal");
-
     try {
       if (isMutationMethod(request.method.toLowerCase())) {
         let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, routeMatch != null);
         return result;
       }
-
       let result = await loadRouteData(request, matches, requestContext, routeMatch);
       return isResponse(result) ? result : _extends({}, result, {
         actionData: null,
@@ -3223,47 +3212,38 @@ function createStaticHandler(routes, opts) {
         if (e.type === ResultType.error && !isRedirectResponse(e.response)) {
           throw e.response;
         }
-
         return e.response;
-      } // Redirects are always returned since they don't propagate to catch
+      }
+      // Redirects are always returned since they don't propagate to catch
       // boundaries
-
-
       if (isRedirectResponse(e)) {
         return e;
       }
-
       throw e;
     }
   }
-
   async function submit(request, matches, actionMatch, requestContext, isRouteRequest) {
     let result;
-
     if (!actionMatch.route.action && !actionMatch.route.lazy) {
       let error = getInternalRouterError(405, {
         method: request.method,
         pathname: new URL(request.url).pathname,
         routeId: actionMatch.route.id
       });
-
       if (isRouteRequest) {
         throw error;
       }
-
       result = {
         type: ResultType.error,
         error
       };
     } else {
       result = await callLoaderOrAction("action", request, actionMatch, matches, manifest, mapRouteProperties, basename, true, isRouteRequest, requestContext);
-
       if (request.signal.aborted) {
         let method = isRouteRequest ? "queryRoute" : "query";
         throw new Error(method + "() call aborted");
       }
     }
-
     if (isRedirectResult(result)) {
       // Uhhhh - this should never happen, we should always throw these from
       // callLoaderOrAction, but the type narrowing here keeps TS happy and we
@@ -3276,29 +3256,24 @@ function createStaticHandler(routes, opts) {
         }
       });
     }
-
     if (isDeferredResult(result)) {
       let error = getInternalRouterError(400, {
         type: "defer-action"
       });
-
       if (isRouteRequest) {
         throw error;
       }
-
       result = {
         type: ResultType.error,
         error
       };
     }
-
     if (isRouteRequest) {
       // Note: This should only be non-Response values if we get here, since
       // isRouteRequest should throw any Response received in callLoaderOrAction
       if (isErrorResult(result)) {
         throw result.error;
       }
-
       return {
         matches: [actionMatch],
         loaderData: {},
@@ -3314,15 +3289,15 @@ function createStaticHandler(routes, opts) {
         activeDeferreds: null
       };
     }
-
     if (isErrorResult(result)) {
       // 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);
       let context = await loadRouteData(request, matches, requestContext, undefined, {
         [boundaryMatch.route.id]: result.error
-      }); // action status codes take precedence over loader status codes
+      });
 
+      // action status codes take precedence over loader status codes
       return _extends({}, context, {
         statusCode: isRouteErrorResponse(result.error) ? result.error.status : 500,
         actionData: null,
@@ -3330,9 +3305,9 @@ function createStaticHandler(routes, opts) {
           [actionMatch.route.id]: result.headers
         } : {})
       });
-    } // Create a GET request for the loaders
-
+    }
 
+    // Create a GET request for the loaders
     let loaderRequest = new Request(request.url, {
       headers: request.headers,
       redirect: request.redirect,
@@ -3350,10 +3325,10 @@ function createStaticHandler(routes, opts) {
       } : {})
     });
   }
-
   async function loadRouteData(request, matches, requestContext, routeMatch, pendingActionError) {
-    let isRouteRequest = routeMatch != null; // Short circuit if we have no loaders to run (queryRoute())
+    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, {
         method: request.method,
@@ -3361,10 +3336,10 @@ function createStaticHandler(routes, opts) {
         routeId: routeMatch == null ? void 0 : routeMatch.route.id
       });
     }
-
     let requestMatches = routeMatch ? [routeMatch] : getLoaderMatchesUntilBoundary(matches, Object.keys(pendingActionError || {})[0]);
-    let matchesToLoad = requestMatches.filter(m => m.route.loader || m.route.lazy); // Short circuit if we have no loaders to run (query())
+    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 {
         matches,
@@ -3378,18 +3353,17 @@ function createStaticHandler(routes, opts) {
         activeDeferreds: null
       };
     }
-
     let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction("loader", request, match, matches, manifest, mapRouteProperties, basename, true, isRouteRequest, requestContext))]);
-
     if (request.signal.aborted) {
       let method = isRouteRequest ? "queryRoute" : "query";
       throw new Error(method + "() call aborted");
-    } // Process and commit output from loaders
-
+    }
 
+    // Process and commit output from loaders
     let activeDeferreds = new Map();
-    let context = processRouteLoaderData(matches, matchesToLoad, results, pendingActionError, activeDeferreds); // Add a null for any non-loader matches for proper revalidation on the client
+    let context = processRouteLoaderData(matches, matchesToLoad, results, pendingActionError, activeDeferreds);
 
+    // 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 => {
       if (!executedLoaders.has(match.route.id)) {
@@ -3401,13 +3375,15 @@ function createStaticHandler(routes, opts) {
       activeDeferreds: activeDeferreds.size > 0 ? Object.fromEntries(activeDeferreds.entries()) : null
     });
   }
-
   return {
     dataRoutes,
     query,
     queryRoute
   };
-} //#endregion
+}
+
+//#endregion
+
 ////////////////////////////////////////////////////////////////////////////////
 //#region Helpers
 ////////////////////////////////////////////////////////////////////////////////
@@ -3416,7 +3392,6 @@ function createStaticHandler(routes, opts) {
  * Given an existing StaticHandlerContext and an error thrown at render time,
  * provide an updated StaticHandlerContext suitable for a second SSR render
  */
-
 function getStaticContextFromError(routes, context, error) {
   let newContext = _extends({}, context, {
     statusCode: 500,
@@ -3424,28 +3399,22 @@ function getStaticContextFromError(routes, context, error) {
       [context._deepestRenderedBoundaryId || routes[0].id]: error
     }
   });
-
   return newContext;
 }
-
 function isSubmissionNavigation(opts) {
   return opts != null && "formData" in opts;
 }
-
 function normalizeTo(location, matches, basename, prependBasename, to, fromRouteId, relative) {
   let contextualMatches;
   let activeRouteMatch;
-
   if (fromRouteId != null && relative !== "path") {
     // Grab matches up to the calling route so our route-relative logic is
     // relative to the correct source route.  When using relative:path,
     // fromRouteId is ignored since that is always relative to the current
     // location path
     contextualMatches = [];
-
     for (let match of matches) {
       contextualMatches.push(match);
-
       if (match.route.id === fromRouteId) {
         activeRouteMatch = match;
         break;
@@ -3454,36 +3423,36 @@ function normalizeTo(location, matches, basename, prependBasename, to, fromRoute
   } else {
     contextualMatches = matches;
     activeRouteMatch = matches[matches.length - 1];
-  } // Resolve the relative path
+  }
 
+  // Resolve the relative path
+  let path = resolveTo(to ? to : ".", getPathContributingMatches(contextualMatches).map(m => m.pathnameBase), stripBasename(location.pathname, basename) || location.pathname, relative === "path");
 
-  let path = resolveTo(to ? to : ".", getPathContributingMatches(contextualMatches).map(m => m.pathnameBase), stripBasename(location.pathname, basename) || location.pathname, relative === "path"); // When `to` is not specified we inherit search/hash from the current
+  // 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
-
   if (to == null) {
     path.search = location.search;
     path.hash = location.hash;
-  } // Add an ?index param for matched index routes if we don't already have one
-
+  }
 
+  // Add an ?index param for matched index routes if we don't already have one
   if ((to == null || to === "" || to === ".") && activeRouteMatch && activeRouteMatch.route.index && !hasNakedIndexQuery(path.search)) {
     path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
-  } // If we're operating within a basename, prepend it to the pathname.  If
+  }
+
+  // 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
   // on root actions
-
-
   if (prependBasename && basename !== "/") {
     path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
   }
-
   return createPath(path);
-} // Normalize navigation options by converting formMethod=GET formData objects to
-// URLSearchParams so they behave identically to links with query params
-
+}
 
+// Normalize navigation options by converting formMethod=GET formData objects to
+// URLSearchParams so they behave identically to links with query params
 function normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {
   // Return location verbatim on non-submission navigations
   if (!opts || !isSubmissionNavigation(opts)) {
@@ -3491,7 +3460,6 @@ function normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {
       path
     };
   }
-
   if (opts.formMethod && !isValidMethod(opts.formMethod)) {
     return {
       path,
@@ -3499,11 +3467,10 @@ function normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {
         method: opts.formMethod
       })
     };
-  } // Create a Submission on non-GET navigations
-
+  }
 
+  // Create a Submission on non-GET navigations
   let submission;
-
   if (opts.formData) {
     let formMethod = opts.formMethod || "get";
     submission = {
@@ -3512,53 +3479,48 @@ function normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {
       formEncType: opts && opts.formEncType || "application/x-www-form-urlencoded",
       formData: opts.formData
     };
-
     if (isMutationMethod(submission.formMethod)) {
       return {
         path,
         submission
       };
     }
-  } // Flatten submission onto URLSearchParams for GET submissions
-
+  }
 
+  // Flatten submission onto URLSearchParams for GET submissions
   let parsedPath = parsePath(path);
-  let searchParams = convertFormDataToSearchParams(opts.formData); // On GET navigation submissions we can drop the ?index param from the
+  let searchParams = convertFormDataToSearchParams(opts.formData);
+  // On GET navigation submissions we can drop the ?index param from the
   // resulting location since all loaders will run.  But fetcher GET submissions
   // only run a single loader so we need to preserve any incoming ?index params
-
   if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {
     searchParams.append("index", "");
   }
-
   parsedPath.search = "?" + searchParams;
   return {
     path: createPath(parsedPath),
     submission
   };
-} // Filter out all routes below any caught error as they aren't going to
-// render so we don't need to load them
-
+}
 
+// Filter out all routes below any caught error as they aren't going to
+// render so we don't need to load them
 function getLoaderMatchesUntilBoundary(matches, boundaryId) {
   let boundaryMatches = matches;
-
   if (boundaryId) {
     let index = matches.findIndex(m => m.route.id === boundaryId);
-
     if (index >= 0) {
       boundaryMatches = matches.slice(0, index);
     }
   }
-
   return boundaryMatches;
 }
-
 function getMatchesToLoad(history, state, matches, submission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, fetchLoadMatches, routesToUse, basename, pendingActionData, pendingError) {
   let actionResult = pendingError ? Object.values(pendingError)[0] : pendingActionData ? Object.values(pendingActionData)[0] : undefined;
   let currentUrl = history.createURL(state.location);
-  let nextUrl = history.createURL(location); // Pick navigation matches that are net-new or qualify for revalidation
+  let nextUrl = history.createURL(location);
 
+  // Pick navigation matches that are net-new or qualify for revalidation
   let boundaryId = pendingError ? Object.keys(pendingError)[0] : undefined;
   let boundaryMatches = getLoaderMatchesUntilBoundary(matches, boundaryId);
   let navigationMatches = boundaryMatches.filter((match, index) => {
@@ -3566,20 +3528,19 @@ function getMatchesToLoad(history, state, matches, submission, location, isReval
       // We haven't loaded this route yet so we don't know if it's got a loader!
       return true;
     }
-
     if (match.route.loader == null) {
       return false;
-    } // Always call the loader on new route instances and pending defer cancellations
-
+    }
 
+    // Always call the loader on new route instances and pending defer cancellations
     if (isNewLoader(state.loaderData, state.matches[index], match) || cancelledDeferredRoutes.some(id => id === match.route.id)) {
       return true;
-    } // This is the default implementation for when we revalidate.  If the route
+    }
+
+    // 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
     // their own specific use cases
-
-
     let currentRouteMatch = state.matches[index];
     let nextRouteMatch = match;
     return shouldRevalidateLoader(match, _extends({
@@ -3589,23 +3550,27 @@ function getMatchesToLoad(history, state, matches, submission, location, isReval
       nextParams: nextRouteMatch.params
     }, submission, {
       actionResult,
-      defaultShouldRevalidate: // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
-      isRevalidationRequired || // Clicked the same link, resubmitted a GET form
-      currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search || // Search params affect all loaders
+      defaultShouldRevalidate:
+      // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
+      isRevalidationRequired ||
+      // Clicked the same link, resubmitted a GET form
+      currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search ||
+      // Search params affect all loaders
       currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)
     }));
-  }); // Pick fetcher.loads that need to be revalidated
+  });
 
+  // Pick fetcher.loads that need to be revalidated
   let revalidatingFetchers = [];
   fetchLoadMatches.forEach((f, key) => {
     // Don't revalidate if fetcher won't be present in the subsequent render
     if (!matches.some(m => m.route.id === f.routeId)) {
       return;
     }
+    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);
 
-    let fetcherMatches = matchRoutes(routesToUse, f.path, basename); // If the fetcher path no longer matches, push it in with null matches so
+    // If the fetcher path no longer matches, push it in with null matches so
     // we can trigger a 404 in callLoadersAndMaybeResolveData
-
     if (!fetcherMatches) {
       revalidatingFetchers.push({
         key,
@@ -3617,9 +3582,7 @@ function getMatchesToLoad(history, state, matches, submission, location, isReval
       });
       return;
     }
-
     let fetcherMatch = getTargetMatch(fetcherMatches, f.path);
-
     if (cancelledFetcherLoads.includes(key)) {
       revalidatingFetchers.push({
         key,
@@ -3630,12 +3593,12 @@ function getMatchesToLoad(history, state, matches, submission, location, isReval
         controller: new AbortController()
       });
       return;
-    } // Revalidating fetchers are decoupled from the route matches since they
+    }
+
+    // Revalidating fetchers are decoupled from the route matches since they
     // hit a static href, so they _always_ check shouldRevalidate and the
     // default is strictly if a revalidation is explicitly required (action
     // submissions, useRevalidator, X-Remix-Revalidate).
-
-
     let shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({
       currentUrl,
       currentParams: state.matches[state.matches.length - 1].params,
@@ -3646,7 +3609,6 @@ function getMatchesToLoad(history, state, matches, submission, location, isReval
       // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
       defaultShouldRevalidate: isRevalidationRequired
     }));
-
     if (shouldRevalidate) {
       revalidatingFetchers.push({
         key,
@@ -3660,60 +3622,61 @@ function getMatchesToLoad(history, state, matches, submission, location, isReval
   });
   return [navigationMatches, revalidatingFetchers];
 }
-
 function isNewLoader(currentLoaderData, currentMatch, match) {
-  let isNew = // [a] -> [a, b]
-  !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 or from a cancelled pending deferred
+  let isNew =
+  // [a] -> [a, b]
+  !currentMatch ||
+  // [a, b] -> [a, c]
+  match.route.id !== currentMatch.route.id;
 
-  let isMissingData = currentLoaderData[match.route.id] === undefined; // Always load if this is a net-new route or we don't yet have data
+  // Handle the case that we don't have data for a re-used route, potentially
+  // from a prior error or from a cancelled pending deferred
+  let isMissingData = currentLoaderData[match.route.id] === undefined;
 
+  // Always load if this is a net-new route or we don't yet have data
   return isNew || isMissingData;
 }
-
 function isNewRouteInstance(currentMatch, match) {
   let currentPath = currentMatch.route.path;
-  return (// param change for this match, /users/123 -> /users/456
-    currentMatch.pathname !== match.pathname || // splat param changed, which is not present in match.path
+  return (
+    // param change for this match, /users/123 -> /users/456
+    currentMatch.pathname !== match.pathname ||
+    // splat param changed, which is not present in match.path
     // e.g. /files/images/avatar.jpg -> files/finances.xls
     currentPath != null && currentPath.endsWith("*") && currentMatch.params["*"] !== match.params["*"]
   );
 }
-
 function shouldRevalidateLoader(loaderMatch, arg) {
   if (loaderMatch.route.shouldRevalidate) {
     let routeChoice = loaderMatch.route.shouldRevalidate(arg);
-
     if (typeof routeChoice === "boolean") {
       return routeChoice;
     }
   }
-
   return arg.defaultShouldRevalidate;
 }
+
 /**
  * Execute route.lazy() methods to lazily load route modules (loader, action,
  * shouldRevalidate) and update the routeManifest in place which shares objects
  * with dataRoutes so those get updated as well.
  */
-
-
 async function loadLazyRouteModule(route, mapRouteProperties, manifest) {
   if (!route.lazy) {
     return;
   }
+  let lazyRoute = await route.lazy();
 
-  let lazyRoute = await route.lazy(); // If the lazy route function was executed and removed by another parallel
+  // 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
-
   if (!route.lazy) {
     return;
   }
-
   let routeToUpdate = manifest[route.id];
-  invariant(routeToUpdate, "No route found in manifest"); // Update the route in place.  This should be safe because there's no way
+  invariant(routeToUpdate, "No route found in manifest");
+
+  // 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.
   //
@@ -3721,52 +3684,45 @@ async function loadLazyRouteModule(route, mapRouteProperties, manifest) {
   // on the route being updated.  The main concern boils down to "does this
   // mutation affect any ongoing navigations or any current state.matches
   // values?".  If not, it should be safe to update in place.
-
   let routeUpdates = {};
-
   for (let lazyRouteProperty in lazyRoute) {
     let staticRouteValue = routeToUpdate[lazyRouteProperty];
-    let isPropertyStaticallyDefined = staticRouteValue !== undefined && // This property isn't static since it should always be updated based
+    let isPropertyStaticallyDefined = staticRouteValue !== undefined &&
+    // This property isn't static since it should always be updated based
     // on the route updates
     lazyRouteProperty !== "hasErrorBoundary";
     warning(!isPropertyStaticallyDefined, "Route \"" + routeToUpdate.id + "\" has a static property \"" + lazyRouteProperty + "\" " + "defined but its lazy function is also returning a value for this property. " + ("The lazy route property \"" + lazyRouteProperty + "\" will be ignored."));
-
     if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {
       routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];
     }
-  } // Mutate the route with the provided updates.  Do this first so we pass
-  // the updated version to mapRouteProperties
+  }
 
+  // Mutate the route with the provided updates.  Do this first so we pass
+  // the updated version to mapRouteProperties
+  Object.assign(routeToUpdate, routeUpdates);
 
-  Object.assign(routeToUpdate, routeUpdates); // Mutate the `hasErrorBoundary` property on the route based on the route
+  // 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.
-
   Object.assign(routeToUpdate, _extends({}, mapRouteProperties(routeToUpdate), {
     lazy: undefined
   }));
 }
-
 async function callLoaderOrAction(type, request, match, matches, manifest, mapRouteProperties, basename, isStaticRequest, isRouteRequest, requestContext) {
   if (isStaticRequest === void 0) {
     isStaticRequest = false;
   }
-
   if (isRouteRequest === void 0) {
     isRouteRequest = false;
   }
-
   let resultType;
   let result;
   let onReject;
-
   let runHandler = handler => {
     // Setup a promise we can race against so that abort signals short circuit
     let reject;
     let abortPromise = new Promise((_, r) => reject = r);
-
     onReject = () => reject();
-
     request.signal.addEventListener("abort", onReject);
     return Promise.race([handler({
       request,
@@ -3774,10 +3730,8 @@ async function callLoaderOrAction(type, request, match, matches, manifest, mapRo
       context: requestContext
     }), abortPromise]);
   };
-
   try {
     let handler = match.route[type];
-
     if (match.route.lazy) {
       if (handler) {
         // Run statically defined handler in parallel with lazy()
@@ -3787,7 +3741,6 @@ async function callLoaderOrAction(type, request, match, matches, manifest, mapRo
         // Load lazy route module, then run any returned handler
         await loadLazyRouteModule(match.route, mapRouteProperties, manifest);
         handler = match.route[type];
-
         if (handler) {
           // Handler still run even if we got interrupted to maintain consistency
           // with un-abortable behavior of handler execution on non-lazy or
@@ -3819,7 +3772,6 @@ async function callLoaderOrAction(type, request, match, matches, manifest, mapRo
     } else {
       result = await runHandler(handler);
     }
-
     invariant(result !== undefined, "You defined " + (type === "action" ? "an action" : "a loader") + " for route " + ("\"" + match.route.id + "\" but didn't return anything from your `" + type + "` ") + "function. Please return a value or `null`.");
   } catch (e) {
     resultType = ResultType.error;
@@ -3829,14 +3781,15 @@ async function callLoaderOrAction(type, request, match, matches, manifest, mapRo
       request.signal.removeEventListener("abort", onReject);
     }
   }
-
   if (isResponse(result)) {
-    let status = result.status; // Process redirects
+    let status = result.status;
 
+    // Process redirects
     if (redirectStatusCodes.has(status)) {
       let location = result.headers.get("Location");
-      invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header"); // Support relative routing in internal redirects
+      invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header");
 
+      // Support relative routing in internal redirects
       if (!ABSOLUTE_URL_REGEX.test(location)) {
         location = normalizeTo(new URL(request.url), matches.slice(0, matches.indexOf(match) + 1), basename, true, location);
       } else if (!isStaticRequest) {
@@ -3846,32 +3799,30 @@ async function callLoaderOrAction(type, request, match, matches, manifest, mapRo
         let currentUrl = new URL(request.url);
         let url = location.startsWith("//") ? new URL(currentUrl.protocol + location) : new URL(location);
         let isSameBasename = stripBasename(url.pathname, basename) != null;
-
         if (url.origin === currentUrl.origin && isSameBasename) {
           location = url.pathname + url.search + url.hash;
         }
-      } // Don't process redirects in the router during static requests requests.
+      }
+
+      // Don't process redirects in the router during static requests requests.
       // Instead, throw the Response and let the server handle it with an HTTP
       // redirect.  We also update the Location header in place in this flow so
       // basename and relative routing is taken into account
-
-
       if (isStaticRequest) {
         result.headers.set("Location", location);
         throw result;
       }
-
       return {
         type: ResultType.redirect,
         status,
         location,
         revalidate: result.headers.get("X-Remix-Revalidate") !== null
       };
-    } // For SSR single-route requests, we want to hand Responses back directly
+    }
+
+    // For SSR single-route requests, we want to hand Responses back directly
     // without unwrapping.  We do this with the QueryRouteResponse wrapper
     // interface so we can know whether it was returned or thrown
-
-
     if (isRouteRequest) {
       // eslint-disable-next-line no-throw-literal
       throw {
@@ -3879,17 +3830,15 @@ async function callLoaderOrAction(type, request, match, matches, manifest, mapRo
         response: result
       };
     }
-
     let data;
-    let contentType = result.headers.get("Content-Type"); // Check between word boundaries instead of startsWith() due to the last
+    let contentType = result.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)) {
       data = await result.json();
     } else {
       data = await result.text();
     }
-
     if (resultType === ResultType.error) {
       return {
         type: resultType,
@@ -3897,7 +3846,6 @@ async function callLoaderOrAction(type, request, match, matches, manifest, mapRo
         headers: result.headers
       };
     }
-
     return {
       type: ResultType.data,
       data,
@@ -3905,17 +3853,14 @@ async function callLoaderOrAction(type, request, match, matches, manifest, mapRo
       headers: result.headers
     };
   }
-
   if (resultType === ResultType.error) {
     return {
       type: resultType,
       error: result
     };
   }
-
   if (isDeferredData(result)) {
     var _result$init, _result$init2;
-
     return {
       type: ResultType.deferred,
       deferredData: result,
@@ -3923,90 +3868,84 @@ async function callLoaderOrAction(type, request, match, matches, manifest, mapRo
       headers: ((_result$init2 = result.init) == null ? void 0 : _result$init2.headers) && new Headers(result.init.headers)
     };
   }
-
   return {
     type: ResultType.data,
     data: result
   };
-} // Utility method for creating the Request instances for loaders/actions during
+}
+
+// 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)
-
-
 function createClientSideRequest(history, location, signal, submission) {
   let url = history.createURL(stripHashFromPath(location)).toString();
   let init = {
     signal
   };
-
   if (submission && isMutationMethod(submission.formMethod)) {
     let {
       formMethod,
       formEncType,
       formData
-    } = submission; // Didn't think we needed this but it turns out unlike other methods, patch
+    } = submission;
+    // Didn't think we needed this but it turns out unlike other methods, patch
     // won't be properly normalized to uppercase and results in a 405 error.
     // See: https://fetch.spec.whatwg.org/#concept-method
-
     init.method = formMethod.toUpperCase();
     init.body = formEncType === "application/x-www-form-urlencoded" ? convertFormDataToSearchParams(formData) : formData;
-  } // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
-
+  }
 
+  // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
   return new Request(url, init);
 }
-
 function convertFormDataToSearchParams(formData) {
   let searchParams = new URLSearchParams();
-
   for (let [key, value] of formData.entries()) {
     // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs
     searchParams.append(key, value instanceof File ? value.name : value);
   }
-
   return searchParams;
 }
-
 function processRouteLoaderData(matches, matchesToLoad, results, pendingError, activeDeferreds) {
   // Fill in loaderData/errors from our loaders
   let loaderData = {};
   let errors = null;
   let statusCode;
   let foundError = false;
-  let loaderHeaders = {}; // Process loader results into state.loaderData/state.errors
+  let loaderHeaders = {};
 
+  // Process loader results into state.loaderData/state.errors
   results.forEach((result, index) => {
     let id = matchesToLoad[index].route.id;
     invariant(!isRedirectResult(result), "Cannot handle redirect results in processLoaderData");
-
     if (isErrorResult(result)) {
       // Look upwards from the matched route for the closest ancestor
       // error boundary, defaulting to the root match
       let boundaryMatch = findNearestBoundary(matches, id);
-      let error = result.error; // If we have a pending action error, we report it at the highest-route
+      let error = result.error;
+      // If we have a pending action error, we report it at the highest-route
       // that throws a loader error, and then clear it out to indicate that
       // it was consumed
-
       if (pendingError) {
         error = Object.values(pendingError)[0];
         pendingError = undefined;
       }
+      errors = errors || {};
 
-      errors = errors || {}; // Prefer higher error values if lower errors bubble to the same boundary
-
+      // Prefer higher error values if lower errors bubble to the same boundary
       if (errors[boundaryMatch.route.id] == null) {
         errors[boundaryMatch.route.id] = error;
-      } // Clear our any prior loaderData for the throwing route
+      }
 
+      // Clear our any prior loaderData for the throwing route
+      loaderData[id] = undefined;
 
-      loaderData[id] = undefined; // Once we find our first (highest) error, we set the status code and
+      // Once we find our first (highest) error, we set the status code and
       // prevent deeper status codes from overriding
-
       if (!foundError) {
         foundError = true;
         statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;
       }
-
       if (result.headers) {
         loaderHeaders[id] = result.headers;
       }
@@ -4016,27 +3955,26 @@ function processRouteLoaderData(matches, matchesToLoad, results, pendingError, a
         loaderData[id] = result.deferredData.data;
       } else {
         loaderData[id] = result.data;
-      } // Error status codes always override success status codes, but if all
-      // loaders are successful we take the deepest status code.
-
+      }
 
+      // Error status codes always override success status codes, but if all
+      // loaders are successful we take the deepest status code.
       if (result.statusCode != null && result.statusCode !== 200 && !foundError) {
         statusCode = result.statusCode;
       }
-
       if (result.headers) {
         loaderHeaders[id] = result.headers;
       }
     }
-  }); // If we didn't consume the pending action error (i.e., all loaders
+  });
+
+  // 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
-
   if (pendingError) {
     errors = pendingError;
     loaderData[Object.keys(pendingError)[0]] = undefined;
   }
-
   return {
     loaderData,
     errors,
@@ -4044,13 +3982,13 @@ function processRouteLoaderData(matches, matchesToLoad, results, pendingError, a
     loaderHeaders
   };
 }
-
 function processLoaderData(state, matches, matchesToLoad, results, pendingError, revalidatingFetchers, fetcherResults, activeDeferreds) {
   let {
     loaderData,
     errors
-  } = processRouteLoaderData(matches, matchesToLoad, results, pendingError, activeDeferreds); // Process results from our revalidating fetchers
+  } = processRouteLoaderData(matches, matchesToLoad, results, pendingError, activeDeferreds);
 
+  // Process results from our revalidating fetchers
   for (let index = 0; index < revalidatingFetchers.length; index++) {
     let {
       key,
@@ -4058,20 +3996,19 @@ function processLoaderData(state, matches, matchesToLoad, results, pendingError,
       controller
     } = revalidatingFetchers[index];
     invariant(fetcherResults !== undefined && fetcherResults[index] !== undefined, "Did not find corresponding fetcher result");
-    let result = fetcherResults[index]; // Process fetcher non-redirect errors
+    let result = fetcherResults[index];
 
+    // Process fetcher non-redirect errors
     if (controller && controller.signal.aborted) {
       // Nothing to do for aborted fetchers
       continue;
     } else if (isErrorResult(result)) {
       let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);
-
       if (!(errors && errors[boundaryMatch.route.id])) {
         errors = _extends({}, errors, {
           [boundaryMatch.route.id]: result.error
         });
       }
-
       state.fetchers.delete(key);
     } else if (isRedirectResult(result)) {
       // Should never get here, redirects should get processed above, but we
@@ -4094,19 +4031,15 @@ function processLoaderData(state, matches, matchesToLoad, results, pendingError,
       state.fetchers.set(key, doneFetcher);
     }
   }
-
   return {
     loaderData,
     errors
   };
 }
-
 function mergeLoaderData(loaderData, newLoaderData, matches, errors) {
   let mergedLoaderData = _extends({}, newLoaderData);
-
   for (let match of matches) {
     let id = match.route.id;
-
     if (newLoaderData.hasOwnProperty(id)) {
       if (newLoaderData[id] !== undefined) {
         mergedLoaderData[id] = newLoaderData[id];
@@ -4116,24 +4049,21 @@ function mergeLoaderData(loaderData, newLoaderData, matches, errors) {
       // wasn't removed by HMR
       mergedLoaderData[id] = loaderData[id];
     }
-
     if (errors && errors.hasOwnProperty(id)) {
       // Don't keep any loader data below the boundary
       break;
     }
   }
-
   return mergedLoaderData;
-} // Find the nearest error boundary, looking upwards from the leaf route (or the
+}
+
+// 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
-
-
 function findNearestBoundary(matches, routeId) {
   let eligibleMatches = routeId ? matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1) : [...matches];
   return eligibleMatches.reverse().find(m => m.route.hasErrorBoundary === true) || matches[0];
 }
-
 function getShortCircuitMatches(routes) {
   // Prefer a root layout route if present, otherwise shim in a route object
   let route = routes.find(r => r.index || !r.path || r.path === "/") || {
@@ -4149,7 +4079,6 @@ function getShortCircuitMatches(routes) {
     route
   };
 }
-
 function getInternalRouterError(status, _temp4) {
   let {
     pathname,
@@ -4159,10 +4088,8 @@ function getInternalRouterError(status, _temp4) {
   } = _temp4 === void 0 ? {} : _temp4;
   let statusText = "Unknown Server Error";
   let errorMessage = "Unknown @remix-run/router error";
-
   if (status === 400) {
     statusText = "Bad Request";
-
     if (method && pathname && routeId) {
       errorMessage = "You made a " + method + " request to \"" + pathname + "\" but " + ("did not provide a `loader` for route \"" + routeId + "\", ") + "so there is no way to handle the request.";
     } else if (type === "defer-action") {
@@ -4176,40 +4103,34 @@ function getInternalRouterError(status, _temp4) {
     errorMessage = "No route matches URL \"" + pathname + "\"";
   } else if (status === 405) {
     statusText = "Method Not Allowed";
-
     if (method && pathname && routeId) {
       errorMessage = "You made a " + method.toUpperCase() + " request to \"" + pathname + "\" but " + ("did not provide an `action` for route \"" + routeId + "\", ") + "so there is no way to handle the request.";
     } else if (method) {
       errorMessage = "Invalid request method \"" + method.toUpperCase() + "\"";
     }
   }
-
   return new ErrorResponse(status || 500, statusText, new Error(errorMessage), true);
-} // Find any returned redirect errors, starting from the lowest match
-
+}
 
+// Find any returned redirect errors, starting from the lowest match
 function findRedirect(results) {
   for (let i = results.length - 1; i >= 0; i--) {
     let result = results[i];
-
     if (isRedirectResult(result)) {
       return result;
     }
   }
 }
-
 function stripHashFromPath(path) {
   let parsedPath = typeof path === "string" ? parsePath(path) : path;
   return createPath(_extends({}, parsedPath, {
     hash: ""
   }));
 }
-
 function isHashChangeOnly(a, b) {
   if (a.pathname !== b.pathname || a.search !== b.search) {
     return false;
   }
-
   if (a.hash === "") {
     // /page -> /page#hash
     return b.hash !== "";
@@ -4219,70 +4140,57 @@ function isHashChangeOnly(a, b) {
   } else if (b.hash !== "") {
     // /page#hash -> /page#other
     return true;
-  } // If the hash is removed the browser will re-perform a request to the server
-  // /page#hash -> /page
-
+  }
 
+  // If the hash is removed the browser will re-perform a request to the server
+  // /page#hash -> /page
   return false;
 }
-
 function isDeferredResult(result) {
   return result.type === ResultType.deferred;
 }
-
 function isErrorResult(result) {
   return result.type === ResultType.error;
 }
-
 function isRedirectResult(result) {
   return (result && result.type) === ResultType.redirect;
 }
-
 function isDeferredData(value) {
   let deferred = value;
   return deferred && typeof deferred === "object" && typeof deferred.data === "object" && typeof deferred.subscribe === "function" && typeof deferred.cancel === "function" && typeof deferred.resolveData === "function";
 }
-
 function isResponse(value) {
   return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
 }
-
 function isRedirectResponse(result) {
   if (!isResponse(result)) {
     return false;
   }
-
   let status = result.status;
   let location = result.headers.get("Location");
   return status >= 300 && status <= 399 && location != null;
 }
-
 function isQueryRouteResponse(obj) {
   return obj && isResponse(obj.response) && (obj.type === ResultType.data || ResultType.error);
 }
-
 function isValidMethod(method) {
   return validRequestMethods.has(method.toLowerCase());
 }
-
 function isMutationMethod(method) {
   return validMutationMethods.has(method.toLowerCase());
 }
-
 async function resolveDeferredResults(currentMatches, matchesToLoad, results, signals, isFetcher, currentLoaderData) {
   for (let index = 0; index < results.length; index++) {
     let result = results[index];
-    let match = matchesToLoad[index]; // If we don't have a match, then we can have a deferred result to do
+    let match = matchesToLoad[index];
+    // If we don't have a match, then we can have a deferred result to do
     // anything with.  This is for revalidating fetchers where the route was
     // removed during HMR
-
     if (!match) {
       continue;
     }
-
     let currentMatch = currentMatches.find(m => m.route.id === match.route.id);
     let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;
-
     if (isDeferredResult(result) && (isFetcher || isRevalidatingLoader)) {
       // Note: we do not have to touch activeDeferreds here since we race them
       // against the signal in resolveDeferredData and they'll get aborted
@@ -4297,18 +4205,14 @@ async function resolveDeferredResults(currentMatches, matchesToLoad, results, si
     }
   }
 }
-
 async function resolveDeferredData(result, signal, unwrap) {
   if (unwrap === void 0) {
     unwrap = false;
   }
-
   let aborted = await result.deferredData.resolveData(signal);
-
   if (aborted) {
     return;
   }
-
   if (unwrap) {
     try {
       return {
@@ -4323,19 +4227,17 @@ async function resolveDeferredData(result, signal, unwrap) {
       };
     }
   }
-
   return {
     type: ResultType.data,
     data: result.deferredData.data
   };
 }
-
 function hasNakedIndexQuery(search) {
   return new URLSearchParams(search).getAll("index").some(v => v === "");
-} // Note: This should match the format exported by useMatches, so if you change
-// this please also change that :)  Eventually we'll DRY this up
-
+}
 
+// Note: This should match the format exported by useMatches, so if you change
+// this please also change that :)  Eventually we'll DRY this up
 function createUseMatchesMatch(match, loaderData) {
   let {
     route,
@@ -4350,20 +4252,18 @@ function createUseMatchesMatch(match, loaderData) {
     handle: route.handle
   };
 }
-
 function getTargetMatch(matches, location) {
   let search = typeof location === "string" ? parsePath(location).search : location.search;
-
   if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || "")) {
     // Return the leaf index route when index is present
     return matches[matches.length - 1];
-  } // Otherwise grab the deepest "path contributing" match (ignoring index and
+  }
+  // Otherwise grab the deepest "path contributing" match (ignoring index and
   // pathless layout routes)
-
-
   let pathMatches = getPathContributingMatches(matches);
   return pathMatches[pathMatches.length - 1];
-} //#endregion
+}
+//#endregion
 
 exports.AbortedDeferredError = AbortedDeferredError;
 exports.ErrorResponse = ErrorResponse;