{"version":3,"file":"@remix-run-btJpMTWE.js","sources":["../../node_modules/@remix-run/router/dist/router.js"],"sourcesContent":["/**\n * @remix-run/router v1.16.1\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Actions represent the type of change to a location value.\n */\nvar Action;\n(function (Action) {\n  /**\n   * A POP indicates a change to an arbitrary index in the history stack, such\n   * as a back or forward navigation. It does not describe the direction of the\n   * navigation, only that the current index changed.\n   *\n   * Note: This is the default action for newly created history objects.\n   */\n  Action[\"Pop\"] = \"POP\";\n  /**\n   * A PUSH indicates a new entry being added to the history stack, such as when\n   * a link is clicked and a new page loads. When this happens, all subsequent\n   * entries in the stack are lost.\n   */\n  Action[\"Push\"] = \"PUSH\";\n  /**\n   * A REPLACE indicates the entry at the current index in the history stack\n   * being replaced by a new one.\n   */\n  Action[\"Replace\"] = \"REPLACE\";\n})(Action || (Action = {}));\nconst PopStateEventType = \"popstate\";\n/**\n * Memory history stores the current location in memory. It is designed for use\n * in stateful non-browser environments like tests and React Native.\n */\nfunction createMemoryHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  let {\n    initialEntries = [\"/\"],\n    initialIndex,\n    v5Compat = false\n  } = options;\n  let entries; // Declare so we can access from createMemoryLocation\n  entries = initialEntries.map((entry, index) => createMemoryLocation(entry, typeof entry === \"string\" ? null : entry.state, index === 0 ? \"default\" : undefined));\n  let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);\n  let action = Action.Pop;\n  let listener = null;\n  function clampIndex(n) {\n    return Math.min(Math.max(n, 0), entries.length - 1);\n  }\n  function getCurrentLocation() {\n    return entries[index];\n  }\n  function createMemoryLocation(to, state, key) {\n    if (state === void 0) {\n      state = null;\n    }\n    let location = createLocation(entries ? getCurrentLocation().pathname : \"/\", to, state, key);\n    warning(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in memory history: \" + JSON.stringify(to));\n    return location;\n  }\n  function createHref(to) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n  let history = {\n    get index() {\n      return index;\n    },\n    get action() {\n      return action;\n    },\n    get location() {\n      return getCurrentLocation();\n    },\n    createHref,\n    createURL(to) {\n      return new URL(createHref(to), \"http://localhost\");\n    },\n    encodeLocation(to) {\n      let path = typeof to === \"string\" ? parsePath(to) : to;\n      return {\n        pathname: path.pathname || \"\",\n        search: path.search || \"\",\n        hash: path.hash || \"\"\n      };\n    },\n    push(to, state) {\n      action = Action.Push;\n      let nextLocation = createMemoryLocation(to, state);\n      index += 1;\n      entries.splice(index, entries.length, nextLocation);\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta: 1\n        });\n      }\n    },\n    replace(to, state) {\n      action = Action.Replace;\n      let nextLocation = createMemoryLocation(to, state);\n      entries[index] = nextLocation;\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta: 0\n        });\n      }\n    },\n    go(delta) {\n      action = Action.Pop;\n      let nextIndex = clampIndex(index + delta);\n      let nextLocation = entries[nextIndex];\n      index = nextIndex;\n      if (listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta\n        });\n      }\n    },\n    listen(fn) {\n      listener = fn;\n      return () => {\n        listener = null;\n      };\n    }\n  };\n  return history;\n}\n/**\n * Browser history stores the location in regular URLs. This is the standard for\n * most web apps, but it requires some configuration on the server to ensure you\n * serve the same app at multiple URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\n */\nfunction createBrowserHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  function createBrowserLocation(window, globalHistory) {\n    let {\n      pathname,\n      search,\n      hash\n    } = window.location;\n    return createLocation(\"\", {\n      pathname,\n      search,\n      hash\n    },\n    // state defaults to `null` because `window.history.state` does\n    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n  }\n  function createBrowserHref(window, to) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n  return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);\n}\n/**\n * Hash history stores the location in window.location.hash. This makes it ideal\n * for situations where you don't want to send the location to the server for\n * some reason, either because you do cannot configure it or the URL space is\n * reserved for something else.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\n */\nfunction createHashHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  function createHashLocation(window, globalHistory) {\n    let {\n      pathname = \"/\",\n      search = \"\",\n      hash = \"\"\n    } = parsePath(window.location.hash.substr(1));\n    // Hash URL should always have a leading / just like window.location.pathname\n    // does, so if an app ends up at a route like /#something then we add a\n    // leading slash so all of our path-matching behaves the same as if it would\n    // in a browser router.  This is particularly important when there exists a\n    // root splat route (<Route path=\"*\">) since that matches internally against\n    // \"/*\" and we'd expect /#something to 404 in a hash router app.\n    if (!pathname.startsWith(\"/\") && !pathname.startsWith(\".\")) {\n      pathname = \"/\" + pathname;\n    }\n    return createLocation(\"\", {\n      pathname,\n      search,\n      hash\n    },\n    // state defaults to `null` because `window.history.state` does\n    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n  }\n  function createHashHref(window, to) {\n    let base = window.document.querySelector(\"base\");\n    let href = \"\";\n    if (base && base.getAttribute(\"href\")) {\n      let url = window.location.href;\n      let hashIndex = url.indexOf(\"#\");\n      href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n    }\n    return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n  }\n  function validateHashLocation(location, to) {\n    warning(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in hash history.push(\" + JSON.stringify(to) + \")\");\n  }\n  return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);\n}\nfunction invariant(value, message) {\n  if (value === false || value === null || typeof value === \"undefined\") {\n    throw new Error(message);\n  }\n}\nfunction warning(cond, message) {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== \"undefined\") console.warn(message);\n    try {\n      // Welcome to debugging history!\n      //\n      // This error is thrown as a convenience, so you can more easily\n      // find the source for a warning that appears in the console by\n      // enabling \"pause on exceptions\" in your JavaScript debugger.\n      throw new Error(message);\n      // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\nfunction createKey() {\n  return Math.random().toString(36).substr(2, 8);\n}\n/**\n * For browser-based histories, we combine the state and key into an object\n */\nfunction getHistoryState(location, index) {\n  return {\n    usr: location.state,\n    key: location.key,\n    idx: index\n  };\n}\n/**\n * Creates a Location object with a unique key from the given Path\n */\nfunction createLocation(current, to, state, key) {\n  if (state === void 0) {\n    state = null;\n  }\n  let location = _extends({\n    pathname: typeof current === \"string\" ? current : current.pathname,\n    search: \"\",\n    hash: \"\"\n  }, typeof to === \"string\" ? parsePath(to) : to, {\n    state,\n    // TODO: This could be cleaned up.  push/replace should probably just take\n    // full Locations now and avoid the need to run through this flow at all\n    // But that's a pretty big refactor to the current test suite so going to\n    // keep as is for the time being and just let any incoming keys take precedence\n    key: to && to.key || key || createKey()\n  });\n  return location;\n}\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\nfunction createPath(_ref) {\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\"\n  } = _ref;\n  if (search && search !== \"?\") pathname += search.charAt(0) === \"?\" ? search : \"?\" + search;\n  if (hash && hash !== \"#\") pathname += hash.charAt(0) === \"#\" ? hash : \"#\" + hash;\n  return pathname;\n}\n/**\n * Parses a string URL path into its separate pathname, search, and hash components.\n */\nfunction parsePath(path) {\n  let parsedPath = {};\n  if (path) {\n    let hashIndex = path.indexOf(\"#\");\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n    let searchIndex = path.indexOf(\"?\");\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n  return parsedPath;\n}\nfunction getUrlBasedHistory(getLocation, createHref, validateLocation, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  let {\n    window = document.defaultView,\n    v5Compat = false\n  } = options;\n  let globalHistory = window.history;\n  let action = Action.Pop;\n  let listener = null;\n  let index = getIndex();\n  // Index should only be null when we initialize. If not, it's because the\n  // user called history.pushState or history.replaceState directly, in which\n  // case we should log a warning as it will result in bugs.\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState(_extends({}, globalHistory.state, {\n      idx: index\n    }), \"\");\n  }\n  function getIndex() {\n    let state = globalHistory.state || {\n      idx: null\n    };\n    return state.idx;\n  }\n  function handlePop() {\n    action = Action.Pop;\n    let nextIndex = getIndex();\n    let delta = nextIndex == null ? null : nextIndex - index;\n    index = nextIndex;\n    if (listener) {\n      listener({\n        action,\n        location: history.location,\n        delta\n      });\n    }\n  }\n  function push(to, state) {\n    action = Action.Push;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n    index = getIndex() + 1;\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    // try...catch because iOS limits us to 100 pushState calls :/\n    try {\n      globalHistory.pushState(historyState, \"\", url);\n    } catch (error) {\n      // If the exception is because `state` can't be serialized, let that throw\n      // outwards just like a replace call would so the dev knows the cause\n      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps\n      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal\n      if (error instanceof DOMException && error.name === \"DataCloneError\") {\n        throw error;\n      }\n      // They are going to lose state here, but there is no real\n      // way to warn them about it since the page will refresh...\n      window.location.assign(url);\n    }\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location,\n        delta: 1\n      });\n    }\n  }\n  function replace(to, state) {\n    action = Action.Replace;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n    index = getIndex();\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    globalHistory.replaceState(historyState, \"\", url);\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location,\n        delta: 0\n      });\n    }\n  }\n  function createURL(to) {\n    // window.location.origin is \"null\" (the literal string value) in Firefox\n    // under certain conditions, notably when serving from a local HTML file\n    // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n    let base = window.location.origin !== \"null\" ? window.location.origin : window.location.href;\n    let href = typeof to === \"string\" ? to : createPath(to);\n    // Treating this as a full URL will strip any trailing spaces so we need to\n    // pre-encode them since they might be part of a matching splat param from\n    // an ancestor route\n    href = href.replace(/ $/, \"%20\");\n    invariant(base, \"No window.location.(origin|href) available to create URL for href: \" + href);\n    return new URL(href, base);\n  }\n  let history = {\n    get action() {\n      return action;\n    },\n    get location() {\n      return getLocation(window, globalHistory);\n    },\n    listen(fn) {\n      if (listener) {\n        throw new Error(\"A history only accepts one active listener\");\n      }\n      window.addEventListener(PopStateEventType, handlePop);\n      listener = fn;\n      return () => {\n        window.removeEventListener(PopStateEventType, handlePop);\n        listener = null;\n      };\n    },\n    createHref(to) {\n      return createHref(window, to);\n    },\n    createURL,\n    encodeLocation(to) {\n      // Encode a Location the same way window.location would\n      let url = createURL(to);\n      return {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash\n      };\n    },\n    push,\n    replace,\n    go(n) {\n      return globalHistory.go(n);\n    }\n  };\n  return history;\n}\n//#endregion\n\nvar ResultType;\n(function (ResultType) {\n  ResultType[\"data\"] = \"data\";\n  ResultType[\"deferred\"] = \"deferred\";\n  ResultType[\"redirect\"] = \"redirect\";\n  ResultType[\"error\"] = \"error\";\n})(ResultType || (ResultType = {}));\nconst immutableRouteKeys = new Set([\"lazy\", \"caseSensitive\", \"path\", \"id\", \"index\", \"children\"]);\nfunction isIndexRoute(route) {\n  return route.index === true;\n}\n// Walk the route tree generating unique IDs where necessary, so we are working\n// solely with AgnosticDataRouteObject's within the Router\nfunction convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath, manifest) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\n  if (manifest === void 0) {\n    manifest = {};\n  }\n  return routes.map((route, index) => {\n    let treePath = [...parentPath, index];\n    let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n    invariant(route.index !== true || !route.children, \"Cannot specify children on an index route\");\n    invariant(!manifest[id], \"Found a route id collision on id \\\"\" + id + \"\\\".  Route \" + \"id's must be globally unique within Data Router usages\");\n    if (isIndexRoute(route)) {\n      let indexRoute = _extends({}, route, mapRouteProperties(route), {\n        id\n      });\n      manifest[id] = indexRoute;\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute = _extends({}, route, mapRouteProperties(route), {\n        id,\n        children: undefined\n      });\n      manifest[id] = pathOrLayoutRoute;\n      if (route.children) {\n        pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties, treePath, manifest);\n      }\n      return pathOrLayoutRoute;\n    }\n  });\n}\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/utils/match-routes\n */\nfunction matchRoutes(routes, locationArg, basename) {\n  if (basename === void 0) {\n    basename = \"/\";\n  }\n  let location = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n  let pathname = stripBasename(location.pathname || \"/\", basename);\n  if (pathname == null) {\n    return null;\n  }\n  let branches = flattenRoutes(routes);\n  rankRouteBranches(branches);\n  let matches = null;\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    // Incoming pathnames are generally encoded from either window.location\n    // or from router.navigate, but we want to match against the unencoded\n    // paths in the route definitions.  Memory router locations won't be\n    // encoded here but there also shouldn't be anything to decode so this\n    // should be a safe operation.  This avoids needing matchRoutes to be\n    // history-aware.\n    let decoded = decodePath(pathname);\n    matches = matchRouteBranch(branches[i], decoded);\n  }\n  return matches;\n}\nfunction convertRouteMatchToUiMatch(match, loaderData) {\n  let {\n    route,\n    pathname,\n    params\n  } = match;\n  return {\n    id: route.id,\n    pathname,\n    params,\n    data: loaderData[route.id],\n    handle: route.handle\n  };\n}\nfunction flattenRoutes(routes, branches, parentsMeta, parentPath) {\n  if (branches === void 0) {\n    branches = [];\n  }\n  if (parentsMeta === void 0) {\n    parentsMeta = [];\n  }\n  if (parentPath === void 0) {\n    parentPath = \"\";\n  }\n  let flattenRoute = (route, index, relativePath) => {\n    let meta = {\n      relativePath: relativePath === undefined ? route.path || \"\" : relativePath,\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route\n    };\n    if (meta.relativePath.startsWith(\"/\")) {\n      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.\");\n      meta.relativePath = meta.relativePath.slice(parentPath.length);\n    }\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta);\n    // Add the children before adding this route to the array, so we traverse the\n    // route tree depth-first and child routes appear before their parents in\n    // the \"flattened\" version.\n    if (route.children && route.children.length > 0) {\n      invariant(\n      // Our types know better, but runtime JS may not!\n      // @ts-expect-error\n      route.index !== true, \"Index routes must not have child routes. Please remove \" + (\"all child routes from route path \\\"\" + path + \"\\\".\"));\n      flattenRoutes(route.children, branches, routesMeta, path);\n    }\n    // Routes without a path shouldn't ever match by themselves unless they are\n    // index routes, so don't add them to the list of possible branches.\n    if (route.path == null && !route.index) {\n      return;\n    }\n    branches.push({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta\n    });\n  };\n  routes.forEach((route, index) => {\n    var _route$path;\n    // coarse-grain check for optional params\n    if (route.path === \"\" || !((_route$path = route.path) != null && _route$path.includes(\"?\"))) {\n      flattenRoute(route, index);\n    } else {\n      for (let exploded of explodeOptionalSegments(route.path)) {\n        flattenRoute(route, index, exploded);\n      }\n    }\n  });\n  return branches;\n}\n/**\n * Computes all combinations of optional path segments for a given path,\n * excluding combinations that are ambiguous and of lower priority.\n *\n * For example, `/one/:two?/three/:four?/:five?` explodes to:\n * - `/one/three`\n * - `/one/:two/three`\n * - `/one/three/:four`\n * - `/one/three/:five`\n * - `/one/:two/three/:four`\n * - `/one/:two/three/:five`\n * - `/one/three/:four/:five`\n * - `/one/:two/three/:four/:five`\n */\nfunction explodeOptionalSegments(path) {\n  let segments = path.split(\"/\");\n  if (segments.length === 0) return [];\n  let [first, ...rest] = segments;\n  // Optional path segments are denoted by a trailing `?`\n  let isOptional = first.endsWith(\"?\");\n  // Compute the corresponding required segment: `foo?` -> `foo`\n  let required = first.replace(/\\?$/, \"\");\n  if (rest.length === 0) {\n    // Intepret empty string as omitting an optional segment\n    // `[\"one\", \"\", \"three\"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`\n    return isOptional ? [required, \"\"] : [required];\n  }\n  let restExploded = explodeOptionalSegments(rest.join(\"/\"));\n  let result = [];\n  // All child paths with the prefix.  Do this for all children before the\n  // optional version for all children, so we get consistent ordering where the\n  // parent optional aspect is preferred as required.  Otherwise, we can get\n  // child sections interspersed where deeper optional segments are higher than\n  // parent optional segments, where for example, /:two would explode _earlier_\n  // then /:one.  By always including the parent as required _for all children_\n  // first, we avoid this issue\n  result.push(...restExploded.map(subpath => subpath === \"\" ? required : [required, subpath].join(\"/\")));\n  // Then, if this is an optional value, add all child versions without\n  if (isOptional) {\n    result.push(...restExploded);\n  }\n  // for absolute paths, ensure `/` instead of empty segment\n  return result.map(exploded => path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded);\n}\nfunction rankRouteBranches(branches) {\n  branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first\n  : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));\n}\nconst paramRe = /^:[\\w-]+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = s => s === \"*\";\nfunction computeScore(path, index) {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n  return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === \"\" ? emptySegmentValue : staticSegmentValue), initialScore);\n}\nfunction compareIndexes(a, b) {\n  let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n  return siblings ?\n  // If two routes are siblings, we should try to match the earlier sibling\n  // first. This allows people to have fine-grained control over the matching\n  // behavior by simply putting routes with identical paths in the order they\n  // want them tried.\n  a[a.length - 1] - b[b.length - 1] :\n  // Otherwise, it doesn't really make sense to rank non-siblings by index,\n  // so they sort equally.\n  0;\n}\nfunction matchRouteBranch(branch, pathname) {\n  let {\n    routesMeta\n  } = branch;\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches = [];\n  for (let i = 0; i < routesMeta.length; ++i) {\n    let meta = routesMeta[i];\n    let end = i === routesMeta.length - 1;\n    let remainingPathname = matchedPathname === \"/\" ? pathname : pathname.slice(matchedPathname.length) || \"/\";\n    let match = matchPath({\n      path: meta.relativePath,\n      caseSensitive: meta.caseSensitive,\n      end\n    }, remainingPathname);\n    if (!match) return null;\n    Object.assign(matchedParams, match.params);\n    let route = meta.route;\n    matches.push({\n      // TODO: Can this as be avoided?\n      params: matchedParams,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),\n      route\n    });\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n  return matches;\n}\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/utils/generate-path\n */\nfunction generatePath(originalPath, params) {\n  if (params === void 0) {\n    params = {};\n  }\n  let path = originalPath;\n  if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n    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(/\\*$/, \"/*\") + \"\\\".\"));\n    path = path.replace(/\\*$/, \"/*\");\n  }\n  // ensure `/` is added at the beginning if the path is absolute\n  const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n  const stringify = p => p == null ? \"\" : typeof p === \"string\" ? p : String(p);\n  const segments = path.split(/\\/+/).map((segment, index, array) => {\n    const isLastSegment = index === array.length - 1;\n    // only apply the splat if it's the last segment\n    if (isLastSegment && segment === \"*\") {\n      const star = \"*\";\n      // Apply the splat\n      return stringify(params[star]);\n    }\n    const keyMatch = segment.match(/^:([\\w-]+)(\\??)$/);\n    if (keyMatch) {\n      const [, key, optional] = keyMatch;\n      let param = params[key];\n      invariant(optional === \"?\" || param != null, \"Missing \\\":\" + key + \"\\\" param\");\n      return stringify(param);\n    }\n    // Remove any optional markers from optional static segments\n    return segment.replace(/\\?$/g, \"\");\n  })\n  // Remove empty segments\n  .filter(segment => !!segment);\n  return prefix + segments.join(\"/\");\n}\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/utils/match-path\n */\nfunction matchPath(pattern, pathname) {\n  if (typeof pattern === \"string\") {\n    pattern = {\n      path: pattern,\n      caseSensitive: false,\n      end: true\n    };\n  }\n  let [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);\n  let match = pathname.match(matcher);\n  if (!match) return null;\n  let matchedPathname = match[0];\n  let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n  let captureGroups = match.slice(1);\n  let params = compiledParams.reduce((memo, _ref, index) => {\n    let {\n      paramName,\n      isOptional\n    } = _ref;\n    // We need to compute the pathnameBase here using the raw splat value\n    // instead of using params[\"*\"] later because it will be decoded then\n    if (paramName === \"*\") {\n      let splatValue = captureGroups[index] || \"\";\n      pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\\/+$/, \"$1\");\n    }\n    const value = captureGroups[index];\n    if (isOptional && !value) {\n      memo[paramName] = undefined;\n    } else {\n      memo[paramName] = (value || \"\").replace(/%2F/g, \"/\");\n    }\n    return memo;\n  }, {});\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern\n  };\n}\nfunction compilePath(path, caseSensitive, end) {\n  if (caseSensitive === void 0) {\n    caseSensitive = false;\n  }\n  if (end === void 0) {\n    end = true;\n  }\n  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(/\\*$/, \"/*\") + \"\\\".\"));\n  let params = [];\n  let regexpSource = \"^\" + path.replace(/\\/*\\*?$/, \"\") // Ignore trailing / and /*, we'll handle it below\n  .replace(/^\\/*/, \"/\") // Make sure it has a leading /\n  .replace(/[\\\\.*+^${}|()[\\]]/g, \"\\\\$&\") // Escape special regex chars\n  .replace(/\\/:([\\w-]+)(\\?)?/g, (_, paramName, isOptional) => {\n    params.push({\n      paramName,\n      isOptional: isOptional != null\n    });\n    return isOptional ? \"/?([^\\\\/]+)?\" : \"/([^\\\\/]+)\";\n  });\n  if (path.endsWith(\"*\")) {\n    params.push({\n      paramName: \"*\"\n    });\n    regexpSource += path === \"*\" || path === \"/*\" ? \"(.*)$\" // Already matched the initial /, just match the rest\n    : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else if (end) {\n    // When matching to the end, ignore trailing slashes\n    regexpSource += \"\\\\/*$\";\n  } else if (path !== \"\" && path !== \"/\") {\n    // If our path is non-empty and contains anything beyond an initial slash,\n    // then we have _some_ form of path in our regex, so we should expect to\n    // match only if we find the end of this path segment.  Look for an optional\n    // non-captured trailing slash (to match a portion of the URL) or the end\n    // of the path (if we've matched to the end).  We used to do this with a\n    // word boundary but that gives false positives on routes like\n    // /user-preferences since `-` counts as a word boundary.\n    regexpSource += \"(?:(?=\\\\/|$))\";\n  } else ;\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n  return [matcher, params];\n}\nfunction decodePath(value) {\n  try {\n    return value.split(\"/\").map(v => decodeURIComponent(v).replace(/\\//g, \"%2F\")).join(\"/\");\n  } catch (error) {\n    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 + \").\"));\n    return value;\n  }\n}\n/**\n * @private\n */\nfunction stripBasename(pathname, basename) {\n  if (basename === \"/\") return pathname;\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n  // We want to leave trailing slash behavior in the user's control, so if they\n  // specify a basename with a trailing slash, we should support it\n  let startIndex = basename.endsWith(\"/\") ? basename.length - 1 : basename.length;\n  let nextChar = pathname.charAt(startIndex);\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n  return pathname.slice(startIndex) || \"/\";\n}\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/utils/resolve-path\n */\nfunction resolvePath(to, fromPathname) {\n  if (fromPathname === void 0) {\n    fromPathname = \"/\";\n  }\n  let {\n    pathname: toPathname,\n    search = \"\",\n    hash = \"\"\n  } = typeof to === \"string\" ? parsePath(to) : to;\n  let pathname = toPathname ? toPathname.startsWith(\"/\") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;\n  return {\n    pathname,\n    search: normalizeSearch(search),\n    hash: normalizeHash(hash)\n  };\n}\nfunction resolvePathname(relativePath, fromPathname) {\n  let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n  let relativeSegments = relativePath.split(\"/\");\n  relativeSegments.forEach(segment => {\n    if (segment === \"..\") {\n      // Keep the root \"\" segment so the pathname starts at /\n      if (segments.length > 1) segments.pop();\n    } else if (segment !== \".\") {\n      segments.push(segment);\n    }\n  });\n  return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\nfunction getInvalidPathError(char, field, dest, path) {\n  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.\";\n}\n/**\n * @private\n *\n * When processing relative navigation we want to ignore ancestor routes that\n * do not contribute to the path, such that index/pathless layout routes don't\n * interfere.\n *\n * For example, when moving a route element into an index route and/or a\n * pathless layout route, relative link behavior contained within should stay\n * the same.  Both of the following examples should link back to the root:\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\" element={<Link to=\"..\"}>\n *   </Route>\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\">\n *       <Route element={<AccountsLayout />}>       // <-- Does not contribute\n *         <Route index element={<Link to=\"..\"} />  // <-- Does not contribute\n *       </Route\n *     </Route>\n *   </Route>\n */\nfunction getPathContributingMatches(matches) {\n  return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);\n}\n// Return the array of pathnames for the current route matches - used to\n// generate the routePathnames input for resolveTo()\nfunction getResolveToMatches(matches, v7_relativeSplatPath) {\n  let pathMatches = getPathContributingMatches(matches);\n  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf\n  // match so we include splat values for \".\" links.  See:\n  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329\n  if (v7_relativeSplatPath) {\n    return pathMatches.map((match, idx) => idx === matches.length - 1 ? match.pathname : match.pathnameBase);\n  }\n  return pathMatches.map(match => match.pathnameBase);\n}\n/**\n * @private\n */\nfunction resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {\n  if (isPathRelative === void 0) {\n    isPathRelative = false;\n  }\n  let to;\n  if (typeof toArg === \"string\") {\n    to = parsePath(toArg);\n  } else {\n    to = _extends({}, toArg);\n    invariant(!to.pathname || !to.pathname.includes(\"?\"), getInvalidPathError(\"?\", \"pathname\", \"search\", to));\n    invariant(!to.pathname || !to.pathname.includes(\"#\"), getInvalidPathError(\"#\", \"pathname\", \"hash\", to));\n    invariant(!to.search || !to.search.includes(\"#\"), getInvalidPathError(\"#\", \"search\", \"hash\", to));\n  }\n  let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n  let toPathname = isEmptyPath ? \"/\" : to.pathname;\n  let from;\n  // Routing is relative to the current pathname if explicitly requested.\n  //\n  // If a pathname is explicitly provided in `to`, it should be relative to the\n  // route context. This is explained in `Note on `<Link to>` values` in our\n  // migration guide from v5 as a means of disambiguation between `to` values\n  // that begin with `/` and those that do not. However, this is problematic for\n  // `to` values that do not provide a pathname. `to` can simply be a search or\n  // hash string, in which case we should assume that the navigation is relative\n  // to the current location's pathname and *not* the route pathname.\n  if (toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n    // With relative=\"route\" (the default), each leading .. segment means\n    // \"go up one route\" instead of \"go up one URL segment\".  This is a key\n    // difference from how <a href> works and a major reason we call this a\n    // \"to\" value instead of a \"href\".\n    if (!isPathRelative && toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n      to.pathname = toSegments.join(\"/\");\n    }\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n  let path = resolvePath(to, from);\n  // Ensure the pathname has a trailing slash if the original \"to\" had one\n  let hasExplicitTrailingSlash = toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\");\n  // Or if this was a link to the current path which has a trailing slash\n  let hasCurrentTrailingSlash = (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n  if (!path.pathname.endsWith(\"/\") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {\n    path.pathname += \"/\";\n  }\n  return path;\n}\n/**\n * @private\n */\nfunction getToPathname(to) {\n  // Empty strings should be treated the same as / paths\n  return to === \"\" || to.pathname === \"\" ? \"/\" : typeof to === \"string\" ? parsePath(to).pathname : to.pathname;\n}\n/**\n * @private\n */\nconst joinPaths = paths => paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n/**\n * @private\n */\nconst normalizePathname = pathname => pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n/**\n * @private\n */\nconst normalizeSearch = search => !search || search === \"?\" ? \"\" : search.startsWith(\"?\") ? search : \"?\" + search;\n/**\n * @private\n */\nconst normalizeHash = hash => !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n */\nconst json = function json(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  let headers = new Headers(responseInit.headers);\n  if (!headers.has(\"Content-Type\")) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n  }\n  return new Response(JSON.stringify(data), _extends({}, responseInit, {\n    headers\n  }));\n};\nclass AbortedDeferredError extends Error {}\nclass DeferredData {\n  constructor(data, responseInit) {\n    this.pendingKeysSet = new Set();\n    this.subscribers = new Set();\n    this.deferredKeys = [];\n    invariant(data && typeof data === \"object\" && !Array.isArray(data), \"defer() only accepts plain objects\");\n    // Set up an AbortController + Promise we can race against to exit early\n    // cancellation\n    let reject;\n    this.abortPromise = new Promise((_, r) => reject = r);\n    this.controller = new AbortController();\n    let onAbort = () => reject(new AbortedDeferredError(\"Deferred data aborted\"));\n    this.unlistenAbortSignal = () => this.controller.signal.removeEventListener(\"abort\", onAbort);\n    this.controller.signal.addEventListener(\"abort\", onAbort);\n    this.data = Object.entries(data).reduce((acc, _ref2) => {\n      let [key, value] = _ref2;\n      return Object.assign(acc, {\n        [key]: this.trackPromise(key, value)\n      });\n    }, {});\n    if (this.done) {\n      // All incoming values were resolved\n      this.unlistenAbortSignal();\n    }\n    this.init = responseInit;\n  }\n  trackPromise(key, value) {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n    this.deferredKeys.push(key);\n    this.pendingKeysSet.add(key);\n    // We store a little wrapper promise that will be extended with\n    // _data/_error props upon resolve/reject\n    let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, undefined, data), error => this.onSettle(promise, key, error));\n    // Register rejection listeners to avoid uncaught promise rejections on\n    // errors or aborted deferred values\n    promise.catch(() => {});\n    Object.defineProperty(promise, \"_tracked\", {\n      get: () => true\n    });\n    return promise;\n  }\n  onSettle(promise, key, error, data) {\n    if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {\n      this.unlistenAbortSignal();\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      return Promise.reject(error);\n    }\n    this.pendingKeysSet.delete(key);\n    if (this.done) {\n      // Nothing left to abort!\n      this.unlistenAbortSignal();\n    }\n    // If the promise was resolved/rejected with undefined, we'll throw an error as you\n    // should always resolve with a value or null\n    if (error === undefined && data === undefined) {\n      let undefinedError = new Error(\"Deferred data for key \\\"\" + key + \"\\\" resolved/rejected with `undefined`, \" + \"you must resolve/reject with a value or `null`.\");\n      Object.defineProperty(promise, \"_error\", {\n        get: () => undefinedError\n      });\n      this.emit(false, key);\n      return Promise.reject(undefinedError);\n    }\n    if (data === undefined) {\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      this.emit(false, key);\n      return Promise.reject(error);\n    }\n    Object.defineProperty(promise, \"_data\", {\n      get: () => data\n    });\n    this.emit(false, key);\n    return data;\n  }\n  emit(aborted, settledKey) {\n    this.subscribers.forEach(subscriber => subscriber(aborted, settledKey));\n  }\n  subscribe(fn) {\n    this.subscribers.add(fn);\n    return () => this.subscribers.delete(fn);\n  }\n  cancel() {\n    this.controller.abort();\n    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));\n    this.emit(true);\n  }\n  async resolveData(signal) {\n    let aborted = false;\n    if (!this.done) {\n      let onAbort = () => this.cancel();\n      signal.addEventListener(\"abort\", onAbort);\n      aborted = await new Promise(resolve => {\n        this.subscribe(aborted => {\n          signal.removeEventListener(\"abort\", onAbort);\n          if (aborted || this.done) {\n            resolve(aborted);\n          }\n        });\n      });\n    }\n    return aborted;\n  }\n  get done() {\n    return this.pendingKeysSet.size === 0;\n  }\n  get unwrappedData() {\n    invariant(this.data !== null && this.done, \"Can only unwrap data on initialized and settled deferreds\");\n    return Object.entries(this.data).reduce((acc, _ref3) => {\n      let [key, value] = _ref3;\n      return Object.assign(acc, {\n        [key]: unwrapTrackedPromise(value)\n      });\n    }, {});\n  }\n  get pendingKeys() {\n    return Array.from(this.pendingKeysSet);\n  }\n}\nfunction isTrackedPromise(value) {\n  return value instanceof Promise && value._tracked === true;\n}\nfunction unwrapTrackedPromise(value) {\n  if (!isTrackedPromise(value)) {\n    return value;\n  }\n  if (value._error) {\n    throw value._error;\n  }\n  return value._data;\n}\nconst defer = function defer(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  return new DeferredData(data, responseInit);\n};\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst redirect = function redirect(url, init) {\n  if (init === void 0) {\n    init = 302;\n  }\n  let responseInit = init;\n  if (typeof responseInit === \"number\") {\n    responseInit = {\n      status: responseInit\n    };\n  } else if (typeof responseInit.status === \"undefined\") {\n    responseInit.status = 302;\n  }\n  let headers = new Headers(responseInit.headers);\n  headers.set(\"Location\", url);\n  return new Response(null, _extends({}, responseInit, {\n    headers\n  }));\n};\n/**\n * A redirect response that will force a document reload to the new location.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst redirectDocument = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Reload-Document\", \"true\");\n  return response;\n};\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n *\n * We don't export the class for public use since it's an implementation\n * detail, but we export the interface above so folks can build their own\n * abstractions around instances via isRouteErrorResponse()\n */\nclass ErrorResponseImpl {\n  constructor(status, statusText, data, internal) {\n    if (internal === void 0) {\n      internal = false;\n    }\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.internal = internal;\n    if (data instanceof Error) {\n      this.data = data.toString();\n      this.error = data;\n    } else {\n      this.data = data;\n    }\n  }\n}\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\nfunction isRouteErrorResponse(error) {\n  return error != null && typeof error.status === \"number\" && typeof error.statusText === \"string\" && typeof error.internal === \"boolean\" && \"data\" in error;\n}\n\nconst validMutationMethodsArr = [\"post\", \"put\", \"patch\", \"delete\"];\nconst validMutationMethods = new Set(validMutationMethodsArr);\nconst validRequestMethodsArr = [\"get\", ...validMutationMethodsArr];\nconst validRequestMethods = new Set(validRequestMethodsArr);\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\nconst IDLE_NAVIGATION = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined\n};\nconst IDLE_FETCHER = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined\n};\nconst IDLE_BLOCKER = {\n  state: \"unblocked\",\n  proceed: undefined,\n  reset: undefined,\n  location: undefined\n};\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\nconst defaultMapRouteProperties = route => ({\n  hasErrorBoundary: Boolean(route.hasErrorBoundary)\n});\nconst TRANSITIONS_STORAGE_KEY = \"remix-router-transitions\";\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Create a router and listen to history POP navigations\n */\nfunction createRouter(init) {\n  const routerWindow = init.window ? init.window : typeof window !== \"undefined\" ? window : undefined;\n  const isBrowser = typeof routerWindow !== \"undefined\" && typeof routerWindow.document !== \"undefined\" && typeof routerWindow.document.createElement !== \"undefined\";\n  const isServer = !isBrowser;\n  invariant(init.routes.length > 0, \"You must provide a non-empty routes array to createRouter\");\n  let mapRouteProperties;\n  if (init.mapRouteProperties) {\n    mapRouteProperties = init.mapRouteProperties;\n  } else if (init.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = init.detectErrorBoundary;\n    mapRouteProperties = route => ({\n      hasErrorBoundary: detectErrorBoundary(route)\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Routes keyed by ID\n  let manifest = {};\n  // Routes in tree format for matching\n  let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties, undefined, manifest);\n  let inFlightDataRoutes;\n  let basename = init.basename || \"/\";\n  let dataStrategyImpl = init.unstable_dataStrategy || defaultDataStrategy;\n  // Config driven behavior flags\n  let future = _extends({\n    v7_fetcherPersist: false,\n    v7_normalizeFormMethod: false,\n    v7_partialHydration: false,\n    v7_prependBasename: false,\n    v7_relativeSplatPath: false,\n    unstable_skipActionErrorRevalidation: false\n  }, init.future);\n  // Cleanup function for history\n  let unlistenHistory = null;\n  // Externally-provided functions to call on all state changes\n  let subscribers = new Set();\n  // Externally-provided object to hold scroll restoration locations during routing\n  let savedScrollPositions = null;\n  // Externally-provided function to get scroll restoration keys\n  let getScrollRestorationKey = null;\n  // Externally-provided function to get current scroll position\n  let getScrollPosition = null;\n  // One-time flag to control the initial hydration scroll restoration.  Because\n  // we don't get the saved positions from <ScrollRestoration /> until _after_\n  // the initial render, we need to manually trigger a separate updateState to\n  // send along the restoreScrollPosition\n  // Set to true if we have `hydrationData` since we assume we were SSR'd and that\n  // SSR did the initial scroll restoration.\n  let initialScrollRestored = init.hydrationData != null;\n  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);\n  let initialErrors = null;\n  if (initialMatches == null) {\n    // If we do not match a user-provided-route, fall back to the root\n    // to allow the error boundary to take over\n    let error = getInternalRouterError(404, {\n      pathname: init.history.location.pathname\n    });\n    let {\n      matches,\n      route\n    } = getShortCircuitMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = {\n      [route.id]: error\n    };\n  }\n  let initialized;\n  let hasLazyRoutes = initialMatches.some(m => m.route.lazy);\n  let hasLoaders = initialMatches.some(m => m.route.loader);\n  if (hasLazyRoutes) {\n    // All initialMatches need to be loaded before we're ready.  If we have lazy\n    // functions around still then we'll need to run them in initialize()\n    initialized = false;\n  } else if (!hasLoaders) {\n    // If we've got no loaders to run, then we're good to go\n    initialized = true;\n  } else if (future.v7_partialHydration) {\n    // If partial hydration is enabled, we're initialized so long as we were\n    // provided with hydrationData for every route with a loader, and no loaders\n    // were marked for explicit hydration\n    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;\n    let errors = init.hydrationData ? init.hydrationData.errors : null;\n    let isRouteInitialized = m => {\n      // No loader, nothing to initialize\n      if (!m.route.loader) {\n        return true;\n      }\n      // Explicitly opting-in to running on hydration\n      if (typeof m.route.loader === \"function\" && m.route.loader.hydrate === true) {\n        return false;\n      }\n      // Otherwise, initialized if hydrated with data or an error\n      return loaderData && loaderData[m.route.id] !== undefined || errors && errors[m.route.id] !== undefined;\n    };\n    // If errors exist, don't consider routes below the boundary\n    if (errors) {\n      let idx = initialMatches.findIndex(m => errors[m.route.id] !== undefined);\n      initialized = initialMatches.slice(0, idx + 1).every(isRouteInitialized);\n    } else {\n      initialized = initialMatches.every(isRouteInitialized);\n    }\n  } else {\n    // Without partial hydration - we're initialized if we were provided any\n    // hydrationData - which is expected to be complete\n    initialized = init.hydrationData != null;\n  }\n  let router;\n  let state = {\n    historyAction: init.history.action,\n    location: init.history.location,\n    matches: initialMatches,\n    initialized,\n    navigation: IDLE_NAVIGATION,\n    // Don't restore on initial updateState() if we were SSR'd\n    restoreScrollPosition: init.hydrationData != null ? false : null,\n    preventScrollReset: false,\n    revalidation: \"idle\",\n    loaderData: init.hydrationData && init.hydrationData.loaderData || {},\n    actionData: init.hydrationData && init.hydrationData.actionData || null,\n    errors: init.hydrationData && init.hydrationData.errors || initialErrors,\n    fetchers: new Map(),\n    blockers: new Map()\n  };\n  // -- Stateful internal variables to manage navigations --\n  // Current navigation in progress (to be committed in completeNavigation)\n  let pendingAction = Action.Pop;\n  // Should the current navigation prevent the scroll reset if scroll cannot\n  // be restored?\n  let pendingPreventScrollReset = false;\n  // AbortController for the active navigation\n  let pendingNavigationController;\n  // Should the current navigation enable document.startViewTransition?\n  let pendingViewTransitionEnabled = false;\n  // Store applied view transitions so we can apply them on POP\n  let appliedViewTransitions = new Map();\n  // Cleanup function for persisting applied transitions to sessionStorage\n  let removePageHideEventListener = null;\n  // We use this to avoid touching history in completeNavigation if a\n  // revalidation is entirely uninterrupted\n  let isUninterruptedRevalidation = false;\n  // Use this internal flag to force revalidation of all loaders:\n  //  - submissions (completed or interrupted)\n  //  - useRevalidator()\n  //  - X-Remix-Revalidate (from redirect)\n  let isRevalidationRequired = false;\n  // Use this internal array to capture routes that require revalidation due\n  // to a cancelled deferred on action submission\n  let cancelledDeferredRoutes = [];\n  // Use this internal array to capture fetcher loads that were cancelled by an\n  // action navigation and require revalidation\n  let cancelledFetcherLoads = [];\n  // AbortControllers for any in-flight fetchers\n  let fetchControllers = new Map();\n  // Track loads based on the order in which they started\n  let incrementingLoadId = 0;\n  // Track the outstanding pending navigation data load to be compared against\n  // the globally incrementing load when a fetcher load lands after a completed\n  // navigation\n  let pendingNavigationLoadId = -1;\n  // Fetchers that triggered data reloads as a result of their actions\n  let fetchReloadIds = new Map();\n  // Fetchers that triggered redirect navigations\n  let fetchRedirectIds = new Set();\n  // Most recent href/match for fetcher.load calls for fetchers\n  let fetchLoadMatches = new Map();\n  // Ref-count mounted fetchers so we know when it's ok to clean them up\n  let activeFetchers = new Map();\n  // Fetchers that have requested a delete when using v7_fetcherPersist,\n  // they'll be officially removed after they return to idle\n  let deletedFetchers = new Set();\n  // Store DeferredData instances for active route matches.  When a\n  // route loader returns defer() we stick one in here.  Then, when a nested\n  // promise resolves we update loaderData.  If a new navigation starts we\n  // cancel active deferreds for eliminated routes.\n  let activeDeferreds = new Map();\n  // Store blocker functions in a separate Map outside of router state since\n  // we don't need to update UI state if they change\n  let blockerFunctions = new Map();\n  // Flag to ignore the next history update, so we can revert the URL change on\n  // a POP navigation that was blocked by the user without touching router state\n  let ignoreNextHistoryUpdate = false;\n  // Initialize the router, all side effects should be kicked off from here.\n  // Implemented as a Fluent API for ease of:\n  //   let router = createRouter(init).initialize();\n  function initialize() {\n    // If history informs us of a POP navigation, start the navigation but do not update\n    // state.  We'll update our own state once the navigation completes\n    unlistenHistory = init.history.listen(_ref => {\n      let {\n        action: historyAction,\n        location,\n        delta\n      } = _ref;\n      // Ignore this event if it was just us resetting the URL from a\n      // blocked POP navigation\n      if (ignoreNextHistoryUpdate) {\n        ignoreNextHistoryUpdate = false;\n        return;\n      }\n      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.\");\n      let blockerKey = shouldBlockNavigation({\n        currentLocation: state.location,\n        nextLocation: location,\n        historyAction\n      });\n      if (blockerKey && delta != null) {\n        // Restore the URL to match the current UI, but don't update router state\n        ignoreNextHistoryUpdate = true;\n        init.history.go(delta * -1);\n        // Put the blocker into a blocked state\n        updateBlocker(blockerKey, {\n          state: \"blocked\",\n          location,\n          proceed() {\n            updateBlocker(blockerKey, {\n              state: \"proceeding\",\n              proceed: undefined,\n              reset: undefined,\n              location\n            });\n            // Re-do the same POP navigation we just blocked\n            init.history.go(delta);\n          },\n          reset() {\n            let blockers = new Map(state.blockers);\n            blockers.set(blockerKey, IDLE_BLOCKER);\n            updateState({\n              blockers\n            });\n          }\n        });\n        return;\n      }\n      return startNavigation(historyAction, location);\n    });\n    if (isBrowser) {\n      // FIXME: This feels gross.  How can we cleanup the lines between\n      // scrollRestoration/appliedTransitions persistance?\n      restoreAppliedTransitions(routerWindow, appliedViewTransitions);\n      let _saveAppliedTransitions = () => persistAppliedTransitions(routerWindow, appliedViewTransitions);\n      routerWindow.addEventListener(\"pagehide\", _saveAppliedTransitions);\n      removePageHideEventListener = () => routerWindow.removeEventListener(\"pagehide\", _saveAppliedTransitions);\n    }\n    // Kick off initial data load if needed.  Use Pop to avoid modifying history\n    // Note we don't do any handling of lazy here.  For SPA's it'll get handled\n    // in the normal navigation flow.  For SSR it's expected that lazy modules are\n    // resolved prior to router creation since we can't go into a fallbackElement\n    // UI for SSR'd apps\n    if (!state.initialized) {\n      startNavigation(Action.Pop, state.location, {\n        initialHydration: true\n      });\n    }\n    return router;\n  }\n  // Clean up a router and it's side effects\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\n    }\n    if (removePageHideEventListener) {\n      removePageHideEventListener();\n    }\n    subscribers.clear();\n    pendingNavigationController && pendingNavigationController.abort();\n    state.fetchers.forEach((_, key) => deleteFetcher(key));\n    state.blockers.forEach((_, key) => deleteBlocker(key));\n  }\n  // Subscribe to state updates for the router\n  function subscribe(fn) {\n    subscribers.add(fn);\n    return () => subscribers.delete(fn);\n  }\n  // Update our state and notify the calling context of the change\n  function updateState(newState, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    state = _extends({}, state, newState);\n    // Prep fetcher cleanup so we can tell the UI which fetcher data entries\n    // can be removed\n    let completedFetchers = [];\n    let deletedFetchersKeys = [];\n    if (future.v7_fetcherPersist) {\n      state.fetchers.forEach((fetcher, key) => {\n        if (fetcher.state === \"idle\") {\n          if (deletedFetchers.has(key)) {\n            // Unmounted from the UI and can be totally removed\n            deletedFetchersKeys.push(key);\n          } else {\n            // Returned to idle but still mounted in the UI, so semi-remains for\n            // revalidations and such\n            completedFetchers.push(key);\n          }\n        }\n      });\n    }\n    // Iterate over a local copy so that if flushSync is used and we end up\n    // removing and adding a new subscriber due to the useCallback dependencies,\n    // we don't get ourselves into a loop calling the new subscriber immediately\n    [...subscribers].forEach(subscriber => subscriber(state, {\n      deletedFetchers: deletedFetchersKeys,\n      unstable_viewTransitionOpts: opts.viewTransitionOpts,\n      unstable_flushSync: opts.flushSync === true\n    }));\n    // Remove idle fetchers from state since we only care about in-flight fetchers.\n    if (future.v7_fetcherPersist) {\n      completedFetchers.forEach(key => state.fetchers.delete(key));\n      deletedFetchersKeys.forEach(key => deleteFetcher(key));\n    }\n  }\n  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION\n  // and setting state.[historyAction/location/matches] to the new route.\n  // - Location is a required param\n  // - Navigation will always be set to IDLE_NAVIGATION\n  // - Can pass any other state in newState\n  function completeNavigation(location, newState, _temp) {\n    var _location$state, _location$state2;\n    let {\n      flushSync\n    } = _temp === void 0 ? {} : _temp;\n    // Deduce if we're in a loading/actionReload state:\n    // - We have committed actionData in the store\n    // - The current navigation was a mutation submission\n    // - We're past the submitting state and into the loading state\n    // - The location being loaded is not the result of a redirect\n    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;\n    let actionData;\n    if (newState.actionData) {\n      if (Object.keys(newState.actionData).length > 0) {\n        actionData = newState.actionData;\n      } else {\n        // Empty actionData -> clear prior actionData due to an action error\n        actionData = null;\n      }\n    } else if (isActionReload) {\n      // Keep the current data if we're wrapping up the action reload\n      actionData = state.actionData;\n    } else {\n      // Clear actionData on any other completed navigations\n      actionData = null;\n    }\n    // Always preserve any existing loaderData from re-used routes\n    let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;\n    // On a successful navigation we can assume we got through all blockers\n    // so we can start fresh\n    let blockers = state.blockers;\n    if (blockers.size > 0) {\n      blockers = new Map(blockers);\n      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));\n    }\n    // Always respect the user flag.  Otherwise don't reset on mutation\n    // submission navigations unless they redirect\n    let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;\n    if (inFlightDataRoutes) {\n      dataRoutes = inFlightDataRoutes;\n      inFlightDataRoutes = undefined;\n    }\n    if (isUninterruptedRevalidation) ; else if (pendingAction === Action.Pop) ; else if (pendingAction === Action.Push) {\n      init.history.push(location, location.state);\n    } else if (pendingAction === Action.Replace) {\n      init.history.replace(location, location.state);\n    }\n    let viewTransitionOpts;\n    // On POP, enable transitions if they were enabled on the original navigation\n    if (pendingAction === Action.Pop) {\n      // Forward takes precedence so they behave like the original navigation\n      let priorPaths = appliedViewTransitions.get(state.location.pathname);\n      if (priorPaths && priorPaths.has(location.pathname)) {\n        viewTransitionOpts = {\n          currentLocation: state.location,\n          nextLocation: location\n        };\n      } else if (appliedViewTransitions.has(location.pathname)) {\n        // If we don't have a previous forward nav, assume we're popping back to\n        // the new location and enable if that location previously enabled\n        viewTransitionOpts = {\n          currentLocation: location,\n          nextLocation: state.location\n        };\n      }\n    } else if (pendingViewTransitionEnabled) {\n      // Store the applied transition on PUSH/REPLACE\n      let toPaths = appliedViewTransitions.get(state.location.pathname);\n      if (toPaths) {\n        toPaths.add(location.pathname);\n      } else {\n        toPaths = new Set([location.pathname]);\n        appliedViewTransitions.set(state.location.pathname, toPaths);\n      }\n      viewTransitionOpts = {\n        currentLocation: state.location,\n        nextLocation: location\n      };\n    }\n    updateState(_extends({}, newState, {\n      actionData,\n      loaderData,\n      historyAction: pendingAction,\n      location,\n      initialized: true,\n      navigation: IDLE_NAVIGATION,\n      revalidation: \"idle\",\n      restoreScrollPosition: getSavedScrollPosition(location, newState.matches || state.matches),\n      preventScrollReset,\n      blockers\n    }), {\n      viewTransitionOpts,\n      flushSync: flushSync === true\n    });\n    // Reset stateful navigation vars\n    pendingAction = Action.Pop;\n    pendingPreventScrollReset = false;\n    pendingViewTransitionEnabled = false;\n    isUninterruptedRevalidation = false;\n    isRevalidationRequired = false;\n    cancelledDeferredRoutes = [];\n    cancelledFetcherLoads = [];\n  }\n  // Trigger a navigation event, which can either be a numerical POP or a PUSH\n  // replace with an optional submission\n  async function navigate(to, opts) {\n    if (typeof to === \"number\") {\n      init.history.go(to);\n      return;\n    }\n    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);\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, false, normalizedPath, opts);\n    let currentLocation = state.location;\n    let nextLocation = createLocation(state.location, path, opts && opts.state);\n    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded\n    // URL from window.location, so we need to encode it here so the behavior\n    // remains the same as POP and non-data-router usages.  new URL() does all\n    // the same encoding we'd get from a history.pushState/window.location read\n    // without having to touch history\n    nextLocation = _extends({}, nextLocation, init.history.encodeLocation(nextLocation));\n    let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n    let historyAction = Action.Push;\n    if (userReplace === true) {\n      historyAction = Action.Replace;\n    } else if (userReplace === false) ; else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) {\n      // By default on submissions to the current location we REPLACE so that\n      // users don't have to double-click the back button to get to the prior\n      // location.  If the user redirects to a different location from the\n      // action/loader this will be ignored and the redirect will be a PUSH\n      historyAction = Action.Replace;\n    }\n    let preventScrollReset = opts && \"preventScrollReset\" in opts ? opts.preventScrollReset === true : undefined;\n    let flushSync = (opts && opts.unstable_flushSync) === true;\n    let blockerKey = shouldBlockNavigation({\n      currentLocation,\n      nextLocation,\n      historyAction\n    });\n    if (blockerKey) {\n      // Put the blocker into a blocked state\n      updateBlocker(blockerKey, {\n        state: \"blocked\",\n        location: nextLocation,\n        proceed() {\n          updateBlocker(blockerKey, {\n            state: \"proceeding\",\n            proceed: undefined,\n            reset: undefined,\n            location: nextLocation\n          });\n          // Send the same navigation through\n          navigate(to, opts);\n        },\n        reset() {\n          let blockers = new Map(state.blockers);\n          blockers.set(blockerKey, IDLE_BLOCKER);\n          updateState({\n            blockers\n          });\n        }\n      });\n      return;\n    }\n    return await startNavigation(historyAction, nextLocation, {\n      submission,\n      // Send through the formData serialization error if we have one so we can\n      // render at the right error boundary after we match routes\n      pendingError: error,\n      preventScrollReset,\n      replace: opts && opts.replace,\n      enableViewTransition: opts && opts.unstable_viewTransition,\n      flushSync\n    });\n  }\n  // Revalidate all current loaders.  If a navigation is in progress or if this\n  // is interrupted by a navigation, allow this to \"succeed\" by calling all\n  // loaders during the next loader round\n  function revalidate() {\n    interruptActiveLoads();\n    updateState({\n      revalidation: \"loading\"\n    });\n    // If we're currently submitting an action, we don't need to start a new\n    // navigation, we'll just let the follow up loader execution call all loaders\n    if (state.navigation.state === \"submitting\") {\n      return;\n    }\n    // If we're currently in an idle state, start a new navigation for the current\n    // action/location and mark it as uninterrupted, which will skip the history\n    // update in completeNavigation\n    if (state.navigation.state === \"idle\") {\n      startNavigation(state.historyAction, state.location, {\n        startUninterruptedRevalidation: true\n      });\n      return;\n    }\n    // Otherwise, if we're currently in a loading state, just start a new\n    // navigation to the navigation.location but do not trigger an uninterrupted\n    // revalidation so that history correctly updates once the navigation completes\n    startNavigation(pendingAction || state.historyAction, state.navigation.location, {\n      overrideNavigation: state.navigation\n    });\n  }\n  // Start a navigation to the given action/location.  Can optionally provide a\n  // overrideNavigation which will override the normalLoad in the case of a redirect\n  // navigation\n  async function startNavigation(historyAction, location, opts) {\n    // Abort any in-progress navigations and start a new one. Unset any ongoing\n    // uninterrupted revalidations unless told otherwise, since we want this\n    // new navigation to update history normally\n    pendingNavigationController && pendingNavigationController.abort();\n    pendingNavigationController = null;\n    pendingAction = historyAction;\n    isUninterruptedRevalidation = (opts && opts.startUninterruptedRevalidation) === true;\n    // Save the current scroll position every time we start a new navigation,\n    // and track whether we should reset scroll on completion\n    saveScrollPosition(state.location, state.matches);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches = matchRoutes(routesToUse, location, basename);\n    let flushSync = (opts && opts.flushSync) === true;\n    // Short circuit with a 404 on the root error boundary if we match nothing\n    if (!matches) {\n      let error = getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n      let {\n        matches: notFoundMatches,\n        route\n      } = getShortCircuitMatches(routesToUse);\n      // Cancel all pending deferred on 404s since we don't keep any routes\n      cancelActiveDeferreds();\n      completeNavigation(location, {\n        matches: notFoundMatches,\n        loaderData: {},\n        errors: {\n          [route.id]: error\n        }\n      }, {\n        flushSync\n      });\n      return;\n    }\n    // Short circuit if it's only a hash change and not a revalidation or\n    // mutation submission.\n    //\n    // Ignore on initial page loads because since the initial load will always\n    // be \"same hash\".  For example, on /page#hash and submit a <Form method=\"post\">\n    // which will default to a navigation to /page\n    if (state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {\n      completeNavigation(location, {\n        matches\n      }, {\n        flushSync\n      });\n      return;\n    }\n    // Create a controller/Request for this navigation\n    pendingNavigationController = new AbortController();\n    let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);\n    let pendingActionResult;\n    if (opts && opts.pendingError) {\n      // If we have a pendingError, it means the user attempted a GET submission\n      // with binary FormData so assign here and skip to handleLoaders.  That\n      // way we handle calling loaders above the boundary etc.  It's not really\n      // different from an actionError in that sense.\n      pendingActionResult = [findNearestBoundary(matches).route.id, {\n        type: ResultType.error,\n        error: opts.pendingError\n      }];\n    } else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {\n      // Call action if we received an action submission\n      let actionResult = await handleAction(request, location, opts.submission, matches, {\n        replace: opts.replace,\n        flushSync\n      });\n      if (actionResult.shortCircuited) {\n        return;\n      }\n      pendingActionResult = actionResult.pendingActionResult;\n      loadingNavigation = getLoadingNavigation(location, opts.submission);\n      flushSync = false;\n      // Create a GET request for the loaders\n      request = createClientSideRequest(init.history, request.url, request.signal);\n    }\n    // Call loaders\n    let {\n      shortCircuited,\n      loaderData,\n      errors\n    } = await handleLoaders(request, location, matches, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult);\n    if (shortCircuited) {\n      return;\n    }\n    // Clean up now that the action/loaders have completed.  Don't clean up if\n    // we short circuited because pendingNavigationController will have already\n    // been assigned to a new controller for the next navigation\n    pendingNavigationController = null;\n    completeNavigation(location, _extends({\n      matches\n    }, getActionDataForCommit(pendingActionResult), {\n      loaderData,\n      errors\n    }));\n  }\n  // Call the action matched by the leaf route for this navigation and handle\n  // redirects/errors\n  async function handleAction(request, location, submission, matches, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    interruptActiveLoads();\n    // Put us in a submitting state\n    let navigation = getSubmittingNavigation(location, submission);\n    updateState({\n      navigation\n    }, {\n      flushSync: opts.flushSync === true\n    });\n    // Call our action and get the result\n    let result;\n    let actionMatch = getTargetMatch(matches, location);\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      result = {\n        type: ResultType.error,\n        error: getInternalRouterError(405, {\n          method: request.method,\n          pathname: location.pathname,\n          routeId: actionMatch.route.id\n        })\n      };\n    } else {\n      let results = await callDataStrategy(\"action\", request, [actionMatch], matches);\n      result = results[0];\n      if (request.signal.aborted) {\n        return {\n          shortCircuited: true\n        };\n      }\n    }\n    if (isRedirectResult(result)) {\n      let replace;\n      if (opts && opts.replace != null) {\n        replace = opts.replace;\n      } else {\n        // If the user didn't explicity indicate replace behavior, replace if\n        // we redirected to the exact same location we're currently at to avoid\n        // double back-buttons\n        let location = normalizeRedirectLocation(result.response.headers.get(\"Location\"), new URL(request.url), basename);\n        replace = location === state.location.pathname + state.location.search;\n      }\n      await startRedirectNavigation(request, result, {\n        submission,\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    if (isDeferredResult(result)) {\n      throw getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n    }\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n      // By default, all submissions are REPLACE navigations, but if the\n      // action threw an error that'll be rendered in an errorElement, we fall\n      // back to PUSH so that the user can use the back button to get back to\n      // the pre-submission form location to try again\n      if ((opts && opts.replace) !== true) {\n        pendingAction = Action.Push;\n      }\n      return {\n        pendingActionResult: [boundaryMatch.route.id, result]\n      };\n    }\n    return {\n      pendingActionResult: [actionMatch.route.id, result]\n    };\n  }\n  // Call all applicable loaders for the given matches, handling redirects,\n  // errors, etc.\n  async function handleLoaders(request, location, matches, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult) {\n    // Figure out the right navigation we want to use for data loading\n    let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);\n    // If this was a redirect from an action we don't have a \"submission\" but\n    // we have it on the loading navigation so use that if available\n    let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, future.unstable_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult);\n    // Cancel pending deferreds for no-longer-matched routes or routes we're\n    // about to reload.  Note that if this is an action reload we would have\n    // already cancelled all pending deferreds so this would be a no-op\n    cancelActiveDeferreds(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId));\n    pendingNavigationLoadId = ++incrementingLoadId;\n    // Short circuit if we have no loaders to run\n    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n      let updatedFetchers = markFetchRedirectsDone();\n      completeNavigation(location, _extends({\n        matches,\n        loaderData: {},\n        // Commit pending error if we're short circuiting\n        errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {\n          [pendingActionResult[0]]: pendingActionResult[1].error\n        } : null\n      }, getActionDataForCommit(pendingActionResult), updatedFetchers ? {\n        fetchers: new Map(state.fetchers)\n      } : {}), {\n        flushSync\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    // If this is an uninterrupted revalidation, we remain in our current idle\n    // state.  If not, we need to switch to our loading state and load data,\n    // preserving any new action data or existing action data (in the case of\n    // a revalidation interrupting an actionReload)\n    // If we have partialHydration enabled, then don't update the state for the\n    // initial data load since it's not a \"navigation\"\n    if (!isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration)) {\n      revalidatingFetchers.forEach(rf => {\n        let fetcher = state.fetchers.get(rf.key);\n        let revalidatingFetcher = getLoadingFetcher(undefined, fetcher ? fetcher.data : undefined);\n        state.fetchers.set(rf.key, revalidatingFetcher);\n      });\n      let actionData;\n      if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {\n        // This is cast to `any` currently because `RouteData`uses any and it\n        // would be a breaking change to use any.\n        // TODO: v7 - change `RouteData` to use `unknown` instead of `any`\n        actionData = {\n          [pendingActionResult[0]]: pendingActionResult[1].data\n        };\n      } else if (state.actionData) {\n        if (Object.keys(state.actionData).length === 0) {\n          actionData = null;\n        } else {\n          actionData = state.actionData;\n        }\n      }\n      updateState(_extends({\n        navigation: loadingNavigation\n      }, actionData !== undefined ? {\n        actionData\n      } : {}, revalidatingFetchers.length > 0 ? {\n        fetchers: new Map(state.fetchers)\n      } : {}), {\n        flushSync\n      });\n    }\n    revalidatingFetchers.forEach(rf => {\n      if (fetchControllers.has(rf.key)) {\n        abortFetcher(rf.key);\n      }\n      if (rf.controller) {\n        // Fetchers use an independent AbortController so that aborting a fetcher\n        // (via deleteFetcher) does not abort the triggering navigation that\n        // triggered the revalidation\n        fetchControllers.set(rf.key, rf.controller);\n      }\n    });\n    // Proxy navigation abort through to revalidation fetchers\n    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(f => abortFetcher(f.key));\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.addEventListener(\"abort\", abortPendingFetchRevalidations);\n    }\n    let {\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, request);\n    if (request.signal.aborted) {\n      return {\n        shortCircuited: true\n      };\n    }\n    // Clean up _after_ loaders have completed.  Don't clean up if we short\n    // circuited because fetchControllers would have been aborted and\n    // reassigned to new controllers for the next navigation\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.removeEventListener(\"abort\", abortPendingFetchRevalidations);\n    }\n    revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key));\n    // If any loaders returned a redirect Response, start a new REPLACE navigation\n    let redirect = findRedirect([...loaderResults, ...fetcherResults]);\n    if (redirect) {\n      if (redirect.idx >= matchesToLoad.length) {\n        // If this redirect came from a fetcher make sure we mark it in\n        // fetchRedirectIds so it doesn't get revalidated on the next set of\n        // loader executions\n        let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n        fetchRedirectIds.add(fetcherKey);\n      }\n      await startRedirectNavigation(request, redirect.result, {\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    // Process and commit output from loaders\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, matches, matchesToLoad, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds);\n    // Wire up subscribers to update loaderData as promises settle\n    activeDeferreds.forEach((deferredData, routeId) => {\n      deferredData.subscribe(aborted => {\n        // Note: No need to updateState here since the TrackedPromise on\n        // loaderData is stable across resolve/reject\n        // Remove this instance if we were aborted or if promises have settled\n        if (aborted || deferredData.done) {\n          activeDeferreds.delete(routeId);\n        }\n      });\n    });\n    // During partial hydration, preserve SSR errors for routes that don't re-run\n    if (future.v7_partialHydration && initialHydration && state.errors) {\n      Object.entries(state.errors).filter(_ref2 => {\n        let [id] = _ref2;\n        return !matchesToLoad.some(m => m.route.id === id);\n      }).forEach(_ref3 => {\n        let [routeId, error] = _ref3;\n        errors = Object.assign(errors || {}, {\n          [routeId]: error\n        });\n      });\n    }\n    let updatedFetchers = markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n    return _extends({\n      loaderData,\n      errors\n    }, shouldUpdateFetchers ? {\n      fetchers: new Map(state.fetchers)\n    } : {});\n  }\n  // Trigger a fetcher load/submit for the given fetcher key\n  function fetch(key, routeId, href, opts) {\n    if (isServer) {\n      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.\");\n    }\n    if (fetchControllers.has(key)) abortFetcher(key);\n    let flushSync = (opts && opts.unstable_flushSync) === true;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, future.v7_relativeSplatPath, routeId, opts == null ? void 0 : opts.relative);\n    let matches = matchRoutes(routesToUse, normalizedPath, basename);\n    if (!matches) {\n      setFetcherError(key, routeId, getInternalRouterError(404, {\n        pathname: normalizedPath\n      }), {\n        flushSync\n      });\n      return;\n    }\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, true, normalizedPath, opts);\n    if (error) {\n      setFetcherError(key, routeId, error, {\n        flushSync\n      });\n      return;\n    }\n    let match = getTargetMatch(matches, path);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n    if (submission && isMutationMethod(submission.formMethod)) {\n      handleFetcherAction(key, routeId, path, match, matches, flushSync, submission);\n      return;\n    }\n    // Store off the match so we can call it's shouldRevalidate on subsequent\n    // revalidations\n    fetchLoadMatches.set(key, {\n      routeId,\n      path\n    });\n    handleFetcherLoader(key, routeId, path, match, matches, flushSync, submission);\n  }\n  // Call the action for the matched fetcher.submit(), and then handle redirects,\n  // errors, and revalidation\n  async function handleFetcherAction(key, routeId, path, match, requestMatches, flushSync, submission) {\n    interruptActiveLoads();\n    fetchLoadMatches.delete(key);\n    if (!match.route.action && !match.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: submission.formMethod,\n        pathname: path,\n        routeId: routeId\n      });\n      setFetcherError(key, routeId, error, {\n        flushSync\n      });\n      return;\n    }\n    // Put this fetcher into it's submitting state\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {\n      flushSync\n    });\n    // Call the action for the fetcher\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);\n    fetchControllers.set(key, abortController);\n    let originatingLoadId = incrementingLoadId;\n    let actionResults = await callDataStrategy(\"action\", fetchRequest, [match], requestMatches);\n    let actionResult = actionResults[0];\n    if (fetchRequest.signal.aborted) {\n      // We can delete this so long as we weren't aborted by our own fetcher\n      // re-submit which would have put _new_ controller is in fetchControllers\n      if (fetchControllers.get(key) === abortController) {\n        fetchControllers.delete(key);\n      }\n      return;\n    }\n    // When using v7_fetcherPersist, we don't want errors bubbling up to the UI\n    // or redirects processed for unmounted fetchers so we just revert them to\n    // idle\n    if (future.v7_fetcherPersist && deletedFetchers.has(key)) {\n      if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      }\n      // Let SuccessResult's fall through for revalidation\n    } else {\n      if (isRedirectResult(actionResult)) {\n        fetchControllers.delete(key);\n        if (pendingNavigationLoadId > originatingLoadId) {\n          // A new navigation was kicked off after our action started, so that\n          // should take precedence over this redirect navigation.  We already\n          // set isRevalidationRequired so all loaders for the new route should\n          // fire unless opted out via shouldRevalidate\n          updateFetcherState(key, getDoneFetcher(undefined));\n          return;\n        } else {\n          fetchRedirectIds.add(key);\n          updateFetcherState(key, getLoadingFetcher(submission));\n          return startRedirectNavigation(fetchRequest, actionResult, {\n            fetcherSubmission: submission\n          });\n        }\n      }\n      // Process any non-redirect errors thrown\n      if (isErrorResult(actionResult)) {\n        setFetcherError(key, routeId, actionResult.error);\n        return;\n      }\n    }\n    if (isDeferredResult(actionResult)) {\n      throw getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n    }\n    // Start the data load for current matches, or the next location if we're\n    // in the middle of a navigation\n    let nextLocation = state.navigation.location || state.location;\n    let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let matches = state.navigation.state !== \"idle\" ? matchRoutes(routesToUse, state.navigation.location, basename) : state.matches;\n    invariant(matches, \"Didn't find any matches after fetcher action\");\n    let loadId = ++incrementingLoadId;\n    fetchReloadIds.set(key, loadId);\n    let loadFetcher = getLoadingFetcher(submission, actionResult.data);\n    state.fetchers.set(key, loadFetcher);\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, false, future.unstable_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, [match.route.id, actionResult]);\n    // Put all revalidating fetchers into the loading state, except for the\n    // current fetcher which we want to keep in it's current loading state which\n    // contains it's action submission info + action data\n    revalidatingFetchers.filter(rf => rf.key !== key).forEach(rf => {\n      let staleKey = rf.key;\n      let existingFetcher = state.fetchers.get(staleKey);\n      let revalidatingFetcher = getLoadingFetcher(undefined, existingFetcher ? existingFetcher.data : undefined);\n      state.fetchers.set(staleKey, revalidatingFetcher);\n      if (fetchControllers.has(staleKey)) {\n        abortFetcher(staleKey);\n      }\n      if (rf.controller) {\n        fetchControllers.set(staleKey, rf.controller);\n      }\n    });\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(rf => abortFetcher(rf.key));\n    abortController.signal.addEventListener(\"abort\", abortPendingFetchRevalidations);\n    let {\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);\n    if (abortController.signal.aborted) {\n      return;\n    }\n    abortController.signal.removeEventListener(\"abort\", abortPendingFetchRevalidations);\n    fetchReloadIds.delete(key);\n    fetchControllers.delete(key);\n    revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));\n    let redirect = findRedirect([...loaderResults, ...fetcherResults]);\n    if (redirect) {\n      if (redirect.idx >= matchesToLoad.length) {\n        // If this redirect came from a fetcher make sure we mark it in\n        // fetchRedirectIds so it doesn't get revalidated on the next set of\n        // loader executions\n        let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n        fetchRedirectIds.add(fetcherKey);\n      }\n      return startRedirectNavigation(revalidationRequest, redirect.result);\n    }\n    // Process and commit output from loaders\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, state.matches, matchesToLoad, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);\n    // Since we let revalidations complete even if the submitting fetcher was\n    // deleted, only put it back to idle if it hasn't been deleted\n    if (state.fetchers.has(key)) {\n      let doneFetcher = getDoneFetcher(actionResult.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n    abortStaleFetchLoads(loadId);\n    // If we are currently in a navigation loading state and this fetcher is\n    // more recent than the navigation, we want the newer data so abort the\n    // navigation and complete it with the fetcher data\n    if (state.navigation.state === \"loading\" && loadId > pendingNavigationLoadId) {\n      invariant(pendingAction, \"Expected pending action\");\n      pendingNavigationController && pendingNavigationController.abort();\n      completeNavigation(state.navigation.location, {\n        matches,\n        loaderData,\n        errors,\n        fetchers: new Map(state.fetchers)\n      });\n    } else {\n      // otherwise just update with the fetcher data, preserving any existing\n      // loaderData for loaders that did not need to reload.  We have to\n      // manually merge here since we aren't going through completeNavigation\n      updateState({\n        errors,\n        loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors),\n        fetchers: new Map(state.fetchers)\n      });\n      isRevalidationRequired = false;\n    }\n  }\n  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n  async function handleFetcherLoader(key, routeId, path, match, matches, flushSync, submission) {\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : undefined), {\n      flushSync\n    });\n    // Call the loader for this fetcher route match\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);\n    fetchControllers.set(key, abortController);\n    let originatingLoadId = incrementingLoadId;\n    let results = await callDataStrategy(\"loader\", fetchRequest, [match], matches);\n    let result = results[0];\n    // Deferred isn't supported for fetcher loads, await everything and treat it\n    // as a normal load.  resolveDeferredData will return undefined if this\n    // fetcher gets aborted, so we just leave result untouched and short circuit\n    // below if that happens\n    if (isDeferredResult(result)) {\n      result = (await resolveDeferredData(result, fetchRequest.signal, true)) || result;\n    }\n    // We can delete this so long as we weren't aborted by our our own fetcher\n    // re-load which would have put _new_ controller is in fetchControllers\n    if (fetchControllers.get(key) === abortController) {\n      fetchControllers.delete(key);\n    }\n    if (fetchRequest.signal.aborted) {\n      return;\n    }\n    // We don't want errors bubbling up or redirects followed for unmounted\n    // fetchers, so short circuit here if it was removed from the UI\n    if (deletedFetchers.has(key)) {\n      updateFetcherState(key, getDoneFetcher(undefined));\n      return;\n    }\n    // If the loader threw a redirect Response, start a new REPLACE navigation\n    if (isRedirectResult(result)) {\n      if (pendingNavigationLoadId > originatingLoadId) {\n        // A new navigation was kicked off after our loader started, so that\n        // should take precedence over this redirect navigation\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      } else {\n        fetchRedirectIds.add(key);\n        await startRedirectNavigation(fetchRequest, result);\n        return;\n      }\n    }\n    // Process any non-redirect errors thrown\n    if (isErrorResult(result)) {\n      setFetcherError(key, routeId, result.error);\n      return;\n    }\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n    // Put the fetcher back into an idle state\n    updateFetcherState(key, getDoneFetcher(result.data));\n  }\n  /**\n   * Utility function to handle redirects returned from an action or loader.\n   * Normally, a redirect \"replaces\" the navigation that triggered it.  So, for\n   * example:\n   *\n   *  - user is on /a\n   *  - user clicks a link to /b\n   *  - loader for /b redirects to /c\n   *\n   * In a non-JS app the browser would track the in-flight navigation to /b and\n   * then replace it with /c when it encountered the redirect response.  In\n   * the end it would only ever update the URL bar with /c.\n   *\n   * In client-side routing using pushState/replaceState, we aim to emulate\n   * this behavior and we also do not update history until the end of the\n   * navigation (including processed redirects).  This means that we never\n   * actually touch history until we've processed redirects, so we just use\n   * the history action from the original navigation (PUSH or REPLACE).\n   */\n  async function startRedirectNavigation(request, redirect, _temp2) {\n    let {\n      submission,\n      fetcherSubmission,\n      replace\n    } = _temp2 === void 0 ? {} : _temp2;\n    if (redirect.response.headers.has(\"X-Remix-Revalidate\")) {\n      isRevalidationRequired = true;\n    }\n    let location = redirect.response.headers.get(\"Location\");\n    invariant(location, \"Expected a Location header on the redirect Response\");\n    location = normalizeRedirectLocation(location, new URL(request.url), basename);\n    let redirectLocation = createLocation(state.location, location, {\n      _isRedirect: true\n    });\n    if (isBrowser) {\n      let isDocumentReload = false;\n      if (redirect.response.headers.has(\"X-Remix-Reload-Document\")) {\n        // Hard reload if the response contained X-Remix-Reload-Document\n        isDocumentReload = true;\n      } else if (ABSOLUTE_URL_REGEX.test(location)) {\n        const url = init.history.createURL(location);\n        isDocumentReload =\n        // Hard reload if it's an absolute URL to a new origin\n        url.origin !== routerWindow.location.origin ||\n        // Hard reload if it's an absolute URL that does not match our basename\n        stripBasename(url.pathname, basename) == null;\n      }\n      if (isDocumentReload) {\n        if (replace) {\n          routerWindow.location.replace(location);\n        } else {\n          routerWindow.location.assign(location);\n        }\n        return;\n      }\n    }\n    // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n    pendingNavigationController = null;\n    let redirectHistoryAction = replace === true ? Action.Replace : Action.Push;\n    // Use the incoming submission if provided, fallback on the active one in\n    // state.navigation\n    let {\n      formMethod,\n      formAction,\n      formEncType\n    } = state.navigation;\n    if (!submission && !fetcherSubmission && formMethod && formAction && formEncType) {\n      submission = getSubmissionFromNavigation(state.navigation);\n    }\n    // If this was a 307/308 submission we want to preserve the HTTP method and\n    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the\n    // redirected location\n    let activeSubmission = submission || fetcherSubmission;\n    if (redirectPreserveMethodStatusCodes.has(redirect.response.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        submission: _extends({}, activeSubmission, {\n          formAction: location\n        }),\n        // Preserve this flag across redirects\n        preventScrollReset: pendingPreventScrollReset\n      });\n    } else {\n      // If we have a navigation submission, we will preserve it through the\n      // redirect navigation\n      let overrideNavigation = getLoadingNavigation(redirectLocation, submission);\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        overrideNavigation,\n        // Send fetcher submissions through for shouldRevalidate\n        fetcherSubmission,\n        // Preserve this flag across redirects\n        preventScrollReset: pendingPreventScrollReset\n      });\n    }\n  }\n  // Utility wrapper for calling dataStrategy client-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(type, request, matchesToLoad, matches) {\n    try {\n      let results = await callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, manifest, mapRouteProperties);\n      return await Promise.all(results.map((result, i) => {\n        if (isRedirectHandlerResult(result)) {\n          let response = result.result;\n          return {\n            type: ResultType.redirect,\n            response: normalizeRelativeRoutingRedirectResponse(response, request, matchesToLoad[i].route.id, matches, basename, future.v7_relativeSplatPath)\n          };\n        }\n        return convertHandlerResultToDataResult(result);\n      }));\n    } catch (e) {\n      // If the outer dataStrategy method throws, just return the error for all\n      // matches - and it'll naturally bubble to the root\n      return matchesToLoad.map(() => ({\n        type: ResultType.error,\n        error: e\n      }));\n    }\n  }\n  async function callLoadersAndMaybeResolveData(currentMatches, matches, matchesToLoad, fetchersToLoad, request) {\n    let [loaderResults, ...fetcherResults] = await Promise.all([matchesToLoad.length ? callDataStrategy(\"loader\", request, matchesToLoad, matches) : [], ...fetchersToLoad.map(f => {\n      if (f.matches && f.match && f.controller) {\n        let fetcherRequest = createClientSideRequest(init.history, f.path, f.controller.signal);\n        return callDataStrategy(\"loader\", fetcherRequest, [f.match], f.matches).then(r => r[0]);\n      } else {\n        return Promise.resolve({\n          type: ResultType.error,\n          error: getInternalRouterError(404, {\n            pathname: f.path\n          })\n        });\n      }\n    })]);\n    await Promise.all([resolveDeferredResults(currentMatches, matchesToLoad, loaderResults, loaderResults.map(() => request.signal), false, state.loaderData), resolveDeferredResults(currentMatches, fetchersToLoad.map(f => f.match), fetcherResults, fetchersToLoad.map(f => f.controller ? f.controller.signal : null), true)]);\n    return {\n      loaderResults,\n      fetcherResults\n    };\n  }\n  function interruptActiveLoads() {\n    // Every interruption triggers a revalidation\n    isRevalidationRequired = true;\n    // Cancel pending route-level deferreds and mark cancelled routes for\n    // revalidation\n    cancelledDeferredRoutes.push(...cancelActiveDeferreds());\n    // Abort in-flight fetcher loads\n    fetchLoadMatches.forEach((_, key) => {\n      if (fetchControllers.has(key)) {\n        cancelledFetcherLoads.push(key);\n        abortFetcher(key);\n      }\n    });\n  }\n  function updateFetcherState(key, fetcher, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    state.fetchers.set(key, fetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    }, {\n      flushSync: (opts && opts.flushSync) === true\n    });\n  }\n  function setFetcherError(key, routeId, error, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    let boundaryMatch = findNearestBoundary(state.matches, routeId);\n    deleteFetcher(key);\n    updateState({\n      errors: {\n        [boundaryMatch.route.id]: error\n      },\n      fetchers: new Map(state.fetchers)\n    }, {\n      flushSync: (opts && opts.flushSync) === true\n    });\n  }\n  function getFetcher(key) {\n    if (future.v7_fetcherPersist) {\n      activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);\n      // If this fetcher was previously marked for deletion, unmark it since we\n      // have a new instance\n      if (deletedFetchers.has(key)) {\n        deletedFetchers.delete(key);\n      }\n    }\n    return state.fetchers.get(key) || IDLE_FETCHER;\n  }\n  function deleteFetcher(key) {\n    let fetcher = state.fetchers.get(key);\n    // Don't abort the controller if this is a deletion of a fetcher.submit()\n    // in it's loading phase since - we don't want to abort the corresponding\n    // revalidation and want them to complete and land\n    if (fetchControllers.has(key) && !(fetcher && fetcher.state === \"loading\" && fetchReloadIds.has(key))) {\n      abortFetcher(key);\n    }\n    fetchLoadMatches.delete(key);\n    fetchReloadIds.delete(key);\n    fetchRedirectIds.delete(key);\n    deletedFetchers.delete(key);\n    state.fetchers.delete(key);\n  }\n  function deleteFetcherAndUpdateState(key) {\n    if (future.v7_fetcherPersist) {\n      let count = (activeFetchers.get(key) || 0) - 1;\n      if (count <= 0) {\n        activeFetchers.delete(key);\n        deletedFetchers.add(key);\n      } else {\n        activeFetchers.set(key, count);\n      }\n    } else {\n      deleteFetcher(key);\n    }\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n  }\n  function abortFetcher(key) {\n    let controller = fetchControllers.get(key);\n    invariant(controller, \"Expected fetch controller: \" + key);\n    controller.abort();\n    fetchControllers.delete(key);\n  }\n  function markFetchersDone(keys) {\n    for (let key of keys) {\n      let fetcher = getFetcher(key);\n      let doneFetcher = getDoneFetcher(fetcher.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n  function markFetchRedirectsDone() {\n    let doneKeys = [];\n    let updatedFetchers = false;\n    for (let key of fetchRedirectIds) {\n      let fetcher = state.fetchers.get(key);\n      invariant(fetcher, \"Expected fetcher: \" + key);\n      if (fetcher.state === \"loading\") {\n        fetchRedirectIds.delete(key);\n        doneKeys.push(key);\n        updatedFetchers = true;\n      }\n    }\n    markFetchersDone(doneKeys);\n    return updatedFetchers;\n  }\n  function abortStaleFetchLoads(landedId) {\n    let yeetedKeys = [];\n    for (let [key, id] of fetchReloadIds) {\n      if (id < landedId) {\n        let fetcher = state.fetchers.get(key);\n        invariant(fetcher, \"Expected fetcher: \" + key);\n        if (fetcher.state === \"loading\") {\n          abortFetcher(key);\n          fetchReloadIds.delete(key);\n          yeetedKeys.push(key);\n        }\n      }\n    }\n    markFetchersDone(yeetedKeys);\n    return yeetedKeys.length > 0;\n  }\n  function getBlocker(key, fn) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n    if (blockerFunctions.get(key) !== fn) {\n      blockerFunctions.set(key, fn);\n    }\n    return blocker;\n  }\n  function deleteBlocker(key) {\n    state.blockers.delete(key);\n    blockerFunctions.delete(key);\n  }\n  // Utility function to update blockers, ensuring valid state transitions\n  function updateBlocker(key, newBlocker) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n    // Poor mans state machine :)\n    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n    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);\n    let blockers = new Map(state.blockers);\n    blockers.set(key, newBlocker);\n    updateState({\n      blockers\n    });\n  }\n  function shouldBlockNavigation(_ref4) {\n    let {\n      currentLocation,\n      nextLocation,\n      historyAction\n    } = _ref4;\n    if (blockerFunctions.size === 0) {\n      return;\n    }\n    // We ony support a single active blocker at the moment since we don't have\n    // any compelling use cases for multi-blocker yet\n    if (blockerFunctions.size > 1) {\n      warning(false, \"A router only supports one blocker at a time\");\n    }\n    let entries = Array.from(blockerFunctions.entries());\n    let [blockerKey, blockerFunction] = entries[entries.length - 1];\n    let blocker = state.blockers.get(blockerKey);\n    if (blocker && blocker.state === \"proceeding\") {\n      // If the blocker is currently proceeding, we don't need to re-check\n      // it and can let this navigation continue\n      return;\n    }\n    // At this point, we know we're unblocked/blocked so we need to check the\n    // user-provided blocker function\n    if (blockerFunction({\n      currentLocation,\n      nextLocation,\n      historyAction\n    })) {\n      return blockerKey;\n    }\n  }\n  function cancelActiveDeferreds(predicate) {\n    let cancelledRouteIds = [];\n    activeDeferreds.forEach((dfd, routeId) => {\n      if (!predicate || predicate(routeId)) {\n        // Cancel the deferred - but do not remove from activeDeferreds here -\n        // we rely on the subscribers to do that so our tests can assert proper\n        // cleanup via _internalActiveDeferreds\n        dfd.cancel();\n        cancelledRouteIds.push(routeId);\n        activeDeferreds.delete(routeId);\n      }\n    });\n    return cancelledRouteIds;\n  }\n  // Opt in to capturing and reporting scroll positions during navigations,\n  // used by the <ScrollRestoration> component\n  function enableScrollRestoration(positions, getPosition, getKey) {\n    savedScrollPositions = positions;\n    getScrollPosition = getPosition;\n    getScrollRestorationKey = getKey || null;\n    // Perform initial hydration scroll restoration, since we miss the boat on\n    // the initial updateState() because we've not yet rendered <ScrollRestoration/>\n    // and therefore have no savedScrollPositions available\n    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n      initialScrollRestored = true;\n      let y = getSavedScrollPosition(state.location, state.matches);\n      if (y != null) {\n        updateState({\n          restoreScrollPosition: y\n        });\n      }\n    }\n    return () => {\n      savedScrollPositions = null;\n      getScrollPosition = null;\n      getScrollRestorationKey = null;\n    };\n  }\n  function getScrollKey(location, matches) {\n    if (getScrollRestorationKey) {\n      let key = getScrollRestorationKey(location, matches.map(m => convertRouteMatchToUiMatch(m, state.loaderData)));\n      return key || location.key;\n    }\n    return location.key;\n  }\n  function saveScrollPosition(location, matches) {\n    if (savedScrollPositions && getScrollPosition) {\n      let key = getScrollKey(location, matches);\n      savedScrollPositions[key] = getScrollPosition();\n    }\n  }\n  function getSavedScrollPosition(location, matches) {\n    if (savedScrollPositions) {\n      let key = getScrollKey(location, matches);\n      let y = savedScrollPositions[key];\n      if (typeof y === \"number\") {\n        return y;\n      }\n    }\n    return null;\n  }\n  function _internalSetRoutes(newRoutes) {\n    manifest = {};\n    inFlightDataRoutes = convertRoutesToDataRoutes(newRoutes, mapRouteProperties, undefined, manifest);\n  }\n  router = {\n    get basename() {\n      return basename;\n    },\n    get future() {\n      return future;\n    },\n    get state() {\n      return state;\n    },\n    get routes() {\n      return dataRoutes;\n    },\n    get window() {\n      return routerWindow;\n    },\n    initialize,\n    subscribe,\n    enableScrollRestoration,\n    navigate,\n    fetch,\n    revalidate,\n    // Passthrough to history-aware createHref used by useHref so we get proper\n    // hash-aware URLs in DOM paths\n    createHref: to => init.history.createHref(to),\n    encodeLocation: to => init.history.encodeLocation(to),\n    getFetcher,\n    deleteFetcher: deleteFetcherAndUpdateState,\n    dispose,\n    getBlocker,\n    deleteBlocker,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds,\n    // TODO: Remove setRoutes, it's temporary to avoid dealing with\n    // updating the tree while validating the update algorithm.\n    _internalSetRoutes\n  };\n  return router;\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\nconst UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\nfunction createStaticHandler(routes, opts) {\n  invariant(routes.length > 0, \"You must provide a non-empty routes array to createStaticHandler\");\n  let manifest = {};\n  let basename = (opts ? opts.basename : null) || \"/\";\n  let mapRouteProperties;\n  if (opts != null && opts.mapRouteProperties) {\n    mapRouteProperties = opts.mapRouteProperties;\n  } else if (opts != null && opts.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = opts.detectErrorBoundary;\n    mapRouteProperties = route => ({\n      hasErrorBoundary: detectErrorBoundary(route)\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Config driven behavior flags\n  let future = _extends({\n    v7_relativeSplatPath: false,\n    v7_throwAbortReason: false\n  }, opts ? opts.future : null);\n  let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, undefined, manifest);\n  /**\n   * The query() method is intended for document requests, in which we want to\n   * call an optional action and potentially multiple loaders for all nested\n   * routes.  It returns a StaticHandlerContext object, which is very similar\n   * to the router state (location, loaderData, actionData, errors, etc.) and\n   * also adds SSR-specific information such as the statusCode and headers\n   * from action/loaders Responses.\n   *\n   * It _should_ never throw and should report all errors through the\n   * returned context.errors object, properly associating errors to their error\n   * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be\n   * used to emulate React error boundaries during SSr by performing a second\n   * pass only down to the boundaryId.\n   *\n   * The one exception where we do not return a StaticHandlerContext is when a\n   * redirect response is returned or thrown from any action/loader.  We\n   * propagate that out and return the raw Response so the HTTP server can\n   * return it directly.\n   *\n   * - `opts.requestContext` is an optional server context that will be passed\n   *   to actions/loaders in the `context` parameter\n   * - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent\n   *   the bubbling of errors which allows single-fetch-type implementations\n   *   where the client will handle the bubbling and we may need to return data\n   *   for the handling route\n   */\n  async function query(request, _temp3) {\n    let {\n      requestContext,\n      skipLoaderErrorBubbling,\n      unstable_dataStrategy\n    } = _temp3 === void 0 ? {} : _temp3;\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\") {\n      let error = getInternalRouterError(405, {\n        method\n      });\n      let {\n        matches: methodNotAllowedMatches,\n        route\n      } = getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: methodNotAllowedMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    } else if (!matches) {\n      let error = getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n      let {\n        matches: notFoundMatches,\n        route\n      } = getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: notFoundMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    let result = await queryImpl(request, location, matches, requestContext, unstable_dataStrategy || null, skipLoaderErrorBubbling === true, null);\n    if (isResponse(result)) {\n      return result;\n    }\n    // When returning StaticHandlerContext, we patch back in the location here\n    // since we need it for React Context.  But this helps keep our submit and\n    // loadRouteData operating on a Request instead of a Location\n    return _extends({\n      location,\n      basename\n    }, result);\n  }\n  /**\n   * The queryRoute() method is intended for targeted route requests, either\n   * for fetch ?_data requests or resource route requests.  In this case, we\n   * are only ever calling a single action or loader, and we are returning the\n   * returned value directly.  In most cases, this will be a Response returned\n   * from the action/loader, but it may be a primitive or other value as well -\n   * and in such cases the calling context should handle that accordingly.\n   *\n   * We do respect the throw/return differentiation, so if an action/loader\n   * throws, then this method will throw the value.  This is important so we\n   * can do proper boundary identification in Remix where a thrown Response\n   * must go to the Catch Boundary but a returned Response is happy-path.\n   *\n   * One thing to note is that any Router-initiated Errors that make sense\n   * to associate with a status code will be thrown as an ErrorResponse\n   * instance which include the raw Error, such that the calling context can\n   * serialize the error as they see fit while including the proper response\n   * code.  Examples here are 404 and 405 errors that occur prior to reaching\n   * any user-defined loaders.\n   *\n   * - `opts.routeId` allows you to specify the specific route handler to call.\n   *   If not provided the handler will determine the proper route by matching\n   *   against `request.url`\n   * - `opts.requestContext` is an optional server context that will be passed\n   *    to actions/loaders in the `context` parameter\n   */\n  async function queryRoute(request, _temp4) {\n    let {\n      routeId,\n      requestContext,\n      unstable_dataStrategy\n    } = _temp4 === void 0 ? {} : _temp4;\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\" && method !== \"OPTIONS\") {\n      throw getInternalRouterError(405, {\n        method\n      });\n    } else if (!matches) {\n      throw getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n    }\n    let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);\n    if (routeId && !match) {\n      throw getInternalRouterError(403, {\n        pathname: location.pathname,\n        routeId\n      });\n    } else if (!match) {\n      // This should never hit I don't think?\n      throw getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n    }\n    let result = await queryImpl(request, location, matches, requestContext, unstable_dataStrategy || null, false, match);\n    if (isResponse(result)) {\n      return result;\n    }\n    let error = result.errors ? Object.values(result.errors)[0] : undefined;\n    if (error !== undefined) {\n      // If we got back result.errors, that means the loader/action threw\n      // _something_ that wasn't a Response, but it's not guaranteed/required\n      // to be an `instanceof Error` either, so we have to use throw here to\n      // preserve the \"error\" state outside of queryImpl.\n      throw error;\n    }\n    // Pick off the right state value to return\n    if (result.actionData) {\n      return Object.values(result.actionData)[0];\n    }\n    if (result.loaderData) {\n      var _result$activeDeferre;\n      let data = Object.values(result.loaderData)[0];\n      if ((_result$activeDeferre = result.activeDeferreds) != null && _result$activeDeferre[match.route.id]) {\n        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];\n      }\n      return data;\n    }\n    return undefined;\n  }\n  async function queryImpl(request, location, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch) {\n    invariant(request.signal, \"query()/queryRoute() requests must contain an AbortController signal\");\n    try {\n      if (isMutationMethod(request.method.toLowerCase())) {\n        let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch != null);\n        return result;\n      }\n      let result = await loadRouteData(request, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch);\n      return isResponse(result) ? result : _extends({}, result, {\n        actionData: null,\n        actionHeaders: {}\n      });\n    } catch (e) {\n      // If the user threw/returned a Response in callLoaderOrAction for a\n      // `queryRoute` call, we throw the `HandlerResult` to bail out early\n      // and then return or throw the raw Response here accordingly\n      if (isHandlerResult(e) && isResponse(e.result)) {\n        if (e.type === ResultType.error) {\n          throw e.result;\n        }\n        return e.result;\n      }\n      // Redirects are always returned since they don't propagate to catch\n      // boundaries\n      if (isRedirectResponse(e)) {\n        return e;\n      }\n      throw e;\n    }\n  }\n  async function submit(request, matches, actionMatch, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, isRouteRequest) {\n    let result;\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: actionMatch.route.id\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error\n      };\n    } else {\n      let results = await callDataStrategy(\"action\", request, [actionMatch], matches, isRouteRequest, requestContext, unstable_dataStrategy);\n      result = results[0];\n      if (request.signal.aborted) {\n        throwStaticHandlerAbortedError(request, isRouteRequest, future);\n      }\n    }\n    if (isRedirectResult(result)) {\n      // Uhhhh - this should never happen, we should always throw these from\n      // callLoaderOrAction, but the type narrowing here keeps TS happy and we\n      // can get back on the \"throw all redirect responses\" train here should\n      // this ever happen :/\n      throw new Response(null, {\n        status: result.response.status,\n        headers: {\n          Location: result.response.headers.get(\"Location\")\n        }\n      });\n    }\n    if (isDeferredResult(result)) {\n      let error = getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error\n      };\n    }\n    if (isRouteRequest) {\n      // Note: This should only be non-Response values if we get here, since\n      // isRouteRequest should throw any Response received in callLoaderOrAction\n      if (isErrorResult(result)) {\n        throw result.error;\n      }\n      return {\n        matches: [actionMatch],\n        loaderData: {},\n        actionData: {\n          [actionMatch.route.id]: result.data\n        },\n        errors: null,\n        // Note: statusCode + headers are unused here since queryRoute will\n        // return the raw Response or value\n        statusCode: 200,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    // Create a GET request for the loaders\n    let loaderRequest = new Request(request.url, {\n      headers: request.headers,\n      redirect: request.redirect,\n      signal: request.signal\n    });\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);\n      let context = await loadRouteData(loaderRequest, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, null, [boundaryMatch.route.id, result]);\n      // action status codes take precedence over loader status codes\n      return _extends({}, context, {\n        statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,\n        actionData: null,\n        actionHeaders: _extends({}, result.headers ? {\n          [actionMatch.route.id]: result.headers\n        } : {})\n      });\n    }\n    let context = await loadRouteData(loaderRequest, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, null);\n    return _extends({}, context, {\n      actionData: {\n        [actionMatch.route.id]: result.data\n      }\n    }, result.statusCode ? {\n      statusCode: result.statusCode\n    } : {}, {\n      actionHeaders: result.headers ? {\n        [actionMatch.route.id]: result.headers\n      } : {}\n    });\n  }\n  async function loadRouteData(request, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch, pendingActionResult) {\n    let isRouteRequest = routeMatch != null;\n    // Short circuit if we have no loaders to run (queryRoute())\n    if (isRouteRequest && !(routeMatch != null && routeMatch.route.loader) && !(routeMatch != null && routeMatch.route.lazy)) {\n      throw getInternalRouterError(400, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: routeMatch == null ? void 0 : routeMatch.route.id\n      });\n    }\n    let requestMatches = routeMatch ? [routeMatch] : pendingActionResult && isErrorResult(pendingActionResult[1]) ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]) : matches;\n    let matchesToLoad = requestMatches.filter(m => m.route.loader || m.route.lazy);\n    // Short circuit if we have no loaders to run (query())\n    if (matchesToLoad.length === 0) {\n      return {\n        matches,\n        // Add a null for all matched routes for proper revalidation on the client\n        loaderData: matches.reduce((acc, m) => Object.assign(acc, {\n          [m.route.id]: null\n        }), {}),\n        errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {\n          [pendingActionResult[0]]: pendingActionResult[1].error\n        } : null,\n        statusCode: 200,\n        loaderHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    let results = await callDataStrategy(\"loader\", request, matchesToLoad, matches, isRouteRequest, requestContext, unstable_dataStrategy);\n    if (request.signal.aborted) {\n      throwStaticHandlerAbortedError(request, isRouteRequest, future);\n    }\n    // Process and commit output from loaders\n    let activeDeferreds = new Map();\n    let context = processRouteLoaderData(matches, matchesToLoad, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling);\n    // Add a null for any non-loader matches for proper revalidation on the client\n    let executedLoaders = new Set(matchesToLoad.map(match => match.route.id));\n    matches.forEach(match => {\n      if (!executedLoaders.has(match.route.id)) {\n        context.loaderData[match.route.id] = null;\n      }\n    });\n    return _extends({}, context, {\n      matches,\n      activeDeferreds: activeDeferreds.size > 0 ? Object.fromEntries(activeDeferreds.entries()) : null\n    });\n  }\n  // Utility wrapper for calling dataStrategy server-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(type, request, matchesToLoad, matches, isRouteRequest, requestContext, unstable_dataStrategy) {\n    let results = await callDataStrategyImpl(unstable_dataStrategy || defaultDataStrategy, type, request, matchesToLoad, matches, manifest, mapRouteProperties, requestContext);\n    return await Promise.all(results.map((result, i) => {\n      if (isRedirectHandlerResult(result)) {\n        let response = result.result;\n        // Throw redirects and let the server handle them with an HTTP redirect\n        throw normalizeRelativeRoutingRedirectResponse(response, request, matchesToLoad[i].route.id, matches, basename, future.v7_relativeSplatPath);\n      }\n      if (isResponse(result.result) && isRouteRequest) {\n        // For SSR single-route requests, we want to hand Responses back\n        // directly without unwrapping\n        throw result;\n      }\n      return convertHandlerResultToDataResult(result);\n    }));\n  }\n  return {\n    dataRoutes,\n    query,\n    queryRoute\n  };\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Helpers\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Given an existing StaticHandlerContext and an error thrown at render time,\n * provide an updated StaticHandlerContext suitable for a second SSR render\n */\nfunction getStaticContextFromError(routes, context, error) {\n  let newContext = _extends({}, context, {\n    statusCode: isRouteErrorResponse(error) ? error.status : 500,\n    errors: {\n      [context._deepestRenderedBoundaryId || routes[0].id]: error\n    }\n  });\n  return newContext;\n}\nfunction throwStaticHandlerAbortedError(request, isRouteRequest, future) {\n  if (future.v7_throwAbortReason && request.signal.reason !== undefined) {\n    throw request.signal.reason;\n  }\n  let method = isRouteRequest ? \"queryRoute\" : \"query\";\n  throw new Error(method + \"() call aborted: \" + request.method + \" \" + request.url);\n}\nfunction isSubmissionNavigation(opts) {\n  return opts != null && (\"formData\" in opts && opts.formData != null || \"body\" in opts && opts.body !== undefined);\n}\nfunction normalizeTo(location, matches, basename, prependBasename, to, v7_relativeSplatPath, fromRouteId, relative) {\n  let contextualMatches;\n  let activeRouteMatch;\n  if (fromRouteId) {\n    // Grab matches up to the calling route so our route-relative logic is\n    // relative to the correct source route\n    contextualMatches = [];\n    for (let match of matches) {\n      contextualMatches.push(match);\n      if (match.route.id === fromRouteId) {\n        activeRouteMatch = match;\n        break;\n      }\n    }\n  } else {\n    contextualMatches = matches;\n    activeRouteMatch = matches[matches.length - 1];\n  }\n  // Resolve the relative path\n  let path = resolveTo(to ? to : \".\", getResolveToMatches(contextualMatches, v7_relativeSplatPath), stripBasename(location.pathname, basename) || location.pathname, relative === \"path\");\n  // When `to` is not specified we inherit search/hash from the current\n  // location, unlike when to=\".\" and we just inherit the path.\n  // See https://github.com/remix-run/remix/issues/927\n  if (to == null) {\n    path.search = location.search;\n    path.hash = location.hash;\n  }\n  // Add an ?index param for matched index routes if we don't already have one\n  if ((to == null || to === \"\" || to === \".\") && activeRouteMatch && activeRouteMatch.route.index && !hasNakedIndexQuery(path.search)) {\n    path.search = path.search ? path.search.replace(/^\\?/, \"?index&\") : \"?index\";\n  }\n  // If we're operating within a basename, prepend it to the pathname.  If\n  // this is a root navigation, then just use the raw basename which allows\n  // the basename to have full control over the presence of a trailing slash\n  // on root actions\n  if (prependBasename && basename !== \"/\") {\n    path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n  return createPath(path);\n}\n// Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\nfunction normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {\n  // Return location verbatim on non-submission navigations\n  if (!opts || !isSubmissionNavigation(opts)) {\n    return {\n      path\n    };\n  }\n  if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n    return {\n      path,\n      error: getInternalRouterError(405, {\n        method: opts.formMethod\n      })\n    };\n  }\n  let getInvalidBodyError = () => ({\n    path,\n    error: getInternalRouterError(400, {\n      type: \"invalid-body\"\n    })\n  });\n  // Create a Submission on non-GET navigations\n  let rawFormMethod = opts.formMethod || \"get\";\n  let formMethod = normalizeFormMethod ? rawFormMethod.toUpperCase() : rawFormMethod.toLowerCase();\n  let formAction = stripHashFromPath(path);\n  if (opts.body !== undefined) {\n    if (opts.formEncType === \"text/plain\") {\n      // text only support POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n      let text = typeof opts.body === \"string\" ? opts.body : opts.body instanceof FormData || opts.body instanceof URLSearchParams ?\n      // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data\n      Array.from(opts.body.entries()).reduce((acc, _ref5) => {\n        let [name, value] = _ref5;\n        return \"\" + acc + name + \"=\" + value + \"\\n\";\n      }, \"\") : String(opts.body);\n      return {\n        path,\n        submission: {\n          formMethod,\n          formAction,\n          formEncType: opts.formEncType,\n          formData: undefined,\n          json: undefined,\n          text\n        }\n      };\n    } else if (opts.formEncType === \"application/json\") {\n      // json only supports POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n      try {\n        let json = typeof opts.body === \"string\" ? JSON.parse(opts.body) : opts.body;\n        return {\n          path,\n          submission: {\n            formMethod,\n            formAction,\n            formEncType: opts.formEncType,\n            formData: undefined,\n            json,\n            text: undefined\n          }\n        };\n      } catch (e) {\n        return getInvalidBodyError();\n      }\n    }\n  }\n  invariant(typeof FormData === \"function\", \"FormData is not available in this environment\");\n  let searchParams;\n  let formData;\n  if (opts.formData) {\n    searchParams = convertFormDataToSearchParams(opts.formData);\n    formData = opts.formData;\n  } else if (opts.body instanceof FormData) {\n    searchParams = convertFormDataToSearchParams(opts.body);\n    formData = opts.body;\n  } else if (opts.body instanceof URLSearchParams) {\n    searchParams = opts.body;\n    formData = convertSearchParamsToFormData(searchParams);\n  } else if (opts.body == null) {\n    searchParams = new URLSearchParams();\n    formData = new FormData();\n  } else {\n    try {\n      searchParams = new URLSearchParams(opts.body);\n      formData = convertSearchParamsToFormData(searchParams);\n    } catch (e) {\n      return getInvalidBodyError();\n    }\n  }\n  let submission = {\n    formMethod,\n    formAction,\n    formEncType: opts && opts.formEncType || \"application/x-www-form-urlencoded\",\n    formData,\n    json: undefined,\n    text: undefined\n  };\n  if (isMutationMethod(submission.formMethod)) {\n    return {\n      path,\n      submission\n    };\n  }\n  // Flatten submission onto URLSearchParams for GET submissions\n  let parsedPath = parsePath(path);\n  // On GET navigation submissions we can drop the ?index param from the\n  // resulting location since all loaders will run.  But fetcher GET submissions\n  // only run a single loader so we need to preserve any incoming ?index params\n  if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n    searchParams.append(\"index\", \"\");\n  }\n  parsedPath.search = \"?\" + searchParams;\n  return {\n    path: createPath(parsedPath),\n    submission\n  };\n}\n// Filter out all routes below any caught error as they aren't going to\n// render so we don't need to load them\nfunction getLoaderMatchesUntilBoundary(matches, boundaryId) {\n  let boundaryMatches = matches;\n  if (boundaryId) {\n    let index = matches.findIndex(m => m.route.id === boundaryId);\n    if (index >= 0) {\n      boundaryMatches = matches.slice(0, index);\n    }\n  }\n  return boundaryMatches;\n}\nfunction getMatchesToLoad(history, state, matches, submission, location, isInitialLoad, skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {\n  let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : undefined;\n  let currentUrl = history.createURL(state.location);\n  let nextUrl = history.createURL(location);\n  // Pick navigation matches that are net-new or qualify for revalidation\n  let boundaryId = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[0] : undefined;\n  let boundaryMatches = boundaryId ? getLoaderMatchesUntilBoundary(matches, boundaryId) : matches;\n  // Don't revalidate loaders by default after action 4xx/5xx responses\n  // when the flag is enabled.  They can still opt-into revalidation via\n  // `shouldRevalidate` via `actionResult`\n  let actionStatus = pendingActionResult ? pendingActionResult[1].statusCode : undefined;\n  let shouldSkipRevalidation = skipActionErrorRevalidation && actionStatus && actionStatus >= 400;\n  let navigationMatches = boundaryMatches.filter((match, index) => {\n    let {\n      route\n    } = match;\n    if (route.lazy) {\n      // We haven't loaded this route yet so we don't know if it's got a loader!\n      return true;\n    }\n    if (route.loader == null) {\n      return false;\n    }\n    if (isInitialLoad) {\n      if (typeof route.loader !== \"function\" || route.loader.hydrate) {\n        return true;\n      }\n      return state.loaderData[route.id] === undefined && (\n      // Don't re-run if the loader ran and threw an error\n      !state.errors || state.errors[route.id] === undefined);\n    }\n    // Always call the loader on new route instances and pending defer cancellations\n    if (isNewLoader(state.loaderData, state.matches[index], match) || cancelledDeferredRoutes.some(id => id === match.route.id)) {\n      return true;\n    }\n    // This is the default implementation for when we revalidate.  If the route\n    // provides it's own implementation, then we give them full control but\n    // provide this value so they can leverage it if needed after they check\n    // their own specific use cases\n    let currentRouteMatch = state.matches[index];\n    let nextRouteMatch = match;\n    return shouldRevalidateLoader(match, _extends({\n      currentUrl,\n      currentParams: currentRouteMatch.params,\n      nextUrl,\n      nextParams: nextRouteMatch.params\n    }, submission, {\n      actionResult,\n      unstable_actionStatus: actionStatus,\n      defaultShouldRevalidate: shouldSkipRevalidation ? false :\n      // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate\n      isRevalidationRequired || currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search ||\n      // Search params affect all loaders\n      currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)\n    }));\n  });\n  // Pick fetcher.loads that need to be revalidated\n  let revalidatingFetchers = [];\n  fetchLoadMatches.forEach((f, key) => {\n    // Don't revalidate:\n    //  - on initial load (shouldn't be any fetchers then anyway)\n    //  - if fetcher won't be present in the subsequent render\n    //    - no longer matches the URL (v7_fetcherPersist=false)\n    //    - was unmounted but persisted due to v7_fetcherPersist=true\n    if (isInitialLoad || !matches.some(m => m.route.id === f.routeId) || deletedFetchers.has(key)) {\n      return;\n    }\n    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);\n    // If the fetcher path no longer matches, push it in with null matches so\n    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is\n    // currently only a use-case for Remix HMR where the route tree can change\n    // at runtime and remove a route previously loaded via a fetcher\n    if (!fetcherMatches) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: null,\n        match: null,\n        controller: null\n      });\n      return;\n    }\n    // Revalidating fetchers are decoupled from the route matches since they\n    // load from a static href.  They revalidate based on explicit revalidation\n    // (submission, useRevalidator, or X-Remix-Revalidate)\n    let fetcher = state.fetchers.get(key);\n    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);\n    let shouldRevalidate = false;\n    if (fetchRedirectIds.has(key)) {\n      // Never trigger a revalidation of an actively redirecting fetcher\n      shouldRevalidate = false;\n    } else if (cancelledFetcherLoads.includes(key)) {\n      // Always revalidate if the fetcher was cancelled\n      shouldRevalidate = true;\n    } else if (fetcher && fetcher.state !== \"idle\" && fetcher.data === undefined) {\n      // If the fetcher hasn't ever completed loading yet, then this isn't a\n      // revalidation, it would just be a brand new load if an explicit\n      // revalidation is required\n      shouldRevalidate = isRevalidationRequired;\n    } else {\n      // Otherwise fall back on any user-defined shouldRevalidate, defaulting\n      // to explicit revalidations only\n      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({\n        currentUrl,\n        currentParams: state.matches[state.matches.length - 1].params,\n        nextUrl,\n        nextParams: matches[matches.length - 1].params\n      }, submission, {\n        actionResult,\n        unstable_actionStatus: actionStatus,\n        defaultShouldRevalidate: shouldSkipRevalidation ? false : isRevalidationRequired\n      }));\n    }\n    if (shouldRevalidate) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: fetcherMatches,\n        match: fetcherMatch,\n        controller: new AbortController()\n      });\n    }\n  });\n  return [navigationMatches, revalidatingFetchers];\n}\nfunction isNewLoader(currentLoaderData, currentMatch, match) {\n  let isNew =\n  // [a] -> [a, b]\n  !currentMatch ||\n  // [a, b] -> [a, c]\n  match.route.id !== currentMatch.route.id;\n  // Handle the case that we don't have data for a re-used route, potentially\n  // from a prior error or from a cancelled pending deferred\n  let isMissingData = currentLoaderData[match.route.id] === undefined;\n  // Always load if this is a net-new route or we don't yet have data\n  return isNew || isMissingData;\n}\nfunction isNewRouteInstance(currentMatch, match) {\n  let currentPath = currentMatch.route.path;\n  return (\n    // param change for this match, /users/123 -> /users/456\n    currentMatch.pathname !== match.pathname ||\n    // splat param changed, which is not present in match.path\n    // e.g. /files/images/avatar.jpg -> files/finances.xls\n    currentPath != null && currentPath.endsWith(\"*\") && currentMatch.params[\"*\"] !== match.params[\"*\"]\n  );\n}\nfunction shouldRevalidateLoader(loaderMatch, arg) {\n  if (loaderMatch.route.shouldRevalidate) {\n    let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n  return arg.defaultShouldRevalidate;\n}\n/**\n * Execute route.lazy() methods to lazily load route modules (loader, action,\n * shouldRevalidate) and update the routeManifest in place which shares objects\n * with dataRoutes so those get updated as well.\n */\nasync function loadLazyRouteModule(route, mapRouteProperties, manifest) {\n  if (!route.lazy) {\n    return;\n  }\n  let lazyRoute = await route.lazy();\n  // If the lazy route function was executed and removed by another parallel\n  // call then we can return - first lazy() to finish wins because the return\n  // value of lazy is expected to be static\n  if (!route.lazy) {\n    return;\n  }\n  let routeToUpdate = manifest[route.id];\n  invariant(routeToUpdate, \"No route found in manifest\");\n  // Update the route in place.  This should be safe because there's no way\n  // we could yet be sitting on this route as we can't get there without\n  // resolving lazy() first.\n  //\n  // This is different than the HMR \"update\" use-case where we may actively be\n  // on the route being updated.  The main concern boils down to \"does this\n  // mutation affect any ongoing navigations or any current state.matches\n  // values?\".  If not, it should be safe to update in place.\n  let routeUpdates = {};\n  for (let lazyRouteProperty in lazyRoute) {\n    let staticRouteValue = routeToUpdate[lazyRouteProperty];\n    let isPropertyStaticallyDefined = staticRouteValue !== undefined &&\n    // This property isn't static since it should always be updated based\n    // on the route updates\n    lazyRouteProperty !== \"hasErrorBoundary\";\n    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.\"));\n    if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {\n      routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];\n    }\n  }\n  // Mutate the route with the provided updates.  Do this first so we pass\n  // the updated version to mapRouteProperties\n  Object.assign(routeToUpdate, routeUpdates);\n  // Mutate the `hasErrorBoundary` property on the route based on the route\n  // updates and remove the `lazy` function so we don't resolve the lazy\n  // route again.\n  Object.assign(routeToUpdate, _extends({}, mapRouteProperties(routeToUpdate), {\n    lazy: undefined\n  }));\n}\n// Default implementation of `dataStrategy` which fetches all loaders in parallel\nfunction defaultDataStrategy(opts) {\n  return Promise.all(opts.matches.map(m => m.resolve()));\n}\nasync function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, manifest, mapRouteProperties, requestContext) {\n  let routeIdsToLoad = matchesToLoad.reduce((acc, m) => acc.add(m.route.id), new Set());\n  let loadedMatches = new Set();\n  // Send all matches here to allow for a middleware-type implementation.\n  // handler will be a no-op for unneeded routes and we filter those results\n  // back out below.\n  let results = await dataStrategyImpl({\n    matches: matches.map(match => {\n      let shouldLoad = routeIdsToLoad.has(match.route.id);\n      // `resolve` encapsulates the route.lazy, executing the\n      // loader/action, and mapping return values/thrown errors to a\n      // HandlerResult.  Users can pass a callback to take fine-grained control\n      // over the execution of the loader/action\n      let resolve = handlerOverride => {\n        loadedMatches.add(match.route.id);\n        return shouldLoad ? callLoaderOrAction(type, request, match, manifest, mapRouteProperties, handlerOverride, requestContext) : Promise.resolve({\n          type: ResultType.data,\n          result: undefined\n        });\n      };\n      return _extends({}, match, {\n        shouldLoad,\n        resolve\n      });\n    }),\n    request,\n    params: matches[0].params,\n    context: requestContext\n  });\n  // Throw if any loadRoute implementations not called since they are what\n  // ensures a route is fully loaded\n  matches.forEach(m => invariant(loadedMatches.has(m.route.id), \"`match.resolve()` was not called for route id \\\"\" + m.route.id + \"\\\". \" + \"You must call `match.resolve()` on every match passed to \" + \"`dataStrategy` to ensure all routes are properly loaded.\"));\n  // Filter out any middleware-only matches for which we didn't need to run handlers\n  return results.filter((_, i) => routeIdsToLoad.has(matches[i].route.id));\n}\n// Default logic for calling a loader/action is the user has no specified a dataStrategy\nasync function callLoaderOrAction(type, request, match, manifest, mapRouteProperties, handlerOverride, staticContext) {\n  let result;\n  let onReject;\n  let runHandler = handler => {\n    // Setup a promise we can race against so that abort signals short circuit\n    let reject;\n    // This will never resolve so safe to type it as Promise<HandlerResult> to\n    // satisfy the function return value\n    let abortPromise = new Promise((_, r) => reject = r);\n    onReject = () => reject();\n    request.signal.addEventListener(\"abort\", onReject);\n    let actualHandler = ctx => {\n      if (typeof handler !== \"function\") {\n        return Promise.reject(new Error(\"You cannot call the handler for a route which defines a boolean \" + (\"\\\"\" + type + \"\\\" [routeId: \" + match.route.id + \"]\")));\n      }\n      return handler({\n        request,\n        params: match.params,\n        context: staticContext\n      }, ...(ctx !== undefined ? [ctx] : []));\n    };\n    let handlerPromise;\n    if (handlerOverride) {\n      handlerPromise = handlerOverride(ctx => actualHandler(ctx));\n    } else {\n      handlerPromise = (async () => {\n        try {\n          let val = await actualHandler();\n          return {\n            type: \"data\",\n            result: val\n          };\n        } catch (e) {\n          return {\n            type: \"error\",\n            result: e\n          };\n        }\n      })();\n    }\n    return Promise.race([handlerPromise, abortPromise]);\n  };\n  try {\n    let handler = match.route[type];\n    if (match.route.lazy) {\n      if (handler) {\n        // Run statically defined handler in parallel with lazy()\n        let handlerError;\n        let [value] = await Promise.all([\n        // If the handler throws, don't let it immediately bubble out,\n        // since we need to let the lazy() execution finish so we know if this\n        // route has a boundary that can handle the error\n        runHandler(handler).catch(e => {\n          handlerError = e;\n        }), loadLazyRouteModule(match.route, mapRouteProperties, manifest)]);\n        if (handlerError !== undefined) {\n          throw handlerError;\n        }\n        result = value;\n      } else {\n        // Load lazy route module, then run any returned handler\n        await loadLazyRouteModule(match.route, mapRouteProperties, manifest);\n        handler = match.route[type];\n        if (handler) {\n          // Handler still runs even if we got interrupted to maintain consistency\n          // with un-abortable behavior of handler execution on non-lazy or\n          // previously-lazy-loaded routes\n          result = await runHandler(handler);\n        } else if (type === \"action\") {\n          let url = new URL(request.url);\n          let pathname = url.pathname + url.search;\n          throw getInternalRouterError(405, {\n            method: request.method,\n            pathname,\n            routeId: match.route.id\n          });\n        } else {\n          // lazy() route has no loader to run.  Short circuit here so we don't\n          // hit the invariant below that errors on returning undefined.\n          return {\n            type: ResultType.data,\n            result: undefined\n          };\n        }\n      }\n    } else if (!handler) {\n      let url = new URL(request.url);\n      let pathname = url.pathname + url.search;\n      throw getInternalRouterError(404, {\n        pathname\n      });\n    } else {\n      result = await runHandler(handler);\n    }\n    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`.\");\n  } catch (e) {\n    // We should already be catching and converting normal handler executions to\n    // HandlerResults and returning them, so anything that throws here is an\n    // unexpected error we still need to wrap\n    return {\n      type: ResultType.error,\n      result: e\n    };\n  } finally {\n    if (onReject) {\n      request.signal.removeEventListener(\"abort\", onReject);\n    }\n  }\n  return result;\n}\nasync function convertHandlerResultToDataResult(handlerResult) {\n  let {\n    result,\n    type,\n    status\n  } = handlerResult;\n  if (isResponse(result)) {\n    let data;\n    try {\n      let contentType = result.headers.get(\"Content-Type\");\n      // Check between word boundaries instead of startsWith() due to the last\n      // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type\n      if (contentType && /\\bapplication\\/json\\b/.test(contentType)) {\n        if (result.body == null) {\n          data = null;\n        } else {\n          data = await result.json();\n        }\n      } else {\n        data = await result.text();\n      }\n    } catch (e) {\n      return {\n        type: ResultType.error,\n        error: e\n      };\n    }\n    if (type === ResultType.error) {\n      return {\n        type: ResultType.error,\n        error: new ErrorResponseImpl(result.status, result.statusText, data),\n        statusCode: result.status,\n        headers: result.headers\n      };\n    }\n    return {\n      type: ResultType.data,\n      data,\n      statusCode: result.status,\n      headers: result.headers\n    };\n  }\n  if (type === ResultType.error) {\n    return {\n      type: ResultType.error,\n      error: result,\n      statusCode: isRouteErrorResponse(result) ? result.status : status\n    };\n  }\n  if (isDeferredData(result)) {\n    var _result$init, _result$init2;\n    return {\n      type: ResultType.deferred,\n      deferredData: result,\n      statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status,\n      headers: ((_result$init2 = result.init) == null ? void 0 : _result$init2.headers) && new Headers(result.init.headers)\n    };\n  }\n  return {\n    type: ResultType.data,\n    data: result,\n    statusCode: status\n  };\n}\n// Support relative routing in internal redirects\nfunction normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, v7_relativeSplatPath) {\n  let location = response.headers.get(\"Location\");\n  invariant(location, \"Redirects returned/thrown from loaders/actions must have a Location header\");\n  if (!ABSOLUTE_URL_REGEX.test(location)) {\n    let trimmedMatches = matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1);\n    location = normalizeTo(new URL(request.url), trimmedMatches, basename, true, location, v7_relativeSplatPath);\n    response.headers.set(\"Location\", location);\n  }\n  return response;\n}\nfunction normalizeRedirectLocation(location, currentUrl, basename) {\n  if (ABSOLUTE_URL_REGEX.test(location)) {\n    // Strip off the protocol+origin for same-origin + same-basename absolute redirects\n    let normalizedLocation = location;\n    let url = normalizedLocation.startsWith(\"//\") ? new URL(currentUrl.protocol + normalizedLocation) : new URL(normalizedLocation);\n    let isSameBasename = stripBasename(url.pathname, basename) != null;\n    if (url.origin === currentUrl.origin && isSameBasename) {\n      return url.pathname + url.search + url.hash;\n    }\n  }\n  return location;\n}\n// Utility method for creating the Request instances for loaders/actions during\n// client-side navigations and fetches.  During SSR we will always have a\n// Request instance from the static handler (query/queryRoute)\nfunction createClientSideRequest(history, location, signal, submission) {\n  let url = history.createURL(stripHashFromPath(location)).toString();\n  let init = {\n    signal\n  };\n  if (submission && isMutationMethod(submission.formMethod)) {\n    let {\n      formMethod,\n      formEncType\n    } = submission;\n    // Didn't think we needed this but it turns out unlike other methods, patch\n    // won't be properly normalized to uppercase and results in a 405 error.\n    // See: https://fetch.spec.whatwg.org/#concept-method\n    init.method = formMethod.toUpperCase();\n    if (formEncType === \"application/json\") {\n      init.headers = new Headers({\n        \"Content-Type\": formEncType\n      });\n      init.body = JSON.stringify(submission.json);\n    } else if (formEncType === \"text/plain\") {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.text;\n    } else if (formEncType === \"application/x-www-form-urlencoded\" && submission.formData) {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = convertFormDataToSearchParams(submission.formData);\n    } else {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.formData;\n    }\n  }\n  return new Request(url, init);\n}\nfunction convertFormDataToSearchParams(formData) {\n  let searchParams = new URLSearchParams();\n  for (let [key, value] of formData.entries()) {\n    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs\n    searchParams.append(key, typeof value === \"string\" ? value : value.name);\n  }\n  return searchParams;\n}\nfunction convertSearchParamsToFormData(searchParams) {\n  let formData = new FormData();\n  for (let [key, value] of searchParams.entries()) {\n    formData.append(key, value);\n  }\n  return formData;\n}\nfunction processRouteLoaderData(matches, matchesToLoad, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling) {\n  // Fill in loaderData/errors from our loaders\n  let loaderData = {};\n  let errors = null;\n  let statusCode;\n  let foundError = false;\n  let loaderHeaders = {};\n  let pendingError = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : undefined;\n  // Process loader results into state.loaderData/state.errors\n  results.forEach((result, index) => {\n    let id = matchesToLoad[index].route.id;\n    invariant(!isRedirectResult(result), \"Cannot handle redirect results in processLoaderData\");\n    if (isErrorResult(result)) {\n      let error = result.error;\n      // If we have a pending action error, we report it at the highest-route\n      // that throws a loader error, and then clear it out to indicate that\n      // it was consumed\n      if (pendingError !== undefined) {\n        error = pendingError;\n        pendingError = undefined;\n      }\n      errors = errors || {};\n      if (skipLoaderErrorBubbling) {\n        errors[id] = error;\n      } else {\n        // Look upwards from the matched route for the closest ancestor error\n        // boundary, defaulting to the root match.  Prefer higher error values\n        // if lower errors bubble to the same boundary\n        let boundaryMatch = findNearestBoundary(matches, id);\n        if (errors[boundaryMatch.route.id] == null) {\n          errors[boundaryMatch.route.id] = error;\n        }\n      }\n      // Clear our any prior loaderData for the throwing route\n      loaderData[id] = undefined;\n      // Once we find our first (highest) error, we set the status code and\n      // prevent deeper status codes from overriding\n      if (!foundError) {\n        foundError = true;\n        statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;\n      }\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    } else {\n      if (isDeferredResult(result)) {\n        activeDeferreds.set(id, result.deferredData);\n        loaderData[id] = result.deferredData.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (result.statusCode != null && result.statusCode !== 200 && !foundError) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      } else {\n        loaderData[id] = result.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (result.statusCode && result.statusCode !== 200 && !foundError) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      }\n    }\n  });\n  // If we didn't consume the pending action error (i.e., all loaders\n  // resolved), then consume it here.  Also clear out any loaderData for the\n  // throwing route\n  if (pendingError !== undefined && pendingActionResult) {\n    errors = {\n      [pendingActionResult[0]]: pendingError\n    };\n    loaderData[pendingActionResult[0]] = undefined;\n  }\n  return {\n    loaderData,\n    errors,\n    statusCode: statusCode || 200,\n    loaderHeaders\n  };\n}\nfunction processLoaderData(state, matches, matchesToLoad, results, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds) {\n  let {\n    loaderData,\n    errors\n  } = processRouteLoaderData(matches, matchesToLoad, results, pendingActionResult, activeDeferreds, false // This method is only called client side so we always want to bubble\n  );\n  // Process results from our revalidating fetchers\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let {\n      key,\n      match,\n      controller\n    } = revalidatingFetchers[index];\n    invariant(fetcherResults !== undefined && fetcherResults[index] !== undefined, \"Did not find corresponding fetcher result\");\n    let result = fetcherResults[index];\n    // Process fetcher non-redirect errors\n    if (controller && controller.signal.aborted) {\n      // Nothing to do for aborted fetchers\n      continue;\n    } else if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);\n      if (!(errors && errors[boundaryMatch.route.id])) {\n        errors = _extends({}, errors, {\n          [boundaryMatch.route.id]: result.error\n        });\n      }\n      state.fetchers.delete(key);\n    } else if (isRedirectResult(result)) {\n      // Should never get here, redirects should get processed above, but we\n      // keep this to type narrow to a success result in the else\n      invariant(false, \"Unhandled fetcher revalidation redirect\");\n    } else if (isDeferredResult(result)) {\n      // Should never get here, deferred data should be awaited for fetchers\n      // in resolveDeferredResults\n      invariant(false, \"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = getDoneFetcher(result.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n  return {\n    loaderData,\n    errors\n  };\n}\nfunction mergeLoaderData(loaderData, newLoaderData, matches, errors) {\n  let mergedLoaderData = _extends({}, newLoaderData);\n  for (let match of matches) {\n    let id = match.route.id;\n    if (newLoaderData.hasOwnProperty(id)) {\n      if (newLoaderData[id] !== undefined) {\n        mergedLoaderData[id] = newLoaderData[id];\n      }\n    } else if (loaderData[id] !== undefined && match.route.loader) {\n      // Preserve existing keys not included in newLoaderData and where a loader\n      // wasn't removed by HMR\n      mergedLoaderData[id] = loaderData[id];\n    }\n    if (errors && errors.hasOwnProperty(id)) {\n      // Don't keep any loader data below the boundary\n      break;\n    }\n  }\n  return mergedLoaderData;\n}\nfunction getActionDataForCommit(pendingActionResult) {\n  if (!pendingActionResult) {\n    return {};\n  }\n  return isErrorResult(pendingActionResult[1]) ? {\n    // Clear out prior actionData on errors\n    actionData: {}\n  } : {\n    actionData: {\n      [pendingActionResult[0]]: pendingActionResult[1].data\n    }\n  };\n}\n// Find the nearest error boundary, looking upwards from the leaf route (or the\n// route specified by routeId) for the closest ancestor error boundary,\n// defaulting to the root match\nfunction findNearestBoundary(matches, routeId) {\n  let eligibleMatches = routeId ? matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1) : [...matches];\n  return eligibleMatches.reverse().find(m => m.route.hasErrorBoundary === true) || matches[0];\n}\nfunction getShortCircuitMatches(routes) {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route = routes.length === 1 ? routes[0] : routes.find(r => r.index || !r.path || r.path === \"/\") || {\n    id: \"__shim-error-route__\"\n  };\n  return {\n    matches: [{\n      params: {},\n      pathname: \"\",\n      pathnameBase: \"\",\n      route\n    }],\n    route\n  };\n}\nfunction getInternalRouterError(status, _temp5) {\n  let {\n    pathname,\n    routeId,\n    method,\n    type\n  } = _temp5 === void 0 ? {} : _temp5;\n  let statusText = \"Unknown Server Error\";\n  let errorMessage = \"Unknown @remix-run/router error\";\n  if (status === 400) {\n    statusText = \"Bad Request\";\n    if (method && pathname && routeId) {\n      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.\";\n    } else if (type === \"defer-action\") {\n      errorMessage = \"defer() is not supported in actions\";\n    } else if (type === \"invalid-body\") {\n      errorMessage = \"Unable to encode submission body\";\n    }\n  } else if (status === 403) {\n    statusText = \"Forbidden\";\n    errorMessage = \"Route \\\"\" + routeId + \"\\\" does not match URL \\\"\" + pathname + \"\\\"\";\n  } else if (status === 404) {\n    statusText = \"Not Found\";\n    errorMessage = \"No route matches URL \\\"\" + pathname + \"\\\"\";\n  } else if (status === 405) {\n    statusText = \"Method Not Allowed\";\n    if (method && pathname && routeId) {\n      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.\";\n    } else if (method) {\n      errorMessage = \"Invalid request method \\\"\" + method.toUpperCase() + \"\\\"\";\n    }\n  }\n  return new ErrorResponseImpl(status || 500, statusText, new Error(errorMessage), true);\n}\n// Find any returned redirect errors, starting from the lowest match\nfunction findRedirect(results) {\n  for (let i = results.length - 1; i >= 0; i--) {\n    let result = results[i];\n    if (isRedirectResult(result)) {\n      return {\n        result,\n        idx: i\n      };\n    }\n  }\n}\nfunction stripHashFromPath(path) {\n  let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n  return createPath(_extends({}, parsedPath, {\n    hash: \"\"\n  }));\n}\nfunction isHashChangeOnly(a, b) {\n  if (a.pathname !== b.pathname || a.search !== b.search) {\n    return false;\n  }\n  if (a.hash === \"\") {\n    // /page -> /page#hash\n    return b.hash !== \"\";\n  } else if (a.hash === b.hash) {\n    // /page#hash -> /page#hash\n    return true;\n  } else if (b.hash !== \"\") {\n    // /page#hash -> /page#other\n    return true;\n  }\n  // If the hash is removed the browser will re-perform a request to the server\n  // /page#hash -> /page\n  return false;\n}\nfunction isHandlerResult(result) {\n  return result != null && typeof result === \"object\" && \"type\" in result && \"result\" in result && (result.type === ResultType.data || result.type === ResultType.error);\n}\nfunction isRedirectHandlerResult(result) {\n  return isResponse(result.result) && redirectStatusCodes.has(result.result.status);\n}\nfunction isDeferredResult(result) {\n  return result.type === ResultType.deferred;\n}\nfunction isErrorResult(result) {\n  return result.type === ResultType.error;\n}\nfunction isRedirectResult(result) {\n  return (result && result.type) === ResultType.redirect;\n}\nfunction isDeferredData(value) {\n  let deferred = value;\n  return deferred && typeof deferred === \"object\" && typeof deferred.data === \"object\" && typeof deferred.subscribe === \"function\" && typeof deferred.cancel === \"function\" && typeof deferred.resolveData === \"function\";\n}\nfunction isResponse(value) {\n  return value != null && typeof value.status === \"number\" && typeof value.statusText === \"string\" && typeof value.headers === \"object\" && typeof value.body !== \"undefined\";\n}\nfunction isRedirectResponse(result) {\n  if (!isResponse(result)) {\n    return false;\n  }\n  let status = result.status;\n  let location = result.headers.get(\"Location\");\n  return status >= 300 && status <= 399 && location != null;\n}\nfunction isValidMethod(method) {\n  return validRequestMethods.has(method.toLowerCase());\n}\nfunction isMutationMethod(method) {\n  return validMutationMethods.has(method.toLowerCase());\n}\nasync function resolveDeferredResults(currentMatches, matchesToLoad, results, signals, isFetcher, currentLoaderData) {\n  for (let index = 0; index < results.length; index++) {\n    let result = results[index];\n    let match = matchesToLoad[index];\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n    let currentMatch = currentMatches.find(m => m.route.id === match.route.id);\n    let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\n    if (isDeferredResult(result) && (isFetcher || isRevalidatingLoader)) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      let signal = signals[index];\n      invariant(signal, \"Expected an AbortSignal for revalidating fetcher deferred result\");\n      await resolveDeferredData(result, signal, isFetcher).then(result => {\n        if (result) {\n          results[index] = result || results[index];\n        }\n      });\n    }\n  }\n}\nasync function resolveDeferredData(result, signal, unwrap) {\n  if (unwrap === void 0) {\n    unwrap = false;\n  }\n  let aborted = await result.deferredData.resolveData(signal);\n  if (aborted) {\n    return;\n  }\n  if (unwrap) {\n    try {\n      return {\n        type: ResultType.data,\n        data: result.deferredData.unwrappedData\n      };\n    } catch (e) {\n      // Handle any TrackedPromise._error values encountered while unwrapping\n      return {\n        type: ResultType.error,\n        error: e\n      };\n    }\n  }\n  return {\n    type: ResultType.data,\n    data: result.deferredData.data\n  };\n}\nfunction hasNakedIndexQuery(search) {\n  return new URLSearchParams(search).getAll(\"index\").some(v => v === \"\");\n}\nfunction getTargetMatch(matches, location) {\n  let search = typeof location === \"string\" ? parsePath(location).search : location.search;\n  if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || \"\")) {\n    // Return the leaf index route when index is present\n    return matches[matches.length - 1];\n  }\n  // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n  // pathless layout routes)\n  let pathMatches = getPathContributingMatches(matches);\n  return pathMatches[pathMatches.length - 1];\n}\nfunction getSubmissionFromNavigation(navigation) {\n  let {\n    formMethod,\n    formAction,\n    formEncType,\n    text,\n    formData,\n    json\n  } = navigation;\n  if (!formMethod || !formAction || !formEncType) {\n    return;\n  }\n  if (text != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json: undefined,\n      text\n    };\n  } else if (formData != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData,\n      json: undefined,\n      text: undefined\n    };\n  } else if (json !== undefined) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json,\n      text: undefined\n    };\n  }\n}\nfunction getLoadingNavigation(location, submission) {\n  if (submission) {\n    let navigation = {\n      state: \"loading\",\n      location,\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text\n    };\n    return navigation;\n  } else {\n    let navigation = {\n      state: \"loading\",\n      location,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined\n    };\n    return navigation;\n  }\n}\nfunction getSubmittingNavigation(location, submission) {\n  let navigation = {\n    state: \"submitting\",\n    location,\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text\n  };\n  return navigation;\n}\nfunction getLoadingFetcher(submission, data) {\n  if (submission) {\n    let fetcher = {\n      state: \"loading\",\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n      data\n    };\n    return fetcher;\n  } else {\n    let fetcher = {\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n      data\n    };\n    return fetcher;\n  }\n}\nfunction getSubmittingFetcher(submission, existingFetcher) {\n  let fetcher = {\n    state: \"submitting\",\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n    data: existingFetcher ? existingFetcher.data : undefined\n  };\n  return fetcher;\n}\nfunction getDoneFetcher(data) {\n  let fetcher = {\n    state: \"idle\",\n    formMethod: undefined,\n    formAction: undefined,\n    formEncType: undefined,\n    formData: undefined,\n    json: undefined,\n    text: undefined,\n    data\n  };\n  return fetcher;\n}\nfunction restoreAppliedTransitions(_window, transitions) {\n  try {\n    let sessionPositions = _window.sessionStorage.getItem(TRANSITIONS_STORAGE_KEY);\n    if (sessionPositions) {\n      let json = JSON.parse(sessionPositions);\n      for (let [k, v] of Object.entries(json || {})) {\n        if (v && Array.isArray(v)) {\n          transitions.set(k, new Set(v || []));\n        }\n      }\n    }\n  } catch (e) {\n    // no-op, use default empty object\n  }\n}\nfunction persistAppliedTransitions(_window, transitions) {\n  if (transitions.size > 0) {\n    let json = {};\n    for (let [k, v] of transitions) {\n      json[k] = [...v];\n    }\n    try {\n      _window.sessionStorage.setItem(TRANSITIONS_STORAGE_KEY, JSON.stringify(json));\n    } catch (error) {\n      warning(false, \"Failed to save applied view transitions in sessionStorage (\" + error + \").\");\n    }\n  }\n}\n//#endregion\n\nexport { AbortedDeferredError, Action, IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, UNSAFE_DEFERRED_SYMBOL, DeferredData as UNSAFE_DeferredData, ErrorResponseImpl as UNSAFE_ErrorResponseImpl, convertRouteMatchToUiMatch as UNSAFE_convertRouteMatchToUiMatch, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, getResolveToMatches as UNSAFE_getResolveToMatches, invariant as UNSAFE_invariant, warning as UNSAFE_warning, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, createRouter, createStaticHandler, defer, generatePath, getStaticContextFromError, getToPathname, isDeferredData, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, parsePath, redirect, redirectDocument, resolvePath, resolveTo, stripBasename };\n//# sourceMappingURL=router.js.map\n"],"names":["_extends","Object","assign","bind","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","apply","this","Action","PopStateEventType","createBrowserHistory","options","getLocation","createHref","validateLocation","window","document","defaultView","v5Compat","globalHistory","history","action","Pop","listener","index","getIndex","replaceState","state","idx","handlePop","nextIndex","delta","location","push","to","Push","createLocation","historyState","getHistoryState","url","pushState","error","DOMException","name","replace","Replace","createURL","base","origin","href","createPath","invariant","URL","listen","fn","Error","addEventListener","removeEventListener","encodeLocation","pathname","search","hash","go","n","getUrlBasedHistory","usr","value","message","warning","cond","console","warn","e","current","parsePath","Math","random","toString","substr","_ref","charAt","path","parsedPath","hashIndex","indexOf","searchIndex","ResultType","immutableRouteKeys","Set","convertRoutesToDataRoutes","routes","mapRouteProperties","parentPath","manifest","map","route","treePath","id","join","children","isIndexRoute","indexRoute","pathOrLayoutRoute","matchRoutes","locationArg","basename","stripBasename","branches","flattenRoutes","sort","a","b","score","siblings","slice","every","compareIndexes","routesMeta","meta","childrenIndex","rankRouteBranches","matches","decoded","decodePath","matchRouteBranch","parentsMeta","flattenRoute","relativePath","caseSensitive","startsWith","joinPaths","concat","computeScore","forEach","_route$path","includes","exploded","explodeOptionalSegments","segments","split","first","rest","isOptional","endsWith","required","restExploded","result","subpath","paramRe","dynamicSegmentValue","indexRouteValue","emptySegmentValue","staticSegmentValue","splatPenalty","isSplat","s","initialScore","some","filter","reduce","segment","test","branch","matchedParams","matchedPathname","end","remainingPathname","match","matchPath","params","pathnameBase","normalizePathname","pattern","matcher","compiledParams","regexpSource","_","paramName","RegExp","compilePath","captureGroups","memo","splatValue","v","decodeURIComponent","toLowerCase","startIndex","nextChar","getInvalidPathError","char","field","dest","JSON","stringify","getPathContributingMatches","getResolveToMatches","v7_relativeSplatPath","pathMatches","resolveTo","toArg","routePathnames","locationPathname","isPathRelative","from","isEmptyPath","toPathname","routePathnameIndex","toSegments","shift","fromPathname","pop","resolvePathname","normalizeSearch","normalizeHash","resolvePath","hasExplicitTrailingSlash","hasCurrentTrailingSlash","paths","ErrorResponseImpl","constructor","status","statusText","data","internal","isRouteErrorResponse","validMutationMethodsArr","validMutationMethods","validRequestMethodsArr","validRequestMethods","redirectStatusCodes","redirectPreserveMethodStatusCodes","IDLE_NAVIGATION","formMethod","formAction","formEncType","formData","json","text","IDLE_FETCHER","IDLE_BLOCKER","proceed","reset","ABSOLUTE_URL_REGEX","defaultMapRouteProperties","hasErrorBoundary","Boolean","TRANSITIONS_STORAGE_KEY","createRouter","init","routerWindow","isBrowser","createElement","isServer","detectErrorBoundary","inFlightDataRoutes","initialized","dataRoutes","dataStrategyImpl","unstable_dataStrategy","defaultDataStrategy","future","v7_fetcherPersist","v7_normalizeFormMethod","v7_partialHydration","v7_prependBasename","unstable_skipActionErrorRevalidation","unlistenHistory","subscribers","savedScrollPositions","getScrollRestorationKey","getScrollPosition","initialScrollRestored","hydrationData","initialMatches","initialErrors","getInternalRouterError","getShortCircuitMatches","router","hasLazyRoutes","m","lazy","hasLoaders","loader","loaderData","errors","isRouteInitialized","hydrate","findIndex","pendingNavigationController","historyAction","navigation","restoreScrollPosition","preventScrollReset","revalidation","actionData","fetchers","Map","blockers","pendingAction","pendingPreventScrollReset","pendingViewTransitionEnabled","appliedViewTransitions","removePageHideEventListener","isUninterruptedRevalidation","isRevalidationRequired","cancelledDeferredRoutes","cancelledFetcherLoads","fetchControllers","incrementingLoadId","pendingNavigationLoadId","fetchReloadIds","fetchRedirectIds","fetchLoadMatches","activeFetchers","deletedFetchers","activeDeferreds","blockerFunctions","ignoreNextHistoryUpdate","updateState","newState","opts","completedFetchers","deletedFetchersKeys","fetcher","has","subscriber","unstable_viewTransitionOpts","viewTransitionOpts","unstable_flushSync","flushSync","delete","deleteFetcher","completeNavigation","_temp","_location$state","_location$state2","isActionReload","isMutationMethod","_isRedirect","keys","mergeLoaderData","size","k","set","priorPaths","get","currentLocation","nextLocation","toPaths","add","getSavedScrollPosition","async","startNavigation","abort","startUninterruptedRevalidation","getScrollKey","saveScrollPosition","enableViewTransition","routesToUse","loadingNavigation","overrideNavigation","notFoundMatches","isHashChangeOnly","submission","AbortController","pendingActionResult","request","createClientSideRequest","signal","pendingError","findNearestBoundary","type","actionResult","getSubmittingNavigation","actionMatch","getTargetMatch","callDataStrategy","aborted","shortCircuited","method","routeId","isRedirectResult","normalizeRedirectLocation","response","headers","startRedirectNavigation","isDeferredResult","isErrorResult","boundaryMatch","handleAction","getLoadingNavigation","fetcherSubmission","initialHydration","activeSubmission","getSubmissionFromNavigation","matchesToLoad","revalidatingFetchers","getMatchesToLoad","cancelActiveDeferreds","updatedFetchers","markFetchRedirectsDone","getActionDataForCommit","rf","revalidatingFetcher","getLoadingFetcher","abortFetcher","controller","abortPendingFetchRevalidations","f","loaderResults","fetcherResults","callLoadersAndMaybeResolveData","redirect","findRedirect","fetcherKey","processLoaderData","deferredData","subscribe","done","entries","_ref2","_ref3","didAbortFetchLoads","abortStaleFetchLoads","shouldUpdateFetchers","handleLoaders","_temp2","redirectLocation","isDocumentReload","redirectHistoryAction","results","requestContext","routeIdsToLoad","acc","loadedMatches","shouldLoad","resolve","handlerOverride","staticContext","onReject","runHandler","handler","reject","abortPromise","Promise","r","handlerPromise","actualHandler","ctx","context","race","handlerError","all","catch","loadLazyRouteModule","callLoaderOrAction","callDataStrategyImpl","isResponse","isRedirectHandlerResult","normalizeRelativeRoutingRedirectResponse","handlerResult","contentType","body","statusCode","_result$init","_result$init2","deferred","cancel","resolveData","isDeferredData","Headers","convertHandlerResultToDataResult","currentMatches","fetchersToLoad","then","resolveDeferredResults","interruptActiveLoads","updateFetcherState","setFetcherError","getFetcher","markFetchersDone","doneFetcher","getDoneFetcher","doneKeys","landedId","yeetedKeys","deleteBlocker","updateBlocker","newBlocker","blocker","shouldBlockNavigation","_ref4","Array","blockerKey","blockerFunction","predicate","cancelledRouteIds","dfd","handle","convertRouteMatchToUiMatch","y","initialize","_window","transitions","sessionPositions","sessionStorage","getItem","parse","isArray","restoreAppliedTransitions","_saveAppliedTransitions","setItem","persistAppliedTransitions","enableScrollRestoration","positions","getPosition","getKey","navigate","normalizedPath","normalizeTo","fromRouteId","relative","normalizeNavigateOptions","userReplace","unstable_viewTransition","fetch","requestMatches","existingFetcher","getSubmittingFetcher","abortController","fetchRequest","originatingLoadId","actionResults","revalidationRequest","loadId","loadFetcher","staleKey","handleFetcherAction","resolveDeferredData","handleFetcherLoader","revalidate","count","dispose","clear","getBlocker","_internalFetchControllers","_internalActiveDeferreds","_internalSetRoutes","newRoutes","prependBasename","contextualMatches","activeRouteMatch","hasNakedIndexQuery","normalizeFormMethod","isFetcher","isSubmissionNavigation","searchParams","getInvalidBodyError","rawFormMethod","toUpperCase","stripHashFromPath","FormData","URLSearchParams","_ref5","String","convertFormDataToSearchParams","convertSearchParamsToFormData","append","isInitialLoad","skipActionErrorRevalidation","currentUrl","nextUrl","boundaryId","boundaryMatches","getLoaderMatchesUntilBoundary","actionStatus","shouldSkipRevalidation","navigationMatches","currentLoaderData","currentMatch","isNew","isMissingData","isNewLoader","currentRouteMatch","nextRouteMatch","shouldRevalidateLoader","currentParams","nextParams","unstable_actionStatus","defaultShouldRevalidate","isNewRouteInstance","fetcherMatches","fetcherMatch","shouldRevalidate","currentPath","loaderMatch","arg","routeChoice","lazyRoute","routeToUpdate","routeUpdates","lazyRouteProperty","isPropertyStaticallyDefined","trimmedMatches","normalizedLocation","protocol","isSameBasename","Request","skipLoaderErrorBubbling","foundError","loaderHeaders","processRouteLoaderData","newLoaderData","mergedLoaderData","reverse","find","_temp5","errorMessage","signals","isRevalidatingLoader","unwrap","unwrappedData","getAll"],"mappings":"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","x_google_ignoreList":[0]}