@remix-run/router 1.6.2 → 1.6.3

package/dist/router.umd.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.6.2
+ * @remix-run/router v1.6.3
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -18,14 +18,12 @@
     _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);
@@ -39,17 +37,41 @@
    * 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
   ////////////////////////////////////////////////////////////////////////////////
@@ -58,7 +80,11 @@
    * 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.
@@ -67,60 +93,47 @@
     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 {
@@ -129,13 +142,11 @@
           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,
@@ -144,12 +155,10 @@
           });
         }
       },
-
       replace(to, state) {
         action = exports.Action.Replace;
         let nextLocation = createMemoryLocation(to, state);
         entries[index] = nextLocation;
-
         if (v5Compat && listener) {
           listener({
             action,
@@ -158,13 +167,11 @@
           });
         }
       },
-
       go(delta) {
         action = exports.Action.Pop;
         let nextIndex = clampIndex(index + delta);
         let nextLocation = entries[nextIndex];
         index = nextIndex;
-
         if (listener) {
           listener({
             action,
@@ -173,17 +180,17 @@
           });
         }
       },
-
       listen(fn) {
         listener = fn;
         return () => {
           listener = null;
         };
       }
-
     };
     return history;
-  } //#endregion
+  }
+  //#endregion
+
   ////////////////////////////////////////////////////////////////////////////////
   //#region Browser History
   ////////////////////////////////////////////////////////////////////////////////
@@ -195,7 +202,6 @@
    *
    * @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
@@ -207,7 +213,6 @@
     if (options === void 0) {
       options = {};
     }
-
     function createBrowserLocation(window, globalHistory) {
       let {
         pathname,
@@ -218,16 +223,17 @@
         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
   ////////////////////////////////////////////////////////////////////////////////
@@ -243,7 +249,6 @@
    *
    * @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
@@ -256,7 +261,6 @@
     if (options === void 0) {
       options = {};
     }
-
     function createHashLocation(window, globalHistory) {
       let {
         pathname = "/",
@@ -267,29 +271,27 @@
         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
   ////////////////////////////////////////////////////////////////////////////////
@@ -297,7 +299,6 @@
   /**
    * @private
    */
-
   function invariant(value, message) {
     if (value === false || value === null || typeof value === "undefined") {
       throw new Error(message);
@@ -307,26 +308,24 @@
     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,
@@ -334,16 +333,14 @@
       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: "",
@@ -356,13 +353,12 @@
       // 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 = "/",
@@ -373,41 +369,33 @@
     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
@@ -415,30 +403,27 @@
     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,
@@ -447,23 +432,29 @@
         });
       }
     }
-
     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,
@@ -472,7 +463,6 @@
         });
       }
     }
-
     function replace(to, state) {
       action = exports.Action.Replace;
       let location = createLocation(history.location, to, state);
@@ -481,7 +471,6 @@
       let historyState = getHistoryState(location, index);
       let url = history.createHref(location);
       globalHistory.replaceState(historyState, "", url);
-
       if (v5Compat && listener) {
         listener({
           action,
@@ -490,7 +479,6 @@
         });
       }
     }
-
     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
@@ -500,21 +488,17 @@
       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 () => {
@@ -522,13 +506,10 @@
           listener = null;
         };
       },
-
       createHref(to) {
         return createHref(window, to);
       },
-
       createURL,
-
       encodeLocation(to) {
         // Encode a Location the same way window.location would
         let url = createURL(to);
@@ -538,66 +519,176 @@
           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 {
@@ -605,41 +696,35 @@
           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
@@ -647,23 +732,18 @@
       // 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,
@@ -671,40 +751,37 @@
         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);
@@ -716,6 +793,7 @@
     });
     return branches;
   }
