https://moma.vn/js/index.js

1/******/ (() => { // webpackBootstrap
2/******/ 	var __webpack_modules__ = ({
3

4/***/ "./node_modules/@remix-run/router/dist/router.js":
5/*!*******************************************************!*\
6  !*** ./node_modules/@remix-run/router/dist/router.js ***!
7  \*******************************************************/
8/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
9
10"use strict";
11__webpack_require__.r(__webpack_exports__);
12/* harmony export */ __webpack_require__.d(__webpack_exports__, {
13/* harmony export */   AbortedDeferredError: () => (/* binding */ AbortedDeferredError),
14/* harmony export */   Action: () => (/* binding */ Action),
15/* harmony export */   IDLE_BLOCKER: () => (/* binding */ IDLE_BLOCKER),
16/* harmony export */   IDLE_FETCHER: () => (/* binding */ IDLE_FETCHER),
17/* harmony export */   IDLE_NAVIGATION: () => (/* binding */ IDLE_NAVIGATION),
18/* harmony export */   UNSAFE_DEFERRED_SYMBOL: () => (/* binding */ UNSAFE_DEFERRED_SYMBOL),
19/* harmony export */   UNSAFE_DeferredData: () => (/* binding */ DeferredData),
20/* harmony export */   UNSAFE_ErrorResponseImpl: () => (/* binding */ ErrorResponseImpl),
21/* harmony export */   UNSAFE_convertRouteMatchToUiMatch: () => (/* binding */ convertRouteMatchToUiMatch),
22/* harmony export */   UNSAFE_convertRoutesToDataRoutes: () => (/* binding */ convertRoutesToDataRoutes),
23/* harmony export */   UNSAFE_decodePath: () => (/* binding */ decodePath),
24/* harmony export */   UNSAFE_getResolveToMatches: () => (/* binding */ getResolveToMatches),
25/* harmony export */   UNSAFE_invariant: () => (/* binding */ invariant),
26/* harmony export */   UNSAFE_warning: () => (/* binding */ warning),
27/* harmony export */   createBrowserHistory: () => (/* binding */ createBrowserHistory),
28/* harmony export */   createHashHistory: () => (/* binding */ createHashHistory),
29/* harmony export */   createMemoryHistory: () => (/* binding */ createMemoryHistory),
30/* harmony export */   createPath: () => (/* binding */ createPath),
31/* harmony export */   createRouter: () => (/* binding */ createRouter),
32/* harmony export */   createStaticHandler: () => (/* binding */ createStaticHandler),
33/* harmony export */   data: () => (/* binding */ data),
34/* harmony export */   defer: () => (/* binding */ defer),
35/* harmony export */   generatePath: () => (/* binding */ generatePath),
36/* harmony export */   getStaticContextFromError: () => (/* binding */ getStaticContextFromError),
37/* harmony export */   getToPathname: () => (/* binding */ getToPathname),
38/* harmony export */   isDataWithResponseInit: () => (/* binding */ isDataWithResponseInit),
39/* harmony export */   isDeferredData: () => (/* binding */ isDeferredData),
40/* harmony export */   isRouteErrorResponse: () => (/* binding */ isRouteErrorResponse),
41/* harmony export */   joinPaths: () => (/* binding */ joinPaths),
42/* harmony export */   json: () => (/* binding */ json),
43/* harmony export */   matchPath: () => (/* binding */ matchPath),
44/* harmony export */   matchRoutes: () => (/* binding */ matchRoutes),
45/* harmony export */   normalizePathname: () => (/* binding */ normalizePathname),
46/* harmony export */   parsePath: () => (/* binding */ parsePath),
47/* harmony export */   redirect: () => (/* binding */ redirect),
48/* harmony export */   redirectDocument: () => (/* binding */ redirectDocument),
49/* harmony export */   replace: () => (/* binding */ replace),
50/* harmony export */   resolvePath: () => (/* binding */ resolvePath),
51/* harmony export */   resolveTo: () => (/* binding */ resolveTo),
52/* harmony export */   stripBasename: () => (/* binding */ stripBasename)
53/* harmony export */ });
54/**
55 * @remix-run/router v1.21.0
56 *
57 * Copyright (c) Remix Software Inc.
58 *
59 * This source code is licensed under the MIT license found in the
60 * LICENSE.md file in the root directory of this source tree.
61 *
62 * @license MIT
63 */
64function _extends() {
65  _extends = Object.assign ? Object.assign.bind() : function (target) {
66    for (var i = 1; i < arguments.length; i++) {
67      var source = arguments[i];
68      for (var key in source) {
69        if (Object.prototype.hasOwnProperty.call(source, key)) {
70          target[key] = source[key];
71        }
72      }
73    }
74    return target;
75  };
76  return _extends.apply(this, arguments);
77}
78
79////////////////////////////////////////////////////////////////////////////////
80//#region Types and Constants
81////////////////////////////////////////////////////////////////////////////////
82/**
83 * Actions represent the type of change to a location value.
84 */
85var Action;
86(function (Action) {
87  /**
88   * A POP indicates a change to an arbitrary index in the history stack, such
89   * as a back or forward navigation. It does not describe the direction of the
90   * navigation, only that the current index changed.
91   *
92   * Note: This is the default action for newly created history objects.
93   */
94  Action["Pop"] = "POP";
95  /**
96   * A PUSH indicates a new entry being added to the history stack, such as when
97   * a link is clicked and a new page loads. When this happens, all subsequent
98   * entries in the stack are lost.
99   */
100  Action["Push"] = "PUSH";
101  /**
102   * A REPLACE indicates the entry at the current index in the history stack
103   * being replaced by a new one.
104   */
105  Action["Replace"] = "REPLACE";
106})(Action || (Action = {}));
107const PopStateEventType = "popstate";
108/**
109 * Memory history stores the current location in memory. It is designed for use
110 * in stateful non-browser environments like tests and React Native.
111 */
112function createMemoryHistory(options) {
113  if (options === void 0) {
114    options = {};
115  }
116  let {
117    initialEntries = ["/"],
118    initialIndex,
119    v5Compat = false
120  } = options;
121  let entries; // Declare so we can access from createMemoryLocation
122  entries = initialEntries.map((entry, index) => createMemoryLocation(entry, typeof entry === "string" ? null : entry.state, index === 0 ? "default" : undefined));
123  let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);
124  let action = Action.Pop;
125  let listener = null;
126  function clampIndex(n) {
127    return Math.min(Math.max(n, 0), entries.length - 1);
128  }
129  function getCurrentLocation() {
130    return entries[index];
131  }
132  function createMemoryLocation(to, state, key) {
133    if (state === void 0) {
134      state = null;
135    }
136    let location = createLocation(entries ? getCurrentLocation().pathname : "/", to, state, key);
137    warning(location.pathname.charAt(0) === "/", "relative pathnames are not supported in memory history: " + JSON.stringify(to));
138    return location;
139  }
140  function createHref(to) {
141    return typeof to === "string" ? to : createPath(to);
142  }
143  let history = {
144    get index() {
145      return index;
146    },
147    get action() {
148      return action;
149    },
150    get location() {
151      return getCurrentLocation();
152    },
153    createHref,
154    createURL(to) {
155      return new URL(createHref(to), "http://localhost");
156    },
157    encodeLocation(to) {
158      let path = typeof to === "string" ? parsePath(to) : to;
159      return {
160        pathname: path.pathname || "",
161        search: path.search || "",
162        hash: path.hash || ""
163      };
164    },
165    push(to, state) {
166      action = Action.Push;
167      let nextLocation = createMemoryLocation(to, state);
168      index += 1;
169      entries.splice(index, entries.length, nextLocation);
170      if (v5Compat && listener) {
171        listener({
172          action,
173          location: nextLocation,
174          delta: 1
175        });
176      }
177    },
178    replace(to, state) {
179      action = Action.Replace;
180      let nextLocation = createMemoryLocation(to, state);
181      entries[index] = nextLocation;
182      if (v5Compat && listener) {
183        listener({
184          action,
185          location: nextLocation,
186          delta: 0
187        });
188      }
189    },
190    go(delta) {
191      action = Action.Pop;
192      let nextIndex = clampIndex(index + delta);
193      let nextLocation = entries[nextIndex];
194      index = nextIndex;
195      if (listener) {
196        listener({
197          action,
198          location: nextLocation,
199          delta
200        });
201      }
202    },
203    listen(fn) {
204      listener = fn;
205      return () => {
206        listener = null;
207      };
208    }
209  };
210  return history;
211}
212/**
213 * Browser history stores the location in regular URLs. This is the standard for
214 * most web apps, but it requires some configuration on the server to ensure you
215 * serve the same app at multiple URLs.
216 *
217 * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory
218 */
219function createBrowserHistory(options) {
220  if (options === void 0) {
221    options = {};
222  }
223  function createBrowserLocation(window, globalHistory) {
224    let {
225      pathname,
226      search,
227      hash
228    } = window.location;
229    return createLocation("", {
230      pathname,
231      search,
232      hash
233    },
234    // state defaults to `null` because `window.history.state` does
235    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || "default");
236  }
237  function createBrowserHref(window, to) {
238    return typeof to === "string" ? to : createPath(to);
239  }
240  return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);
241}
242/**
243 * Hash history stores the location in window.location.hash. This makes it ideal
244 * for situations where you don't want to send the location to the server for
245 * some reason, either because you do cannot configure it or the URL space is
246 * reserved for something else.
247 *
248 * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory
249 */
250function createHashHistory(options) {
251  if (options === void 0) {
252    options = {};
253  }
254  function createHashLocation(window, globalHistory) {
255    let {
256      pathname = "/",
257      search = "",
258      hash = ""
259    } = parsePath(window.location.hash.substr(1));
260    // Hash URL should always have a leading / just like window.location.pathname
261    // does, so if an app ends up at a route like /#something then we add a
262    // leading slash so all of our path-matching behaves the same as if it would
263    // in a browser router.  This is particularly important when there exists a
264    // root splat route (<Route path="*">) since that matches internally against
265    // "/*" and we'd expect /#something to 404 in a hash router app.
266    if (!pathname.startsWith("/") && !pathname.startsWith(".")) {
267      pathname = "/" + pathname;
268    }
269    return createLocation("", {
270      pathname,
271      search,
272      hash
273    },
274    // state defaults to `null` because `window.history.state` does
275    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || "default");
276  }
277  function createHashHref(window, to) {
278    let base = window.document.querySelector("base");
279    let href = "";
280    if (base && base.getAttribute("href")) {
281      let url = window.location.href;
282      let hashIndex = url.indexOf("#");
283      href = hashIndex === -1 ? url : url.slice(0, hashIndex);
284    }
285    return href + "#" + (typeof to === "string" ? to : createPath(to));
286  }
287  function validateHashLocation(location, to) {
288    warning(location.pathname.charAt(0) === "/", "relative pathnames are not supported in hash history.push(" + JSON.stringify(to) + ")");
289  }
290  return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);
291}
292function invariant(value, message) {
293  if (value === false || value === null || typeof value === "undefined") {
294    throw new Error(message);
295  }
296}
297function warning(cond, message) {
298  if (!cond) {
299    // eslint-disable-next-line no-console
300    if (typeof console !== "undefined") console.warn(message);
301    try {
302      // Welcome to debugging history!
303      //
304      // This error is thrown as a convenience, so you can more easily
305      // find the source for a warning that appears in the console by
306      // enabling "pause on exceptions" in your JavaScript debugger.
307      throw new Error(message);
308      // eslint-disable-next-line no-empty
309    } catch (e) {}
310  }
311}
312function createKey() {
313  return Math.random().toString(36).substr(2, 8);
314}
315/**
316 * For browser-based histories, we combine the state and key into an object
317 */
318function getHistoryState(location, index) {
319  return {
320    usr: location.state,
321    key: location.key,
322    idx: index
323  };
324}
325/**
326 * Creates a Location object with a unique key from the given Path
327 */
328function createLocation(current, to, state, key) {
329  if (state === void 0) {
330    state = null;
331  }
332  let location = _extends({
333    pathname: typeof current === "string" ? current : current.pathname,
334    search: "",
335    hash: ""
336  }, typeof to === "string" ? parsePath(to) : to, {
337    state,
338    // TODO: This could be cleaned up.  push/replace should probably just take
339    // full Locations now and avoid the need to run through this flow at all
340    // But that's a pretty big refactor to the current test suite so going to
341    // keep as is for the time being and just let any incoming keys take precedence
342    key: to && to.key || key || createKey()
343  });
344  return location;
345}
346/**
347 * Creates a string URL path from the given pathname, search, and hash components.
348 */
349function createPath(_ref) {
350  let {
351    pathname = "/",
352    search = "",
353    hash = ""
354  } = _ref;
355  if (search && search !== "?") pathname += search.charAt(0) === "?" ? search : "?" + search;
356  if (hash && hash !== "#") pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
357  return pathname;
358}
359/**
360 * Parses a string URL path into its separate pathname, search, and hash components.
361 */
362function parsePath(path) {
363  let parsedPath = {};
364  if (path) {
365    let hashIndex = path.indexOf("#");
366    if (hashIndex >= 0) {
367      parsedPath.hash = path.substr(hashIndex);
368      path = path.substr(0, hashIndex);
369    }
370    let searchIndex = path.indexOf("?");
371    if (searchIndex >= 0) {
372      parsedPath.search = path.substr(searchIndex);
373      path = path.substr(0, searchIndex);
374    }
375    if (path) {
376      parsedPath.pathname = path;
377    }
378  }
379  return parsedPath;
380}
381function getUrlBasedHistory(getLocation, createHref, validateLocation, options) {
382  if (options === void 0) {
383    options = {};
384  }
385  let {
386    window = document.defaultView,
387    v5Compat = false
388  } = options;
389  let globalHistory = window.history;
390  let action = Action.Pop;
391  let listener = null;
392  let index = getIndex();
393  // Index should only be null when we initialize. If not, it's because the
394  // user called history.pushState or history.replaceState directly, in which
395  // case we should log a warning as it will result in bugs.
396  if (index == null) {
397    index = 0;
398    globalHistory.replaceState(_extends({}, globalHistory.state, {
399      idx: index
400    }), "");
401  }
402  function getIndex() {
403    let state = globalHistory.state || {
404      idx: null
405    };
406    return state.idx;
407  }
408  function handlePop() {
409    action = Action.Pop;
410    let nextIndex = getIndex();
411    let delta = nextIndex == null ? null : nextIndex - index;
412    index = nextIndex;
413    if (listener) {
414      listener({
415        action,
416        location: history.location,
417        delta
418      });
419    }
420  }
421  function push(to, state) {
422    action = Action.Push;
423    let location = createLocation(history.location, to, state);
424    if (validateLocation) validateLocation(location, to);
425    index = getIndex() + 1;
426    let historyState = getHistoryState(location, index);
427    let url = history.createHref(location);
428    // try...catch because iOS limits us to 100 pushState calls :/
429    try {
430      globalHistory.pushState(historyState, "", url);
431    } catch (error) {
432      // If the exception is because `state` can't be serialized, let that throw
433      // outwards just like a replace call would so the dev knows the cause
434      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps
435      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal
436      if (error instanceof DOMException && error.name === "DataCloneError") {
437        throw error;
438      }
439      // They are going to lose state here, but there is no real
440      // way to warn them about it since the page will refresh...
441      window.location.assign(url);
442    }
443    if (v5Compat && listener) {
444      listener({
445        action,
446        location: history.location,
447        delta: 1
448      });
449    }
450  }
451  function replace(to, state) {
452    action = Action.Replace;
453    let location = createLocation(history.location, to, state);
454    if (validateLocation) validateLocation(location, to);
455    index = getIndex();
456    let historyState = getHistoryState(location, index);
457    let url = history.createHref(location);
458    globalHistory.replaceState(historyState, "", url);
459    if (v5Compat && listener) {
460      listener({
461        action,
462        location: history.location,
463        delta: 0
464      });
465    }
466  }
467  function createURL(to) {
468    // window.location.origin is "null" (the literal string value) in Firefox
469    // under certain conditions, notably when serving from a local HTML file
470    // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297
471    let base = window.location.origin !== "null" ? window.location.origin : window.location.href;
472    let href = typeof to === "string" ? to : createPath(to);
473    // Treating this as a full URL will strip any trailing spaces so we need to
474    // pre-encode them since they might be part of a matching splat param from
475    // an ancestor route
476    href = href.replace(/ $/, "%20");
477    invariant(base, "No window.location.(origin|href) available to create URL for href: " + href);
478    return new URL(href, base);
479  }
480  let history = {
481    get action() {
482      return action;
483    },
484    get location() {
485      return getLocation(window, globalHistory);
486    },
487    listen(fn) {
488      if (listener) {
489        throw new Error("A history only accepts one active listener");
490      }
491      window.addEventListener(PopStateEventType, handlePop);
492      listener = fn;
493      return () => {
494        window.removeEventListener(PopStateEventType, handlePop);
495        listener = null;
496      };
497    },
498    createHref(to) {
499      return createHref(window, to);
500    },
501    createURL,
502    encodeLocation(to) {
503      // Encode a Location the same way window.location would
504      let url = createURL(to);
505      return {
506        pathname: url.pathname,
507        search: url.search,
508        hash: url.hash
509      };
510    },
511    push,
512    replace,
513    go(n) {
514      return globalHistory.go(n);
515    }
516  };
517  return history;
518}
519//#endregion
520
521var ResultType;
522(function (ResultType) {
523  ResultType["data"] = "data";
524  ResultType["deferred"] = "deferred";
525  ResultType["redirect"] = "redirect";
526  ResultType["error"] = "error";
527})(ResultType || (ResultType = {}));
528const immutableRouteKeys = new Set(["lazy", "caseSensitive", "path", "id", "index", "children"]);
529function isIndexRoute(route) {
530  return route.index === true;
531}
532// Walk the route tree generating unique IDs where necessary, so we are working
533// solely with AgnosticDataRouteObject's within the Router
534function convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath, manifest) {
535  if (parentPath === void 0) {
536    parentPath = [];
537  }
538  if (manifest === void 0) {
539    manifest = {};
540  }
541  return routes.map((route, index) => {
542    let treePath = [...parentPath, String(index)];
543    let id = typeof route.id === "string" ? route.id : treePath.join("-");
544    invariant(route.index !== true || !route.children, "Cannot specify children on an index route");
545    invariant(!manifest[id], "Found a route id collision on id \"" + id + "\".  Route " + "id's must be globally unique within Data Router usages");
546    if (isIndexRoute(route)) {
547      let indexRoute = _extends({}, route, mapRouteProperties(route), {
548        id
549      });
550      manifest[id] = indexRoute;
551      return indexRoute;
552    } else {
553      let pathOrLayoutRoute = _extends({}, route, mapRouteProperties(route), {
554        id,
555        children: undefined
556      });
557      manifest[id] = pathOrLayoutRoute;
558      if (route.children) {
559        pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties, treePath, manifest);
560      }
561      return pathOrLayoutRoute;
562    }
563  });
564}
565/**
566 * Matches the given routes to a location and returns the match data.
567 *
568 * @see https://reactrouter.com/v6/utils/match-routes
569 */
570function matchRoutes(routes, locationArg, basename) {
571  if (basename === void 0) {
572    basename = "/";
573  }
574  return matchRoutesImpl(routes, locationArg, basename, false);
575}
576function matchRoutesImpl(routes, locationArg, basename, allowPartial) {
577  let location = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
578  let pathname = stripBasename(location.pathname || "/", basename);
579  if (pathname == null) {
580    return null;
581  }
582  let branches = flattenRoutes(routes);
583  rankRouteBranches(branches);
584  let matches = null;
585  for (let i = 0; matches == null && i < branches.length; ++i) {
586    // Incoming pathnames are generally encoded from either window.location
587    // or from router.navigate, but we want to match against the unencoded
588    // paths in the route definitions.  Memory router locations won't be
589    // encoded here but there also shouldn't be anything to decode so this
590    // should be a safe operation.  This avoids needing matchRoutes to be
591    // history-aware.
592    let decoded = decodePath(pathname);
593    matches = matchRouteBranch(branches[i], decoded, allowPartial);
594  }
595  return matches;
596}
597function convertRouteMatchToUiMatch(match, loaderData) {
598  let {
599    route,
600    pathname,
601    params
602  } = match;
603  return {
604    id: route.id,
605    pathname,
606    params,
607    data: loaderData[route.id],
608    handle: route.handle
609  };
610}
611function flattenRoutes(routes, branches, parentsMeta, parentPath) {
612  if (branches === void 0) {
613    branches = [];
614  }
615  if (parentsMeta === void 0) {
616    parentsMeta = [];
617  }
618  if (parentPath === void 0) {
619    parentPath = "";
620  }
621  let flattenRoute = (route, index, relativePath) => {
622    let meta = {
623      relativePath: relativePath === undefined ? route.path || "" : relativePath,
624      caseSensitive: route.caseSensitive === true,
625      childrenIndex: index,
626      route
627    };
628    if (meta.relativePath.startsWith("/")) {
629      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.");
630      meta.relativePath = meta.relativePath.slice(parentPath.length);
631    }
632    let path = joinPaths([parentPath, meta.relativePath]);
633    let routesMeta = parentsMeta.concat(meta);
634    // Add the children before adding this route to the array, so we traverse the
635    // route tree depth-first and child routes appear before their parents in
636    // the "flattened" version.
637    if (route.children && route.children.length > 0) {
638      invariant(
639      // Our types know better, but runtime JS may not!
640      // @ts-expect-error
641      route.index !== true, "Index routes must not have child routes. Please remove " + ("all child routes from route path \"" + path + "\"."));
642      flattenRoutes(route.children, branches, routesMeta, path);
643    }
644    // Routes without a path shouldn't ever match by themselves unless they are
645    // index routes, so don't add them to the list of possible branches.
646    if (route.path == null && !route.index) {
647      return;
648    }
649    branches.push({
650      path,
651      score: computeScore(path, route.index),
652      routesMeta
653    });
654  };
655  routes.forEach((route, index) => {
656    var _route$path;
657    // coarse-grain check for optional params
658    if (route.path === "" || !((_route$path = route.path) != null && _route$path.includes("?"))) {
659      flattenRoute(route, index);
660    } else {
661      for (let exploded of explodeOptionalSegments(route.path)) {
662        flattenRoute(route, index, exploded);
663      }
664    }
665  });
666  return branches;
667}
668/**
669 * Computes all combinations of optional path segments for a given path,
670 * excluding combinations that are ambiguous and of lower priority.
671 *
672 * For example, `/one/:two?/three/:four?/:five?` explodes to:
673 * - `/one/three`
674 * - `/one/:two/three`
675 * - `/one/three/:four`
676 * - `/one/three/:five`
677 * - `/one/:two/three/:four`
678 * - `/one/:two/three/:five`
679 * - `/one/three/:four/:five`
680 * - `/one/:two/three/:four/:five`
681 */
682function explodeOptionalSegments(path) {
683  let segments = path.split("/");
684  if (segments.length === 0) return [];
685  let [first, ...rest] = segments;
686  // Optional path segments are denoted by a trailing `?`
687  let isOptional = first.endsWith("?");
688  // Compute the corresponding required segment: `foo?` -> `foo`
689  let required = first.replace(/\?$/, "");
690  if (rest.length === 0) {
691    // Intepret empty string as omitting an optional segment
692    // `["one", "", "three"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`
693    return isOptional ? [required, ""] : [required];
694  }
695  let restExploded = explodeOptionalSegments(rest.join("/"));
696  let result = [];
697  // All child paths with the prefix.  Do this for all children before the
698  // optional version for all children, so we get consistent ordering where the
699  // parent optional aspect is preferred as required.  Otherwise, we can get
700  // child sections interspersed where deeper optional segments are higher than
701  // parent optional segments, where for example, /:two would explode _earlier_
702  // then /:one.  By always including the parent as required _for all children_
703  // first, we avoid this issue
704  result.push(...restExploded.map(subpath => subpath === "" ? required : [required, subpath].join("/")));
705  // Then, if this is an optional value, add all child versions without
706  if (isOptional) {
707    result.push(...restExploded);
708  }
709  // for absolute paths, ensure `/` instead of empty segment
710  return result.map(exploded => path.startsWith("/") && exploded === "" ? "/" : exploded);
711}
712function rankRouteBranches(branches) {
713  branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first
714  : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));
715}
716const paramRe = /^:[\w-]+$/;
717const dynamicSegmentValue = 3;
718const indexRouteValue = 2;
719const emptySegmentValue = 1;
720const staticSegmentValue = 10;
721const splatPenalty = -2;
722const isSplat = s => s === "*";
723function computeScore(path, index) {
724  let segments = path.split("/");
725  let initialScore = segments.length;
726  if (segments.some(isSplat)) {
727    initialScore += splatPenalty;
728  }
729  if (index) {
730    initialScore += indexRouteValue;
731  }
732  return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === "" ? emptySegmentValue : staticSegmentValue), initialScore);
733}
734function compareIndexes(a, b) {
735  let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);
736  return siblings ?
737  // If two routes are siblings, we should try to match the earlier sibling
738  // first. This allows people to have fine-grained control over the matching
739  // behavior by simply putting routes with identical paths in the order they
740  // want them tried.
741  a[a.length - 1] - b[b.length - 1] :
742  // Otherwise, it doesn't really make sense to rank non-siblings by index,
743  // so they sort equally.
744  0;
745}
746function matchRouteBranch(branch, pathname, allowPartial) {
747  if (allowPartial === void 0) {
748    allowPartial = false;
749  }
750  let {
751    routesMeta
752  } = branch;
753  let matchedParams = {};
754  let matchedPathname = "/";
755  let matches = [];
756  for (let i = 0; i < routesMeta.length; ++i) {
757    let meta = routesMeta[i];
758    let end = i === routesMeta.length - 1;
759    let remainingPathname = matchedPathname === "/" ? pathname : pathname.slice(matchedPathname.length) || "/";
760    let match = matchPath({
761      path: meta.relativePath,
762      caseSensitive: meta.caseSensitive,
763      end
764    }, remainingPathname);
765    let route = meta.route;
766    if (!match && end && allowPartial && !routesMeta[routesMeta.length - 1].route.index) {
767      match = matchPath({
768        path: meta.relativePath,
769        caseSensitive: meta.caseSensitive,
770        end: false
771      }, remainingPathname);
772    }
773    if (!match) {
774      return null;
775    }
776    Object.assign(matchedParams, match.params);
777    matches.push({
778      // TODO: Can this as be avoided?
779      params: matchedParams,
780      pathname: joinPaths([matchedPathname, match.pathname]),
781      pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),
782      route
783    });
784    if (match.pathnameBase !== "/") {
785      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
786    }
787  }
788  return matches;
789}
790/**
791 * Returns a path with params interpolated.
792 *
793 * @see https://reactrouter.com/v6/utils/generate-path
794 */
795function generatePath(originalPath, params) {
796  if (params === void 0) {
797    params = {};
798  }
799  let path = originalPath;
800  if (path.endsWith("*") && path !== "*" && !path.endsWith("/*")) {
801    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(/\*$/, "/*") + "\"."));
802    path = path.replace(/\*$/, "/*");
803  }
804  // ensure `/` is added at the beginning if the path is absolute
805  const prefix = path.startsWith("/") ? "/" : "";
806  const stringify = p => p == null ? "" : typeof p === "string" ? p : String(p);
807  const segments = path.split(/\/+/).map((segment, index, array) => {
808    const isLastSegment = index === array.length - 1;
809    // only apply the splat if it's the last segment
810    if (isLastSegment && segment === "*") {
811      const star = "*";
812      // Apply the splat
813      return stringify(params[star]);
814    }
815    const keyMatch = segment.match(/^:([\w-]+)(\??)$/);
816    if (keyMatch) {
817      const [, key, optional] = keyMatch;
818      let param = params[key];
819      invariant(optional === "?" || param != null, "Missing \":" + key + "\" param");
820      return stringify(param);
821    }
822    // Remove any optional markers from optional static segments
823    return segment.replace(/\?$/g, "");
824  })
825  // Remove empty segments
826  .filter(segment => !!segment);
827  return prefix + segments.join("/");
828}
829/**
830 * Performs pattern matching on a URL pathname and returns information about
831 * the match.
832 *
833 * @see https://reactrouter.com/v6/utils/match-path
834 */
835function matchPath(pattern, pathname) {
836  if (typeof pattern === "string") {
837    pattern = {
838      path: pattern,
839      caseSensitive: false,
840      end: true
841    };
842  }
843  let [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);
844  let match = pathname.match(matcher);
845  if (!match) return null;
846  let matchedPathname = match[0];
847  let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
848  let captureGroups = match.slice(1);
849  let params = compiledParams.reduce((memo, _ref, index) => {
850    let {
851      paramName,
852      isOptional
853    } = _ref;
854    // We need to compute the pathnameBase here using the raw splat value
855    // instead of using params["*"] later because it will be decoded then
856    if (paramName === "*") {
857      let splatValue = captureGroups[index] || "";
858      pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
859    }
860    const value = captureGroups[index];
861    if (isOptional && !value) {
862      memo[paramName] = undefined;
863    } else {
864      memo[paramName] = (value || "").replace(/%2F/g, "/");
865    }
866    return memo;
867  }, {});
868  return {
869    params,
870    pathname: matchedPathname,
871    pathnameBase,
872    pattern
873  };
874}
875function compilePath(path, caseSensitive, end) {
876  if (caseSensitive === void 0) {
877    caseSensitive = false;
878  }
879  if (end === void 0) {
880    end = true;
881  }
882  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(/\*$/, "/*") + "\"."));
883  let params = [];
884  let regexpSource = "^" + path.replace(/\/*\*?$/, "") // Ignore trailing / and /*, we'll handle it below
885  .replace(/^\/*/, "/") // Make sure it has a leading /
886  .replace(/[\\.*+^${}|()[\]]/g, "\\$&") // Escape special regex chars
887  .replace(/\/:([\w-]+)(\?)?/g, (_, paramName, isOptional) => {
888    params.push({
889      paramName,
890      isOptional: isOptional != null
891    });
892    return isOptional ? "/?([^\\/]+)?" : "/([^\\/]+)";
893  });
894  if (path.endsWith("*")) {
895    params.push({
896      paramName: "*"
897    });
898    regexpSource += path === "*" || path === "/*" ? "(.*)$" // Already matched the initial /, just match the rest
899    : "(?:\\/(.+)|\\/*)$"; // Don't include the / in params["*"]
900  } else if (end) {
901    // When matching to the end, ignore trailing slashes
902    regexpSource += "\\/*$";
903  } else if (path !== "" && path !== "/") {
904    // If our path is non-empty and contains anything beyond an initial slash,
905    // then we have _some_ form of path in our regex, so we should expect to
906    // match only if we find the end of this path segment.  Look for an optional
907    // non-captured trailing slash (to match a portion of the URL) or the end
908    // of the path (if we've matched to the end).  We used to do this with a
909    // word boundary but that gives false positives on routes like
910    // /user-preferences since `-` counts as a word boundary.
911    regexpSource += "(?:(?=\\/|$))";
912  } else ;
913  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : "i");
914  return [matcher, params];
915}
916function decodePath(value) {
917  try {
918    return value.split("/").map(v => decodeURIComponent(v).replace(/\//g, "%2F")).join("/");
919  } catch (error) {
920    warning(false, "The URL path \"" + value + "\" could not be decoded because it is is a " + "malformed URL segment. This is probably due to a bad percent " + ("encoding (" + error + ")."));
921    return value;
922  }
923}
924/**
925 * @private
926 */
927function stripBasename(pathname, basename) {
928  if (basename === "/") return pathname;
929  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {
930    return null;
931  }
932  // We want to leave trailing slash behavior in the user's control, so if they
933  // specify a basename with a trailing slash, we should support it
934  let startIndex = basename.endsWith("/") ? basename.length - 1 : basename.length;
935  let nextChar = pathname.charAt(startIndex);
936  if (nextChar && nextChar !== "/") {
937    // pathname does not start with basename/
938    return null;
939  }
940  return pathname.slice(startIndex) || "/";
941}
942/**
943 * Returns a resolved path object relative to the given pathname.
944 *
945 * @see https://reactrouter.com/v6/utils/resolve-path
946 */
947function resolvePath(to, fromPathname) {
948  if (fromPathname === void 0) {
949    fromPathname = "/";
950  }
951  let {
952    pathname: toPathname,
953    search = "",
954    hash = ""
955  } = typeof to === "string" ? parsePath(to) : to;
956  let pathname = toPathname ? toPathname.startsWith("/") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;
957  return {
958    pathname,
959    search: normalizeSearch(search),
960    hash: normalizeHash(hash)
961  };
962}
963function resolvePathname(relativePath, fromPathname) {
964  let segments = fromPathname.replace(/\/+$/, "").split("/");
965  let relativeSegments = relativePath.split("/");
966  relativeSegments.forEach(segment => {
967    if (segment === "..") {
968      // Keep the root "" segment so the pathname starts at /
969      if (segments.length > 1) segments.pop();
970    } else if (segment !== ".") {
971      segments.push(segment);
972    }
973  });
974  return segments.length > 1 ? segments.join("/") : "/";
975}
976function getInvalidPathError(char, field, dest, path) {
977  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.";
978}
979/**
980 * @private
981 *
982 * When processing relative navigation we want to ignore ancestor routes that
983 * do not contribute to the path, such that index/pathless layout routes don't
984 * interfere.
985 *
986 * For example, when moving a route element into an index route and/or a
987 * pathless layout route, relative link behavior contained within should stay
988 * the same.  Both of the following examples should link back to the root:
989 *
990 *   <Route path="/">
991 *     <Route path="accounts" element={<Link to=".."}>
992 *   </Route>
993 *
994 *   <Route path="/">
995 *     <Route path="accounts">
996 *       <Route element={<AccountsLayout />}>       // <-- Does not contribute
997 *         <Route index element={<Link to=".."} />  // <-- Does not contribute
998 *       </Route
999 *     </Route>
1000 *   </Route>
1001 */
1002function getPathContributingMatches(matches) {
1003  return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);
1004}
1005// Return the array of pathnames for the current route matches - used to
1006// generate the routePathnames input for resolveTo()
1007function getResolveToMatches(matches, v7_relativeSplatPath) {
1008  let pathMatches = getPathContributingMatches(matches);
1009  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf
1010  // match so we include splat values for "." links.  See:
1011  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329
1012  if (v7_relativeSplatPath) {
1013    return pathMatches.map((match, idx) => idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase);
1014  }
1015  return pathMatches.map(match => match.pathnameBase);
1016}
1017/**
1018 * @private
1019 */
1020function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
1021  if (isPathRelative === void 0) {
1022    isPathRelative = false;
1023  }
1024  let to;
1025  if (typeof toArg === "string") {
1026    to = parsePath(toArg);
1027  } else {
1028    to = _extends({}, toArg);
1029    invariant(!to.pathname || !to.pathname.includes("?"), getInvalidPathError("?", "pathname", "search", to));
1030    invariant(!to.pathname || !to.pathname.includes("#"), getInvalidPathError("#", "pathname", "hash", to));
1031    invariant(!to.search || !to.search.includes("#"), getInvalidPathError("#", "search", "hash", to));
1032  }
1033  let isEmptyPath = toArg === "" || to.pathname === "";
1034  let toPathname = isEmptyPath ? "/" : to.pathname;
1035  let from;
1036  // Routing is relative to the current pathname if explicitly requested.
1037  //
1038  // If a pathname is explicitly provided in `to`, it should be relative to the
1039  // route context. This is explained in `Note on `<Link to>` values` in our
1040  // migration guide from v5 as a means of disambiguation between `to` values
1041  // that begin with `/` and those that do not. However, this is problematic for
1042  // `to` values that do not provide a pathname. `to` can simply be a search or
1043  // hash string, in which case we should assume that the navigation is relative
1044  // to the current location's pathname and *not* the route pathname.
1045  if (toPathname == null) {
1046    from = locationPathname;
1047  } else {
1048    let routePathnameIndex = routePathnames.length - 1;
1049    // With relative="route" (the default), each leading .. segment means
1050    // "go up one route" instead of "go up one URL segment".  This is a key
1051    // difference from how <a href> works and a major reason we call this a
1052    // "to" value instead of a "href".
1053    if (!isPathRelative && toPathname.startsWith("..")) {
1054      let toSegments = toPathname.split("/");
1055      while (toSegments[0] === "..") {
1056        toSegments.shift();
1057        routePathnameIndex -= 1;
1058      }
1059      to.pathname = toSegments.join("/");
1060    }
1061    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
1062  }
1063  let path = resolvePath(to, from);
1064  // Ensure the pathname has a trailing slash if the original "to" had one
1065  let hasExplicitTrailingSlash = toPathname && toPathname !== "/" && toPathname.endsWith("/");
1066  // Or if this was a link to the current path which has a trailing slash
1067  let hasCurrentTrailingSlash = (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");
1068  if (!path.pathname.endsWith("/") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {
1069    path.pathname += "/";
1070  }
1071  return path;
1072}
1073/**
1074 * @private
1075 */
1076function getToPathname(to) {
1077  // Empty strings should be treated the same as / paths
1078  return to === "" || to.pathname === "" ? "/" : typeof to === "string" ? parsePath(to).pathname : to.pathname;
1079}
1080/**
1081 * @private
1082 */
1083const joinPaths = paths => paths.join("/").replace(/\/\/+/g, "/");
1084/**
1085 * @private
1086 */
1087const normalizePathname = pathname => pathname.replace(/\/+$/, "").replace(/^\/*/, "/");
1088/**
1089 * @private
1090 */
1091const normalizeSearch = search => !search || search === "?" ? "" : search.startsWith("?") ? search : "?" + search;
1092/**
1093 * @private
1094 */
1095const normalizeHash = hash => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
1096/**
1097 * This is a shortcut for creating `application/json` responses. Converts `data`
1098 * to JSON and sets the `Content-Type` header.
1099 *
1100 * @deprecated The `json` method is deprecated in favor of returning raw objects.
1101 * This method will be removed in v7.
1102 */
1103const json = function json(data, init) {
1104  if (init === void 0) {
1105    init = {};
1106  }
1107  let responseInit = typeof init === "number" ? {
1108    status: init
1109  } : init;
1110  let headers = new Headers(responseInit.headers);
1111  if (!headers.has("Content-Type")) {
1112    headers.set("Content-Type", "application/json; charset=utf-8");
1113  }
1114  return new Response(JSON.stringify(data), _extends({}, responseInit, {
1115    headers
1116  }));
1117};
1118class DataWithResponseInit {
1119  constructor(data, init) {
1120    this.type = "DataWithResponseInit";
1121    this.data = data;
1122    this.init = init || null;
1123  }
1124}
1125/**
1126 * Create "responses" that contain `status`/`headers` without forcing
1127 * serialization into an actual `Response` - used by Remix single fetch
1128 */
1129function data(data, init) {
1130  return new DataWithResponseInit(data, typeof init === "number" ? {
1131    status: init
1132  } : init);
1133}
1134class AbortedDeferredError extends Error {}
1135class DeferredData {
1136  constructor(data, responseInit) {
1137    this.pendingKeysSet = new Set();
1138    this.subscribers = new Set();
1139    this.deferredKeys = [];
1140    invariant(data && typeof data === "object" && !Array.isArray(data), "defer() only accepts plain objects");
1141    // Set up an AbortController + Promise we can race against to exit early
1142    // cancellation
1143    let reject;
1144    this.abortPromise = new Promise((_, r) => reject = r);
1145    this.controller = new AbortController();
1146    let onAbort = () => reject(new AbortedDeferredError("Deferred data aborted"));
1147    this.unlistenAbortSignal = () => this.controller.signal.removeEventListener("abort", onAbort);
1148    this.controller.signal.addEventListener("abort", onAbort);
1149    this.data = Object.entries(data).reduce((acc, _ref2) => {
1150      let [key, value] = _ref2;
1151      return Object.assign(acc, {
1152        [key]: this.trackPromise(key, value)
1153      });
1154    }, {});
1155    if (this.done) {
1156      // All incoming values were resolved
1157      this.unlistenAbortSignal();
1158    }
1159    this.init = responseInit;
1160  }
1161  trackPromise(key, value) {
1162    if (!(value instanceof Promise)) {
1163      return value;
1164    }
1165    this.deferredKeys.push(key);
1166    this.pendingKeysSet.add(key);
1167    // We store a little wrapper promise that will be extended with
1168    // _data/_error props upon resolve/reject
1169    let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, undefined, data), error => this.onSettle(promise, key, error));
1170    // Register rejection listeners to avoid uncaught promise rejections on
1171    // errors or aborted deferred values
1172    promise.catch(() => {});
1173    Object.defineProperty(promise, "_tracked", {
1174      get: () => true
1175    });
1176    return promise;
1177  }
1178  onSettle(promise, key, error, data) {
1179    if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {
1180      this.unlistenAbortSignal();
1181      Object.defineProperty(promise, "_error", {
1182        get: () => error
1183      });
1184      return Promise.reject(error);
1185    }
1186    this.pendingKeysSet.delete(key);
1187    if (this.done) {
1188      // Nothing left to abort!
1189      this.unlistenAbortSignal();
1190    }
1191    // If the promise was resolved/rejected with undefined, we'll throw an error as you
1192    // should always resolve with a value or null
1193    if (error === undefined && data === undefined) {
1194      let undefinedError = new Error("Deferred data for key \"" + key + "\" resolved/rejected with `undefined`, " + "you must resolve/reject with a value or `null`.");
1195      Object.defineProperty(promise, "_error", {
1196        get: () => undefinedError
1197      });
1198      this.emit(false, key);
1199      return Promise.reject(undefinedError);
1200    }
1201    if (data === undefined) {
1202      Object.defineProperty(promise, "_error", {
1203        get: () => error
1204      });
1205      this.emit(false, key);
1206      return Promise.reject(error);
1207    }
1208    Object.defineProperty(promise, "_data", {
1209      get: () => data
1210    });
1211    this.emit(false, key);
1212    return data;
1213  }
1214  emit(aborted, settledKey) {
1215    this.subscribers.forEach(subscriber => subscriber(aborted, settledKey));
1216  }
1217  subscribe(fn) {
1218    this.subscribers.add(fn);
1219    return () => this.subscribers.delete(fn);
1220  }
1221  cancel() {
1222    this.controller.abort();
1223    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));
1224    this.emit(true);
1225  }
1226  async resolveData(signal) {
1227    let aborted = false;
1228    if (!this.done) {
1229      let onAbort = () => this.cancel();
1230      signal.addEventListener("abort", onAbort);
1231      aborted = await new Promise(resolve => {
1232        this.subscribe(aborted => {
1233          signal.removeEventListener("abort", onAbort);
1234          if (aborted || this.done) {
1235            resolve(aborted);
1236          }
1237        });
1238      });
1239    }
1240    return aborted;
1241  }
1242  get done() {
1243    return this.pendingKeysSet.size === 0;
1244  }
1245  get unwrappedData() {
1246    invariant(this.data !== null && this.done, "Can only unwrap data on initialized and settled deferreds");
1247    return Object.entries(this.data).reduce((acc, _ref3) => {
1248      let [key, value] = _ref3;
1249      return Object.assign(acc, {
1250        [key]: unwrapTrackedPromise(value)
1251      });
1252    }, {});
1253  }
1254  get pendingKeys() {
1255    return Array.from(this.pendingKeysSet);
1256  }
1257}
1258function isTrackedPromise(value) {
1259  return value instanceof Promise && value._tracked === true;
1260}
1261function unwrapTrackedPromise(value) {
1262  if (!isTrackedPromise(value)) {
1263    return value;
1264  }
1265  if (value._error) {
1266    throw value._error;
1267  }
1268  return value._data;
1269}
1270/**
1271 * @deprecated The `defer` method is deprecated in favor of returning raw
1272 * objects. This method will be removed in v7.
1273 */
1274const defer = function defer(data, init) {
1275  if (init === void 0) {
1276    init = {};
1277  }
1278  let responseInit = typeof init === "number" ? {
1279    status: init
1280  } : init;
1281  return new DeferredData(data, responseInit);
1282};
1283/**
1284 * A redirect response. Sets the status code and the `Location` header.
1285 * Defaults to "302 Found".
1286 */
1287const redirect = function redirect(url, init) {
1288  if (init === void 0) {
1289    init = 302;
1290  }
1291  let responseInit = init;
1292  if (typeof responseInit === "number") {
1293    responseInit = {
1294      status: responseInit
1295    };
1296  } else if (typeof responseInit.status === "undefined") {
1297    responseInit.status = 302;
1298  }
1299  let headers = new Headers(responseInit.headers);
1300  headers.set("Location", url);
1301  return new Response(null, _extends({}, responseInit, {
1302    headers
1303  }));
1304};
1305/**
1306 * A redirect response that will force a document reload to the new location.
1307 * Sets the status code and the `Location` header.
1308 * Defaults to "302 Found".
1309 */
1310const redirectDocument = (url, init) => {
1311  let response = redirect(url, init);
1312  response.headers.set("X-Remix-Reload-Document", "true");
1313  return response;
1314};
1315/**
1316 * A redirect response that will perform a `history.replaceState` instead of a
1317 * `history.pushState` for client-side navigation redirects.
1318 * Sets the status code and the `Location` header.
1319 * Defaults to "302 Found".
1320 */
1321const replace = (url, init) => {
1322  let response = redirect(url, init);
1323  response.headers.set("X-Remix-Replace", "true");
1324  return response;
1325};
1326/**
1327 * @private
1328 * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies
1329 *
1330 * We don't export the class for public use since it's an implementation
1331 * detail, but we export the interface above so folks can build their own
1332 * abstractions around instances via isRouteErrorResponse()
1333 */
1334class ErrorResponseImpl {
1335  constructor(status, statusText, data, internal) {
1336    if (internal === void 0) {
1337      internal = false;
1338    }
1339    this.status = status;
1340    this.statusText = statusText || "";
1341    this.internal = internal;
1342    if (data instanceof Error) {
1343      this.data = data.toString();
1344      this.error = data;
1345    } else {
1346      this.data = data;
1347    }
1348  }
1349}
1350/**
1351 * Check if the given error is an ErrorResponse generated from a 4xx/5xx
1352 * Response thrown from an action/loader
1353 */
1354function isRouteErrorResponse(error) {
1355  return error != null && typeof error.status === "number" && typeof error.statusText === "string" && typeof error.internal === "boolean" && "data" in error;
1356}
1357
1358const validMutationMethodsArr = ["post", "put", "patch", "delete"];
1359const validMutationMethods = new Set(validMutationMethodsArr);
1360const validRequestMethodsArr = ["get", ...validMutationMethodsArr];
1361const validRequestMethods = new Set(validRequestMethodsArr);
1362const redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
1363const redirectPreserveMethodStatusCodes = new Set([307, 308]);
1364const IDLE_NAVIGATION = {
1365  state: "idle",
1366  location: undefined,
1367  formMethod: undefined,
1368  formAction: undefined,
1369  formEncType: undefined,
1370  formData: undefined,
1371  json: undefined,
1372  text: undefined
1373};
1374const IDLE_FETCHER = {
1375  state: "idle",
1376  data: undefined,
1377  formMethod: undefined,
1378  formAction: undefined,
1379  formEncType: undefined,
1380  formData: undefined,
1381  json: undefined,
1382  text: undefined
1383};
1384const IDLE_BLOCKER = {
1385  state: "unblocked",
1386  proceed: undefined,
1387  reset: undefined,
1388  location: undefined
1389};
1390const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
1391const defaultMapRouteProperties = route => ({
1392  hasErrorBoundary: Boolean(route.hasErrorBoundary)
1393});
1394const TRANSITIONS_STORAGE_KEY = "remix-router-transitions";
1395//#endregion
1396////////////////////////////////////////////////////////////////////////////////
1397//#region createRouter
1398////////////////////////////////////////////////////////////////////////////////
1399/**
1400 * Create a router and listen to history POP navigations
1401 */
1402function createRouter(init) {
1403  const routerWindow = init.window ? init.window : typeof window !== "undefined" ? window : undefined;
1404  const isBrowser = typeof routerWindow !== "undefined" && typeof routerWindow.document !== "undefined" && typeof routerWindow.document.createElement !== "undefined";
1405  const isServer = !isBrowser;
1406  invariant(init.routes.length > 0, "You must provide a non-empty routes array to createRouter");
1407  let mapRouteProperties;
1408  if (init.mapRouteProperties) {
1409    mapRouteProperties = init.mapRouteProperties;
1410  } else if (init.detectErrorBoundary) {
1411    // If they are still using the deprecated version, wrap it with the new API
1412    let detectErrorBoundary = init.detectErrorBoundary;
1413    mapRouteProperties = route => ({
1414      hasErrorBoundary: detectErrorBoundary(route)
1415    });
1416  } else {
1417    mapRouteProperties = defaultMapRouteProperties;
1418  }
1419  // Routes keyed by ID
1420  let manifest = {};
1421  // Routes in tree format for matching
1422  let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties, undefined, manifest);
1423  let inFlightDataRoutes;
1424  let basename = init.basename || "/";
1425  let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;
1426  let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;
1427  // Config driven behavior flags
1428  let future = _extends({
1429    v7_fetcherPersist: false,
1430    v7_normalizeFormMethod: false,
1431    v7_partialHydration: false,
1432    v7_prependBasename: false,
1433    v7_relativeSplatPath: false,
1434    v7_skipActionErrorRevalidation: false
1435  }, init.future);
1436  // Cleanup function for history
1437  let unlistenHistory = null;
1438  // Externally-provided functions to call on all state changes
1439  let subscribers = new Set();
1440  // Externally-provided object to hold scroll restoration locations during routing
1441  let savedScrollPositions = null;
1442  // Externally-provided function to get scroll restoration keys
1443  let getScrollRestorationKey = null;
1444  // Externally-provided function to get current scroll position
1445  let getScrollPosition = null;
1446  // One-time flag to control the initial hydration scroll restoration.  Because
1447  // we don't get the saved positions from <ScrollRestoration /> until _after_
1448  // the initial render, we need to manually trigger a separate updateState to
1449  // send along the restoreScrollPosition
1450  // Set to true if we have `hydrationData` since we assume we were SSR'd and that
1451  // SSR did the initial scroll restoration.
1452  let initialScrollRestored = init.hydrationData != null;
1453  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);
1454  let initialErrors = null;
1455  if (initialMatches == null && !patchRoutesOnNavigationImpl) {
1456    // If we do not match a user-provided-route, fall back to the root
1457    // to allow the error boundary to take over
1458    let error = getInternalRouterError(404, {
1459      pathname: init.history.location.pathname
1460    });
1461    let {
1462      matches,
1463      route
1464    } = getShortCircuitMatches(dataRoutes);
1465    initialMatches = matches;
1466    initialErrors = {
1467      [route.id]: error
1468    };
1469  }
1470  // In SPA apps, if the user provided a patchRoutesOnNavigation implementation and
1471  // our initial match is a splat route, clear them out so we run through lazy
1472  // discovery on hydration in case there's a more accurate lazy route match.
1473  // In SSR apps (with `hydrationData`), we expect that the server will send
1474  // up the proper matched routes so we don't want to run lazy discovery on
1475  // initial hydration and want to hydrate into the splat route.
1476  if (initialMatches && !init.hydrationData) {
1477    let fogOfWar = checkFogOfWar(initialMatches, dataRoutes, init.history.location.pathname);
1478    if (fogOfWar.active) {
1479      initialMatches = null;
1480    }
1481  }
1482  let initialized;
1483  if (!initialMatches) {
1484    initialized = false;
1485    initialMatches = [];
1486    // If partial hydration and fog of war is enabled, we will be running
1487    // `patchRoutesOnNavigation` during hydration so include any partial matches as
1488    // the initial matches so we can properly render `HydrateFallback`'s
1489    if (future.v7_partialHydration) {
1490      let fogOfWar = checkFogOfWar(null, dataRoutes, init.history.location.pathname);
1491      if (fogOfWar.active && fogOfWar.matches) {
1492        initialMatches = fogOfWar.matches;
1493      }
1494    }
1495  } else if (initialMatches.some(m => m.route.lazy)) {
1496    // All initialMatches need to be loaded before we're ready.  If we have lazy
1497    // functions around still then we'll need to run them in initialize()
1498    initialized = false;
1499  } else if (!initialMatches.some(m => m.route.loader)) {
1500    // If we've got no loaders to run, then we're good to go
1501    initialized = true;
1502  } else if (future.v7_partialHydration) {
1503    // If partial hydration is enabled, we're initialized so long as we were
1504    // provided with hydrationData for every route with a loader, and no loaders
1505    // were marked for explicit hydration
1506    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;
1507    let errors = init.hydrationData ? init.hydrationData.errors : null;
1508    // If errors exist, don't consider routes below the boundary
1509    if (errors) {
1510      let idx = initialMatches.findIndex(m => errors[m.route.id] !== undefined);
1511      initialized = initialMatches.slice(0, idx + 1).every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));
1512    } else {
1513      initialized = initialMatches.every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));
1514    }
1515  } else {
1516    // Without partial hydration - we're initialized if we were provided any
1517    // hydrationData - which is expected to be complete
1518    initialized = init.hydrationData != null;
1519  }
1520  let router;
1521  let state = {
1522    historyAction: init.history.action,
1523    location: init.history.location,
1524    matches: initialMatches,
1525    initialized,
1526    navigation: IDLE_NAVIGATION,
1527    // Don't restore on initial updateState() if we were SSR'd
1528    restoreScrollPosition: init.hydrationData != null ? false : null,
1529    preventScrollReset: false,
1530    revalidation: "idle",
1531    loaderData: init.hydrationData && init.hydrationData.loaderData || {},
1532    actionData: init.hydrationData && init.hydrationData.actionData || null,
1533    errors: init.hydrationData && init.hydrationData.errors || initialErrors,
1534    fetchers: new Map(),
1535    blockers: new Map()
1536  };
1537  // -- Stateful internal variables to manage navigations --
1538  // Current navigation in progress (to be committed in completeNavigation)
1539  let pendingAction = Action.Pop;
1540  // Should the current navigation prevent the scroll reset if scroll cannot
1541  // be restored?
1542  let pendingPreventScrollReset = false;
1543  // AbortController for the active navigation
1544  let pendingNavigationController;
1545  // Should the current navigation enable document.startViewTransition?
1546  let pendingViewTransitionEnabled = false;
1547  // Store applied view transitions so we can apply them on POP
1548  let appliedViewTransitions = new Map();
1549  // Cleanup function for persisting applied transitions to sessionStorage
1550  let removePageHideEventListener = null;
1551  // We use this to avoid touching history in completeNavigation if a
1552  // revalidation is entirely uninterrupted
1553  let isUninterruptedRevalidation = false;
1554  // Use this internal flag to force revalidation of all loaders:
1555  //  - submissions (completed or interrupted)
1556  //  - useRevalidator()
1557  //  - X-Remix-Revalidate (from redirect)
1558  let isRevalidationRequired = false;
1559  // Use this internal array to capture routes that require revalidation due
1560  // to a cancelled deferred on action submission
1561  let cancelledDeferredRoutes = [];
1562  // Use this internal array to capture fetcher loads that were cancelled by an
1563  // action navigation and require revalidation
1564  let cancelledFetcherLoads = new Set();
1565  // AbortControllers for any in-flight fetchers
1566  let fetchControllers = new Map();
1567  // Track loads based on the order in which they started
1568  let incrementingLoadId = 0;
1569  // Track the outstanding pending navigation data load to be compared against
1570  // the globally incrementing load when a fetcher load lands after a completed
1571  // navigation
1572  let pendingNavigationLoadId = -1;
1573  // Fetchers that triggered data reloads as a result of their actions
1574  let fetchReloadIds = new Map();
1575  // Fetchers that triggered redirect navigations
1576  let fetchRedirectIds = new Set();
1577  // Most recent href/match for fetcher.load calls for fetchers
1578  let fetchLoadMatches = new Map();
1579  // Ref-count mounted fetchers so we know when it's ok to clean them up
1580  let activeFetchers = new Map();
1581  // Fetchers that have requested a delete when using v7_fetcherPersist,
1582  // they'll be officially removed after they return to idle
1583  let deletedFetchers = new Set();
1584  // Store DeferredData instances for active route matches.  When a
1585  // route loader returns defer() we stick one in here.  Then, when a nested
1586  // promise resolves we update loaderData.  If a new navigation starts we
1587  // cancel active deferreds for eliminated routes.
1588  let activeDeferreds = new Map();
1589  // Store blocker functions in a separate Map outside of router state since
1590  // we don't need to update UI state if they change
1591  let blockerFunctions = new Map();
1592  // Flag to ignore the next history update, so we can revert the URL change on
1593  // a POP navigation that was blocked by the user without touching router state
1594  let unblockBlockerHistoryUpdate = undefined;
1595  // Initialize the router, all side effects should be kicked off from here.
1596  // Implemented as a Fluent API for ease of:
1597  //   let router = createRouter(init).initialize();
1598  function initialize() {
1599    // If history informs us of a POP navigation, start the navigation but do not update
1600    // state.  We'll update our own state once the navigation completes
1601    unlistenHistory = init.history.listen(_ref => {
1602      let {
1603        action: historyAction,
1604        location,
1605        delta
1606      } = _ref;
1607      // Ignore this event if it was just us resetting the URL from a
1608      // blocked POP navigation
1609      if (unblockBlockerHistoryUpdate) {
1610        unblockBlockerHistoryUpdate();
1611        unblockBlockerHistoryUpdate = undefined;
1612        return;
1613      }
1614      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.");
1615      let blockerKey = shouldBlockNavigation({
1616        currentLocation: state.location,
1617        nextLocation: location,
1618        historyAction
1619      });
1620      if (blockerKey && delta != null) {
1621        // Restore the URL to match the current UI, but don't update router state
1622        let nextHistoryUpdatePromise = new Promise(resolve => {
1623          unblockBlockerHistoryUpdate = resolve;
1624        });
1625        init.history.go(delta * -1);
1626        // Put the blocker into a blocked state
1627        updateBlocker(blockerKey, {
1628          state: "blocked",
1629          location,
1630          proceed() {
1631            updateBlocker(blockerKey, {
1632              state: "proceeding",
1633              proceed: undefined,
1634              reset: undefined,
1635              location
1636            });
1637            // Re-do the same POP navigation we just blocked, after the url
1638            // restoration is also complete.  See:
1639            // https://github.com/remix-run/react-router/issues/11613
1640            nextHistoryUpdatePromise.then(() => init.history.go(delta));
1641          },
1642          reset() {
1643            let blockers = new Map(state.blockers);
1644            blockers.set(blockerKey, IDLE_BLOCKER);
1645            updateState({
1646              blockers
1647            });
1648          }
1649        });
1650        return;
1651      }
1652      return startNavigation(historyAction, location);
1653    });
1654    if (isBrowser) {
1655      // FIXME: This feels gross.  How can we cleanup the lines between
1656      // scrollRestoration/appliedTransitions persistance?
1657      restoreAppliedTransitions(routerWindow, appliedViewTransitions);
1658      let _saveAppliedTransitions = () => persistAppliedTransitions(routerWindow, appliedViewTransitions);
1659      routerWindow.addEventListener("pagehide", _saveAppliedTransitions);
1660      removePageHideEventListener = () => routerWindow.removeEventListener("pagehide", _saveAppliedTransitions);
1661    }
1662    // Kick off initial data load if needed.  Use Pop to avoid modifying history
1663    // Note we don't do any handling of lazy here.  For SPA's it'll get handled
1664    // in the normal navigation flow.  For SSR it's expected that lazy modules are
1665    // resolved prior to router creation since we can't go into a fallbackElement
1666    // UI for SSR'd apps
1667    if (!state.initialized) {
1668      startNavigation(Action.Pop, state.location, {
1669        initialHydration: true
1670      });
1671    }
1672    return router;
1673  }
1674  // Clean up a router and it's side effects
1675  function dispose() {
1676    if (unlistenHistory) {
1677      unlistenHistory();
1678    }
1679    if (removePageHideEventListener) {
1680      removePageHideEventListener();
1681    }
1682    subscribers.clear();
1683    pendingNavigationController && pendingNavigationController.abort();
1684    state.fetchers.forEach((_, key) => deleteFetcher(key));
1685    state.blockers.forEach((_, key) => deleteBlocker(key));
1686  }
1687  // Subscribe to state updates for the router
1688  function subscribe(fn) {
1689    subscribers.add(fn);
1690    return () => subscribers.delete(fn);
1691  }
1692  // Update our state and notify the calling context of the change
1693  function updateState(newState, opts) {
1694    if (opts === void 0) {
1695      opts = {};
1696    }
1697    state = _extends({}, state, newState);
1698    // Prep fetcher cleanup so we can tell the UI which fetcher data entries
1699    // can be removed
1700    let completedFetchers = [];
1701    let deletedFetchersKeys = [];
1702    if (future.v7_fetcherPersist) {
1703      state.fetchers.forEach((fetcher, key) => {
1704        if (fetcher.state === "idle") {
1705          if (deletedFetchers.has(key)) {
1706            // Unmounted from the UI and can be totally removed
1707            deletedFetchersKeys.push(key);
1708          } else {
1709            // Returned to idle but still mounted in the UI, so semi-remains for
1710            // revalidations and such
1711            completedFetchers.push(key);
1712          }
1713        }
1714      });
1715    }
1716    // Iterate over a local copy so that if flushSync is used and we end up
1717    // removing and adding a new subscriber due to the useCallback dependencies,
1718    // we don't get ourselves into a loop calling the new subscriber immediately
1719    [...subscribers].forEach(subscriber => subscriber(state, {
1720      deletedFetchers: deletedFetchersKeys,
1721      viewTransitionOpts: opts.viewTransitionOpts,
1722      flushSync: opts.flushSync === true
1723    }));
1724    // Remove idle fetchers from state since we only care about in-flight fetchers.
1725    if (future.v7_fetcherPersist) {
1726      completedFetchers.forEach(key => state.fetchers.delete(key));
1727      deletedFetchersKeys.forEach(key => deleteFetcher(key));
1728    }
1729  }
1730  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION
1731  // and setting state.[historyAction/location/matches] to the new route.
1732  // - Location is a required param
1733  // - Navigation will always be set to IDLE_NAVIGATION
1734  // - Can pass any other state in newState
1735  function completeNavigation(location, newState, _temp) {
1736    var _location$state, _location$state2;
1737    let {
1738      flushSync
1739    } = _temp === void 0 ? {} : _temp;
1740    // Deduce if we're in a loading/actionReload state:
1741    // - We have committed actionData in the store
1742    // - The current navigation was a mutation submission
1743    // - We're past the submitting state and into the loading state
1744    // - The location being loaded is not the result of a redirect
1745    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;
1746    let actionData;
1747    if (newState.actionData) {
1748      if (Object.keys(newState.actionData).length > 0) {
1749        actionData = newState.actionData;
1750      } else {
1751        // Empty actionData -> clear prior actionData due to an action error
1752        actionData = null;
1753      }
1754    } else if (isActionReload) {
1755      // Keep the current data if we're wrapping up the action reload
1756      actionData = state.actionData;
1757    } else {
1758      // Clear actionData on any other completed navigations
1759      actionData = null;
1760    }
1761    // Always preserve any existing loaderData from re-used routes
1762    let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;
1763    // On a successful navigation we can assume we got through all blockers
1764    // so we can start fresh
1765    let blockers = state.blockers;
1766    if (blockers.size > 0) {
1767      blockers = new Map(blockers);
1768      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));
1769    }
1770    // Always respect the user flag.  Otherwise don't reset on mutation
1771    // submission navigations unless they redirect
1772    let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;
1773    // Commit any in-flight routes at the end of the HMR revalidation "navigation"
1774    if (inFlightDataRoutes) {
1775      dataRoutes = inFlightDataRoutes;
1776      inFlightDataRoutes = undefined;
1777    }
1778    if (isUninterruptedRevalidation) ; else if (pendingAction === Action.Pop) ; else if (pendingAction === Action.Push) {
1779      init.history.push(location, location.state);
1780    } else if (pendingAction === Action.Replace) {
1781      init.history.replace(location, location.state);
1782    }
1783    let viewTransitionOpts;
1784    // On POP, enable transitions if they were enabled on the original navigation
1785    if (pendingAction === Action.Pop) {
1786      // Forward takes precedence so they behave like the original navigation
1787      let priorPaths = appliedViewTransitions.get(state.location.pathname);
1788      if (priorPaths && priorPaths.has(location.pathname)) {
1789        viewTransitionOpts = {
1790          currentLocation: state.location,
1791          nextLocation: location
1792        };
1793      } else if (appliedViewTransitions.has(location.pathname)) {
1794        // If we don't have a previous forward nav, assume we're popping back to
1795        // the new location and enable if that location previously enabled
1796        viewTransitionOpts = {
1797          currentLocation: location,
1798          nextLocation: state.location
1799        };
1800      }
1801    } else if (pendingViewTransitionEnabled) {
1802      // Store the applied transition on PUSH/REPLACE
1803      let toPaths = appliedViewTransitions.get(state.location.pathname);
1804      if (toPaths) {
1805        toPaths.add(location.pathname);
1806      } else {
1807        toPaths = new Set([location.pathname]);
1808        appliedViewTransitions.set(state.location.pathname, toPaths);
1809      }
1810      viewTransitionOpts = {
1811        currentLocation: state.location,
1812        nextLocation: location
1813      };
1814    }
1815    updateState(_extends({}, newState, {
1816      actionData,
1817      loaderData,
1818      historyAction: pendingAction,
1819      location,
1820      initialized: true,
1821      navigation: IDLE_NAVIGATION,
1822      revalidation: "idle",
1823      restoreScrollPosition: getSavedScrollPosition(location, newState.matches || state.matches),
1824      preventScrollReset,
1825      blockers
1826    }), {
1827      viewTransitionOpts,
1828      flushSync: flushSync === true
1829    });
1830    // Reset stateful navigation vars
1831    pendingAction = Action.Pop;
1832    pendingPreventScrollReset = false;
1833    pendingViewTransitionEnabled = false;
1834    isUninterruptedRevalidation = false;
1835    isRevalidationRequired = false;
1836    cancelledDeferredRoutes = [];
1837  }
1838  // Trigger a navigation event, which can either be a numerical POP or a PUSH
1839  // replace with an optional submission
1840  async function navigate(to, opts) {
1841    if (typeof to === "number") {
1842      init.history.go(to);
1843      return;
1844    }
1845    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, to, future.v7_relativeSplatPath, opts == null ? void 0 : opts.fromRouteId, opts == null ? void 0 : opts.relative);
1846    let {
1847      path,
1848      submission,
1849      error
1850    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, false, normalizedPath, opts);
1851    let currentLocation = state.location;
1852    let nextLocation = createLocation(state.location, path, opts && opts.state);
1853    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded
1854    // URL from window.location, so we need to encode it here so the behavior
1855    // remains the same as POP and non-data-router usages.  new URL() does all
1856    // the same encoding we'd get from a history.pushState/window.location read
1857    // without having to touch history
1858    nextLocation = _extends({}, nextLocation, init.history.encodeLocation(nextLocation));
1859    let userReplace = opts && opts.replace != null ? opts.replace : undefined;
1860    let historyAction = Action.Push;
1861    if (userReplace === true) {
1862      historyAction = Action.Replace;
1863    } else if (userReplace === false) ; else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) {
1864      // By default on submissions to the current location we REPLACE so that
1865      // users don't have to double-click the back button to get to the prior
1866      // location.  If the user redirects to a different location from the
1867      // action/loader this will be ignored and the redirect will be a PUSH
1868      historyAction = Action.Replace;
1869    }
1870    let preventScrollReset = opts && "preventScrollReset" in opts ? opts.preventScrollReset === true : undefined;
1871    let flushSync = (opts && opts.flushSync) === true;
1872    let blockerKey = shouldBlockNavigation({
1873      currentLocation,
1874      nextLocation,
1875      historyAction
1876    });
1877    if (blockerKey) {
1878      // Put the blocker into a blocked state
1879      updateBlocker(blockerKey, {
1880        state: "blocked",
1881        location: nextLocation,
1882        proceed() {
1883          updateBlocker(blockerKey, {
1884            state: "proceeding",
1885            proceed: undefined,
1886            reset: undefined,
1887            location: nextLocation
1888          });
1889          // Send the same navigation through
1890          navigate(to, opts);
1891        },
1892        reset() {
1893          let blockers = new Map(state.blockers);
1894          blockers.set(blockerKey, IDLE_BLOCKER);
1895          updateState({
1896            blockers
1897          });
1898        }
1899      });
1900      return;
1901    }
1902    return await startNavigation(historyAction, nextLocation, {
1903      submission,
1904      // Send through the formData serialization error if we have one so we can
1905      // render at the right error boundary after we match routes
1906      pendingError: error,
1907      preventScrollReset,
1908      replace: opts && opts.replace,
1909      enableViewTransition: opts && opts.viewTransition,
1910      flushSync
1911    });
1912  }
1913  // Revalidate all current loaders.  If a navigation is in progress or if this
1914  // is interrupted by a navigation, allow this to "succeed" by calling all
1915  // loaders during the next loader round
1916  function revalidate() {
1917    interruptActiveLoads();
1918    updateState({
1919      revalidation: "loading"
1920    });
1921    // If we're currently submitting an action, we don't need to start a new
1922    // navigation, we'll just let the follow up loader execution call all loaders
1923    if (state.navigation.state === "submitting") {
1924      return;
1925    }
1926    // If we're currently in an idle state, start a new navigation for the current
1927    // action/location and mark it as uninterrupted, which will skip the history
1928    // update in completeNavigation
1929    if (state.navigation.state === "idle") {
1930      startNavigation(state.historyAction, state.location, {
1931        startUninterruptedRevalidation: true
1932      });
1933      return;
1934    }
1935    // Otherwise, if we're currently in a loading state, just start a new
1936    // navigation to the navigation.location but do not trigger an uninterrupted
1937    // revalidation so that history correctly updates once the navigation completes
1938    startNavigation(pendingAction || state.historyAction, state.navigation.location, {
1939      overrideNavigation: state.navigation,
1940      // Proxy through any rending view transition
1941      enableViewTransition: pendingViewTransitionEnabled === true
1942    });
1943  }
1944  // Start a navigation to the given action/location.  Can optionally provide a
1945  // overrideNavigation which will override the normalLoad in the case of a redirect
1946  // navigation
1947  async function startNavigation(historyAction, location, opts) {
1948    // Abort any in-progress navigations and start a new one. Unset any ongoing
1949    // uninterrupted revalidations unless told otherwise, since we want this
1950    // new navigation to update history normally
1951    pendingNavigationController && pendingNavigationController.abort();
1952    pendingNavigationController = null;
1953    pendingAction = historyAction;
1954    isUninterruptedRevalidation = (opts && opts.startUninterruptedRevalidation) === true;
1955    // Save the current scroll position every time we start a new navigation,
1956    // and track whether we should reset scroll on completion
1957    saveScrollPosition(state.location, state.matches);
1958    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
1959    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;
1960    let routesToUse = inFlightDataRoutes || dataRoutes;
1961    let loadingNavigation = opts && opts.overrideNavigation;
1962    let matches = matchRoutes(routesToUse, location, basename);
1963    let flushSync = (opts && opts.flushSync) === true;
1964    let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);
1965    if (fogOfWar.active && fogOfWar.matches) {
1966      matches = fogOfWar.matches;
1967    }
1968    // Short circuit with a 404 on the root error boundary if we match nothing
1969    if (!matches) {
1970      let {
1971        error,
1972        notFoundMatches,
1973        route
1974      } = handleNavigational404(location.pathname);
1975      completeNavigation(location, {
1976        matches: notFoundMatches,
1977        loaderData: {},
1978        errors: {
1979          [route.id]: error
1980        }
1981      }, {
1982        flushSync
1983      });
1984      return;
1985    }
1986    // Short circuit if it's only a hash change and not a revalidation or
1987    // mutation submission.
1988    //
1989    // Ignore on initial page loads because since the initial hydration will always
1990    // be "same hash".  For example, on /page#hash and submit a <Form method="post">
1991    // which will default to a navigation to /page
1992    if (state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {
1993      completeNavigation(location, {
1994        matches
1995      }, {
1996        flushSync
1997      });
1998      return;
1999    }
2000    // Create a controller/Request for this navigation
2001    pendingNavigationController = new AbortController();
2002    let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);
2003    let pendingActionResult;
2004    if (opts && opts.pendingError) {
2005      // If we have a pendingError, it means the user attempted a GET submission
2006      // with binary FormData so assign here and skip to handleLoaders.  That
2007      // way we handle calling loaders above the boundary etc.  It's not really
2008      // different from an actionError in that sense.
2009      pendingActionResult = [findNearestBoundary(matches).route.id, {
2010        type: ResultType.error,
2011        error: opts.pendingError
2012      }];
2013    } else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {
2014      // Call action if we received an action submission
2015      let actionResult = await handleAction(request, location, opts.submission, matches, fogOfWar.active, {
2016        replace: opts.replace,
2017        flushSync
2018      });
2019      if (actionResult.shortCircuited) {
2020        return;
2021      }
2022      // If we received a 404 from handleAction, it's because we couldn't lazily
2023      // discover the destination route so we don't want to call loaders
2024      if (actionResult.pendingActionResult) {
2025        let [routeId, result] = actionResult.pendingActionResult;
2026        if (isErrorResult(result) && isRouteErrorResponse(result.error) && result.error.status === 404) {
2027          pendingNavigationController = null;
2028          completeNavigation(location, {
2029            matches: actionResult.matches,
2030            loaderData: {},
2031            errors: {
2032              [routeId]: result.error
2033            }
2034          });
2035          return;
2036        }
2037      }
2038      matches = actionResult.matches || matches;
2039      pendingActionResult = actionResult.pendingActionResult;
2040      loadingNavigation = getLoadingNavigation(location, opts.submission);
2041      flushSync = false;
2042      // No need to do fog of war matching again on loader execution
2043      fogOfWar.active = false;
2044      // Create a GET request for the loaders
2045      request = createClientSideRequest(init.history, request.url, request.signal);
2046    }
2047    // Call loaders
2048    let {
2049      shortCircuited,
2050      matches: updatedMatches,
2051      loaderData,
2052      errors
2053    } = await handleLoaders(request, location, matches, fogOfWar.active, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult);
2054    if (shortCircuited) {
2055      return;
2056    }
2057    // Clean up now that the action/loaders have completed.  Don't clean up if
2058    // we short circuited because pendingNavigationController will have already
2059    // been assigned to a new controller for the next navigation
2060    pendingNavigationController = null;
2061    completeNavigation(location, _extends({
2062      matches: updatedMatches || matches
2063    }, getActionDataForCommit(pendingActionResult), {
2064      loaderData,
2065      errors
2066    }));
2067  }
2068  // Call the action matched by the leaf route for this navigation and handle
2069  // redirects/errors
2070  async function handleAction(request, location, submission, matches, isFogOfWar, opts) {
2071    if (opts === void 0) {
2072      opts = {};
2073    }
2074    interruptActiveLoads();
2075    // Put us in a submitting state
2076    let navigation = getSubmittingNavigation(location, submission);
2077    updateState({
2078      navigation
2079    }, {
2080      flushSync: opts.flushSync === true
2081    });
2082    if (isFogOfWar) {
2083      let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
2084      if (discoverResult.type === "aborted") {
2085        return {
2086          shortCircuited: true
2087        };
2088      } else if (discoverResult.type === "error") {
2089        let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
2090        return {
2091          matches: discoverResult.partialMatches,
2092          pendingActionResult: [boundaryId, {
2093            type: ResultType.error,
2094            error: discoverResult.error
2095          }]
2096        };
2097      } else if (!discoverResult.matches) {
2098        let {
2099          notFoundMatches,
2100          error,
2101          route
2102        } = handleNavigational404(location.pathname);
2103        return {
2104          matches: notFoundMatches,
2105          pendingActionResult: [route.id, {
2106            type: ResultType.error,
2107            error
2108          }]
2109        };
2110      } else {
2111        matches = discoverResult.matches;
2112      }
2113    }
2114    // Call our action and get the result
2115    let result;
2116    let actionMatch = getTargetMatch(matches, location);
2117    if (!actionMatch.route.action && !actionMatch.route.lazy) {
2118      result = {
2119        type: ResultType.error,
2120        error: getInternalRouterError(405, {
2121          method: request.method,
2122          pathname: location.pathname,
2123          routeId: actionMatch.route.id
2124        })
2125      };
2126    } else {
2127      let results = await callDataStrategy("action", state, request, [actionMatch], matches, null);
2128      result = results[actionMatch.route.id];
2129      if (request.signal.aborted) {
2130        return {
2131          shortCircuited: true
2132        };
2133      }
2134    }
2135    if (isRedirectResult(result)) {
2136      let replace;
2137      if (opts && opts.replace != null) {
2138        replace = opts.replace;
2139      } else {
2140        // If the user didn't explicity indicate replace behavior, replace if
2141        // we redirected to the exact same location we're currently at to avoid
2142        // double back-buttons
2143        let location = normalizeRedirectLocation(result.response.headers.get("Location"), new URL(request.url), basename);
2144        replace = location === state.location.pathname + state.location.search;
2145      }
2146      await startRedirectNavigation(request, result, true, {
2147        submission,
2148        replace
2149      });
2150      return {
2151        shortCircuited: true
2152      };
2153    }
2154    if (isDeferredResult(result)) {
2155      throw getInternalRouterError(400, {
2156        type: "defer-action"
2157      });
2158    }
2159    if (isErrorResult(result)) {
2160      // Store off the pending error - we use it to determine which loaders
2161      // to call and will commit it when we complete the navigation
2162      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);
2163      // By default, all submissions to the current location are REPLACE
2164      // navigations, but if the action threw an error that'll be rendered in
2165      // an errorElement, we fall back to PUSH so that the user can use the
2166      // back button to get back to the pre-submission form location to try
2167      // again
2168      if ((opts && opts.replace) !== true) {
2169        pendingAction = Action.Push;
2170      }
2171      return {
2172        matches,
2173        pendingActionResult: [boundaryMatch.route.id, result]
2174      };
2175    }
2176    return {
2177      matches,
2178      pendingActionResult: [actionMatch.route.id, result]
2179    };
2180  }
2181  // Call all applicable loaders for the given matches, handling redirects,
2182  // errors, etc.
2183  async function handleLoaders(request, location, matches, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult) {
2184    // Figure out the right navigation we want to use for data loading
2185    let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);
2186    // If this was a redirect from an action we don't have a "submission" but
2187    // we have it on the loading navigation so use that if available
2188    let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);
2189    // If this is an uninterrupted revalidation, we remain in our current idle
2190    // state.  If not, we need to switch to our loading state and load data,
2191    // preserving any new action data or existing action data (in the case of
2192    // a revalidation interrupting an actionReload)
2193    // If we have partialHydration enabled, then don't update the state for the
2194    // initial data load since it's not a "navigation"
2195    let shouldUpdateNavigationState = !isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration);
2196    // When fog of war is enabled, we enter our `loading` state earlier so we
2197    // can discover new routes during the `loading` state.  We skip this if
2198    // we've already run actions since we would have done our matching already.
2199    // If the children() function threw then, we want to proceed with the
2200    // partial matches it discovered.
2201    if (isFogOfWar) {
2202      if (shouldUpdateNavigationState) {
2203        let actionData = getUpdatedActionData(pendingActionResult);
2204        updateState(_extends({
2205          navigation: loadingNavigation
2206        }, actionData !== undefined ? {
2207          actionData
2208        } : {}), {
2209          flushSync
2210        });
2211      }
2212      let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
2213      if (discoverResult.type === "aborted") {
2214        return {
2215          shortCircuited: true
2216        };
2217      } else if (discoverResult.type === "error") {
2218        let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
2219        return {
2220          matches: discoverResult.partialMatches,
2221          loaderData: {},
2222          errors: {
2223            [boundaryId]: discoverResult.error
2224          }
2225        };
2226      } else if (!discoverResult.matches) {
2227        let {
2228          error,
2229          notFoundMatches,
2230          route
2231        } = handleNavigational404(location.pathname);
2232        return {
2233          matches: notFoundMatches,
2234          loaderData: {},
2235          errors: {
2236            [route.id]: error
2237          }
2238        };
2239      } else {
2240        matches = discoverResult.matches;
2241      }
2242    }
2243    let routesToUse = inFlightDataRoutes || dataRoutes;
2244    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult);
2245    // Cancel pending deferreds for no-longer-matched routes or routes we're
2246    // about to reload.  Note that if this is an action reload we would have
2247    // already cancelled all pending deferreds so this would be a no-op
2248    cancelActiveDeferreds(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId));
2249    pendingNavigationLoadId = ++incrementingLoadId;
2250    // Short circuit if we have no loaders to run
2251    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {
2252      let updatedFetchers = markFetchRedirectsDone();
2253      completeNavigation(location, _extends({
2254        matches,
2255        loaderData: {},
2256        // Commit pending error if we're short circuiting
2257        errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {
2258          [pendingActionResult[0]]: pendingActionResult[1].error
2259        } : null
2260      }, getActionDataForCommit(pendingActionResult), updatedFetchers ? {
2261        fetchers: new Map(state.fetchers)
2262      } : {}), {
2263        flushSync
2264      });
2265      return {
2266        shortCircuited: true
2267      };
2268    }
2269    if (shouldUpdateNavigationState) {
2270      let updates = {};
2271      if (!isFogOfWar) {
2272        // Only update navigation/actionNData if we didn't already do it above
2273        updates.navigation = loadingNavigation;
2274        let actionData = getUpdatedActionData(pendingActionResult);
2275        if (actionData !== undefined) {
2276          updates.actionData = actionData;
2277        }
2278      }
2279      if (revalidatingFetchers.length > 0) {
2280        updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);
2281      }
2282      updateState(updates, {
2283        flushSync
2284      });
2285    }
2286    revalidatingFetchers.forEach(rf => {
2287      abortFetcher(rf.key);
2288      if (rf.controller) {
2289        // Fetchers use an independent AbortController so that aborting a fetcher
2290        // (via deleteFetcher) does not abort the triggering navigation that
2291        // triggered the revalidation
2292        fetchControllers.set(rf.key, rf.controller);
2293      }
2294    });
2295    // Proxy navigation abort through to revalidation fetchers
2296    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(f => abortFetcher(f.key));
2297    if (pendingNavigationController) {
2298      pendingNavigationController.signal.addEventListener("abort", abortPendingFetchRevalidations);
2299    }
2300    let {
2301      loaderResults,
2302      fetcherResults
2303    } = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, request);
2304    if (request.signal.aborted) {
2305      return {
2306        shortCircuited: true
2307      };
2308    }
2309    // Clean up _after_ loaders have completed.  Don't clean up if we short
2310    // circuited because fetchControllers would have been aborted and
2311    // reassigned to new controllers for the next navigation
2312    if (pendingNavigationController) {
2313      pendingNavigationController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
2314    }
2315    revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key));
2316    // If any loaders returned a redirect Response, start a new REPLACE navigation
2317    let redirect = findRedirect(loaderResults);
2318    if (redirect) {
2319      await startRedirectNavigation(request, redirect.result, true, {
2320        replace
2321      });
2322      return {
2323        shortCircuited: true
2324      };
2325    }
2326    redirect = findRedirect(fetcherResults);
2327    if (redirect) {
2328      // If this redirect came from a fetcher make sure we mark it in
2329      // fetchRedirectIds so it doesn't get revalidated on the next set of
2330      // loader executions
2331      fetchRedirectIds.add(redirect.key);
2332      await startRedirectNavigation(request, redirect.result, true, {
2333        replace
2334      });
2335      return {
2336        shortCircuited: true
2337      };
2338    }
2339    // Process and commit output from loaders
2340    let {
2341      loaderData,
2342      errors
2343    } = processLoaderData(state, matches, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds);
2344    // Wire up subscribers to update loaderData as promises settle
2345    activeDeferreds.forEach((deferredData, routeId) => {
2346      deferredData.subscribe(aborted => {
2347        // Note: No need to updateState here since the TrackedPromise on
2348        // loaderData is stable across resolve/reject
2349        // Remove this instance if we were aborted or if promises have settled
2350        if (aborted || deferredData.done) {
2351          activeDeferreds.delete(routeId);
2352        }
2353      });
2354    });
2355    // Preserve SSR errors during partial hydration
2356    if (future.v7_partialHydration && initialHydration && state.errors) {
2357      errors = _extends({}, state.errors, errors);
2358    }
2359    let updatedFetchers = markFetchRedirectsDone();
2360    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);
2361    let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;
2362    return _extends({
2363      matches,
2364      loaderData,
2365      errors
2366    }, shouldUpdateFetchers ? {
2367      fetchers: new Map(state.fetchers)
2368    } : {});
2369  }
2370  function getUpdatedActionData(pendingActionResult) {
2371    if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {
2372      // This is cast to `any` currently because `RouteData`uses any and it
2373      // would be a breaking change to use any.
2374      // TODO: v7 - change `RouteData` to use `unknown` instead of `any`
2375      return {
2376        [pendingActionResult[0]]: pendingActionResult[1].data
2377      };
2378    } else if (state.actionData) {
2379      if (Object.keys(state.actionData).length === 0) {
2380        return null;
2381      } else {
2382        return state.actionData;
2383      }
2384    }
2385  }
2386  function getUpdatedRevalidatingFetchers(revalidatingFetchers) {
2387    revalidatingFetchers.forEach(rf => {
2388      let fetcher = state.fetchers.get(rf.key);
2389      let revalidatingFetcher = getLoadingFetcher(undefined, fetcher ? fetcher.data : undefined);
2390      state.fetchers.set(rf.key, revalidatingFetcher);
2391    });
2392    return new Map(state.fetchers);
2393  }
2394  // Trigger a fetcher load/submit for the given fetcher key
2395  function fetch(key, routeId, href, opts) {
2396    if (isServer) {
2397      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.");
2398    }
2399    abortFetcher(key);
2400    let flushSync = (opts && opts.flushSync) === true;
2401    let routesToUse = inFlightDataRoutes || dataRoutes;
2402    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, future.v7_relativeSplatPath, routeId, opts == null ? void 0 : opts.relative);
2403    let matches = matchRoutes(routesToUse, normalizedPath, basename);
2404    let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);
2405    if (fogOfWar.active && fogOfWar.matches) {
2406      matches = fogOfWar.matches;
2407    }
2408    if (!matches) {
2409      setFetcherError(key, routeId, getInternalRouterError(404, {
2410        pathname: normalizedPath
2411      }), {
2412        flushSync
2413      });
2414      return;
2415    }
2416    let {
2417      path,
2418      submission,
2419      error
2420    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, true, normalizedPath, opts);
2421    if (error) {
2422      setFetcherError(key, routeId, error, {
2423        flushSync
2424      });
2425      return;
2426    }
2427    let match = getTargetMatch(matches, path);
2428    let preventScrollReset = (opts && opts.preventScrollReset) === true;
2429    if (submission && isMutationMethod(submission.formMethod)) {
2430      handleFetcherAction(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);
2431      return;
2432    }
2433    // Store off the match so we can call it's shouldRevalidate on subsequent
2434    // revalidations
2435    fetchLoadMatches.set(key, {
2436      routeId,
2437      path
2438    });
2439    handleFetcherLoader(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);
2440  }
2441  // Call the action for the matched fetcher.submit(), and then handle redirects,
2442  // errors, and revalidation
2443  async function handleFetcherAction(key, routeId, path, match, requestMatches, isFogOfWar, flushSync, preventScrollReset, submission) {
2444    interruptActiveLoads();
2445    fetchLoadMatches.delete(key);
2446    function detectAndHandle405Error(m) {
2447      if (!m.route.action && !m.route.lazy) {
2448        let error = getInternalRouterError(405, {
2449          method: submission.formMethod,
2450          pathname: path,
2451          routeId: routeId
2452        });
2453        setFetcherError(key, routeId, error, {
2454          flushSync
2455        });
2456        return true;
2457      }
2458      return false;
2459    }
2460    if (!isFogOfWar && detectAndHandle405Error(match)) {
2461      return;
2462    }
2463    // Put this fetcher into it's submitting state
2464    let existingFetcher = state.fetchers.get(key);
2465    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {
2466      flushSync
2467    });
2468    let abortController = new AbortController();
2469    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);
2470    if (isFogOfWar) {
2471      let discoverResult = await discoverRoutes(requestMatches, path, fetchRequest.signal);
2472      if (discoverResult.type === "aborted") {
2473        return;
2474      } else if (discoverResult.type === "error") {
2475        setFetcherError(key, routeId, discoverResult.error, {
2476          flushSync
2477        });
2478        return;
2479      } else if (!discoverResult.matches) {
2480        setFetcherError(key, routeId, getInternalRouterError(404, {
2481          pathname: path
2482        }), {
2483          flushSync
2484        });
2485        return;
2486      } else {
2487        requestMatches = discoverResult.matches;
2488        match = getTargetMatch(requestMatches, path);
2489        if (detectAndHandle405Error(match)) {
2490          return;
2491        }
2492      }
2493    }
2494    // Call the action for the fetcher
2495    fetchControllers.set(key, abortController);
2496    let originatingLoadId = incrementingLoadId;
2497    let actionResults = await callDataStrategy("action", state, fetchRequest, [match], requestMatches, key);
2498    let actionResult = actionResults[match.route.id];
2499    if (fetchRequest.signal.aborted) {
2500      // We can delete this so long as we weren't aborted by our own fetcher
2501      // re-submit which would have put _new_ controller is in fetchControllers
2502      if (fetchControllers.get(key) === abortController) {
2503        fetchControllers.delete(key);
2504      }
2505      return;
2506    }
2507    // When using v7_fetcherPersist, we don't want errors bubbling up to the UI
2508    // or redirects processed for unmounted fetchers so we just revert them to
2509    // idle
2510    if (future.v7_fetcherPersist && deletedFetchers.has(key)) {
2511      if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {
2512        updateFetcherState(key, getDoneFetcher(undefined));
2513        return;
2514      }
2515      // Let SuccessResult's fall through for revalidation
2516    } else {
2517      if (isRedirectResult(actionResult)) {
2518        fetchControllers.delete(key);
2519        if (pendingNavigationLoadId > originatingLoadId) {
2520          // A new navigation was kicked off after our action started, so that
2521          // should take precedence over this redirect navigation.  We already
2522          // set isRevalidationRequired so all loaders for the new route should
2523          // fire unless opted out via shouldRevalidate
2524          updateFetcherState(key, getDoneFetcher(undefined));
2525          return;
2526        } else {
2527          fetchRedirectIds.add(key);
2528          updateFetcherState(key, getLoadingFetcher(submission));
2529          return startRedirectNavigation(fetchRequest, actionResult, false, {
2530            fetcherSubmission: submission,
2531            preventScrollReset
2532          });
2533        }
2534      }
2535      // Process any non-redirect errors thrown
2536      if (isErrorResult(actionResult)) {
2537        setFetcherError(key, routeId, actionResult.error);
2538        return;
2539      }
2540    }
2541    if (isDeferredResult(actionResult)) {
2542      throw getInternalRouterError(400, {
2543        type: "defer-action"
2544      });
2545    }
2546    // Start the data load for current matches, or the next location if we're
2547    // in the middle of a navigation
2548    let nextLocation = state.navigation.location || state.location;
2549    let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);
2550    let routesToUse = inFlightDataRoutes || dataRoutes;
2551    let matches = state.navigation.state !== "idle" ? matchRoutes(routesToUse, state.navigation.location, basename) : state.matches;
2552    invariant(matches, "Didn't find any matches after fetcher action");
2553    let loadId = ++incrementingLoadId;
2554    fetchReloadIds.set(key, loadId);
2555    let loadFetcher = getLoadingFetcher(submission, actionResult.data);
2556    state.fetchers.set(key, loadFetcher);
2557    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, false, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, [match.route.id, actionResult]);
2558    // Put all revalidating fetchers into the loading state, except for the
2559    // current fetcher which we want to keep in it's current loading state which
2560    // contains it's action submission info + action data
2561    revalidatingFetchers.filter(rf => rf.key !== key).forEach(rf => {
2562      let staleKey = rf.key;
2563      let existingFetcher = state.fetchers.get(staleKey);
2564      let revalidatingFetcher = getLoadingFetcher(undefined, existingFetcher ? existingFetcher.data : undefined);
2565      state.fetchers.set(staleKey, revalidatingFetcher);
2566      abortFetcher(staleKey);
2567      if (rf.controller) {
2568        fetchControllers.set(staleKey, rf.controller);
2569      }
2570    });
2571    updateState({
2572      fetchers: new Map(state.fetchers)
2573    });
2574    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(rf => abortFetcher(rf.key));
2575    abortController.signal.addEventListener("abort", abortPendingFetchRevalidations);
2576    let {
2577      loaderResults,
2578      fetcherResults
2579    } = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);
2580    if (abortController.signal.aborted) {
2581      return;
2582    }
2583    abortController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
2584    fetchReloadIds.delete(key);
2585    fetchControllers.delete(key);
2586    revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));
2587    let redirect = findRedirect(loaderResults);
2588    if (redirect) {
2589      return startRedirectNavigation(revalidationRequest, redirect.result, false, {
2590        preventScrollReset
2591      });
2592    }
2593    redirect = findRedirect(fetcherResults);
2594    if (redirect) {
2595      // If this redirect came from a fetcher make sure we mark it in
2596      // fetchRedirectIds so it doesn't get revalidated on the next set of
2597      // loader executions
2598      fetchRedirectIds.add(redirect.key);
2599      return startRedirectNavigation(revalidationRequest, redirect.result, false, {
2600        preventScrollReset
2601      });
2602    }
2603    // Process and commit output from loaders
2604    let {
2605      loaderData,
2606      errors
2607    } = processLoaderData(state, matches, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);
2608    // Since we let revalidations complete even if the submitting fetcher was
2609    // deleted, only put it back to idle if it hasn't been deleted
2610    if (state.fetchers.has(key)) {
2611      let doneFetcher = getDoneFetcher(actionResult.data);
2612      state.fetchers.set(key, doneFetcher);
2613    }
2614    abortStaleFetchLoads(loadId);
2615    // If we are currently in a navigation loading state and this fetcher is
2616    // more recent than the navigation, we want the newer data so abort the
2617    // navigation and complete it with the fetcher data
2618    if (state.navigation.state === "loading" && loadId > pendingNavigationLoadId) {
2619      invariant(pendingAction, "Expected pending action");
2620      pendingNavigationController && pendingNavigationController.abort();
2621      completeNavigation(state.navigation.location, {
2622        matches,
2623        loaderData,
2624        errors,
2625        fetchers: new Map(state.fetchers)
2626      });
2627    } else {
2628      // otherwise just update with the fetcher data, preserving any existing
2629      // loaderData for loaders that did not need to reload.  We have to
2630      // manually merge here since we aren't going through completeNavigation
2631      updateState({
2632        errors,
2633        loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors),
2634        fetchers: new Map(state.fetchers)
2635      });
2636      isRevalidationRequired = false;
2637    }
2638  }
2639  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.
2640  async function handleFetcherLoader(key, routeId, path, match, matches, isFogOfWar, flushSync, preventScrollReset, submission) {
2641    let existingFetcher = state.fetchers.get(key);
2642    updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : undefined), {
2643      flushSync
2644    });
2645    let abortController = new AbortController();
2646    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);
2647    if (isFogOfWar) {
2648      let discoverResult = await discoverRoutes(matches, path, fetchRequest.signal);
2649      if (discoverResult.type === "aborted") {
2650        return;
2651      } else if (discoverResult.type === "error") {
2652        setFetcherError(key, routeId, discoverResult.error, {
2653          flushSync
2654        });
2655        return;
2656      } else if (!discoverResult.matches) {
2657        setFetcherError(key, routeId, getInternalRouterError(404, {
2658          pathname: path
2659        }), {
2660          flushSync
2661        });
2662        return;
2663      } else {
2664        matches = discoverResult.matches;
2665        match = getTargetMatch(matches, path);
2666      }
2667    }
2668    // Call the loader for this fetcher route match
2669    fetchControllers.set(key, abortController);
2670    let originatingLoadId = incrementingLoadId;
2671    let results = await callDataStrategy("loader", state, fetchRequest, [match], matches, key);
2672    let result = results[match.route.id];
2673    // Deferred isn't supported for fetcher loads, await everything and treat it
2674    // as a normal load.  resolveDeferredData will return undefined if this
2675    // fetcher gets aborted, so we just leave result untouched and short circuit
2676    // below if that happens
2677    if (isDeferredResult(result)) {
2678      result = (await resolveDeferredData(result, fetchRequest.signal, true)) || result;
2679    }
2680    // We can delete this so long as we weren't aborted by our our own fetcher
2681    // re-load which would have put _new_ controller is in fetchControllers
2682    if (fetchControllers.get(key) === abortController) {
2683      fetchControllers.delete(key);
2684    }
2685    if (fetchRequest.signal.aborted) {
2686      return;
2687    }
2688    // We don't want errors bubbling up or redirects followed for unmounted
2689    // fetchers, so short circuit here if it was removed from the UI
2690    if (deletedFetchers.has(key)) {
2691      updateFetcherState(key, getDoneFetcher(undefined));
2692      return;
2693    }
2694    // If the loader threw a redirect Response, start a new REPLACE navigation
2695    if (isRedirectResult(result)) {
2696      if (pendingNavigationLoadId > originatingLoadId) {
2697        // A new navigation was kicked off after our loader started, so that
2698        // should take precedence over this redirect navigation
2699        updateFetcherState(key, getDoneFetcher(undefined));
2700        return;
2701      } else {
2702        fetchRedirectIds.add(key);
2703        await startRedirectNavigation(fetchRequest, result, false, {
2704          preventScrollReset
2705        });
2706        return;
2707      }
2708    }
2709    // Process any non-redirect errors thrown
2710    if (isErrorResult(result)) {
2711      setFetcherError(key, routeId, result.error);
2712      return;
2713    }
2714    invariant(!isDeferredResult(result), "Unhandled fetcher deferred data");
2715    // Put the fetcher back into an idle state
2716    updateFetcherState(key, getDoneFetcher(result.data));
2717  }
2718  /**
2719   * Utility function to handle redirects returned from an action or loader.
2720   * Normally, a redirect "replaces" the navigation that triggered it.  So, for
2721   * example:
2722   *
2723   *  - user is on /a
2724   *  - user clicks a link to /b
2725   *  - loader for /b redirects to /c
2726   *
2727   * In a non-JS app the browser would track the in-flight navigation to /b and
2728   * then replace it with /c when it encountered the redirect response.  In
2729   * the end it would only ever update the URL bar with /c.
2730   *
2731   * In client-side routing using pushState/replaceState, we aim to emulate
2732   * this behavior and we also do not update history until the end of the
2733   * navigation (including processed redirects).  This means that we never
2734   * actually touch history until we've processed redirects, so we just use
2735   * the history action from the original navigation (PUSH or REPLACE).
2736   */
2737  async function startRedirectNavigation(request, redirect, isNavigation, _temp2) {
2738    let {
2739      submission,
2740      fetcherSubmission,
2741      preventScrollReset,
2742      replace
2743    } = _temp2 === void 0 ? {} : _temp2;
2744    if (redirect.response.headers.has("X-Remix-Revalidate")) {
2745      isRevalidationRequired = true;
2746    }
2747    let location = redirect.response.headers.get("Location");
2748    invariant(location, "Expected a Location header on the redirect Response");
2749    location = normalizeRedirectLocation(location, new URL(request.url), basename);
2750    let redirectLocation = createLocation(state.location, location, {
2751      _isRedirect: true
2752    });
2753    if (isBrowser) {
2754      let isDocumentReload = false;
2755      if (redirect.response.headers.has("X-Remix-Reload-Document")) {
2756        // Hard reload if the response contained X-Remix-Reload-Document
2757        isDocumentReload = true;
2758      } else if (ABSOLUTE_URL_REGEX.test(location)) {
2759        const url = init.history.createURL(location);
2760        isDocumentReload =
2761        // Hard reload if it's an absolute URL to a new origin
2762        url.origin !== routerWindow.location.origin ||
2763        // Hard reload if it's an absolute URL that does not match our basename
2764        stripBasename(url.pathname, basename) == null;
2765      }
2766      if (isDocumentReload) {
2767        if (replace) {
2768          routerWindow.location.replace(location);
2769        } else {
2770          routerWindow.location.assign(location);
2771        }
2772        return;
2773      }
2774    }
2775    // There's no need to abort on redirects, since we don't detect the
2776    // redirect until the action/loaders have settled
2777    pendingNavigationController = null;
2778    let redirectHistoryAction = replace === true || redirect.response.headers.has("X-Remix-Replace") ? Action.Replace : Action.Push;
2779    // Use the incoming submission if provided, fallback on the active one in
2780    // state.navigation
2781    let {
2782      formMethod,
2783      formAction,
2784      formEncType
2785    } = state.navigation;
2786    if (!submission && !fetcherSubmission && formMethod && formAction && formEncType) {
2787      submission = getSubmissionFromNavigation(state.navigation);
2788    }
2789    // If this was a 307/308 submission we want to preserve the HTTP method and
2790    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the
2791    // redirected location
2792    let activeSubmission = submission || fetcherSubmission;
2793    if (redirectPreserveMethodStatusCodes.has(redirect.response.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {
2794      await startNavigation(redirectHistoryAction, redirectLocation, {
2795        submission: _extends({}, activeSubmission, {
2796          formAction: location
2797        }),
2798        // Preserve these flags across redirects
2799        preventScrollReset: preventScrollReset || pendingPreventScrollReset,
2800        enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined
2801      });
2802    } else {
2803      // If we have a navigation submission, we will preserve it through the
2804      // redirect navigation
2805      let overrideNavigation = getLoadingNavigation(redirectLocation, submission);
2806      await startNavigation(redirectHistoryAction, redirectLocation, {
2807        overrideNavigation,
2808        // Send fetcher submissions through for shouldRevalidate
2809        fetcherSubmission,
2810        // Preserve these flags across redirects
2811        preventScrollReset: preventScrollReset || pendingPreventScrollReset,
2812        enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined
2813      });
2814    }
2815  }
2816  // Utility wrapper for calling dataStrategy client-side without having to
2817  // pass around the manifest, mapRouteProperties, etc.
2818  async function callDataStrategy(type, state, request, matchesToLoad, matches, fetcherKey) {
2819    let results;
2820    let dataResults = {};
2821    try {
2822      results = await callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties);
2823    } catch (e) {
2824      // If the outer dataStrategy method throws, just return the error for all
2825      // matches - and it'll naturally bubble to the root
2826      matchesToLoad.forEach(m => {
2827        dataResults[m.route.id] = {
2828          type: ResultType.error,
2829          error: e
2830        };
2831      });
2832      return dataResults;
2833    }
2834    for (let [routeId, result] of Object.entries(results)) {
2835      if (isRedirectDataStrategyResultResult(result)) {
2836        let response = result.result;
2837        dataResults[routeId] = {
2838          type: ResultType.redirect,
2839          response: normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, future.v7_relativeSplatPath)
2840        };
2841      } else {
2842        dataResults[routeId] = await convertDataStrategyResultToDataResult(result);
2843      }
2844    }
2845    return dataResults;
2846  }
2847  async function callLoadersAndMaybeResolveData(state, matches, matchesToLoad, fetchersToLoad, request) {
2848    let currentMatches = state.matches;
2849    // Kick off loaders and fetchers in parallel
2850    let loaderResultsPromise = callDataStrategy("loader", state, request, matchesToLoad, matches, null);
2851    let fetcherResultsPromise = Promise.all(fetchersToLoad.map(async f => {
2852      if (f.matches && f.match && f.controller) {
2853        let results = await callDataStrategy("loader", state, createClientSideRequest(init.history, f.path, f.controller.signal), [f.match], f.matches, f.key);
2854        let result = results[f.match.route.id];
2855        // Fetcher results are keyed by fetcher key from here on out, not routeId
2856        return {
2857          [f.key]: result
2858        };
2859      } else {
2860        return Promise.resolve({
2861          [f.key]: {
2862            type: ResultType.error,
2863            error: getInternalRouterError(404, {
2864              pathname: f.path
2865            })
2866          }
2867        });
2868      }
2869    }));
2870    let loaderResults = await loaderResultsPromise;
2871    let fetcherResults = (await fetcherResultsPromise).reduce((acc, r) => Object.assign(acc, r), {});
2872    await Promise.all([resolveNavigationDeferredResults(matches, loaderResults, request.signal, currentMatches, state.loaderData), resolveFetcherDeferredResults(matches, fetcherResults, fetchersToLoad)]);
2873    return {
2874      loaderResults,
2875      fetcherResults
2876    };
2877  }
2878  function interruptActiveLoads() {
2879    // Every interruption triggers a revalidation
2880    isRevalidationRequired = true;
2881    // Cancel pending route-level deferreds and mark cancelled routes for
2882    // revalidation
2883    cancelledDeferredRoutes.push(...cancelActiveDeferreds());
2884    // Abort in-flight fetcher loads
2885    fetchLoadMatches.forEach((_, key) => {
2886      if (fetchControllers.has(key)) {
2887        cancelledFetcherLoads.add(key);
2888      }
2889      abortFetcher(key);
2890    });
2891  }
2892  function updateFetcherState(key, fetcher, opts) {
2893    if (opts === void 0) {
2894      opts = {};
2895    }
2896    state.fetchers.set(key, fetcher);
2897    updateState({
2898      fetchers: new Map(state.fetchers)
2899    }, {
2900      flushSync: (opts && opts.flushSync) === true
2901    });
2902  }
2903  function setFetcherError(key, routeId, error, opts) {
2904    if (opts === void 0) {
2905      opts = {};
2906    }
2907    let boundaryMatch = findNearestBoundary(state.matches, routeId);
2908    deleteFetcher(key);
2909    updateState({
2910      errors: {
2911        [boundaryMatch.route.id]: error
2912      },
2913      fetchers: new Map(state.fetchers)
2914    }, {
2915      flushSync: (opts && opts.flushSync) === true
2916    });
2917  }
2918  function getFetcher(key) {
2919    if (future.v7_fetcherPersist) {
2920      activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);
2921      // If this fetcher was previously marked for deletion, unmark it since we
2922      // have a new instance
2923      if (deletedFetchers.has(key)) {
2924        deletedFetchers.delete(key);
2925      }
2926    }
2927    return state.fetchers.get(key) || IDLE_FETCHER;
2928  }
2929  function deleteFetcher(key) {
2930    let fetcher = state.fetchers.get(key);
2931    // Don't abort the controller if this is a deletion of a fetcher.submit()
2932    // in it's loading phase since - we don't want to abort the corresponding
2933    // revalidation and want them to complete and land
2934    if (fetchControllers.has(key) && !(fetcher && fetcher.state === "loading" && fetchReloadIds.has(key))) {
2935      abortFetcher(key);
2936    }
2937    fetchLoadMatches.delete(key);
2938    fetchReloadIds.delete(key);
2939    fetchRedirectIds.delete(key);
2940    deletedFetchers.delete(key);
2941    cancelledFetcherLoads.delete(key);
2942    state.fetchers.delete(key);
2943  }
2944  function deleteFetcherAndUpdateState(key) {
2945    if (future.v7_fetcherPersist) {
2946      let count = (activeFetchers.get(key) || 0) - 1;
2947      if (count <= 0) {
2948        activeFetchers.delete(key);
2949        deletedFetchers.add(key);
2950      } else {
2951        activeFetchers.set(key, count);
2952      }
2953    } else {
2954      deleteFetcher(key);
2955    }
2956    updateState({
2957      fetchers: new Map(state.fetchers)
2958    });
2959  }
2960  function abortFetcher(key) {
2961    let controller = fetchControllers.get(key);
2962    if (controller) {
2963      controller.abort();
2964      fetchControllers.delete(key);
2965    }
2966  }
2967  function markFetchersDone(keys) {
2968    for (let key of keys) {
2969      let fetcher = getFetcher(key);
2970      let doneFetcher = getDoneFetcher(fetcher.data);
2971      state.fetchers.set(key, doneFetcher);
2972    }
2973  }
2974  function markFetchRedirectsDone() {
2975    let doneKeys = [];
2976    let updatedFetchers = false;
2977    for (let key of fetchRedirectIds) {
2978      let fetcher = state.fetchers.get(key);
2979      invariant(fetcher, "Expected fetcher: " + key);
2980      if (fetcher.state === "loading") {
2981        fetchRedirectIds.delete(key);
2982        doneKeys.push(key);
2983        updatedFetchers = true;
2984      }
2985    }
2986    markFetchersDone(doneKeys);
2987    return updatedFetchers;
2988  }
2989  function abortStaleFetchLoads(landedId) {
2990    let yeetedKeys = [];
2991    for (let [key, id] of fetchReloadIds) {
2992      if (id < landedId) {
2993        let fetcher = state.fetchers.get(key);
2994        invariant(fetcher, "Expected fetcher: " + key);
2995        if (fetcher.state === "loading") {
2996          abortFetcher(key);
2997          fetchReloadIds.delete(key);
2998          yeetedKeys.push(key);
2999        }
3000      }
3001    }
3002    markFetchersDone(yeetedKeys);
3003    return yeetedKeys.length > 0;
3004  }
3005  function getBlocker(key, fn) {
3006    let blocker = state.blockers.get(key) || IDLE_BLOCKER;
3007    if (blockerFunctions.get(key) !== fn) {
3008      blockerFunctions.set(key, fn);
3009    }
3010    return blocker;
3011  }
3012  function deleteBlocker(key) {
3013    state.blockers.delete(key);
3014    blockerFunctions.delete(key);
3015  }
3016  // Utility function to update blockers, ensuring valid state transitions
3017  function updateBlocker(key, newBlocker) {
3018    let blocker = state.blockers.get(key) || IDLE_BLOCKER;
3019    // Poor mans state machine :)
3020    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM
3021    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);
3022    let blockers = new Map(state.blockers);
3023    blockers.set(key, newBlocker);
3024    updateState({
3025      blockers
3026    });
3027  }
3028  function shouldBlockNavigation(_ref2) {
3029    let {
3030      currentLocation,
3031      nextLocation,
3032      historyAction
3033    } = _ref2;
3034    if (blockerFunctions.size === 0) {
3035      return;
3036    }
3037    // We ony support a single active blocker at the moment since we don't have
3038    // any compelling use cases for multi-blocker yet
3039    if (blockerFunctions.size > 1) {
3040      warning(false, "A router only supports one blocker at a time");
3041    }
3042    let entries = Array.from(blockerFunctions.entries());
3043    let [blockerKey, blockerFunction] = entries[entries.length - 1];
3044    let blocker = state.blockers.get(blockerKey);
3045    if (blocker && blocker.state === "proceeding") {
3046      // If the blocker is currently proceeding, we don't need to re-check
3047      // it and can let this navigation continue
3048      return;
3049    }
3050    // At this point, we know we're unblocked/blocked so we need to check the
3051    // user-provided blocker function
3052    if (blockerFunction({
3053      currentLocation,
3054      nextLocation,
3055      historyAction
3056    })) {
3057      return blockerKey;
3058    }
3059  }
3060  function handleNavigational404(pathname) {
3061    let error = getInternalRouterError(404, {
3062      pathname
3063    });
3064    let routesToUse = inFlightDataRoutes || dataRoutes;
3065    let {
3066      matches,
3067      route
3068    } = getShortCircuitMatches(routesToUse);
3069    // Cancel all pending deferred on 404s since we don't keep any routes
3070    cancelActiveDeferreds();
3071    return {
3072      notFoundMatches: matches,
3073      route,
3074      error
3075    };
3076  }
3077  function cancelActiveDeferreds(predicate) {
3078    let cancelledRouteIds = [];
3079    activeDeferreds.forEach((dfd, routeId) => {
3080      if (!predicate || predicate(routeId)) {
3081        // Cancel the deferred - but do not remove from activeDeferreds here -
3082        // we rely on the subscribers to do that so our tests can assert proper
3083        // cleanup via _internalActiveDeferreds
3084        dfd.cancel();
3085        cancelledRouteIds.push(routeId);
3086        activeDeferreds.delete(routeId);
3087      }
3088    });
3089    return cancelledRouteIds;
3090  }
3091  // Opt in to capturing and reporting scroll positions during navigations,
3092  // used by the <ScrollRestoration> component
3093  function enableScrollRestoration(positions, getPosition, getKey) {
3094    savedScrollPositions = positions;
3095    getScrollPosition = getPosition;
3096    getScrollRestorationKey = getKey || null;
3097    // Perform initial hydration scroll restoration, since we miss the boat on
3098    // the initial updateState() because we've not yet rendered <ScrollRestoration/>
3099    // and therefore have no savedScrollPositions available
3100    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {
3101      initialScrollRestored = true;
3102      let y = getSavedScrollPosition(state.location, state.matches);
3103      if (y != null) {
3104        updateState({
3105          restoreScrollPosition: y
3106        });
3107      }
3108    }
3109    return () => {
3110      savedScrollPositions = null;
3111      getScrollPosition = null;
3112      getScrollRestorationKey = null;
3113    };
3114  }
3115  function getScrollKey(location, matches) {
3116    if (getScrollRestorationKey) {
3117      let key = getScrollRestorationKey(location, matches.map(m => convertRouteMatchToUiMatch(m, state.loaderData)));
3118      return key || location.key;
3119    }
3120    return location.key;
3121  }
3122  function saveScrollPosition(location, matches) {
3123    if (savedScrollPositions && getScrollPosition) {
3124      let key = getScrollKey(location, matches);
3125      savedScrollPositions[key] = getScrollPosition();
3126    }
3127  }
3128  function getSavedScrollPosition(location, matches) {
3129    if (savedScrollPositions) {
3130      let key = getScrollKey(location, matches);
3131      let y = savedScrollPositions[key];
3132      if (typeof y === "number") {
3133        return y;
3134      }
3135    }
3136    return null;
3137  }
3138  function checkFogOfWar(matches, routesToUse, pathname) {
3139    if (patchRoutesOnNavigationImpl) {
3140      if (!matches) {
3141        let fogMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
3142        return {
3143          active: true,
3144          matches: fogMatches || []
3145        };
3146      } else {
3147        if (Object.keys(matches[0].params).length > 0) {
3148          // If we matched a dynamic param or a splat, it might only be because
3149          // we haven't yet discovered other routes that would match with a
3150          // higher score.  Call patchRoutesOnNavigation just to be sure
3151          let partialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
3152          return {
3153            active: true,
3154            matches: partialMatches
3155          };
3156        }
3157      }
3158    }
3159    return {
3160      active: false,
3161      matches: null
3162    };
3163  }
3164  async function discoverRoutes(matches, pathname, signal) {
3165    if (!patchRoutesOnNavigationImpl) {
3166      return {
3167        type: "success",
3168        matches
3169      };
3170    }
3171    let partialMatches = matches;
3172    while (true) {
3173      let isNonHMR = inFlightDataRoutes == null;
3174      let routesToUse = inFlightDataRoutes || dataRoutes;
3175      let localManifest = manifest;
3176      try {
3177        await patchRoutesOnNavigationImpl({
3178          path: pathname,
3179          matches: partialMatches,
3180          patch: (routeId, children) => {
3181            if (signal.aborted) return;
3182            patchRoutesImpl(routeId, children, routesToUse, localManifest, mapRouteProperties);
3183          }
3184        });
3185      } catch (e) {
3186        return {
3187          type: "error",
3188          error: e,
3189          partialMatches
3190        };
3191      } finally {
3192        // If we are not in the middle of an HMR revalidation and we changed the
3193        // routes, provide a new identity so when we `updateState` at the end of
3194        // this navigation/fetch `router.routes` will be a new identity and
3195        // trigger a re-run of memoized `router.routes` dependencies.
3196        // HMR will already update the identity and reflow when it lands
3197        // `inFlightDataRoutes` in `completeNavigation`
3198        if (isNonHMR && !signal.aborted) {
3199          dataRoutes = [...dataRoutes];
3200        }
3201      }
3202      if (signal.aborted) {
3203        return {
3204          type: "aborted"
3205        };
3206      }
3207      let newMatches = matchRoutes(routesToUse, pathname, basename);
3208      if (newMatches) {
3209        return {
3210          type: "success",
3211          matches: newMatches
3212        };
3213      }
3214      let newPartialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
3215      // Avoid loops if the second pass results in the same partial matches
3216      if (!newPartialMatches || partialMatches.length === newPartialMatches.length && partialMatches.every((m, i) => m.route.id === newPartialMatches[i].route.id)) {
3217        return {
3218          type: "success",
3219          matches: null
3220        };
3221      }
3222      partialMatches = newPartialMatches;
3223    }
3224  }
3225  function _internalSetRoutes(newRoutes) {
3226    manifest = {};
3227    inFlightDataRoutes = convertRoutesToDataRoutes(newRoutes, mapRouteProperties, undefined, manifest);
3228  }
3229  function patchRoutes(routeId, children) {
3230    let isNonHMR = inFlightDataRoutes == null;
3231    let routesToUse = inFlightDataRoutes || dataRoutes;
3232    patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties);
3233    // If we are not in the middle of an HMR revalidation and we changed the
3234    // routes, provide a new identity and trigger a reflow via `updateState`
3235    // to re-run memoized `router.routes` dependencies.
3236    // HMR will already update the identity and reflow when it lands
3237    // `inFlightDataRoutes` in `completeNavigation`
3238    if (isNonHMR) {
3239      dataRoutes = [...dataRoutes];
3240      updateState({});
3241    }
3242  }
3243  router = {
3244    get basename() {
3245      return basename;
3246    },
3247    get future() {
3248      return future;
3249    },
3250    get state() {
3251      return state;
3252    },
3253    get routes() {
3254      return dataRoutes;
3255    },
3256    get window() {
3257      return routerWindow;
3258    },
3259    initialize,
3260    subscribe,
3261    enableScrollRestoration,
3262    navigate,
3263    fetch,
3264    revalidate,
3265    // Passthrough to history-aware createHref used by useHref so we get proper
3266    // hash-aware URLs in DOM paths
3267    createHref: to => init.history.createHref(to),
3268    encodeLocation: to => init.history.encodeLocation(to),
3269    getFetcher,
3270    deleteFetcher: deleteFetcherAndUpdateState,
3271    dispose,
3272    getBlocker,
3273    deleteBlocker,
3274    patchRoutes,
3275    _internalFetchControllers: fetchControllers,
3276    _internalActiveDeferreds: activeDeferreds,
3277    // TODO: Remove setRoutes, it's temporary to avoid dealing with
3278    // updating the tree while validating the update algorithm.
3279    _internalSetRoutes
3280  };
3281  return router;
3282}
3283//#endregion
3284////////////////////////////////////////////////////////////////////////////////
3285//#region createStaticHandler
3286////////////////////////////////////////////////////////////////////////////////
3287const UNSAFE_DEFERRED_SYMBOL = Symbol("deferred");
3288function createStaticHandler(routes, opts) {
3289  invariant(routes.length > 0, "You must provide a non-empty routes array to createStaticHandler");
3290  let manifest = {};
3291  let basename = (opts ? opts.basename : null) || "/";
3292  let mapRouteProperties;
3293  if (opts != null && opts.mapRouteProperties) {
3294    mapRouteProperties = opts.mapRouteProperties;
3295  } else if (opts != null && opts.detectErrorBoundary) {
3296    // If they are still using the deprecated version, wrap it with the new API
3297    let detectErrorBoundary = opts.detectErrorBoundary;
3298    mapRouteProperties = route => ({
3299      hasErrorBoundary: detectErrorBoundary(route)
3300    });
3301  } else {
3302    mapRouteProperties = defaultMapRouteProperties;
3303  }
3304  // Config driven behavior flags
3305  let future = _extends({
3306    v7_relativeSplatPath: false,
3307    v7_throwAbortReason: false
3308  }, opts ? opts.future : null);
3309  let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, undefined, manifest);
3310  /**
3311   * The query() method is intended for document requests, in which we want to
3312   * call an optional action and potentially multiple loaders for all nested
3313   * routes.  It returns a StaticHandlerContext object, which is very similar
3314   * to the router state (location, loaderData, actionData, errors, etc.) and
3315   * also adds SSR-specific information such as the statusCode and headers
3316   * from action/loaders Responses.
3317   *
3318   * It _should_ never throw and should report all errors through the
3319   * returned context.errors object, properly associating errors to their error
3320   * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be
3321   * used to emulate React error boundaries during SSr by performing a second
3322   * pass only down to the boundaryId.
3323   *
3324   * The one exception where we do not return a StaticHandlerContext is when a
3325   * redirect response is returned or thrown from any action/loader.  We
3326   * propagate that out and return the raw Response so the HTTP server can
3327   * return it directly.
3328   *
3329   * - `opts.requestContext` is an optional server context that will be passed
3330   *   to actions/loaders in the `context` parameter
3331   * - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent
3332   *   the bubbling of errors which allows single-fetch-type implementations
3333   *   where the client will handle the bubbling and we may need to return data
3334   *   for the handling route
3335   */
3336  async function query(request, _temp3) {
3337    let {
3338      requestContext,
3339      skipLoaderErrorBubbling,
3340      dataStrategy
3341    } = _temp3 === void 0 ? {} : _temp3;
3342    let url = new URL(request.url);
3343    let method = request.method;
3344    let location = createLocation("", createPath(url), null, "default");
3345    let matches = matchRoutes(dataRoutes, location, basename);
3346    // SSR supports HEAD requests while SPA doesn't
3347    if (!isValidMethod(method) && method !== "HEAD") {
3348      let error = getInternalRouterError(405, {
3349        method
3350      });
3351      let {
3352        matches: methodNotAllowedMatches,
3353        route
3354      } = getShortCircuitMatches(dataRoutes);
3355      return {
3356        basename,
3357        location,
3358        matches: methodNotAllowedMatches,
3359        loaderData: {},
3360        actionData: null,
3361        errors: {
3362          [route.id]: error
3363        },
3364        statusCode: error.status,
3365        loaderHeaders: {},
3366        actionHeaders: {},
3367        activeDeferreds: null
3368      };
3369    } else if (!matches) {
3370      let error = getInternalRouterError(404, {
3371        pathname: location.pathname
3372      });
3373      let {
3374        matches: notFoundMatches,
3375        route
3376      } = getShortCircuitMatches(dataRoutes);
3377      return {
3378        basename,
3379        location,
3380        matches: notFoundMatches,
3381        loaderData: {},
3382        actionData: null,
3383        errors: {
3384          [route.id]: error
3385        },
3386        statusCode: error.status,
3387        loaderHeaders: {},
3388        actionHeaders: {},
3389        activeDeferreds: null
3390      };
3391    }
3392    let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, skipLoaderErrorBubbling === true, null);
3393    if (isResponse(result)) {
3394      return result;
3395    }
3396    // When returning StaticHandlerContext, we patch back in the location here
3397    // since we need it for React Context.  But this helps keep our submit and
3398    // loadRouteData operating on a Request instead of a Location
3399    return _extends({
3400      location,
3401      basename
3402    }, result);
3403  }
3404  /**
3405   * The queryRoute() method is intended for targeted route requests, either
3406   * for fetch ?_data requests or resource route requests.  In this case, we
3407   * are only ever calling a single action or loader, and we are returning the
3408   * returned value directly.  In most cases, this will be a Response returned
3409   * from the action/loader, but it may be a primitive or other value as well -
3410   * and in such cases the calling context should handle that accordingly.
3411   *
3412   * We do respect the throw/return differentiation, so if an action/loader
3413   * throws, then this method will throw the value.  This is important so we
3414   * can do proper boundary identification in Remix where a thrown Response
3415   * must go to the Catch Boundary but a returned Response is happy-path.
3416   *
3417   * One thing to note is that any Router-initiated Errors that make sense
3418   * to associate with a status code will be thrown as an ErrorResponse
3419   * instance which include the raw Error, such that the calling context can
3420   * serialize the error as they see fit while including the proper response
3421   * code.  Examples here are 404 and 405 errors that occur prior to reaching
3422   * any user-defined loaders.
3423   *
3424   * - `opts.routeId` allows you to specify the specific route handler to call.
3425   *   If not provided the handler will determine the proper route by matching
3426   *   against `request.url`
3427   * - `opts.requestContext` is an optional server context that will be passed
3428   *    to actions/loaders in the `context` parameter
3429   */
3430  async function queryRoute(request, _temp4) {
3431    let {
3432      routeId,
3433      requestContext,
3434      dataStrategy
3435    } = _temp4 === void 0 ? {} : _temp4;
3436    let url = new URL(request.url);
3437    let method = request.method;
3438    let location = createLocation("", createPath(url), null, "default");
3439    let matches = matchRoutes(dataRoutes, location, basename);
3440    // SSR supports HEAD requests while SPA doesn't
3441    if (!isValidMethod(method) && method !== "HEAD" && method !== "OPTIONS") {
3442      throw getInternalRouterError(405, {
3443        method
3444      });
3445    } else if (!matches) {
3446      throw getInternalRouterError(404, {
3447        pathname: location.pathname
3448      });
3449    }
3450    let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);
3451    if (routeId && !match) {
3452      throw getInternalRouterError(403, {
3453        pathname: location.pathname,
3454        routeId
3455      });
3456    } else if (!match) {
3457      // This should never hit I don't think?
3458      throw getInternalRouterError(404, {
3459        pathname: location.pathname
3460      });
3461    }
3462    let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, false, match);
3463    if (isResponse(result)) {
3464      return result;
3465    }
3466    let error = result.errors ? Object.values(result.errors)[0] : undefined;
3467    if (error !== undefined) {
3468      // If we got back result.errors, that means the loader/action threw
3469      // _something_ that wasn't a Response, but it's not guaranteed/required
3470      // to be an `instanceof Error` either, so we have to use throw here to
3471      // preserve the "error" state outside of queryImpl.
3472      throw error;
3473    }
3474    // Pick off the right state value to return
3475    if (result.actionData) {
3476      return Object.values(result.actionData)[0];
3477    }
3478    if (result.loaderData) {
3479      var _result$activeDeferre;
3480      let data = Object.values(result.loaderData)[0];
3481      if ((_result$activeDeferre = result.activeDeferreds) != null && _result$activeDeferre[match.route.id]) {
3482        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];
3483      }
3484      return data;
3485    }
3486    return undefined;
3487  }
3488  async function queryImpl(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch) {
3489    invariant(request.signal, "query()/queryRoute() requests must contain an AbortController signal");
3490    try {
3491      if (isMutationMethod(request.method.toLowerCase())) {
3492        let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch != null);
3493        return result;
3494      }
3495      let result = await loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch);
3496      return isResponse(result) ? result : _extends({}, result, {
3497        actionData: null,
3498        actionHeaders: {}
3499      });
3500    } catch (e) {
3501      // If the user threw/returned a Response in callLoaderOrAction for a
3502      // `queryRoute` call, we throw the `DataStrategyResult` to bail out early
3503      // and then return or throw the raw Response here accordingly
3504      if (isDataStrategyResult(e) && isResponse(e.result)) {
3505        if (e.type === ResultType.error) {
3506          throw e.result;
3507        }
3508        return e.result;
3509      }
3510      // Redirects are always returned since they don't propagate to catch
3511      // boundaries
3512      if (isRedirectResponse(e)) {
3513        return e;
3514      }
3515      throw e;
3516    }
3517  }
3518  async function submit(request, matches, actionMatch, requestContext, dataStrategy, skipLoaderErrorBubbling, isRouteRequest) {
3519    let result;
3520    if (!actionMatch.route.action && !actionMatch.route.lazy) {
3521      let error = getInternalRouterError(405, {
3522        method: request.method,
3523        pathname: new URL(request.url).pathname,
3524        routeId: actionMatch.route.id
3525      });
3526      if (isRouteRequest) {
3527        throw error;
3528      }
3529      result = {
3530        type: ResultType.error,
3531        error
3532      };
3533    } else {
3534      let results = await callDataStrategy("action", request, [actionMatch], matches, isRouteRequest, requestContext, dataStrategy);
3535      result = results[actionMatch.route.id];
3536      if (request.signal.aborted) {
3537        throwStaticHandlerAbortedError(request, isRouteRequest, future);
3538      }
3539    }
3540    if (isRedirectResult(result)) {
3541      // Uhhhh - this should never happen, we should always throw these from
3542      // callLoaderOrAction, but the type narrowing here keeps TS happy and we
3543      // can get back on the "throw all redirect responses" train here should
3544      // this ever happen :/
3545      throw new Response(null, {
3546        status: result.response.status,
3547        headers: {
3548          Location: result.response.headers.get("Location")
3549        }
3550      });
3551    }
3552    if (isDeferredResult(result)) {
3553      let error = getInternalRouterError(400, {
3554        type: "defer-action"
3555      });
3556      if (isRouteRequest) {
3557        throw error;
3558      }
3559      result = {
3560        type: ResultType.error,
3561        error
3562      };
3563    }
3564    if (isRouteRequest) {
3565      // Note: This should only be non-Response values if we get here, since
3566      // isRouteRequest should throw any Response received in callLoaderOrAction
3567      if (isErrorResult(result)) {
3568        throw result.error;
3569      }
3570      return {
3571        matches: [actionMatch],
3572        loaderData: {},
3573        actionData: {
3574          [actionMatch.route.id]: result.data
3575        },
3576        errors: null,
3577        // Note: statusCode + headers are unused here since queryRoute will
3578        // return the raw Response or value
3579        statusCode: 200,
3580        loaderHeaders: {},
3581        actionHeaders: {},
3582        activeDeferreds: null
3583      };
3584    }
3585    // Create a GET request for the loaders
3586    let loaderRequest = new Request(request.url, {
3587      headers: request.headers,
3588      redirect: request.redirect,
3589      signal: request.signal
3590    });
3591    if (isErrorResult(result)) {
3592      // Store off the pending error - we use it to determine which loaders
3593      // to call and will commit it when we complete the navigation
3594      let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);
3595      let context = await loadRouteData(loaderRequest, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null, [boundaryMatch.route.id, result]);
3596      // action status codes take precedence over loader status codes
3597      return _extends({}, context, {
3598        statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,
3599        actionData: null,
3600        actionHeaders: _extends({}, result.headers ? {
3601          [actionMatch.route.id]: result.headers
3602        } : {})
3603      });
3604    }
3605    let context = await loadRouteData(loaderRequest, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null);
3606    return _extends({}, context, {
3607      actionData: {
3608        [actionMatch.route.id]: result.data
3609      }
3610    }, result.statusCode ? {
3611      statusCode: result.statusCode
3612    } : {}, {
3613      actionHeaders: result.headers ? {
3614        [actionMatch.route.id]: result.headers
3615      } : {}
3616    });
3617  }
3618  async function loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, pendingActionResult) {
3619    let isRouteRequest = routeMatch != null;
3620    // Short circuit if we have no loaders to run (queryRoute())
3621    if (isRouteRequest && !(routeMatch != null && routeMatch.route.loader) && !(routeMatch != null && routeMatch.route.lazy)) {
3622      throw getInternalRouterError(400, {
3623        method: request.method,
3624        pathname: new URL(request.url).pathname,
3625        routeId: routeMatch == null ? void 0 : routeMatch.route.id
3626      });
3627    }
3628    let requestMatches = routeMatch ? [routeMatch] : pendingActionResult && isErrorResult(pendingActionResult[1]) ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]) : matches;
3629    let matchesToLoad = requestMatches.filter(m => m.route.loader || m.route.lazy);
3630    // Short circuit if we have no loaders to run (query())
3631    if (matchesToLoad.length === 0) {
3632      return {
3633        matches,
3634        // Add a null for all matched routes for proper revalidation on the client
3635        loaderData: matches.reduce((acc, m) => Object.assign(acc, {
3636          [m.route.id]: null
3637        }), {}),
3638        errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {
3639          [pendingActionResult[0]]: pendingActionResult[1].error
3640        } : null,
3641        statusCode: 200,
3642        loaderHeaders: {},
3643        activeDeferreds: null
3644      };
3645    }
3646    let results = await callDataStrategy("loader", request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy);
3647    if (request.signal.aborted) {
3648      throwStaticHandlerAbortedError(request, isRouteRequest, future);
3649    }
3650    // Process and commit output from loaders
3651    let activeDeferreds = new Map();
3652    let context = processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling);
3653    // Add a null for any non-loader matches for proper revalidation on the client
3654    let executedLoaders = new Set(matchesToLoad.map(match => match.route.id));
3655    matches.forEach(match => {
3656      if (!executedLoaders.has(match.route.id)) {
3657        context.loaderData[match.route.id] = null;
3658      }
3659    });
3660    return _extends({}, context, {
3661      matches,
3662      activeDeferreds: activeDeferreds.size > 0 ? Object.fromEntries(activeDeferreds.entries()) : null
3663    });
3664  }
3665  // Utility wrapper for calling dataStrategy server-side without having to
3666  // pass around the manifest, mapRouteProperties, etc.
3667  async function callDataStrategy(type, request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy) {
3668    let results = await callDataStrategyImpl(dataStrategy || defaultDataStrategy, type, null, request, matchesToLoad, matches, null, manifest, mapRouteProperties, requestContext);
3669    let dataResults = {};
3670    await Promise.all(matches.map(async match => {
3671      if (!(match.route.id in results)) {
3672        return;
3673      }
3674      let result = results[match.route.id];
3675      if (isRedirectDataStrategyResultResult(result)) {
3676        let response = result.result;
3677        // Throw redirects and let the server handle them with an HTTP redirect
3678        throw normalizeRelativeRoutingRedirectResponse(response, request, match.route.id, matches, basename, future.v7_relativeSplatPath);
3679      }
3680      if (isResponse(result.result) && isRouteRequest) {
3681        // For SSR single-route requests, we want to hand Responses back
3682        // directly without unwrapping
3683        throw result;
3684      }
3685      dataResults[match.route.id] = await convertDataStrategyResultToDataResult(result);
3686    }));
3687    return dataResults;
3688  }
3689  return {
3690    dataRoutes,
3691    query,
3692    queryRoute
3693  };
3694}
3695//#endregion
3696////////////////////////////////////////////////////////////////////////////////
3697//#region Helpers
3698////////////////////////////////////////////////////////////////////////////////
3699/**
3700 * Given an existing StaticHandlerContext and an error thrown at render time,
3701 * provide an updated StaticHandlerContext suitable for a second SSR render
3702 */
3703function getStaticContextFromError(routes, context, error) {
3704  let newContext = _extends({}, context, {
3705    statusCode: isRouteErrorResponse(error) ? error.status : 500,
3706    errors: {
3707      [context._deepestRenderedBoundaryId || routes[0].id]: error
3708    }
3709  });
3710  return newContext;
3711}
3712function throwStaticHandlerAbortedError(request, isRouteRequest, future) {
3713  if (future.v7_throwAbortReason && request.signal.reason !== undefined) {
3714    throw request.signal.reason;
3715  }
3716  let method = isRouteRequest ? "queryRoute" : "query";
3717  throw new Error(method + "() call aborted: " + request.method + " " + request.url);
3718}
3719function isSubmissionNavigation(opts) {
3720  return opts != null && ("formData" in opts && opts.formData != null || "body" in opts && opts.body !== undefined);
3721}
3722function normalizeTo(location, matches, basename, prependBasename, to, v7_relativeSplatPath, fromRouteId, relative) {
3723  let contextualMatches;
3724  let activeRouteMatch;
3725  if (fromRouteId) {
3726    // Grab matches up to the calling route so our route-relative logic is
3727    // relative to the correct source route
3728    contextualMatches = [];
3729    for (let match of matches) {
3730      contextualMatches.push(match);
3731      if (match.route.id === fromRouteId) {
3732        activeRouteMatch = match;
3733        break;
3734      }
3735    }
3736  } else {
3737    contextualMatches = matches;
3738    activeRouteMatch = matches[matches.length - 1];
3739  }
3740  // Resolve the relative path
3741  let path = resolveTo(to ? to : ".", getResolveToMatches(contextualMatches, v7_relativeSplatPath), stripBasename(location.pathname, basename) || location.pathname, relative === "path");
3742  // When `to` is not specified we inherit search/hash from the current
3743  // location, unlike when to="." and we just inherit the path.
3744  // See https://github.com/remix-run/remix/issues/927
3745  if (to == null) {
3746    path.search = location.search;
3747    path.hash = location.hash;
3748  }
3749  // Account for `?index` params when routing to the current location
3750  if ((to == null || to === "" || to === ".") && activeRouteMatch) {
3751    let nakedIndex = hasNakedIndexQuery(path.search);
3752    if (activeRouteMatch.route.index && !nakedIndex) {
3753      // Add one when we're targeting an index route
3754      path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
3755    } else if (!activeRouteMatch.route.index && nakedIndex) {
3756      // Remove existing ones when we're not
3757      let params = new URLSearchParams(path.search);
3758      let indexValues = params.getAll("index");
3759      params.delete("index");
3760      indexValues.filter(v => v).forEach(v => params.append("index", v));
3761      let qs = params.toString();
3762      path.search = qs ? "?" + qs : "";
3763    }
3764  }
3765  // If we're operating within a basename, prepend it to the pathname.  If
3766  // this is a root navigation, then just use the raw basename which allows
3767  // the basename to have full control over the presence of a trailing slash
3768  // on root actions
3769  if (prependBasename && basename !== "/") {
3770    path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
3771  }
3772  return createPath(path);
3773}
3774// Normalize navigation options by converting formMethod=GET formData objects to
3775// URLSearchParams so they behave identically to links with query params
3776function normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {
3777  // Return location verbatim on non-submission navigations
3778  if (!opts || !isSubmissionNavigation(opts)) {
3779    return {
3780      path
3781    };
3782  }
3783  if (opts.formMethod && !isValidMethod(opts.formMethod)) {
3784    return {
3785      path,
3786      error: getInternalRouterError(405, {
3787        method: opts.formMethod
3788      })
3789    };
3790  }
3791  let getInvalidBodyError = () => ({
3792    path,
3793    error: getInternalRouterError(400, {
3794      type: "invalid-body"
3795    })
3796  });
3797  // Create a Submission on non-GET navigations
3798  let rawFormMethod = opts.formMethod || "get";
3799  let formMethod = normalizeFormMethod ? rawFormMethod.toUpperCase() : rawFormMethod.toLowerCase();
3800  let formAction = stripHashFromPath(path);
3801  if (opts.body !== undefined) {
3802    if (opts.formEncType === "text/plain") {
3803      // text only support POST/PUT/PATCH/DELETE submissions
3804      if (!isMutationMethod(formMethod)) {
3805        return getInvalidBodyError();
3806      }
3807      let text = typeof opts.body === "string" ? opts.body : opts.body instanceof FormData || opts.body instanceof URLSearchParams ?
3808      // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data
3809      Array.from(opts.body.entries()).reduce((acc, _ref3) => {
3810        let [name, value] = _ref3;
3811        return "" + acc + name + "=" + value + "\n";
3812      }, "") : String(opts.body);
3813      return {
3814        path,
3815        submission: {
3816          formMethod,
3817          formAction,
3818          formEncType: opts.formEncType,
3819          formData: undefined,
3820          json: undefined,
3821          text
3822        }
3823      };
3824    } else if (opts.formEncType === "application/json") {
3825      // json only supports POST/PUT/PATCH/DELETE submissions
3826      if (!isMutationMethod(formMethod)) {
3827        return getInvalidBodyError();
3828      }
3829      try {
3830        let json = typeof opts.body === "string" ? JSON.parse(opts.body) : opts.body;
3831        return {
3832          path,
3833          submission: {
3834            formMethod,
3835            formAction,
3836            formEncType: opts.formEncType,
3837            formData: undefined,
3838            json,
3839            text: undefined
3840          }
3841        };
3842      } catch (e) {
3843        return getInvalidBodyError();
3844      }
3845    }
3846  }
3847  invariant(typeof FormData === "function", "FormData is not available in this environment");
3848  let searchParams;
3849  let formData;
3850  if (opts.formData) {
3851    searchParams = convertFormDataToSearchParams(opts.formData);
3852    formData = opts.formData;
3853  } else if (opts.body instanceof FormData) {
3854    searchParams = convertFormDataToSearchParams(opts.body);
3855    formData = opts.body;
3856  } else if (opts.body instanceof URLSearchParams) {
3857    searchParams = opts.body;
3858    formData = convertSearchParamsToFormData(searchParams);
3859  } else if (opts.body == null) {
3860    searchParams = new URLSearchParams();
3861    formData = new FormData();
3862  } else {
3863    try {
3864      searchParams = new URLSearchParams(opts.body);
3865      formData = convertSearchParamsToFormData(searchParams);
3866    } catch (e) {
3867      return getInvalidBodyError();
3868    }
3869  }
3870  let submission = {
3871    formMethod,
3872    formAction,
3873    formEncType: opts && opts.formEncType || "application/x-www-form-urlencoded",
3874    formData,
3875    json: undefined,
3876    text: undefined
3877  };
3878  if (isMutationMethod(submission.formMethod)) {
3879    return {
3880      path,
3881      submission
3882    };
3883  }
3884  // Flatten submission onto URLSearchParams for GET submissions
3885  let parsedPath = parsePath(path);
3886  // On GET navigation submissions we can drop the ?index param from the
3887  // resulting location since all loaders will run.  But fetcher GET submissions
3888  // only run a single loader so we need to preserve any incoming ?index params
3889  if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {
3890    searchParams.append("index", "");
3891  }
3892  parsedPath.search = "?" + searchParams;
3893  return {
3894    path: createPath(parsedPath),
3895    submission
3896  };
3897}
3898// Filter out all routes at/below any caught error as they aren't going to
3899// render so we don't need to load them
3900function getLoaderMatchesUntilBoundary(matches, boundaryId, includeBoundary) {
3901  if (includeBoundary === void 0) {
3902    includeBoundary = false;
3903  }
3904  let index = matches.findIndex(m => m.route.id === boundaryId);
3905  if (index >= 0) {
3906    return matches.slice(0, includeBoundary ? index + 1 : index);
3907  }
3908  return matches;
3909}
3910function getMatchesToLoad(history, state, matches, submission, location, initialHydration, skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {
3911  let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : undefined;
3912  let currentUrl = history.createURL(state.location);
3913  let nextUrl = history.createURL(location);
3914  // Pick navigation matches that are net-new or qualify for revalidation
3915  let boundaryMatches = matches;
3916  if (initialHydration && state.errors) {
3917    // On initial hydration, only consider matches up to _and including_ the boundary.
3918    // This is inclusive to handle cases where a server loader ran successfully,
3919    // a child server loader bubbled up to this route, but this route has
3920    // `clientLoader.hydrate` so we want to still run the `clientLoader` so that
3921    // we have a complete version of `loaderData`
3922    boundaryMatches = getLoaderMatchesUntilBoundary(matches, Object.keys(state.errors)[0], true);
3923  } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {
3924    // If an action threw an error, we call loaders up to, but not including the
3925    // boundary
3926    boundaryMatches = getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]);
3927  }
3928  // Don't revalidate loaders by default after action 4xx/5xx responses
3929  // when the flag is enabled.  They can still opt-into revalidation via
3930  // `shouldRevalidate` via `actionResult`
3931  let actionStatus = pendingActionResult ? pendingActionResult[1].statusCode : undefined;
3932  let shouldSkipRevalidation = skipActionErrorRevalidation && actionStatus && actionStatus >= 400;
3933  let navigationMatches = boundaryMatches.filter((match, index) => {
3934    let {
3935      route
3936    } = match;
3937    if (route.lazy) {
3938      // We haven't loaded this route yet so we don't know if it's got a loader!
3939      return true;
3940    }
3941    if (route.loader == null) {
3942      return false;
3943    }
3944    if (initialHydration) {
3945      return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);
3946    }
3947    // Always call the loader on new route instances and pending defer cancellations
3948    if (isNewLoader(state.loaderData, state.matches[index], match) || cancelledDeferredRoutes.some(id => id === match.route.id)) {
3949      return true;
3950    }
3951    // This is the default implementation for when we revalidate.  If the route
3952    // provides it's own implementation, then we give them full control but
3953    // provide this value so they can leverage it if needed after they check
3954    // their own specific use cases
3955    let currentRouteMatch = state.matches[index];
3956    let nextRouteMatch = match;
3957    return shouldRevalidateLoader(match, _extends({
3958      currentUrl,
3959      currentParams: currentRouteMatch.params,
3960      nextUrl,
3961      nextParams: nextRouteMatch.params
3962    }, submission, {
3963      actionResult,
3964      actionStatus,
3965      defaultShouldRevalidate: shouldSkipRevalidation ? false :
3966      // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
3967      isRevalidationRequired || currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search ||
3968      // Search params affect all loaders
3969      currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)
3970    }));
3971  });
3972  // Pick fetcher.loads that need to be revalidated
3973  let revalidatingFetchers = [];
3974  fetchLoadMatches.forEach((f, key) => {
3975    // Don't revalidate:
3976    //  - on initial hydration (shouldn't be any fetchers then anyway)
3977    //  - if fetcher won't be present in the subsequent render
3978    //    - no longer matches the URL (v7_fetcherPersist=false)
3979    //    - was unmounted but persisted due to v7_fetcherPersist=true
3980    if (initialHydration || !matches.some(m => m.route.id === f.routeId) || deletedFetchers.has(key)) {
3981      return;
3982    }
3983    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);
3984    // If the fetcher path no longer matches, push it in with null matches so
3985    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is
3986    // currently only a use-case for Remix HMR where the route tree can change
3987    // at runtime and remove a route previously loaded via a fetcher
3988    if (!fetcherMatches) {
3989      revalidatingFetchers.push({
3990        key,
3991        routeId: f.routeId,
3992        path: f.path,
3993        matches: null,
3994        match: null,
3995        controller: null
3996      });
3997      return;
3998    }
3999    // Revalidating fetchers are decoupled from the route matches since they
4000    // load from a static href.  They revalidate based on explicit revalidation
4001    // (submission, useRevalidator, or X-Remix-Revalidate)
4002    let fetcher = state.fetchers.get(key);
4003    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);
4004    let shouldRevalidate = false;
4005    if (fetchRedirectIds.has(key)) {
4006      // Never trigger a revalidation of an actively redirecting fetcher
4007      shouldRevalidate = false;
4008    } else if (cancelledFetcherLoads.has(key)) {
4009      // Always mark for revalidation if the fetcher was cancelled
4010      cancelledFetcherLoads.delete(key);
4011      shouldRevalidate = true;
4012    } else if (fetcher && fetcher.state !== "idle" && fetcher.data === undefined) {
4013      // If the fetcher hasn't ever completed loading yet, then this isn't a
4014      // revalidation, it would just be a brand new load if an explicit
4015      // revalidation is required
4016      shouldRevalidate = isRevalidationRequired;
4017    } else {
4018      // Otherwise fall back on any user-defined shouldRevalidate, defaulting
4019      // to explicit revalidations only
4020      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({
4021        currentUrl,
4022        currentParams: state.matches[state.matches.length - 1].params,
4023        nextUrl,
4024        nextParams: matches[matches.length - 1].params
4025      }, submission, {
4026        actionResult,
4027        actionStatus,
4028        defaultShouldRevalidate: shouldSkipRevalidation ? false : isRevalidationRequired
4029      }));
4030    }
4031    if (shouldRevalidate) {
4032      revalidatingFetchers.push({
4033        key,
4034        routeId: f.routeId,
4035        path: f.path,
4036        matches: fetcherMatches,
4037        match: fetcherMatch,
4038        controller: new AbortController()
4039      });
4040    }
4041  });
4042  return [navigationMatches, revalidatingFetchers];
4043}
4044function shouldLoadRouteOnHydration(route, loaderData, errors) {
4045  // We dunno if we have a loader - gotta find out!
4046  if (route.lazy) {
4047    return true;
4048  }
4049  // No loader, nothing to initialize
4050  if (!route.loader) {
4051    return false;
4052  }
4053  let hasData = loaderData != null && loaderData[route.id] !== undefined;
4054  let hasError = errors != null && errors[route.id] !== undefined;
4055  // Don't run if we error'd during SSR
4056  if (!hasData && hasError) {
4057    return false;
4058  }
4059  // Explicitly opting-in to running on hydration
4060  if (typeof route.loader === "function" && route.loader.hydrate === true) {
4061    return true;
4062  }
4063  // Otherwise, run if we're not yet initialized with anything
4064  return !hasData && !hasError;
4065}
4066function isNewLoader(currentLoaderData, currentMatch, match) {
4067  let isNew =
4068  // [a] -> [a, b]
4069  !currentMatch ||
4070  // [a, b] -> [a, c]
4071  match.route.id !== currentMatch.route.id;
4072  // Handle the case that we don't have data for a re-used route, potentially
4073  // from a prior error or from a cancelled pending deferred
4074  let isMissingData = currentLoaderData[match.route.id] === undefined;
4075  // Always load if this is a net-new route or we don't yet have data
4076  return isNew || isMissingData;
4077}
4078function isNewRouteInstance(currentMatch, match) {
4079  let currentPath = currentMatch.route.path;
4080  return (
4081    // param change for this match, /users/123 -> /users/456
4082    currentMatch.pathname !== match.pathname ||
4083    // splat param changed, which is not present in match.path
4084    // e.g. /files/images/avatar.jpg -> files/finances.xls
4085    currentPath != null && currentPath.endsWith("*") && currentMatch.params["*"] !== match.params["*"]
4086  );
4087}
4088function shouldRevalidateLoader(loaderMatch, arg) {
4089  if (loaderMatch.route.shouldRevalidate) {
4090    let routeChoice = loaderMatch.route.shouldRevalidate(arg);
4091    if (typeof routeChoice === "boolean") {
4092      return routeChoice;
4093    }
4094  }
4095  return arg.defaultShouldRevalidate;
4096}
4097function patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties) {
4098  var _childrenToPatch;
4099  let childrenToPatch;
4100  if (routeId) {
4101    let route = manifest[routeId];
4102    invariant(route, "No route found to patch children into: routeId = " + routeId);
4103    if (!route.children) {
4104      route.children = [];
4105    }
4106    childrenToPatch = route.children;
4107  } else {
4108    childrenToPatch = routesToUse;
4109  }
4110  // Don't patch in routes we already know about so that `patch` is idempotent
4111  // to simplify user-land code. This is useful because we re-call the
4112  // `patchRoutesOnNavigation` function for matched routes with params.
4113  let uniqueChildren = children.filter(newRoute => !childrenToPatch.some(existingRoute => isSameRoute(newRoute, existingRoute)));
4114  let newRoutes = convertRoutesToDataRoutes(uniqueChildren, mapRouteProperties, [routeId || "_", "patch", String(((_childrenToPatch = childrenToPatch) == null ? void 0 : _childrenToPatch.length) || "0")], manifest);
4115  childrenToPatch.push(...newRoutes);
4116}
4117function isSameRoute(newRoute, existingRoute) {
4118  // Most optimal check is by id
4119  if ("id" in newRoute && "id" in existingRoute && newRoute.id === existingRoute.id) {
4120    return true;
4121  }
4122  // Second is by pathing differences
4123  if (!(newRoute.index === existingRoute.index && newRoute.path === existingRoute.path && newRoute.caseSensitive === existingRoute.caseSensitive)) {
4124    return false;
4125  }
4126  // Pathless layout routes are trickier since we need to check children.
4127  // If they have no children then they're the same as far as we can tell
4128  if ((!newRoute.children || newRoute.children.length === 0) && (!existingRoute.children || existingRoute.children.length === 0)) {
4129    return true;
4130  }
4131  // Otherwise, we look to see if every child in the new route is already
4132  // represented in the existing route's children
4133  return newRoute.children.every((aChild, i) => {
4134    var _existingRoute$childr;
4135    return (_existingRoute$childr = existingRoute.children) == null ? void 0 : _existingRoute$childr.some(bChild => isSameRoute(aChild, bChild));
4136  });
4137}
4138/**
4139 * Execute route.lazy() methods to lazily load route modules (loader, action,
4140 * shouldRevalidate) and update the routeManifest in place which shares objects
4141 * with dataRoutes so those get updated as well.
4142 */
4143async function loadLazyRouteModule(route, mapRouteProperties, manifest) {
4144  if (!route.lazy) {
4145    return;
4146  }
4147  let lazyRoute = await route.lazy();
4148  // If the lazy route function was executed and removed by another parallel
4149  // call then we can return - first lazy() to finish wins because the return
4150  // value of lazy is expected to be static
4151  if (!route.lazy) {
4152    return;
4153  }
4154  let routeToUpdate = manifest[route.id];
4155  invariant(routeToUpdate, "No route found in manifest");
4156  // Update the route in place.  This should be safe because there's no way
4157  // we could yet be sitting on this route as we can't get there without
4158  // resolving lazy() first.
4159  //
4160  // This is different than the HMR "update" use-case where we may actively be
4161  // on the route being updated.  The main concern boils down to "does this
4162  // mutation affect any ongoing navigations or any current state.matches
4163  // values?".  If not, it should be safe to update in place.
4164  let routeUpdates = {};
4165  for (let lazyRouteProperty in lazyRoute) {
4166    let staticRouteValue = routeToUpdate[lazyRouteProperty];
4167    let isPropertyStaticallyDefined = staticRouteValue !== undefined &&
4168    // This property isn't static since it should always be updated based
4169    // on the route updates
4170    lazyRouteProperty !== "hasErrorBoundary";
4171    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."));
4172    if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {
4173      routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];
4174    }
4175  }
4176  // Mutate the route with the provided updates.  Do this first so we pass
4177  // the updated version to mapRouteProperties
4178  Object.assign(routeToUpdate, routeUpdates);
4179  // Mutate the `hasErrorBoundary` property on the route based on the route
4180  // updates and remove the `lazy` function so we don't resolve the lazy
4181  // route again.
4182  Object.assign(routeToUpdate, _extends({}, mapRouteProperties(routeToUpdate), {
4183    lazy: undefined
4184  }));
4185}
4186// Default implementation of `dataStrategy` which fetches all loaders in parallel
4187async function defaultDataStrategy(_ref4) {
4188  let {
4189    matches
4190  } = _ref4;
4191  let matchesToLoad = matches.filter(m => m.shouldLoad);
4192  let results = await Promise.all(matchesToLoad.map(m => m.resolve()));
4193  return results.reduce((acc, result, i) => Object.assign(acc, {
4194    [matchesToLoad[i].route.id]: result
4195  }), {});
4196}
4197async function callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties, requestContext) {
4198  let loadRouteDefinitionsPromises = matches.map(m => m.route.lazy ? loadLazyRouteModule(m.route, mapRouteProperties, manifest) : undefined);
4199  let dsMatches = matches.map((match, i) => {
4200    let loadRoutePromise = loadRouteDefinitionsPromises[i];
4201    let shouldLoad = matchesToLoad.some(m => m.route.id === match.route.id);
4202    // `resolve` encapsulates route.lazy(), executing the loader/action,
4203    // and mapping return values/thrown errors to a `DataStrategyResult`.  Users
4204    // can pass a callback to take fine-grained control over the execution
4205    // of the loader/action
4206    let resolve = async handlerOverride => {
4207      if (handlerOverride && request.method === "GET" && (match.route.lazy || match.route.loader)) {
4208        shouldLoad = true;
4209      }
4210      return shouldLoad ? callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, requestContext) : Promise.resolve({
4211        type: ResultType.data,
4212        result: undefined
4213      });
4214    };
4215    return _extends({}, match, {
4216      shouldLoad,
4217      resolve
4218    });
4219  });
4220  // Send all matches here to allow for a middleware-type implementation.
4221  // handler will be a no-op for unneeded routes and we filter those results
4222  // back out below.
4223  let results = await dataStrategyImpl({
4224    matches: dsMatches,
4225    request,
4226    params: matches[0].params,
4227    fetcherKey,
4228    context: requestContext
4229  });
4230  // Wait for all routes to load here but 'swallow the error since we want
4231  // it to bubble up from the `await loadRoutePromise` in `callLoaderOrAction` -
4232  // called from `match.resolve()`
4233  try {
4234    await Promise.all(loadRouteDefinitionsPromises);
4235  } catch (e) {
4236    // No-op
4237  }
4238  return results;
4239}
4240// Default logic for calling a loader/action is the user has no specified a dataStrategy
4241async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, staticContext) {
4242  let result;
4243  let onReject;
4244  let runHandler = handler => {
4245    // Setup a promise we can race against so that abort signals short circuit
4246    let reject;
4247    // This will never resolve so safe to type it as Promise<DataStrategyResult> to
4248    // satisfy the function return value
4249    let abortPromise = new Promise((_, r) => reject = r);
4250    onReject = () => reject();
4251    request.signal.addEventListener("abort", onReject);
4252    let actualHandler = ctx => {
4253      if (typeof handler !== "function") {
4254        return Promise.reject(new Error("You cannot call the handler for a route which defines a boolean " + ("\"" + type + "\" [routeId: " + match.route.id + "]")));
4255      }
4256      return handler({
4257        request,
4258        params: match.params,
4259        context: staticContext
4260      }, ...(ctx !== undefined ? [ctx] : []));
4261    };
4262    let handlerPromise = (async () => {
4263      try {
4264        let val = await (handlerOverride ? handlerOverride(ctx => actualHandler(ctx)) : actualHandler());
4265        return {
4266          type: "data",
4267          result: val
4268        };
4269      } catch (e) {
4270        return {
4271          type: "error",
4272          result: e
4273        };
4274      }
4275    })();
4276    return Promise.race([handlerPromise, abortPromise]);
4277  };
4278  try {
4279    let handler = match.route[type];
4280    // If we have a route.lazy promise, await that first
4281    if (loadRoutePromise) {
4282      if (handler) {
4283        // Run statically defined handler in parallel with lazy()
4284        let handlerError;
4285        let [value] = await Promise.all([
4286        // If the handler throws, don't let it immediately bubble out,
4287        // since we need to let the lazy() execution finish so we know if this
4288        // route has a boundary that can handle the error
4289        runHandler(handler).catch(e => {
4290          handlerError = e;
4291        }), loadRoutePromise]);
4292        if (handlerError !== undefined) {
4293          throw handlerError;
4294        }
4295        result = value;
4296      } else {
4297        // Load lazy route module, then run any returned handler
4298        await loadRoutePromise;
4299        handler = match.route[type];
4300        if (handler) {
4301          // Handler still runs even if we got interrupted to maintain consistency
4302          // with un-abortable behavior of handler execution on non-lazy or
4303          // previously-lazy-loaded routes
4304          result = await runHandler(handler);
4305        } else if (type === "action") {
4306          let url = new URL(request.url);
4307          let pathname = url.pathname + url.search;
4308          throw getInternalRouterError(405, {
4309            method: request.method,
4310            pathname,
4311            routeId: match.route.id
4312          });
4313        } else {
4314          // lazy() route has no loader to run.  Short circuit here so we don't
4315          // hit the invariant below that errors on returning undefined.
4316          return {
4317            type: ResultType.data,
4318            result: undefined
4319          };
4320        }
4321      }
4322    } else if (!handler) {
4323      let url = new URL(request.url);
4324      let pathname = url.pathname + url.search;
4325      throw getInternalRouterError(404, {
4326        pathname
4327      });
4328    } else {
4329      result = await runHandler(handler);
4330    }
4331    invariant(result.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`.");
4332  } catch (e) {
4333    // We should already be catching and converting normal handler executions to
4334    // DataStrategyResults and returning them, so anything that throws here is an
4335    // unexpected error we still need to wrap
4336    return {
4337      type: ResultType.error,
4338      result: e
4339    };
4340  } finally {
4341    if (onReject) {
4342      request.signal.removeEventListener("abort", onReject);
4343    }
4344  }
4345  return result;
4346}
4347async function convertDataStrategyResultToDataResult(dataStrategyResult) {
4348  let {
4349    result,
4350    type
4351  } = dataStrategyResult;
4352  if (isResponse(result)) {
4353    let data;
4354    try {
4355      let contentType = result.headers.get("Content-Type");
4356      // Check between word boundaries instead of startsWith() due to the last
4357      // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type
4358      if (contentType && /\bapplication\/json\b/.test(contentType)) {
4359        if (result.body == null) {
4360          data = null;
4361        } else {
4362          data = await result.json();
4363        }
4364      } else {
4365        data = await result.text();
4366      }
4367    } catch (e) {
4368      return {
4369        type: ResultType.error,
4370        error: e
4371      };
4372    }
4373    if (type === ResultType.error) {
4374      return {
4375        type: ResultType.error,
4376        error: new ErrorResponseImpl(result.status, result.statusText, data),
4377        statusCode: result.status,
4378        headers: result.headers
4379      };
4380    }
4381    return {
4382      type: ResultType.data,
4383      data,
4384      statusCode: result.status,
4385      headers: result.headers
4386    };
4387  }
4388  if (type === ResultType.error) {
4389    if (isDataWithResponseInit(result)) {
4390      var _result$init2;
4391      if (result.data instanceof Error) {
4392        var _result$init;
4393        return {
4394          type: ResultType.error,
4395          error: result.data,
4396          statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status
4397        };
4398      }
4399      // Convert thrown data() to ErrorResponse instances
4400      result = new ErrorResponseImpl(((_result$init2 = result.init) == null ? void 0 : _result$init2.status) || 500, undefined, result.data);
4401    }
4402    return {
4403      type: ResultType.error,
4404      error: result,
4405      statusCode: isRouteErrorResponse(result) ? result.status : undefined
4406    };
4407  }
4408  if (isDeferredData(result)) {
4409    var _result$init3, _result$init4;
4410    return {
4411      type: ResultType.deferred,
4412      deferredData: result,
4413      statusCode: (_result$init3 = result.init) == null ? void 0 : _result$init3.status,
4414      headers: ((_result$init4 = result.init) == null ? void 0 : _result$init4.headers) && new Headers(result.init.headers)
4415    };
4416  }
4417  if (isDataWithResponseInit(result)) {
4418    var _result$init5, _result$init6;
4419    return {
4420      type: ResultType.data,
4421      data: result.data,
4422      statusCode: (_result$init5 = result.init) == null ? void 0 : _result$init5.status,
4423      headers: (_result$init6 = result.init) != null && _result$init6.headers ? new Headers(result.init.headers) : undefined
4424    };
4425  }
4426  return {
4427    type: ResultType.data,
4428    data: result
4429  };
4430}
4431// Support relative routing in internal redirects
4432function normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, v7_relativeSplatPath) {
4433  let location = response.headers.get("Location");
4434  invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header");
4435  if (!ABSOLUTE_URL_REGEX.test(location)) {
4436    let trimmedMatches = matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1);
4437    location = normalizeTo(new URL(request.url), trimmedMatches, basename, true, location, v7_relativeSplatPath);
4438    response.headers.set("Location", location);
4439  }
4440  return response;
4441}
4442function normalizeRedirectLocation(location, currentUrl, basename) {
4443  if (ABSOLUTE_URL_REGEX.test(location)) {
4444    // Strip off the protocol+origin for same-origin + same-basename absolute redirects
4445    let normalizedLocation = location;
4446    let url = normalizedLocation.startsWith("//") ? new URL(currentUrl.protocol + normalizedLocation) : new URL(normalizedLocation);
4447    let isSameBasename = stripBasename(url.pathname, basename) != null;
4448    if (url.origin === currentUrl.origin && isSameBasename) {
4449      return url.pathname + url.search + url.hash;
4450    }
4451  }
4452  return location;
4453}
4454// Utility method for creating the Request instances for loaders/actions during
4455// client-side navigations and fetches.  During SSR we will always have a
4456// Request instance from the static handler (query/queryRoute)
4457function createClientSideRequest(history, location, signal, submission) {
4458  let url = history.createURL(stripHashFromPath(location)).toString();
4459  let init = {
4460    signal
4461  };
4462  if (submission && isMutationMethod(submission.formMethod)) {
4463    let {
4464      formMethod,
4465      formEncType
4466    } = submission;
4467    // Didn't think we needed this but it turns out unlike other methods, patch
4468    // won't be properly normalized to uppercase and results in a 405 error.
4469    // See: https://fetch.spec.whatwg.org/#concept-method
4470    init.method = formMethod.toUpperCase();
4471    if (formEncType === "application/json") {
4472      init.headers = new Headers({
4473        "Content-Type": formEncType
4474      });
4475      init.body = JSON.stringify(submission.json);
4476    } else if (formEncType === "text/plain") {
4477      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
4478      init.body = submission.text;
4479    } else if (formEncType === "application/x-www-form-urlencoded" && submission.formData) {
4480      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
4481      init.body = convertFormDataToSearchParams(submission.formData);
4482    } else {
4483      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
4484      init.body = submission.formData;
4485    }
4486  }
4487  return new Request(url, init);
4488}
4489function convertFormDataToSearchParams(formData) {
4490  let searchParams = new URLSearchParams();
4491  for (let [key, value] of formData.entries()) {
4492    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs
4493    searchParams.append(key, typeof value === "string" ? value : value.name);
4494  }
4495  return searchParams;
4496}
4497function convertSearchParamsToFormData(searchParams) {
4498  let formData = new FormData();
4499  for (let [key, value] of searchParams.entries()) {
4500    formData.append(key, value);
4501  }
4502  return formData;
4503}
4504function processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling) {
4505  // Fill in loaderData/errors from our loaders
4506  let loaderData = {};
4507  let errors = null;
4508  let statusCode;
4509  let foundError = false;
4510  let loaderHeaders = {};
4511  let pendingError = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : undefined;
4512  // Process loader results into state.loaderData/state.errors
4513  matches.forEach(match => {
4514    if (!(match.route.id in results)) {
4515      return;
4516    }
4517    let id = match.route.id;
4518    let result = results[id];
4519    invariant(!isRedirectResult(result), "Cannot handle redirect results in processLoaderData");
4520    if (isErrorResult(result)) {
4521      let error = result.error;
4522      // If we have a pending action error, we report it at the highest-route
4523      // that throws a loader error, and then clear it out to indicate that
4524      // it was consumed
4525      if (pendingError !== undefined) {
4526        error = pendingError;
4527        pendingError = undefined;
4528      }
4529      errors = errors || {};
4530      if (skipLoaderErrorBubbling) {
4531        errors[id] = error;
4532      } else {
4533        // Look upwards from the matched route for the closest ancestor error
4534        // boundary, defaulting to the root match.  Prefer higher error values
4535        // if lower errors bubble to the same boundary
4536        let boundaryMatch = findNearestBoundary(matches, id);
4537        if (errors[boundaryMatch.route.id] == null) {
4538          errors[boundaryMatch.route.id] = error;
4539        }
4540      }
4541      // Clear our any prior loaderData for the throwing route
4542      loaderData[id] = undefined;
4543      // Once we find our first (highest) error, we set the status code and
4544      // prevent deeper status codes from overriding
4545      if (!foundError) {
4546        foundError = true;
4547        statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;
4548      }
4549      if (result.headers) {
4550        loaderHeaders[id] = result.headers;
4551      }
4552    } else {
4553      if (isDeferredResult(result)) {
4554        activeDeferreds.set(id, result.deferredData);
4555        loaderData[id] = result.deferredData.data;
4556        // Error status codes always override success status codes, but if all
4557        // loaders are successful we take the deepest status code.
4558        if (result.statusCode != null && result.statusCode !== 200 && !foundError) {
4559          statusCode = result.statusCode;
4560        }
4561        if (result.headers) {
4562          loaderHeaders[id] = result.headers;
4563        }
4564      } else {
4565        loaderData[id] = result.data;
4566        // Error status codes always override success status codes, but if all
4567        // loaders are successful we take the deepest status code.
4568        if (result.statusCode && result.statusCode !== 200 && !foundError) {
4569          statusCode = result.statusCode;
4570        }
4571        if (result.headers) {
4572          loaderHeaders[id] = result.headers;
4573        }
4574      }
4575    }
4576  });
4577  // If we didn't consume the pending action error (i.e., all loaders
4578  // resolved), then consume it here.  Also clear out any loaderData for the
4579  // throwing route
4580  if (pendingError !== undefined && pendingActionResult) {
4581    errors = {
4582      [pendingActionResult[0]]: pendingError
4583    };
4584    loaderData[pendingActionResult[0]] = undefined;
4585  }
4586  return {
4587    loaderData,
4588    errors,
4589    statusCode: statusCode || 200,
4590    loaderHeaders
4591  };
4592}
4593function processLoaderData(state, matches, results, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds) {
4594  let {
4595    loaderData,
4596    errors
4597  } = processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, false // This method is only called client side so we always want to bubble
4598  );
4599  // Process results from our revalidating fetchers
4600  revalidatingFetchers.forEach(rf => {
4601    let {
4602      key,
4603      match,
4604      controller
4605    } = rf;
4606    let result = fetcherResults[key];
4607    invariant(result, "Did not find corresponding fetcher result");
4608    // Process fetcher non-redirect errors
4609    if (controller && controller.signal.aborted) {
4610      // Nothing to do for aborted fetchers
4611      return;
4612    } else if (isErrorResult(result)) {
4613      let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);
4614      if (!(errors && errors[boundaryMatch.route.id])) {
4615        errors = _extends({}, errors, {
4616          [boundaryMatch.route.id]: result.error
4617        });
4618      }
4619      state.fetchers.delete(key);
4620    } else if (isRedirectResult(result)) {
4621      // Should never get here, redirects should get processed above, but we
4622      // keep this to type narrow to a success result in the else
4623      invariant(false, "Unhandled fetcher revalidation redirect");
4624    } else if (isDeferredResult(result)) {
4625      // Should never get here, deferred data should be awaited for fetchers
4626      // in resolveDeferredResults
4627      invariant(false, "Unhandled fetcher deferred data");
4628    } else {
4629      let doneFetcher = getDoneFetcher(result.data);
4630      state.fetchers.set(key, doneFetcher);
4631    }
4632  });
4633  return {
4634    loaderData,
4635    errors
4636  };
4637}
4638function mergeLoaderData(loaderData, newLoaderData, matches, errors) {
4639  let mergedLoaderData = _extends({}, newLoaderData);
4640  for (let match of matches) {
4641    let id = match.route.id;
4642    if (newLoaderData.hasOwnProperty(id)) {
4643      if (newLoaderData[id] !== undefined) {
4644        mergedLoaderData[id] = newLoaderData[id];
4645      }
4646    } else if (loaderData[id] !== undefined && match.route.loader) {
4647      // Preserve existing keys not included in newLoaderData and where a loader
4648      // wasn't removed by HMR
4649      mergedLoaderData[id] = loaderData[id];
4650    }
4651    if (errors && errors.hasOwnProperty(id)) {
4652      // Don't keep any loader data below the boundary
4653      break;
4654    }
4655  }
4656  return mergedLoaderData;
4657}
4658function getActionDataForCommit(pendingActionResult) {
4659  if (!pendingActionResult) {
4660    return {};
4661  }
4662  return isErrorResult(pendingActionResult[1]) ? {
4663    // Clear out prior actionData on errors
4664    actionData: {}
4665  } : {
4666    actionData: {
4667      [pendingActionResult[0]]: pendingActionResult[1].data
4668    }
4669  };
4670}
4671// Find the nearest error boundary, looking upwards from the leaf route (or the
4672// route specified by routeId) for the closest ancestor error boundary,
4673// defaulting to the root match
4674function findNearestBoundary(matches, routeId) {
4675  let eligibleMatches = routeId ? matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1) : [...matches];
4676  return eligibleMatches.reverse().find(m => m.route.hasErrorBoundary === true) || matches[0];
4677}
4678function getShortCircuitMatches(routes) {
4679  // Prefer a root layout route if present, otherwise shim in a route object
4680  let route = routes.length === 1 ? routes[0] : routes.find(r => r.index || !r.path || r.path === "/") || {
4681    id: "__shim-error-route__"
4682  };
4683  return {
4684    matches: [{
4685      params: {},
4686      pathname: "",
4687      pathnameBase: "",
4688      route
4689    }],
4690    route
4691  };
4692}
4693function getInternalRouterError(status, _temp5) {
4694  let {
4695    pathname,
4696    routeId,
4697    method,
4698    type,
4699    message
4700  } = _temp5 === void 0 ? {} : _temp5;
4701  let statusText = "Unknown Server Error";
4702  let errorMessage = "Unknown @remix-run/router error";
4703  if (status === 400) {
4704    statusText = "Bad Request";
4705    if (method && pathname && routeId) {
4706      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.";
4707    } else if (type === "defer-action") {
4708      errorMessage = "defer() is not supported in actions";
4709    } else if (type === "invalid-body") {
4710      errorMessage = "Unable to encode submission body";
4711    }
4712  } else if (status === 403) {
4713    statusText = "Forbidden";
4714    errorMessage = "Route \"" + routeId + "\" does not match URL \"" + pathname + "\"";
4715  } else if (status === 404) {
4716    statusText = "Not Found";
4717    errorMessage = "No route matches URL \"" + pathname + "\"";
4718  } else if (status === 405) {
4719    statusText = "Method Not Allowed";
4720    if (method && pathname && routeId) {
4721      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.";
4722    } else if (method) {
4723      errorMessage = "Invalid request method \"" + method.toUpperCase() + "\"";
4724    }
4725  }
4726  return new ErrorResponseImpl(status || 500, statusText, new Error(errorMessage), true);
4727}
4728// Find any returned redirect errors, starting from the lowest match
4729function findRedirect(results) {
4730  let entries = Object.entries(results);
4731  for (let i = entries.length - 1; i >= 0; i--) {
4732    let [key, result] = entries[i];
4733    if (isRedirectResult(result)) {
4734      return {
4735        key,
4736        result
4737      };
4738    }
4739  }
4740}
4741function stripHashFromPath(path) {
4742  let parsedPath = typeof path === "string" ? parsePath(path) : path;
4743  return createPath(_extends({}, parsedPath, {
4744    hash: ""
4745  }));
4746}
4747function isHashChangeOnly(a, b) {
4748  if (a.pathname !== b.pathname || a.search !== b.search) {
4749    return false;
4750  }
4751  if (a.hash === "") {
4752    // /page -> /page#hash
4753    return b.hash !== "";
4754  } else if (a.hash === b.hash) {
4755    // /page#hash -> /page#hash
4756    return true;
4757  } else if (b.hash !== "") {
4758    // /page#hash -> /page#other
4759    return true;
4760  }
4761  // If the hash is removed the browser will re-perform a request to the server
4762  // /page#hash -> /page
4763  return false;
4764}
4765function isDataStrategyResult(result) {
4766  return result != null && typeof result === "object" && "type" in result && "result" in result && (result.type === ResultType.data || result.type === ResultType.error);
4767}
4768function isRedirectDataStrategyResultResult(result) {
4769  return isResponse(result.result) && redirectStatusCodes.has(result.result.status);
4770}
4771function isDeferredResult(result) {
4772  return result.type === ResultType.deferred;
4773}
4774function isErrorResult(result) {
4775  return result.type === ResultType.error;
4776}
4777function isRedirectResult(result) {
4778  return (result && result.type) === ResultType.redirect;
4779}
4780function isDataWithResponseInit(value) {
4781  return typeof value === "object" && value != null && "type" in value && "data" in value && "init" in value && value.type === "DataWithResponseInit";
4782}
4783function isDeferredData(value) {
4784  let deferred = value;
4785  return deferred && typeof deferred === "object" && typeof deferred.data === "object" && typeof deferred.subscribe === "function" && typeof deferred.cancel === "function" && typeof deferred.resolveData === "function";
4786}
4787function isResponse(value) {
4788  return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
4789}
4790function isRedirectResponse(result) {
4791  if (!isResponse(result)) {
4792    return false;
4793  }
4794  let status = result.status;
4795  let location = result.headers.get("Location");
4796  return status >= 300 && status <= 399 && location != null;
4797}
4798function isValidMethod(method) {
4799  return validRequestMethods.has(method.toLowerCase());
4800}
4801function isMutationMethod(method) {
4802  return validMutationMethods.has(method.toLowerCase());
4803}
4804async function resolveNavigationDeferredResults(matches, results, signal, currentMatches, currentLoaderData) {
4805  let entries = Object.entries(results);
4806  for (let index = 0; index < entries.length; index++) {
4807    let [routeId, result] = entries[index];
4808    let match = matches.find(m => (m == null ? void 0 : m.route.id) === routeId);
4809    // If we don't have a match, then we can have a deferred result to do
4810    // anything with.  This is for revalidating fetchers where the route was
4811    // removed during HMR
4812    if (!match) {
4813      continue;
4814    }
4815    let currentMatch = currentMatches.find(m => m.route.id === match.route.id);
4816    let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;
4817    if (isDeferredResult(result) && isRevalidatingLoader) {
4818      // Note: we do not have to touch activeDeferreds here since we race them
4819      // against the signal in resolveDeferredData and they'll get aborted
4820      // there if needed
4821      await resolveDeferredData(result, signal, false).then(result => {
4822        if (result) {
4823          results[routeId] = result;
4824        }
4825      });
4826    }
4827  }
4828}
4829async function resolveFetcherDeferredResults(matches, results, revalidatingFetchers) {
4830  for (let index = 0; index < revalidatingFetchers.length; index++) {
4831    let {
4832      key,
4833      routeId,
4834      controller
4835    } = revalidatingFetchers[index];
4836    let result = results[key];
4837    let match = matches.find(m => (m == null ? void 0 : m.route.id) === routeId);
4838    // If we don't have a match, then we can have a deferred result to do
4839    // anything with.  This is for revalidating fetchers where the route was
4840    // removed during HMR
4841    if (!match) {
4842      continue;
4843    }
4844    if (isDeferredResult(result)) {
4845      // Note: we do not have to touch activeDeferreds here since we race them
4846      // against the signal in resolveDeferredData and they'll get aborted
4847      // there if needed
4848      invariant(controller, "Expected an AbortController for revalidating fetcher deferred result");
4849      await resolveDeferredData(result, controller.signal, true).then(result => {
4850        if (result) {
4851          results[key] = result;
4852        }
4853      });
4854    }
4855  }
4856}
4857async function resolveDeferredData(result, signal, unwrap) {
4858  if (unwrap === void 0) {
4859    unwrap = false;
4860  }
4861  let aborted = await result.deferredData.resolveData(signal);
4862  if (aborted) {
4863    return;
4864  }
4865  if (unwrap) {
4866    try {
4867      return {
4868        type: ResultType.data,
4869        data: result.deferredData.unwrappedData
4870      };
4871    } catch (e) {
4872      // Handle any TrackedPromise._error values encountered while unwrapping
4873      return {
4874        type: ResultType.error,
4875        error: e
4876      };
4877    }
4878  }
4879  return {
4880    type: ResultType.data,
4881    data: result.deferredData.data
4882  };
4883}
4884function hasNakedIndexQuery(search) {
4885  return new URLSearchParams(search).getAll("index").some(v => v === "");
4886}
4887function getTargetMatch(matches, location) {
4888  let search = typeof location === "string" ? parsePath(location).search : location.search;
4889  if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || "")) {
4890    // Return the leaf index route when index is present
4891    return matches[matches.length - 1];
4892  }
4893  // Otherwise grab the deepest "path contributing" match (ignoring index and
4894  // pathless layout routes)
4895  let pathMatches = getPathContributingMatches(matches);
4896  return pathMatches[pathMatches.length - 1];
4897}
4898function getSubmissionFromNavigation(navigation) {
4899  let {
4900    formMethod,
4901    formAction,
4902    formEncType,
4903    text,
4904    formData,
4905    json
4906  } = navigation;
4907  if (!formMethod || !formAction || !formEncType) {
4908    return;
4909  }
4910  if (text != null) {
4911    return {
4912      formMethod,
4913      formAction,
4914      formEncType,
4915      formData: undefined,
4916      json: undefined,
4917      text
4918    };
4919  } else if (formData != null) {
4920    return {
4921      formMethod,
4922      formAction,
4923      formEncType,
4924      formData,
4925      json: undefined,
4926      text: undefined
4927    };
4928  } else if (json !== undefined) {
4929    return {
4930      formMethod,
4931      formAction,
4932      formEncType,
4933      formData: undefined,
4934      json,
4935      text: undefined
4936    };
4937  }
4938}
4939function getLoadingNavigation(location, submission) {
4940  if (submission) {
4941    let navigation = {
4942      state: "loading",
4943      location,
4944      formMethod: submission.formMethod,
4945      formAction: submission.formAction,
4946      formEncType: submission.formEncType,
4947      formData: submission.formData,
4948      json: submission.json,
4949      text: submission.text
4950    };
4951    return navigation;
4952  } else {
4953    let navigation = {
4954      state: "loading",
4955      location,
4956      formMethod: undefined,
4957      formAction: undefined,
4958      formEncType: undefined,
4959      formData: undefined,
4960      json: undefined,
4961      text: undefined
4962    };
4963    return navigation;
4964  }
4965}
4966function getSubmittingNavigation(location, submission) {
4967  let navigation = {
4968    state: "submitting",
4969    location,
4970    formMethod: submission.formMethod,
4971    formAction: submission.formAction,
4972    formEncType: submission.formEncType,
4973    formData: submission.formData,
4974    json: submission.json,
4975    text: submission.text
4976  };
4977  return navigation;
4978}
4979function getLoadingFetcher(submission, data) {
4980  if (submission) {
4981    let fetcher = {
4982      state: "loading",
4983      formMethod: submission.formMethod,
4984      formAction: submission.formAction,
4985      formEncType: submission.formEncType,
4986      formData: submission.formData,
4987      json: submission.json,
4988      text: submission.text,
4989      data
4990    };
4991    return fetcher;
4992  } else {
4993    let fetcher = {
4994      state: "loading",
4995      formMethod: undefined,
4996      formAction: undefined,
4997      formEncType: undefined,
4998      formData: undefined,
4999      json: undefined,
5000      text: undefined,
5001      data
5002    };
5003    return fetcher;
5004  }
5005}
5006function getSubmittingFetcher(submission, existingFetcher) {
5007  let fetcher = {
5008    state: "submitting",
5009    formMethod: submission.formMethod,
5010    formAction: submission.formAction,
5011    formEncType: submission.formEncType,
5012    formData: submission.formData,
5013    json: submission.json,
5014    text: submission.text,
5015    data: existingFetcher ? existingFetcher.data : undefined
5016  };
5017  return fetcher;
5018}
5019function getDoneFetcher(data) {
5020  let fetcher = {
5021    state: "idle",
5022    formMethod: undefined,
5023    formAction: undefined,
5024    formEncType: undefined,
5025    formData: undefined,
5026    json: undefined,
5027    text: undefined,
5028    data
5029  };
5030  return fetcher;
5031}
5032function restoreAppliedTransitions(_window, transitions) {
5033  try {
5034    let sessionPositions = _window.sessionStorage.getItem(TRANSITIONS_STORAGE_KEY);
5035    if (sessionPositions) {
5036      let json = JSON.parse(sessionPositions);
5037      for (let [k, v] of Object.entries(json || {})) {
5038        if (v && Array.isArray(v)) {
5039          transitions.set(k, new Set(v || []));
5040        }
5041      }
5042    }
5043  } catch (e) {
5044    // no-op, use default empty object
5045  }
5046}
5047function persistAppliedTransitions(_window, transitions) {
5048  if (transitions.size > 0) {
5049    let json = {};
5050    for (let [k, v] of transitions) {
5051      json[k] = [...v];
5052    }
5053    try {
5054      _window.sessionStorage.setItem(TRANSITIONS_STORAGE_KEY, JSON.stringify(json));
5055    } catch (error) {
5056      warning(false, "Failed to save applied view transitions in sessionStorage (" + error + ").");
5057    }
5058  }
5059}
5060//#endregion
5061
5062
5063//# sourceMappingURL=router.js.map
5064
5065
5066/***/ }),
5067