{"version":3,"file":"vendors/vendors-main-router.js.bundle.js","mappings":"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","sources":["webpack://typescript/./node_modules/@remix-run/router/dist/router.js"],"sourcesContent":["/**\n * @remix-run/router v1.22.0\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, String(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/v6/utils/match-routes\n */\nfunction matchRoutes(routes, locationArg, basename) {\n  if (basename === void 0) {\n    basename = \"/\";\n  }\n  return matchRoutesImpl(routes, locationArg, basename, false);\n}\nfunction matchRoutesImpl(routes, locationArg, basename, allowPartial) {\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, allowPartial);\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, allowPartial) {\n  if (allowPartial === void 0) {\n    allowPartial = false;\n  }\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    let route = meta.route;\n    if (!match && end && allowPartial && !routesMeta[routesMeta.length - 1].route.index) {\n      match = matchPath({\n        path: meta.relativePath,\n        caseSensitive: meta.caseSensitive,\n        end: false\n      }, remainingPathname);\n    }\n    if (!match) {\n      return null;\n    }\n    Object.assign(matchedParams, match.params);\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/v6/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/v6/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/v6/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 === pathMatches.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 *\n * @deprecated The `json` method is deprecated in favor of returning raw objects.\n * This method will be removed in v7.\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 DataWithResponseInit {\n  constructor(data, init) {\n    this.type = \"DataWithResponseInit\";\n    this.data = data;\n    this.init = init || null;\n  }\n}\n/**\n * Create \"responses\" that contain `status`/`headers` without forcing\n * serialization into an actual `Response` - used by Remix single fetch\n */\nfunction data(data, init) {\n  return new DataWithResponseInit(data, typeof init === \"number\" ? {\n    status: init\n  } : init);\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}\n/**\n * @deprecated The `defer` method is deprecated in favor of returning raw\n * objects. This method will be removed in v7.\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 * A redirect response that will perform a `history.replaceState` instead of a\n * `history.pushState` for client-side navigation redirects.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst replace = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Replace\", \"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.dataStrategy || defaultDataStrategy;\n  let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;\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    v7_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 initialMatchesIsFOW = false;\n  let initialErrors = null;\n  if (initialMatches == null && !patchRoutesOnNavigationImpl) {\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  // In SPA apps, if the user provided a patchRoutesOnNavigation implementation and\n  // our initial match is a splat route, clear them out so we run through lazy\n  // discovery on hydration in case there's a more accurate lazy route match.\n  // In SSR apps (with `hydrationData`), we expect that the server will send\n  // up the proper matched routes so we don't want to run lazy discovery on\n  // initial hydration and want to hydrate into the splat route.\n  if (initialMatches && !init.hydrationData) {\n    let fogOfWar = checkFogOfWar(initialMatches, dataRoutes, init.history.location.pathname);\n    if (fogOfWar.active) {\n      initialMatches = null;\n    }\n  }\n  let initialized;\n  if (!initialMatches) {\n    initialized = false;\n    initialMatches = [];\n    // If partial hydration and fog of war is enabled, we will be running\n    // `patchRoutesOnNavigation` during hydration so include any partial matches as\n    // the initial matches so we can properly render `HydrateFallback`'s\n    if (future.v7_partialHydration) {\n      let fogOfWar = checkFogOfWar(null, dataRoutes, init.history.location.pathname);\n      if (fogOfWar.active && fogOfWar.matches) {\n        initialMatchesIsFOW = true;\n        initialMatches = fogOfWar.matches;\n      }\n    }\n  } else if (initialMatches.some(m => m.route.lazy)) {\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 (!initialMatches.some(m => m.route.loader)) {\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    // 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(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));\n    } else {\n      initialized = initialMatches.every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));\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 = new Set();\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 unblockBlockerHistoryUpdate = undefined;\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 (unblockBlockerHistoryUpdate) {\n        unblockBlockerHistoryUpdate();\n        unblockBlockerHistoryUpdate = undefined;\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        let nextHistoryUpdatePromise = new Promise(resolve => {\n          unblockBlockerHistoryUpdate = resolve;\n        });\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, after the url\n            // restoration is also complete.  See:\n            // https://github.com/remix-run/react-router/issues/11613\n            nextHistoryUpdatePromise.then(() => 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    // Remove any lingering deleted fetchers that have already been removed\n    // from state.fetchers\n    deletedFetchers.forEach(key => {\n      if (!state.fetchers.has(key) && !fetchControllers.has(key)) {\n        deletedFetchersKeys.push(key);\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      viewTransitionOpts: opts.viewTransitionOpts,\n      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    } else {\n      // We already called deleteFetcher() on these, can remove them from this\n      // Set now that we've handed the keys off to the data layer\n      deletedFetchersKeys.forEach(key => deletedFetchers.delete(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    // Commit any in-flight routes at the end of the HMR revalidation \"navigation\"\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  }\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.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.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      // Proxy through any rending view transition\n      enableViewTransition: pendingViewTransitionEnabled === true\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 = opts != null && opts.initialHydration && state.matches && state.matches.length > 0 && !initialMatchesIsFOW ?\n    // `matchRoutes()` has already been called if we're in here via `router.initialize()`\n    state.matches : matchRoutes(routesToUse, location, basename);\n    let flushSync = (opts && opts.flushSync) === true;\n    let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n    // Short circuit with a 404 on the root error boundary if we match nothing\n    if (!matches) {\n      let {\n        error,\n        notFoundMatches,\n        route\n      } = handleNavigational404(location.pathname);\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 hydration 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, fogOfWar.active, {\n        replace: opts.replace,\n        flushSync\n      });\n      if (actionResult.shortCircuited) {\n        return;\n      }\n      // If we received a 404 from handleAction, it's because we couldn't lazily\n      // discover the destination route so we don't want to call loaders\n      if (actionResult.pendingActionResult) {\n        let [routeId, result] = actionResult.pendingActionResult;\n        if (isErrorResult(result) && isRouteErrorResponse(result.error) && result.error.status === 404) {\n          pendingNavigationController = null;\n          completeNavigation(location, {\n            matches: actionResult.matches,\n            loaderData: {},\n            errors: {\n              [routeId]: result.error\n            }\n          });\n          return;\n        }\n      }\n      matches = actionResult.matches || matches;\n      pendingActionResult = actionResult.pendingActionResult;\n      loadingNavigation = getLoadingNavigation(location, opts.submission);\n      flushSync = false;\n      // No need to do fog of war matching again on loader execution\n      fogOfWar.active = 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      matches: updatedMatches,\n      loaderData,\n      errors\n    } = await handleLoaders(request, location, matches, fogOfWar.active, 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: updatedMatches || 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, isFogOfWar, 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    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);\n      if (discoverResult.type === \"aborted\") {\n        return {\n          shortCircuited: true\n        };\n      } else if (discoverResult.type === \"error\") {\n        let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;\n        return {\n          matches: discoverResult.partialMatches,\n          pendingActionResult: [boundaryId, {\n            type: ResultType.error,\n            error: discoverResult.error\n          }]\n        };\n      } else if (!discoverResult.matches) {\n        let {\n          notFoundMatches,\n          error,\n          route\n        } = handleNavigational404(location.pathname);\n        return {\n          matches: notFoundMatches,\n          pendingActionResult: [route.id, {\n            type: ResultType.error,\n            error\n          }]\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\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\", state, request, [actionMatch], matches, null);\n      result = results[actionMatch.route.id];\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, true, {\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 to the current location are REPLACE\n      // navigations, but if the action threw an error that'll be rendered in\n      // an errorElement, we fall back to PUSH so that the user can use the\n      // back button to get back to the pre-submission form location to try\n      // again\n      if ((opts && opts.replace) !== true) {\n        pendingAction = Action.Push;\n      }\n      return {\n        matches,\n        pendingActionResult: [boundaryMatch.route.id, result]\n      };\n    }\n    return {\n      matches,\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, isFogOfWar, 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    // 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    let shouldUpdateNavigationState = !isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration);\n    // When fog of war is enabled, we enter our `loading` state earlier so we\n    // can discover new routes during the `loading` state.  We skip this if\n    // we've already run actions since we would have done our matching already.\n    // If the children() function threw then, we want to proceed with the\n    // partial matches it discovered.\n    if (isFogOfWar) {\n      if (shouldUpdateNavigationState) {\n        let actionData = getUpdatedActionData(pendingActionResult);\n        updateState(_extends({\n          navigation: loadingNavigation\n        }, actionData !== undefined ? {\n          actionData\n        } : {}), {\n          flushSync\n        });\n      }\n      let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);\n      if (discoverResult.type === \"aborted\") {\n        return {\n          shortCircuited: true\n        };\n      } else if (discoverResult.type === \"error\") {\n        let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;\n        return {\n          matches: discoverResult.partialMatches,\n          loaderData: {},\n          errors: {\n            [boundaryId]: discoverResult.error\n          }\n        };\n      } else if (!discoverResult.matches) {\n        let {\n          error,\n          notFoundMatches,\n          route\n        } = handleNavigational404(location.pathname);\n        return {\n          matches: notFoundMatches,\n          loaderData: {},\n          errors: {\n            [route.id]: error\n          }\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult);\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 (shouldUpdateNavigationState) {\n      let updates = {};\n      if (!isFogOfWar) {\n        // Only update navigation/actionNData if we didn't already do it above\n        updates.navigation = loadingNavigation;\n        let actionData = getUpdatedActionData(pendingActionResult);\n        if (actionData !== undefined) {\n          updates.actionData = actionData;\n        }\n      }\n      if (revalidatingFetchers.length > 0) {\n        updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);\n      }\n      updateState(updates, {\n        flushSync\n      });\n    }\n    revalidatingFetchers.forEach(rf => {\n      abortFetcher(rf.key);\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, 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);\n    if (redirect) {\n      await startRedirectNavigation(request, redirect.result, true, {\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    redirect = findRedirect(fetcherResults);\n    if (redirect) {\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      fetchRedirectIds.add(redirect.key);\n      await startRedirectNavigation(request, redirect.result, true, {\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, 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    // Preserve SSR errors during partial hydration\n    if (future.v7_partialHydration && initialHydration && state.errors) {\n      errors = _extends({}, state.errors, errors);\n    }\n    let updatedFetchers = markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n    return _extends({\n      matches,\n      loaderData,\n      errors\n    }, shouldUpdateFetchers ? {\n      fetchers: new Map(state.fetchers)\n    } : {});\n  }\n  function getUpdatedActionData(pendingActionResult) {\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      return {\n        [pendingActionResult[0]]: pendingActionResult[1].data\n      };\n    } else if (state.actionData) {\n      if (Object.keys(state.actionData).length === 0) {\n        return null;\n      } else {\n        return state.actionData;\n      }\n    }\n  }\n  function getUpdatedRevalidatingFetchers(revalidatingFetchers) {\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    return new Map(state.fetchers);\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    abortFetcher(key);\n    let flushSync = (opts && opts.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    let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\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    let preventScrollReset = (opts && opts.preventScrollReset) === true;\n    if (submission && isMutationMethod(submission.formMethod)) {\n      handleFetcherAction(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, 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, fogOfWar.active, flushSync, preventScrollReset, 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, isFogOfWar, flushSync, preventScrollReset, submission) {\n    interruptActiveLoads();\n    fetchLoadMatches.delete(key);\n    function detectAndHandle405Error(m) {\n      if (!m.route.action && !m.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 true;\n      }\n      return false;\n    }\n    if (!isFogOfWar && detectAndHandle405Error(match)) {\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    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(requestMatches, new URL(fetchRequest.url).pathname, fetchRequest.signal);\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        setFetcherError(key, routeId, discoverResult.error, {\n          flushSync\n        });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(key, routeId, getInternalRouterError(404, {\n          pathname: path\n        }), {\n          flushSync\n        });\n        return;\n      } else {\n        requestMatches = discoverResult.matches;\n        match = getTargetMatch(requestMatches, path);\n        if (detectAndHandle405Error(match)) {\n          return;\n        }\n      }\n    }\n    // Call the action for the fetcher\n    fetchControllers.set(key, abortController);\n    let originatingLoadId = incrementingLoadId;\n    let actionResults = await callDataStrategy(\"action\", state, fetchRequest, [match], requestMatches, key);\n    let actionResult = actionResults[match.route.id];\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, false, {\n            fetcherSubmission: submission,\n            preventScrollReset\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.v7_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      abortFetcher(staleKey);\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, 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);\n    if (redirect) {\n      return startRedirectNavigation(revalidationRequest, redirect.result, false, {\n        preventScrollReset\n      });\n    }\n    redirect = findRedirect(fetcherResults);\n    if (redirect) {\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      fetchRedirectIds.add(redirect.key);\n      return startRedirectNavigation(revalidationRequest, redirect.result, false, {\n        preventScrollReset\n      });\n    }\n    // Process and commit output from loaders\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, matches, 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, isFogOfWar, flushSync, preventScrollReset, submission) {\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : undefined), {\n      flushSync\n    });\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(matches, new URL(fetchRequest.url).pathname, fetchRequest.signal);\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        setFetcherError(key, routeId, discoverResult.error, {\n          flushSync\n        });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(key, routeId, getInternalRouterError(404, {\n          pathname: path\n        }), {\n          flushSync\n        });\n        return;\n      } else {\n        matches = discoverResult.matches;\n        match = getTargetMatch(matches, path);\n      }\n    }\n    // Call the loader for this fetcher route match\n    fetchControllers.set(key, abortController);\n    let originatingLoadId = incrementingLoadId;\n    let results = await callDataStrategy(\"loader\", state, fetchRequest, [match], matches, key);\n    let result = results[match.route.id];\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, false, {\n          preventScrollReset\n        });\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, isNavigation, _temp2) {\n    let {\n      submission,\n      fetcherSubmission,\n      preventScrollReset,\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 || redirect.response.headers.has(\"X-Remix-Replace\") ? 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 these flags across redirects\n        preventScrollReset: preventScrollReset || pendingPreventScrollReset,\n        enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined\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 these flags across redirects\n        preventScrollReset: preventScrollReset || pendingPreventScrollReset,\n        enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined\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, state, request, matchesToLoad, matches, fetcherKey) {\n    let results;\n    let dataResults = {};\n    try {\n      results = await callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties);\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      matchesToLoad.forEach(m => {\n        dataResults[m.route.id] = {\n          type: ResultType.error,\n          error: e\n        };\n      });\n      return dataResults;\n    }\n    for (let [routeId, result] of Object.entries(results)) {\n      if (isRedirectDataStrategyResultResult(result)) {\n        let response = result.result;\n        dataResults[routeId] = {\n          type: ResultType.redirect,\n          response: normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, future.v7_relativeSplatPath)\n        };\n      } else {\n        dataResults[routeId] = await convertDataStrategyResultToDataResult(result);\n      }\n    }\n    return dataResults;\n  }\n  async function callLoadersAndMaybeResolveData(state, matches, matchesToLoad, fetchersToLoad, request) {\n    let currentMatches = state.matches;\n    // Kick off loaders and fetchers in parallel\n    let loaderResultsPromise = callDataStrategy(\"loader\", state, request, matchesToLoad, matches, null);\n    let fetcherResultsPromise = Promise.all(fetchersToLoad.map(async f => {\n      if (f.matches && f.match && f.controller) {\n        let results = await callDataStrategy(\"loader\", state, createClientSideRequest(init.history, f.path, f.controller.signal), [f.match], f.matches, f.key);\n        let result = results[f.match.route.id];\n        // Fetcher results are keyed by fetcher key from here on out, not routeId\n        return {\n          [f.key]: result\n        };\n      } else {\n        return Promise.resolve({\n          [f.key]: {\n            type: ResultType.error,\n            error: getInternalRouterError(404, {\n              pathname: f.path\n            })\n          }\n        });\n      }\n    }));\n    let loaderResults = await loaderResultsPromise;\n    let fetcherResults = (await fetcherResultsPromise).reduce((acc, r) => Object.assign(acc, r), {});\n    await Promise.all([resolveNavigationDeferredResults(matches, loaderResults, request.signal, currentMatches, state.loaderData), resolveFetcherDeferredResults(matches, fetcherResults, fetchersToLoad)]);\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.add(key);\n      }\n      abortFetcher(key);\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    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    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    // If we opted into the flag we can clear this now since we're calling\n    // deleteFetcher() at the end of updateState() and we've already handed the\n    // deleted fetcher keys off to the data layer.\n    // If not, we're eagerly calling deleteFetcher() and we need to keep this\n    // Set populated until the next updateState call, and we'll clear\n    // `deletedFetchers` then\n    if (future.v7_fetcherPersist) {\n      deletedFetchers.delete(key);\n    }\n    cancelledFetcherLoads.delete(key);\n    state.fetchers.delete(key);\n  }\n  function deleteFetcherAndUpdateState(key) {\n    let count = (activeFetchers.get(key) || 0) - 1;\n    if (count <= 0) {\n      activeFetchers.delete(key);\n      deletedFetchers.add(key);\n      if (!future.v7_fetcherPersist) {\n        deleteFetcher(key);\n      }\n    } else {\n      activeFetchers.set(key, count);\n    }\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n  }\n  function abortFetcher(key) {\n    let controller = fetchControllers.get(key);\n    if (controller) {\n      controller.abort();\n      fetchControllers.delete(key);\n    }\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(_ref2) {\n    let {\n      currentLocation,\n      nextLocation,\n      historyAction\n    } = _ref2;\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 handleNavigational404(pathname) {\n    let error = getInternalRouterError(404, {\n      pathname\n    });\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let {\n      matches,\n      route\n    } = getShortCircuitMatches(routesToUse);\n    // Cancel all pending deferred on 404s since we don't keep any routes\n    cancelActiveDeferreds();\n    return {\n      notFoundMatches: matches,\n      route,\n      error\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 checkFogOfWar(matches, routesToUse, pathname) {\n    if (patchRoutesOnNavigationImpl) {\n      if (!matches) {\n        let fogMatches = matchRoutesImpl(routesToUse, pathname, basename, true);\n        return {\n          active: true,\n          matches: fogMatches || []\n        };\n      } else {\n        if (Object.keys(matches[0].params).length > 0) {\n          // If we matched a dynamic param or a splat, it might only be because\n          // we haven't yet discovered other routes that would match with a\n          // higher score.  Call patchRoutesOnNavigation just to be sure\n          let partialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);\n          return {\n            active: true,\n            matches: partialMatches\n          };\n        }\n      }\n    }\n    return {\n      active: false,\n      matches: null\n    };\n  }\n  async function discoverRoutes(matches, pathname, signal) {\n    if (!patchRoutesOnNavigationImpl) {\n      return {\n        type: \"success\",\n        matches\n      };\n    }\n    let partialMatches = matches;\n    while (true) {\n      let isNonHMR = inFlightDataRoutes == null;\n      let routesToUse = inFlightDataRoutes || dataRoutes;\n      let localManifest = manifest;\n      try {\n        await patchRoutesOnNavigationImpl({\n          signal,\n          path: pathname,\n          matches: partialMatches,\n          patch: (routeId, children) => {\n            if (signal.aborted) return;\n            patchRoutesImpl(routeId, children, routesToUse, localManifest, mapRouteProperties);\n          }\n        });\n      } catch (e) {\n        return {\n          type: \"error\",\n          error: e,\n          partialMatches\n        };\n      } finally {\n        // If we are not in the middle of an HMR revalidation and we changed the\n        // routes, provide a new identity so when we `updateState` at the end of\n        // this navigation/fetch `router.routes` will be a new identity and\n        // trigger a re-run of memoized `router.routes` dependencies.\n        // HMR will already update the identity and reflow when it lands\n        // `inFlightDataRoutes` in `completeNavigation`\n        if (isNonHMR && !signal.aborted) {\n          dataRoutes = [...dataRoutes];\n        }\n      }\n      if (signal.aborted) {\n        return {\n          type: \"aborted\"\n        };\n      }\n      let newMatches = matchRoutes(routesToUse, pathname, basename);\n      if (newMatches) {\n        return {\n          type: \"success\",\n          matches: newMatches\n        };\n      }\n      let newPartialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);\n      // Avoid loops if the second pass results in the same partial matches\n      if (!newPartialMatches || partialMatches.length === newPartialMatches.length && partialMatches.every((m, i) => m.route.id === newPartialMatches[i].route.id)) {\n        return {\n          type: \"success\",\n          matches: null\n        };\n      }\n      partialMatches = newPartialMatches;\n    }\n  }\n  function _internalSetRoutes(newRoutes) {\n    manifest = {};\n    inFlightDataRoutes = convertRoutesToDataRoutes(newRoutes, mapRouteProperties, undefined, manifest);\n  }\n  function patchRoutes(routeId, children) {\n    let isNonHMR = inFlightDataRoutes == null;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties);\n    // If we are not in the middle of an HMR revalidation and we changed the\n    // routes, provide a new identity and trigger a reflow via `updateState`\n    // to re-run memoized `router.routes` dependencies.\n    // HMR will already update the identity and reflow when it lands\n    // `inFlightDataRoutes` in `completeNavigation`\n    if (isNonHMR) {\n      dataRoutes = [...dataRoutes];\n      updateState({});\n    }\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    patchRoutes,\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      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, 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      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, 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, 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, dataStrategy, skipLoaderErrorBubbling, routeMatch != null);\n        return result;\n      }\n      let result = await loadRouteData(request, matches, requestContext, 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 `DataStrategyResult` to bail out early\n      // and then return or throw the raw Response here accordingly\n      if (isDataStrategyResult(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, 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, dataStrategy);\n      result = results[actionMatch.route.id];\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, 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, 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, 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, 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, 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, dataStrategy) {\n    let results = await callDataStrategyImpl(dataStrategy || defaultDataStrategy, type, null, request, matchesToLoad, matches, null, manifest, mapRouteProperties, requestContext);\n    let dataResults = {};\n    await Promise.all(matches.map(async match => {\n      if (!(match.route.id in results)) {\n        return;\n      }\n      let result = results[match.route.id];\n      if (isRedirectDataStrategyResultResult(result)) {\n        let response = result.result;\n        // Throw redirects and let the server handle them with an HTTP redirect\n        throw normalizeRelativeRoutingRedirectResponse(response, request, match.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      dataResults[match.route.id] = await convertDataStrategyResultToDataResult(result);\n    }));\n    return dataResults;\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  // Account for `?index` params when routing to the current location\n  if ((to == null || to === \"\" || to === \".\") && activeRouteMatch) {\n    let nakedIndex = hasNakedIndexQuery(path.search);\n    if (activeRouteMatch.route.index && !nakedIndex) {\n      // Add one when we're targeting an index route\n      path.search = path.search ? path.search.replace(/^\\?/, \"?index&\") : \"?index\";\n    } else if (!activeRouteMatch.route.index && nakedIndex) {\n      // Remove existing ones when we're not\n      let params = new URLSearchParams(path.search);\n      let indexValues = params.getAll(\"index\");\n      params.delete(\"index\");\n      indexValues.filter(v => v).forEach(v => params.append(\"index\", v));\n      let qs = params.toString();\n      path.search = qs ? \"?\" + qs : \"\";\n    }\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, _ref3) => {\n        let [name, value] = _ref3;\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 at/below any caught error as they aren't going to\n// render so we don't need to load them\nfunction getLoaderMatchesUntilBoundary(matches, boundaryId, includeBoundary) {\n  if (includeBoundary === void 0) {\n    includeBoundary = false;\n  }\n  let index = matches.findIndex(m => m.route.id === boundaryId);\n  if (index >= 0) {\n    return matches.slice(0, includeBoundary ? index + 1 : index);\n  }\n  return matches;\n}\nfunction getMatchesToLoad(history, state, matches, submission, location, initialHydration, 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 boundaryMatches = matches;\n  if (initialHydration && state.errors) {\n    // On initial hydration, only consider matches up to _and including_ the boundary.\n    // This is inclusive to handle cases where a server loader ran successfully,\n    // a child server loader bubbled up to this route, but this route has\n    // `clientLoader.hydrate` so we want to still run the `clientLoader` so that\n    // we have a complete version of `loaderData`\n    boundaryMatches = getLoaderMatchesUntilBoundary(matches, Object.keys(state.errors)[0], true);\n  } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {\n    // If an action threw an error, we call loaders up to, but not including the\n    // boundary\n    boundaryMatches = getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]);\n  }\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 (initialHydration) {\n      return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);\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      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 hydration (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 (initialHydration || !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.has(key)) {\n      // Always mark for revalidation if the fetcher was cancelled\n      cancelledFetcherLoads.delete(key);\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        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 shouldLoadRouteOnHydration(route, loaderData, errors) {\n  // We dunno if we have a loader - gotta find out!\n  if (route.lazy) {\n    return true;\n  }\n  // No loader, nothing to initialize\n  if (!route.loader) {\n    return false;\n  }\n  let hasData = loaderData != null && loaderData[route.id] !== undefined;\n  let hasError = errors != null && errors[route.id] !== undefined;\n  // Don't run if we error'd during SSR\n  if (!hasData && hasError) {\n    return false;\n  }\n  // Explicitly opting-in to running on hydration\n  if (typeof route.loader === \"function\" && route.loader.hydrate === true) {\n    return true;\n  }\n  // Otherwise, run if we're not yet initialized with anything\n  return !hasData && !hasError;\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}\nfunction patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties) {\n  var _childrenToPatch;\n  let childrenToPatch;\n  if (routeId) {\n    let route = manifest[routeId];\n    invariant(route, \"No route found to patch children into: routeId = \" + routeId);\n    if (!route.children) {\n      route.children = [];\n    }\n    childrenToPatch = route.children;\n  } else {\n    childrenToPatch = routesToUse;\n  }\n  // Don't patch in routes we already know about so that `patch` is idempotent\n  // to simplify user-land code. This is useful because we re-call the\n  // `patchRoutesOnNavigation` function for matched routes with params.\n  let uniqueChildren = children.filter(newRoute => !childrenToPatch.some(existingRoute => isSameRoute(newRoute, existingRoute)));\n  let newRoutes = convertRoutesToDataRoutes(uniqueChildren, mapRouteProperties, [routeId || \"_\", \"patch\", String(((_childrenToPatch = childrenToPatch) == null ? void 0 : _childrenToPatch.length) || \"0\")], manifest);\n  childrenToPatch.push(...newRoutes);\n}\nfunction isSameRoute(newRoute, existingRoute) {\n  // Most optimal check is by id\n  if (\"id\" in newRoute && \"id\" in existingRoute && newRoute.id === existingRoute.id) {\n    return true;\n  }\n  // Second is by pathing differences\n  if (!(newRoute.index === existingRoute.index && newRoute.path === existingRoute.path && newRoute.caseSensitive === existingRoute.caseSensitive)) {\n    return false;\n  }\n  // Pathless layout routes are trickier since we need to check children.\n  // If they have no children then they're the same as far as we can tell\n  if ((!newRoute.children || newRoute.children.length === 0) && (!existingRoute.children || existingRoute.children.length === 0)) {\n    return true;\n  }\n  // Otherwise, we look to see if every child in the new route is already\n  // represented in the existing route's children\n  return newRoute.children.every((aChild, i) => {\n    var _existingRoute$childr;\n    return (_existingRoute$childr = existingRoute.children) == null ? void 0 : _existingRoute$childr.some(bChild => isSameRoute(aChild, bChild));\n  });\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\nasync function defaultDataStrategy(_ref4) {\n  let {\n    matches\n  } = _ref4;\n  let matchesToLoad = matches.filter(m => m.shouldLoad);\n  let results = await Promise.all(matchesToLoad.map(m => m.resolve()));\n  return results.reduce((acc, result, i) => Object.assign(acc, {\n    [matchesToLoad[i].route.id]: result\n  }), {});\n}\nasync function callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties, requestContext) {\n  let loadRouteDefinitionsPromises = matches.map(m => m.route.lazy ? loadLazyRouteModule(m.route, mapRouteProperties, manifest) : undefined);\n  let dsMatches = matches.map((match, i) => {\n    let loadRoutePromise = loadRouteDefinitionsPromises[i];\n    let shouldLoad = matchesToLoad.some(m => m.route.id === match.route.id);\n    // `resolve` encapsulates route.lazy(), executing the loader/action,\n    // and mapping return values/thrown errors to a `DataStrategyResult`.  Users\n    // can pass a callback to take fine-grained control over the execution\n    // of the loader/action\n    let resolve = async handlerOverride => {\n      if (handlerOverride && request.method === \"GET\" && (match.route.lazy || match.route.loader)) {\n        shouldLoad = true;\n      }\n      return shouldLoad ? callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, requestContext) : Promise.resolve({\n        type: ResultType.data,\n        result: undefined\n      });\n    };\n    return _extends({}, match, {\n      shouldLoad,\n      resolve\n    });\n  });\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: dsMatches,\n    request,\n    params: matches[0].params,\n    fetcherKey,\n    context: requestContext\n  });\n  // Wait for all routes to load here but 'swallow the error since we want\n  // it to bubble up from the `await loadRoutePromise` in `callLoaderOrAction` -\n  // called from `match.resolve()`\n  try {\n    await Promise.all(loadRouteDefinitionsPromises);\n  } catch (e) {\n    // No-op\n  }\n  return results;\n}\n// Default logic for calling a loader/action is the user has no specified a dataStrategy\nasync function callLoaderOrAction(type, request, match, loadRoutePromise, 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<DataStrategyResult> 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 = (async () => {\n      try {\n        let val = await (handlerOverride ? handlerOverride(ctx => actualHandler(ctx)) : 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    return Promise.race([handlerPromise, abortPromise]);\n  };\n  try {\n    let handler = match.route[type];\n    // If we have a route.lazy promise, await that first\n    if (loadRoutePromise) {\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        }), loadRoutePromise]);\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 loadRoutePromise;\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    // DataStrategyResults 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 convertDataStrategyResultToDataResult(dataStrategyResult) {\n  let {\n    result,\n    type\n  } = dataStrategyResult;\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    if (isDataWithResponseInit(result)) {\n      var _result$init3, _result$init4;\n      if (result.data instanceof Error) {\n        var _result$init, _result$init2;\n        return {\n          type: ResultType.error,\n          error: result.data,\n          statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status,\n          headers: (_result$init2 = result.init) != null && _result$init2.headers ? new Headers(result.init.headers) : undefined\n        };\n      }\n      // Convert thrown data() to ErrorResponse instances\n      return {\n        type: ResultType.error,\n        error: new ErrorResponseImpl(((_result$init3 = result.init) == null ? void 0 : _result$init3.status) || 500, undefined, result.data),\n        statusCode: isRouteErrorResponse(result) ? result.status : undefined,\n        headers: (_result$init4 = result.init) != null && _result$init4.headers ? new Headers(result.init.headers) : undefined\n      };\n    }\n    return {\n      type: ResultType.error,\n      error: result,\n      statusCode: isRouteErrorResponse(result) ? result.status : undefined\n    };\n  }\n  if (isDeferredData(result)) {\n    var _result$init5, _result$init6;\n    return {\n      type: ResultType.deferred,\n      deferredData: result,\n      statusCode: (_result$init5 = result.init) == null ? void 0 : _result$init5.status,\n      headers: ((_result$init6 = result.init) == null ? void 0 : _result$init6.headers) && new Headers(result.init.headers)\n    };\n  }\n  if (isDataWithResponseInit(result)) {\n    var _result$init7, _result$init8;\n    return {\n      type: ResultType.data,\n      data: result.data,\n      statusCode: (_result$init7 = result.init) == null ? void 0 : _result$init7.status,\n      headers: (_result$init8 = result.init) != null && _result$init8.headers ? new Headers(result.init.headers) : undefined\n    };\n  }\n  return {\n    type: ResultType.data,\n    data: result\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, 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  matches.forEach(match => {\n    if (!(match.route.id in results)) {\n      return;\n    }\n    let id = match.route.id;\n    let result = results[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, results, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds) {\n  let {\n    loaderData,\n    errors\n  } = processRouteLoaderData(matches, 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  revalidatingFetchers.forEach(rf => {\n    let {\n      key,\n      match,\n      controller\n    } = rf;\n    let result = fetcherResults[key];\n    invariant(result, \"Did not find corresponding fetcher result\");\n    // Process fetcher non-redirect errors\n    if (controller && controller.signal.aborted) {\n      // Nothing to do for aborted fetchers\n      return;\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    message\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  let entries = Object.entries(results);\n  for (let i = entries.length - 1; i >= 0; i--) {\n    let [key, result] = entries[i];\n    if (isRedirectResult(result)) {\n      return {\n        key,\n        result\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 isDataStrategyResult(result) {\n  return result != null && typeof result === \"object\" && \"type\" in result && \"result\" in result && (result.type === ResultType.data || result.type === ResultType.error);\n}\nfunction isRedirectDataStrategyResultResult(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 isDataWithResponseInit(value) {\n  return typeof value === \"object\" && value != null && \"type\" in value && \"data\" in value && \"init\" in value && value.type === \"DataWithResponseInit\";\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 resolveNavigationDeferredResults(matches, results, signal, currentMatches, currentLoaderData) {\n  let entries = Object.entries(results);\n  for (let index = 0; index < entries.length; index++) {\n    let [routeId, result] = entries[index];\n    let match = matches.find(m => (m == null ? void 0 : m.route.id) === routeId);\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) && 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      await resolveDeferredData(result, signal, false).then(result => {\n        if (result) {\n          results[routeId] = result;\n        }\n      });\n    }\n  }\n}\nasync function resolveFetcherDeferredResults(matches, results, revalidatingFetchers) {\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let {\n      key,\n      routeId,\n      controller\n    } = revalidatingFetchers[index];\n    let result = results[key];\n    let match = matches.find(m => (m == null ? void 0 : m.route.id) === routeId);\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    if (isDeferredResult(result)) {\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      invariant(controller, \"Expected an AbortController for revalidating fetcher deferred result\");\n      await resolveDeferredData(result, controller.signal, true).then(result => {\n        if (result) {\n          results[key] = result;\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, decodePath as UNSAFE_decodePath, getResolveToMatches as UNSAFE_getResolveToMatches, invariant as UNSAFE_invariant, warning as UNSAFE_warning, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, createRouter, createStaticHandler, data, defer, generatePath, getStaticContextFromError, getToPathname, isDataWithResponseInit, isDeferredData, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, parsePath, redirect, redirectDocument, replace, 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","createMemoryHistory","options","entries","initialEntries","initialIndex","v5Compat","map","entry","index","createMemoryLocation","state","undefined","clampIndex","action","Pop","listener","n","Math","min","max","getCurrentLocation","to","location","createLocation","pathname","warning","charAt","JSON","stringify","createHref","createPath","createURL","URL","encodeLocation","path","parsePath","search","hash","push","Push","nextLocation","splice","delta","replace","Replace","go","nextIndex","listen","fn","createBrowserHistory","getUrlBasedHistory","window","globalHistory","usr","createHashHistory","substr","startsWith","base","document","querySelector","href","getAttribute","url","hashIndex","indexOf","slice","invariant","value","message","Error","cond","console","warn","e","getHistoryState","idx","current","random","toString","_ref","parsedPath","searchIndex","getLocation","validateLocation","defaultView","history","getIndex","handlePop","origin","replaceState","addEventListener","removeEventListener","historyState","pushState","error","DOMException","name","ResultType","immutableRouteKeys","Set","convertRoutesToDataRoutes","routes","mapRouteProperties","parentPath","manifest","route","treePath","String","id","join","children","isIndexRoute","indexRoute","pathOrLayoutRoute","matchRoutes","locationArg","basename","matchRoutesImpl","allowPartial","stripBasename","branches","flattenRoutes","sort","a","b","score","every","compareIndexes","routesMeta","meta","childrenIndex","rankRouteBranches","matches","decoded","decodePath","matchRouteBranch","convertRouteMatchToUiMatch","match","loaderData","params","data","handle","parentsMeta","flattenRoute","relativePath","caseSensitive","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","matchPath","pathnameBase","normalizePathname","generatePath","originalPath","prefix","p","array","keyMatch","optional","param","pattern","matcher","compiledParams","regexpSource","_","paramName","RegExp","compilePath","captureGroups","memo","splatValue","v","decodeURIComponent","toLowerCase","startIndex","nextChar","resolvePath","fromPathname","toPathname","pop","resolvePathname","normalizeSearch","normalizeHash","getInvalidPathError","char","field","dest","getPathContributingMatches","getResolveToMatches","v7_relativeSplatPath","pathMatches","resolveTo","toArg","routePathnames","locationPathname","isPathRelative","from","isEmptyPath","routePathnameIndex","toSegments","shift","hasExplicitTrailingSlash","hasCurrentTrailingSlash","paths","json","init","responseInit","status","headers","Headers","has","set","Response","AbortedDeferredError","DeferredData","constructor","reject","pendingKeysSet","subscribers","deferredKeys","Array","isArray","abortPromise","Promise","r","controller","AbortController","onAbort","unlistenAbortSignal","signal","acc","_ref2","trackPromise","done","add","promise","race","then","onSettle","catch","defineProperty","get","aborted","delete","undefinedError","emit","settledKey","subscriber","subscribe","cancel","abort","k","resolveData","resolve","size","unwrappedData","_ref3","unwrapTrackedPromise","pendingKeys","_tracked","isTrackedPromise","_error","_data","defer","redirect","redirectDocument","response","ErrorResponseImpl","statusText","internal","isRouteErrorResponse","validMutationMethodsArr","validMutationMethods","validRequestMethodsArr","validRequestMethods","redirectStatusCodes","redirectPreserveMethodStatusCodes","IDLE_NAVIGATION","formMethod","formAction","formEncType","formData","text","IDLE_FETCHER","IDLE_BLOCKER","proceed","reset","ABSOLUTE_URL_REGEX","defaultMapRouteProperties","hasErrorBoundary","Boolean","TRANSITIONS_STORAGE_KEY","createRouter","routerWindow","isBrowser","createElement","isServer","detectErrorBoundary","inFlightDataRoutes","initialized","router","dataRoutes","dataStrategyImpl","dataStrategy","defaultDataStrategy","patchRoutesOnNavigationImpl","patchRoutesOnNavigation","future","v7_fetcherPersist","v7_normalizeFormMethod","v7_partialHydration","v7_prependBasename","v7_skipActionErrorRevalidation","unlistenHistory","savedScrollPositions","getScrollRestorationKey","getScrollPosition","initialScrollRestored","hydrationData","initialMatches","initialMatchesIsFOW","initialErrors","getInternalRouterError","getShortCircuitMatches","checkFogOfWar","active","m","lazy","loader","errors","findIndex","shouldLoadRouteOnHydration","fogOfWar","pendingNavigationController","unblockBlockerHistoryUpdate","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","updateState","newState","opts","completedFetchers","deletedFetchersKeys","fetcher","viewTransitionOpts","flushSync","deleteFetcher","completeNavigation","_temp","_location$state","_location$state2","isActionReload","isMutationMethod","_isRedirect","keys","mergeLoaderData","priorPaths","currentLocation","toPaths","getSavedScrollPosition","async","startNavigation","startUninterruptedRevalidation","getScrollKey","saveScrollPosition","enableViewTransition","routesToUse","loadingNavigation","overrideNavigation","initialHydration","notFoundMatches","handleNavigational404","submission","pendingActionResult","request","createClientSideRequest","pendingError","findNearestBoundary","type","actionResult","isFogOfWar","interruptActiveLoads","getSubmittingNavigation","discoverResult","discoverRoutes","shortCircuited","boundaryId","partialMatches","actionMatch","getTargetMatch","callDataStrategy","method","routeId","isRedirectResult","normalizeRedirectLocation","startRedirectNavigation","isDeferredResult","isErrorResult","boundaryMatch","handleAction","getLoadingNavigation","updatedMatches","fetcherSubmission","activeSubmission","getSubmissionFromNavigation","shouldUpdateNavigationState","getUpdatedActionData","matchesToLoad","revalidatingFetchers","getMatchesToLoad","cancelActiveDeferreds","updatedFetchers","markFetchRedirectsDone","getActionDataForCommit","updates","rf","revalidatingFetcher","getLoadingFetcher","getUpdatedRevalidatingFetchers","abortFetcher","abortPendingFetchRevalidations","f","loaderResults","fetcherResults","callLoadersAndMaybeResolveData","findRedirect","processLoaderData","deferredData","didAbortFetchLoads","abortStaleFetchLoads","shouldUpdateFetchers","handleLoaders","isNavigation","_temp2","redirectLocation","isDocumentReload","redirectHistoryAction","fetcherKey","results","dataResults","requestContext","loadRouteDefinitionsPromises","lazyRoute","routeToUpdate","routeUpdates","lazyRouteProperty","isPropertyStaticallyDefined","loadLazyRouteModule","dsMatches","loadRoutePromise","shouldLoad","handlerOverride","staticContext","onReject","runHandler","handler","actualHandler","ctx","context","handlerPromise","handlerError","all","callLoaderOrAction","callDataStrategyImpl","isRedirectDataStrategyResultResult","normalizeRelativeRoutingRedirectResponse","convertDataStrategyResultToDataResult","fetchersToLoad","currentMatches","loaderResultsPromise","fetcherResultsPromise","resolveNavigationDeferredResults","resolveFetcherDeferredResults","updateFetcherState","setFetcherError","getFetcher","markFetchersDone","doneFetcher","getDoneFetcher","doneKeys","landedId","yeetedKeys","deleteBlocker","updateBlocker","newBlocker","blocker","shouldBlockNavigation","blockerKey","blockerFunction","predicate","cancelledRouteIds","dfd","y","isNonHMR","localManifest","patch","patchRoutesImpl","newMatches","newPartialMatches","initialize","nextHistoryUpdatePromise","_window","transitions","sessionPositions","sessionStorage","getItem","parse","restoreAppliedTransitions","_saveAppliedTransitions","setItem","persistAppliedTransitions","enableScrollRestoration","positions","getPosition","getKey","navigate","normalizedPath","normalizeTo","fromRouteId","relative","normalizeNavigateOptions","userReplace","viewTransition","fetch","requestMatches","detectAndHandle405Error","existingFetcher","getSubmittingFetcher","abortController","fetchRequest","originatingLoadId","revalidationRequest","loadId","loadFetcher","staleKey","handleFetcherAction","resolveDeferredData","handleFetcherLoader","revalidate","count","dispose","clear","getBlocker","patchRoutes","_internalFetchControllers","_internalActiveDeferreds","_internalSetRoutes","newRoutes","prependBasename","contextualMatches","activeRouteMatch","nakedIndex","hasNakedIndexQuery","URLSearchParams","indexValues","getAll","append","qs","normalizeFormMethod","isFetcher","body","isSubmissionNavigation","searchParams","getInvalidBodyError","rawFormMethod","toUpperCase","stripHashFromPath","FormData","convertFormDataToSearchParams","convertSearchParamsToFormData","getLoaderMatchesUntilBoundary","includeBoundary","skipActionErrorRevalidation","currentUrl","nextUrl","boundaryMatches","actionStatus","statusCode","shouldSkipRevalidation","navigationMatches","currentLoaderData","currentMatch","isNew","isMissingData","isNewLoader","currentRouteMatch","nextRouteMatch","shouldRevalidateLoader","currentParams","nextParams","defaultShouldRevalidate","isNewRouteInstance","fetcherMatches","fetcherMatch","shouldRevalidate","hasData","hasError","hydrate","currentPath","loaderMatch","arg","routeChoice","_childrenToPatch","childrenToPatch","newRoute","existingRoute","isSameRoute","aChild","_existingRoute$childr","bChild","_ref4","dataStrategyResult","isResponse","contentType","_result$init3","_result$init4","_result$init","_result$init2","_result$init5","_result$init6","_result$init7","_result$init8","isDataWithResponseInit","deferred","isDeferredData","trimmedMatches","normalizedLocation","protocol","isSameBasename","Request","skipLoaderErrorBubbling","foundError","loaderHeaders","processRouteLoaderData","newLoaderData","mergedLoaderData","reverse","find","_temp5","errorMessage","isRevalidatingLoader","unwrap","Symbol"],"sourceRoot":""}