+
   /**
    * Computes all combinations of optional path segments for a given path,
    * excluding combinations that are ambiguous and of lower priority.
@@ -730,82 +808,74 @@
    * - `/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
@@ -813,7 +883,6 @@
     let matchedParams = {};
     let matchedPathname = "/";
     let matches = [];
-
     for (let i = 0; i < routesMeta.length; ++i) {
       let meta = routesMeta[i];
       let end = i === routesMeta.length - 1;
@@ -833,72 +902,70 @@
         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.
@@ -913,7 +980,6 @@
         end: true
       };
     }
-
     let [matcher, paramNames] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);
     let match = pathname.match(matcher);
     if (!match) return null;
@@ -927,7 +993,6 @@
         let splatValue = captureGroups[index] || "";
         pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
       }
-
       memo[paramName] = safelyDecodeURIComponent(captureGroups[index] || "", paramName);
       return memo;
     }, {});
@@ -938,16 +1003,13 @@
       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
@@ -957,7 +1019,6 @@
       paramNames.push(paramName);
       return "/([^\\/]+)";
     });
-
     if (path.endsWith("*")) {
       paramNames.push("*");
       regexpSource += path === "*" || path === "/*" ? "(.*)$" // Already matched the initial /, just match the rest
@@ -975,11 +1036,9 @@
       // /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);
@@ -988,7 +1047,6 @@
       return value;
     }
   }
-
   function safelyDecodeURIComponent(value, paramName) {
     try {
       return decodeURIComponent(value);
@@ -997,41 +1055,36 @@
       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 = "",
@@ -1044,7 +1097,6 @@
       hash: normalizeHash(hash)
     };
   }
-
   function resolvePathname(relativePath, fromPathname) {
     let segments = fromPathname.replace(/\/+$/, "").split("/");
     let relativeSegments = relativePath.split("/");
@@ -1058,10 +1110,10 @@
     });
     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
    *
@@ -1085,22 +1137,18 @@
    *     </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 {
@@ -1109,10 +1157,11 @@
       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
@@ -1121,71 +1170,66 @@
     // `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.
@@ -1194,16 +1238,13 @@
     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
     }));
@@ -1214,17 +1255,15 @@
       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;
@@ -1232,34 +1271,31 @@
           [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();
@@ -1268,14 +1304,11 @@
         });
         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
@@ -1283,54 +1316,43 @@
         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) => {
@@ -1340,40 +1362,31 @@
         });
       }, {});
     }
-
     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".
@@ -1382,9 +1395,7 @@
     if (init === void 0) {
       init = 302;
     }
-
     let responseInit = init;
-
     if (typeof responseInit === "number") {
       responseInit = {
         status: responseInit
@@ -1392,28 +1403,25 @@
     } 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;
@@ -1421,24 +1429,82 @@
         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];
@@ -1468,12 +1534,12 @@
     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
   ////////////////////////////////////////////////////////////////////////////////
@@ -1481,57 +1547,54 @@
   /**
    * 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
@@ -1547,10 +1610,11 @@
         [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 = {
@@ -1568,57 +1632,74 @@
       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
@@ -1628,98 +1709,90 @@
           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
@@ -1727,7 +1800,6 @@
       // - 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;
@@ -1741,25 +1813,24 @@
       } 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,
@@ -1773,30 +1844,28 @@
         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,
@@ -1804,16 +1873,16 @@
         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) {
@@ -1823,42 +1892,36 @@
         // 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
@@ -1867,43 +1930,44 @@
         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
@@ -1911,15 +1975,17 @@
       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
@@ -1927,8 +1993,8 @@
         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,
@@ -1938,26 +2004,26 @@
           }
         });
         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
@@ -1971,40 +2037,36 @@
         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
@@ -2014,25 +2076,25 @@
         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,
@@ -2044,17 +2106,14 @@
         };
       } 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 {
@@ -2063,7 +2122,6 @@
           // double back-buttons
           replace = result.location === state.location.pathname + state.location.search;
         }
-
         await startRedirectNavigation(state, result, {
           submission,
           replace
@@ -2072,19 +2130,18 @@
           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: {},
@@ -2093,26 +2150,23 @@
           }
         };
       }
-
       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",
@@ -2122,12 +2176,11 @@
           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,
@@ -2135,12 +2188,14 @@
         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({
@@ -2156,12 +2211,12 @@
         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);
@@ -2187,7 +2242,6 @@
           fetchers: new Map(state.fetchers)
         } : {}));
       }
-
       pendingNavigationLoadId = ++incrementingLoadId;
       revalidatingFetchers.forEach(rf => {
         if (rf.controller) {
@@ -2196,37 +2250,34 @@
           // 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
@@ -2234,14 +2285,15 @@
         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
@@ -2262,56 +2314,50 @@
         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,
@@ -2320,49 +2366,43 @@
         });
         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)
@@ -2371,22 +2411,21 @@
           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;
@@ -2394,22 +2433,21 @@
       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);
@@ -2423,7 +2461,6 @@
           " _hasFetcherDoneAnything ": true
         };
         state.fetchers.set(staleKey, revalidatingFetcher);
-
         if (rf.controller) {
           fetchControllers.set(staleKey, rf.controller);
         }
@@ -2431,49 +2468,50 @@
       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();
@@ -2490,17 +2528,17 @@
         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,
@@ -2511,48 +2549,48 @@
         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: {
@@ -2561,9 +2599,9 @@
         });
         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,
@@ -2578,6 +2616,7 @@
         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
@@ -2597,57 +2636,49 @@
      * 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,
@@ -2655,11 +2686,11 @@
           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, {
@@ -2701,7 +2732,6 @@
         });
       }
     }
-
     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
@@ -2728,14 +2758,15 @@
         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);
@@ -2743,7 +2774,6 @@
         }
       });
     }
-
     function setFetcherError(key, routeId, error) {
       let boundaryMatch = findNearestBoundary(state.matches, routeId);
       deleteFetcher(key);
@@ -2754,22 +2784,25 @@
         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);
@@ -2785,34 +2818,27 @@
         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);
@@ -2820,67 +2846,59 @@
           }
         }
       }
-
       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,
@@ -2889,7 +2907,6 @@
         return blockerKey;
       }
     }
-
     function cancelActiveDeferreds(predicate) {
       let cancelledRouteIds = [];
       activeDeferreds.forEach((dfd, routeId) => {
@@ -2903,37 +2920,33 @@
         }
       });
       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));
@@ -2941,39 +2954,31 @@
         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,
@@ -2996,7 +3001,9 @@
       _internalSetRoutes
     };
     return router;
-  } //#endregion
+  }
+  //#endregion
+
   ////////////////////////////////////////////////////////////////////////////////
   //#region createStaticHandler
   ////////////////////////////////////////////////////////////////////////////////
@@ -3007,21 +3014,19 @@
     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
@@ -3041,7 +3046,6 @@
      * propagate that out and return the raw Response so the HTTP server can
      * return it directly.
      */
-
     async function query(request, _temp2) {
       let {
         requestContext
@@ -3049,8 +3053,9 @@
       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
@@ -3096,21 +3101,20 @@
           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
@@ -3131,8 +3135,6 @@
      * code.  Examples here are 404 and 405 errors that occur prior to reaching
      * any user-defined loaders.
      */
-
-
     async function queryRoute(request, _temp3) {
       let {
         routeId,
@@ -3141,8 +3143,9 @@
       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
@@ -3152,9 +3155,7 @@
           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,
@@ -3166,52 +3167,40 @@
           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,
@@ -3225,47 +3214,38 @@
           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
@@ -3278,29 +3258,24 @@
           }
         });
       }
-
       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: {},
@@ -3316,15 +3291,15 @@
           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,
@@ -3332,9 +3307,9 @@
             [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,
@@ -3352,10 +3327,10 @@
         } : {})
       });
     }
-
     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,
@@ -3363,10 +3338,10 @@
           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,
@@ -3380,18 +3355,17 @@
           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)) {
@@ -3403,13 +3377,15 @@
         activeDeferreds: activeDeferreds.size > 0 ? Object.fromEntries(activeDeferreds.entries()) : null
       });
     }
-
     return {
       dataRoutes,
       query,
       queryRoute
     };
-  } //#endregion
+  }
+
+  //#endregion
+
   ////////////////////////////////////////////////////////////////////////////////
   //#region Helpers
   ////////////////////////////////////////////////////////////////////////////////
@@ -3418,7 +3394,6 @@
    * 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,
@@ -3426,28 +3401,22 @@
         [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;
@@ -3456,36 +3425,36 @@
     } 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)) {
@@ -3493,7 +3462,6 @@
         path
       };
     }
-
     if (opts.formMethod && !isValidMethod(opts.formMethod)) {
       return {
         path,
@@ -3501,11 +3469,10 @@
           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 = {
@@ -3514,53 +3481,48 @@
         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) => {
@@ -3568,20 +3530,19 @@
         // 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({
@@ -3591,23 +3552,27 @@
         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,
@@ -3619,9 +3584,7 @@
         });
         return;
       }
-
       let fetcherMatch = getTargetMatch(fetcherMatches, f.path);
-
       if (cancelledFetcherLoads.includes(key)) {
         revalidatingFetchers.push({
           key,
@@ -3632,12 +3595,12 @@
           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,
@@ -3648,7 +3611,6 @@
         // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
         defaultShouldRevalidate: isRevalidationRequired
       }));
-
       if (shouldRevalidate) {
         revalidatingFetchers.push({
           key,
@@ -3662,60 +3624,61 @@
     });
     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.
     //
@@ -3723,52 +3686,45 @@
     // 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,
@@ -3776,10 +3732,8 @@
         context: requestContext
       }), abortPromise]);
     };
-
     try {
       let handler = match.route[type];
-
       if (match.route.lazy) {
         if (handler) {
           // Run statically defined handler in parallel with lazy()
@@ -3789,7 +3743,6 @@
           // 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
@@ -3821,7 +3774,6 @@
       } 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;
@@ -3831,14 +3783,15 @@
         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) {
@@ -3848,32 +3801,30 @@
           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 {
@@ -3881,17 +3832,15 @@
           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,
@@ -3899,7 +3848,6 @@
           headers: result.headers
         };
       }
-
       return {
         type: ResultType.data,
         data,
@@ -3907,17 +3855,14 @@
         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,
@@ -3925,90 +3870,84 @@
         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;
         }
@@ -4018,27 +3957,26 @@
           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,
@@ -4046,13 +3984,13 @@
       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,
@@ -4060,20 +3998,19 @@
         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
@@ -4096,19 +4033,15 @@
         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];
@@ -4118,24 +4051,21 @@
         // 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 === "/") || {
@@ -4151,7 +4081,6 @@
       route
     };
   }
-
   function getInternalRouterError(status, _temp4) {
     let {
       pathname,
@@ -4161,10 +4090,8 @@
     } = _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") {
@@ -4178,40 +4105,34 @@
       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 !== "";
@@ -4221,70 +4142,57 @@
     } 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
@@ -4299,18 +4207,14 @@
       }
     }
   }
-
   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 {
@@ -4325,19 +4229,17 @@
         };
       }
     }
-
     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,
@@ -4352,20 +4254,18 @@
       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;