{"version":3,"file":"static/module-remix-run.311c75f4.js","mappings":"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","sources":["webpack://@spotify-confidence/app/../../node_modules/@remix-run/router/dist/router.js"],"sourcesContent":["/**\n * @remix-run/router v1.14.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    invariant(base, \"No window.location.(origin|href) available to create URL for href: \" + href);\n    return new URL(href, base);\n  }\n  let history = {\n    get action() {\n      return action;\n    },\n    get location() {\n      return getLocation(window, globalHistory);\n    },\n    listen(fn) {\n      if (listener) {\n        throw new Error(\"A history only accepts one active listener\");\n      }\n      window.addEventListener(PopStateEventType, handlePop);\n      listener = fn;\n      return () => {\n        window.removeEventListener(PopStateEventType, handlePop);\n        listener = null;\n      };\n    },\n    createHref(to) {\n      return createHref(window, to);\n    },\n    createURL,\n    encodeLocation(to) {\n      // Encode a Location the same way window.location would\n      let url = createURL(to);\n      return {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash\n      };\n    },\n    push,\n    replace,\n    go(n) {\n      return globalHistory.go(n);\n    }\n  };\n  return history;\n}\n//#endregion\n\nvar ResultType;\n(function (ResultType) {\n  ResultType[\"data\"] = \"data\";\n  ResultType[\"deferred\"] = \"deferred\";\n  ResultType[\"redirect\"] = \"redirect\";\n  ResultType[\"error\"] = \"error\";\n})(ResultType || (ResultType = {}));\nconst immutableRouteKeys = new Set([\"lazy\", \"caseSensitive\", \"path\", \"id\", \"index\", \"children\"]);\nfunction isIndexRoute(route) {\n  return route.index === true;\n}\n// Walk the route tree generating unique IDs where necessary, so we are working\n// solely with AgnosticDataRouteObject's within the Router\nfunction convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath, manifest) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\n  if (manifest === void 0) {\n    manifest = {};\n  }\n  return routes.map((route, index) => {\n    let treePath = [...parentPath, index];\n    let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n    invariant(route.index !== true || !route.children, \"Cannot specify children on an index route\");\n    invariant(!manifest[id], \"Found a route id collision on id \\\"\" + id + \"\\\".  Route \" + \"id's must be globally unique within Data Router usages\");\n    if (isIndexRoute(route)) {\n      let indexRoute = _extends({}, route, mapRouteProperties(route), {\n        id\n      });\n      manifest[id] = indexRoute;\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute = _extends({}, route, mapRouteProperties(route), {\n        id,\n        children: undefined\n      });\n      manifest[id] = pathOrLayoutRoute;\n      if (route.children) {\n        pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties, treePath, manifest);\n      }\n      return pathOrLayoutRoute;\n    }\n  });\n}\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/utils/match-routes\n */\nfunction matchRoutes(routes, locationArg, basename) {\n  if (basename === void 0) {\n    basename = \"/\";\n  }\n  let location = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n  let pathname = stripBasename(location.pathname || \"/\", basename);\n  if (pathname == null) {\n    return null;\n  }\n  let branches = flattenRoutes(routes);\n  rankRouteBranches(branches);\n  let matches = null;\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    matches = matchRouteBranch(branches[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    safelyDecodeURI(pathname));\n  }\n  return matches;\n}\nfunction convertRouteMatchToUiMatch(match, loaderData) {\n  let {\n    route,\n    pathname,\n    params\n  } = match;\n  return {\n    id: route.id,\n    pathname,\n    params,\n    data: loaderData[route.id],\n    handle: route.handle\n  };\n}\nfunction flattenRoutes(routes, branches, parentsMeta, parentPath) {\n  if (branches === void 0) {\n    branches = [];\n  }\n  if (parentsMeta === void 0) {\n    parentsMeta = [];\n  }\n  if (parentPath === void 0) {\n    parentPath = \"\";\n  }\n  let flattenRoute = (route, index, relativePath) => {\n    let meta = {\n      relativePath: relativePath === undefined ? route.path || \"\" : relativePath,\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route\n    };\n    if (meta.relativePath.startsWith(\"/\")) {\n      invariant(meta.relativePath.startsWith(parentPath), \"Absolute route path \\\"\" + meta.relativePath + \"\\\" nested under path \" + (\"\\\"\" + parentPath + \"\\\" is not valid. An absolute child route path \") + \"must start with the combined path of all its parent routes.\");\n      meta.relativePath = meta.relativePath.slice(parentPath.length);\n    }\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta);\n    // Add the children before adding this route to the array, so we traverse the\n    // route tree depth-first and child routes appear before their parents in\n    // the \"flattened\" version.\n    if (route.children && route.children.length > 0) {\n      invariant(\n      // Our types know better, but runtime JS may not!\n      // @ts-expect-error\n      route.index !== true, \"Index routes must not have child routes. Please remove \" + (\"all child routes from route path \\\"\" + path + \"\\\".\"));\n      flattenRoutes(route.children, branches, routesMeta, path);\n    }\n    // Routes without a path shouldn't ever match by themselves unless they are\n    // index routes, so don't add them to the list of possible branches.\n    if (route.path == null && !route.index) {\n      return;\n    }\n    branches.push({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta\n    });\n  };\n  routes.forEach((route, index) => {\n    var _route$path;\n    // coarse-grain check for optional params\n    if (route.path === \"\" || !((_route$path = route.path) != null && _route$path.includes(\"?\"))) {\n      flattenRoute(route, index);\n    } else {\n      for (let exploded of explodeOptionalSegments(route.path)) {\n        flattenRoute(route, index, exploded);\n      }\n    }\n  });\n  return branches;\n}\n/**\n * Computes all combinations of optional path segments for a given path,\n * excluding combinations that are ambiguous and of lower priority.\n *\n * For example, `/one/:two?/three/:four?/:five?` explodes to:\n * - `/one/three`\n * - `/one/:two/three`\n * - `/one/three/:four`\n * - `/one/three/:five`\n * - `/one/:two/three/:four`\n * - `/one/:two/three/:five`\n * - `/one/three/:four/:five`\n * - `/one/:two/three/:four/:five`\n */\nfunction explodeOptionalSegments(path) {\n  let segments = path.split(\"/\");\n  if (segments.length === 0) return [];\n  let [first, ...rest] = segments;\n  // Optional path segments are denoted by a trailing `?`\n  let isOptional = first.endsWith(\"?\");\n  // Compute the corresponding required segment: `foo?` -> `foo`\n  let required = first.replace(/\\?$/, \"\");\n  if (rest.length === 0) {\n    // Intepret empty string as omitting an optional segment\n    // `[\"one\", \"\", \"three\"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`\n    return isOptional ? [required, \"\"] : [required];\n  }\n  let restExploded = explodeOptionalSegments(rest.join(\"/\"));\n  let result = [];\n  // All child paths with the prefix.  Do this for all children before the\n  // optional version for all children, so we get consistent ordering where the\n  // parent optional aspect is preferred as required.  Otherwise, we can get\n  // child sections interspersed where deeper optional segments are higher than\n  // parent optional segments, where for example, /:two would explode _earlier_\n  // then /:one.  By always including the parent as required _for all children_\n  // first, we avoid this issue\n  result.push(...restExploded.map(subpath => subpath === \"\" ? required : [required, subpath].join(\"/\")));\n  // Then, if this is an optional value, add all child versions without\n  if (isOptional) {\n    result.push(...restExploded);\n  }\n  // for absolute paths, ensure `/` instead of empty segment\n  return result.map(exploded => path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded);\n}\nfunction rankRouteBranches(branches) {\n  branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first\n  : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));\n}\nconst paramRe = /^:\\w+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = s => s === \"*\";\nfunction computeScore(path, index) {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n  return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === \"\" ? emptySegmentValue : staticSegmentValue), initialScore);\n}\nfunction compareIndexes(a, b) {\n  let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n  return siblings ?\n  // If two routes are siblings, we should try to match the earlier sibling\n  // first. This allows people to have fine-grained control over the matching\n  // behavior by simply putting routes with identical paths in the order they\n  // want them tried.\n  a[a.length - 1] - b[b.length - 1] :\n  // Otherwise, it doesn't really make sense to rank non-siblings by index,\n  // so they sort equally.\n  0;\n}\nfunction matchRouteBranch(branch, pathname) {\n  let {\n    routesMeta\n  } = branch;\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches = [];\n  for (let i = 0; i < routesMeta.length; ++i) {\n    let meta = routesMeta[i];\n    let end = i === routesMeta.length - 1;\n    let remainingPathname = matchedPathname === \"/\" ? pathname : pathname.slice(matchedPathname.length) || \"/\";\n    let match = matchPath({\n      path: meta.relativePath,\n      caseSensitive: meta.caseSensitive,\n      end\n    }, remainingPathname);\n    if (!match) return null;\n    Object.assign(matchedParams, match.params);\n    let route = meta.route;\n    matches.push({\n      // TODO: Can this as be avoided?\n      params: matchedParams,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),\n      route\n    });\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n  return matches;\n}\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/utils/generate-path\n */\nfunction generatePath(originalPath, params) {\n  if (params === void 0) {\n    params = {};\n  }\n  let path = originalPath;\n  if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n    warning(false, \"Route path \\\"\" + path + \"\\\" will be treated as if it were \" + (\"\\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\" because the `*` character must \") + \"always follow a `/` in the pattern. To get rid of this warning, \" + (\"please change the route path to \\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\".\"));\n    path = path.replace(/\\*$/, \"/*\");\n  }\n  // ensure `/` is added at the beginning if the path is absolute\n  const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n  const stringify = p => p == null ? \"\" : typeof p === \"string\" ? p : String(p);\n  const segments = path.split(/\\/+/).map((segment, index, array) => {\n    const isLastSegment = index === array.length - 1;\n    // only apply the splat if it's the last segment\n    if (isLastSegment && segment === \"*\") {\n      const star = \"*\";\n      // Apply the splat\n      return stringify(params[star]);\n    }\n    const keyMatch = segment.match(/^:(\\w+)(\\??)$/);\n    if (keyMatch) {\n      const [, key, optional] = keyMatch;\n      let param = params[key];\n      invariant(optional === \"?\" || param != null, \"Missing \\\":\" + key + \"\\\" param\");\n      return stringify(param);\n    }\n    // Remove any optional markers from optional static segments\n    return segment.replace(/\\?$/g, \"\");\n  })\n  // Remove empty segments\n  .filter(segment => !!segment);\n  return prefix + segments.join(\"/\");\n}\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/utils/match-path\n */\nfunction matchPath(pattern, pathname) {\n  if (typeof pattern === \"string\") {\n    pattern = {\n      path: pattern,\n      caseSensitive: false,\n      end: true\n    };\n  }\n  let [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);\n  let match = pathname.match(matcher);\n  if (!match) return null;\n  let matchedPathname = match[0];\n  let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n  let captureGroups = match.slice(1);\n  let params = compiledParams.reduce((memo, _ref, index) => {\n    let {\n      paramName,\n      isOptional\n    } = _ref;\n    // We need to compute the pathnameBase here using the raw splat value\n    // instead of using params[\"*\"] later because it will be decoded then\n    if (paramName === \"*\") {\n      let splatValue = captureGroups[index] || \"\";\n      pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\\/+$/, \"$1\");\n    }\n    const value = captureGroups[index];\n    if (isOptional && !value) {\n      memo[paramName] = undefined;\n    } else {\n      memo[paramName] = safelyDecodeURIComponent(value || \"\", paramName);\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 safelyDecodeURI(value) {\n  try {\n    return decodeURI(value);\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}\nfunction safelyDecodeURIComponent(value, paramName) {\n  try {\n    return decodeURIComponent(value);\n  } catch (error) {\n    warning(false, \"The value for the URL param \\\"\" + paramName + \"\\\" will not be decoded because\" + (\" the string \\\"\" + value + \"\\\" is a malformed URL segment. This is probably\") + (\" due to a bad percent encoding (\" + error + \").\"));\n    return value;\n  }\n}\n/**\n * @private\n */\nfunction stripBasename(pathname, basename) {\n  if (basename === \"/\") return pathname;\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n  // We want to leave trailing slash behavior in the user's control, so if they\n  // specify a basename with a trailing slash, we should support it\n  let startIndex = basename.endsWith(\"/\") ? basename.length - 1 : basename.length;\n  let nextChar = pathname.charAt(startIndex);\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n  return pathname.slice(startIndex) || \"/\";\n}\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/utils/resolve-path\n */\nfunction resolvePath(to, fromPathname) {\n  if (fromPathname === void 0) {\n    fromPathname = \"/\";\n  }\n  let {\n    pathname: toPathname,\n    search = \"\",\n    hash = \"\"\n  } = typeof to === \"string\" ? parsePath(to) : to;\n  let pathname = toPathname ? toPathname.startsWith(\"/\") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;\n  return {\n    pathname,\n    search: normalizeSearch(search),\n    hash: normalizeHash(hash)\n  };\n}\nfunction resolvePathname(relativePath, fromPathname) {\n  let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n  let relativeSegments = relativePath.split(\"/\");\n  relativeSegments.forEach(segment => {\n    if (segment === \"..\") {\n      // Keep the root \"\" segment so the pathname starts at /\n      if (segments.length > 1) segments.pop();\n    } else if (segment !== \".\") {\n      segments.push(segment);\n    }\n  });\n  return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\nfunction getInvalidPathError(char, field, dest, path) {\n  return \"Cannot include a '\" + char + \"' character in a manually specified \" + (\"`to.\" + field + \"` field [\" + JSON.stringify(path) + \"].  Please separate it out to the \") + (\"`to.\" + dest + \"` field. Alternatively you may provide the full path as \") + \"a string in <Link to=\\\"...\\\"> and the router will parse it for you.\";\n}\n/**\n * @private\n *\n * When processing relative navigation we want to ignore ancestor routes that\n * do not contribute to the path, such that index/pathless layout routes don't\n * interfere.\n *\n * For example, when moving a route element into an index route and/or a\n * pathless layout route, relative link behavior contained within should stay\n * the same.  Both of the following examples should link back to the root:\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\" element={<Link to=\"..\"}>\n *   </Route>\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\">\n *       <Route element={<AccountsLayout />}>       // <-- Does not contribute\n *         <Route index element={<Link to=\"..\"} />  // <-- Does not contribute\n *       </Route\n *     </Route>\n *   </Route>\n */\nfunction getPathContributingMatches(matches) {\n  return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);\n}\n// Return the array of pathnames for the current route matches - used to\n// generate the routePathnames input for resolveTo()\nfunction getResolveToMatches(matches, v7_relativeSplatPath) {\n  let pathMatches = getPathContributingMatches(matches);\n  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf\n  // match so we include splat values for \".\" links.  See:\n  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329\n  if (v7_relativeSplatPath) {\n    return pathMatches.map((match, idx) => idx === matches.length - 1 ? match.pathname : match.pathnameBase);\n  }\n  return pathMatches.map(match => match.pathnameBase);\n}\n/**\n * @private\n */\nfunction resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {\n  if (isPathRelative === void 0) {\n    isPathRelative = false;\n  }\n  let to;\n  if (typeof toArg === \"string\") {\n    to = parsePath(toArg);\n  } else {\n    to = _extends({}, toArg);\n    invariant(!to.pathname || !to.pathname.includes(\"?\"), getInvalidPathError(\"?\", \"pathname\", \"search\", to));\n    invariant(!to.pathname || !to.pathname.includes(\"#\"), getInvalidPathError(\"#\", \"pathname\", \"hash\", to));\n    invariant(!to.search || !to.search.includes(\"#\"), getInvalidPathError(\"#\", \"search\", \"hash\", to));\n  }\n  let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n  let toPathname = isEmptyPath ? \"/\" : to.pathname;\n  let from;\n  // Routing is relative to the current pathname if explicitly requested.\n  //\n  // If a pathname is explicitly provided in `to`, it should be relative to the\n  // route context. This is explained in `Note on `<Link to>` values` in our\n  // migration guide from v5 as a means of disambiguation between `to` values\n  // that begin with `/` and those that do not. However, this is problematic for\n  // `to` values that do not provide a pathname. `to` can simply be a search or\n  // hash string, in which case we should assume that the navigation is relative\n  // to the current location's pathname and *not* the route pathname.\n  if (toPathname == null) {\n    from = locationPathname;\n  } else if (isPathRelative) {\n    let fromSegments = routePathnames.length === 0 ? [] : routePathnames[routePathnames.length - 1].replace(/^\\//, \"\").split(\"/\");\n    if (toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\n      // With relative=\"path\", each leading .. segment means \"go up one URL segment\"\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        fromSegments.pop();\n      }\n      to.pathname = toSegments.join(\"/\");\n    }\n    from = \"/\" + fromSegments.join(\"/\");\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n    if (toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\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      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n      to.pathname = toSegments.join(\"/\");\n    }\n    // If there are more \"..\" segments than parent routes, resolve relative to\n    // the root / URL.\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n  let path = resolvePath(to, from);\n  // Ensure the pathname has a trailing slash if the original \"to\" had one\n  let hasExplicitTrailingSlash = toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\");\n  // Or if this was a link to the current path which has a trailing slash\n  let hasCurrentTrailingSlash = (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n  if (!path.pathname.endsWith(\"/\") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {\n    path.pathname += \"/\";\n  }\n  return path;\n}\n/**\n * @private\n */\nfunction getToPathname(to) {\n  // Empty strings should be treated the same as / paths\n  return to === \"\" || to.pathname === \"\" ? \"/\" : typeof to === \"string\" ? parsePath(to).pathname : to.pathname;\n}\n/**\n * @private\n */\nconst joinPaths = paths => paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n/**\n * @private\n */\nconst normalizePathname = pathname => pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n/**\n * @private\n */\nconst normalizeSearch = search => !search || search === \"?\" ? \"\" : search.startsWith(\"?\") ? search : \"?\" + search;\n/**\n * @private\n */\nconst normalizeHash = hash => !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n */\nconst json = function json(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  let headers = new Headers(responseInit.headers);\n  if (!headers.has(\"Content-Type\")) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n  }\n  return new Response(JSON.stringify(data), _extends({}, responseInit, {\n    headers\n  }));\n};\nclass AbortedDeferredError extends Error {}\nclass DeferredData {\n  constructor(data, responseInit) {\n    this.pendingKeysSet = new Set();\n    this.subscribers = new Set();\n    this.deferredKeys = [];\n    invariant(data && typeof data === \"object\" && !Array.isArray(data), \"defer() only accepts plain objects\");\n    // Set up an AbortController + Promise we can race against to exit early\n    // cancellation\n    let reject;\n    this.abortPromise = new Promise((_, r) => reject = r);\n    this.controller = new AbortController();\n    let onAbort = () => reject(new AbortedDeferredError(\"Deferred data aborted\"));\n    this.unlistenAbortSignal = () => this.controller.signal.removeEventListener(\"abort\", onAbort);\n    this.controller.signal.addEventListener(\"abort\", onAbort);\n    this.data = Object.entries(data).reduce((acc, _ref2) => {\n      let [key, value] = _ref2;\n      return Object.assign(acc, {\n        [key]: this.trackPromise(key, value)\n      });\n    }, {});\n    if (this.done) {\n      // All incoming values were resolved\n      this.unlistenAbortSignal();\n    }\n    this.init = responseInit;\n  }\n  trackPromise(key, value) {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n    this.deferredKeys.push(key);\n    this.pendingKeysSet.add(key);\n    // We store a little wrapper promise that will be extended with\n    // _data/_error props upon resolve/reject\n    let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, undefined, data), error => this.onSettle(promise, key, error));\n    // Register rejection listeners to avoid uncaught promise rejections on\n    // errors or aborted deferred values\n    promise.catch(() => {});\n    Object.defineProperty(promise, \"_tracked\", {\n      get: () => true\n    });\n    return promise;\n  }\n  onSettle(promise, key, error, data) {\n    if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {\n      this.unlistenAbortSignal();\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      return Promise.reject(error);\n    }\n    this.pendingKeysSet.delete(key);\n    if (this.done) {\n      // Nothing left to abort!\n      this.unlistenAbortSignal();\n    }\n    // If the promise was resolved/rejected with undefined, we'll throw an error as you\n    // should always resolve with a value or null\n    if (error === undefined && data === undefined) {\n      let undefinedError = new Error(\"Deferred data for key \\\"\" + key + \"\\\" resolved/rejected with `undefined`, \" + \"you must resolve/reject with a value or `null`.\");\n      Object.defineProperty(promise, \"_error\", {\n        get: () => undefinedError\n      });\n      this.emit(false, key);\n      return Promise.reject(undefinedError);\n    }\n    if (data === undefined) {\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      this.emit(false, key);\n      return Promise.reject(error);\n    }\n    Object.defineProperty(promise, \"_data\", {\n      get: () => data\n    });\n    this.emit(false, key);\n    return data;\n  }\n  emit(aborted, settledKey) {\n    this.subscribers.forEach(subscriber => subscriber(aborted, settledKey));\n  }\n  subscribe(fn) {\n    this.subscribers.add(fn);\n    return () => this.subscribers.delete(fn);\n  }\n  cancel() {\n    this.controller.abort();\n    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));\n    this.emit(true);\n  }\n  async resolveData(signal) {\n    let aborted = false;\n    if (!this.done) {\n      let onAbort = () => this.cancel();\n      signal.addEventListener(\"abort\", onAbort);\n      aborted = await new Promise(resolve => {\n        this.subscribe(aborted => {\n          signal.removeEventListener(\"abort\", onAbort);\n          if (aborted || this.done) {\n            resolve(aborted);\n          }\n        });\n      });\n    }\n    return aborted;\n  }\n  get done() {\n    return this.pendingKeysSet.size === 0;\n  }\n  get unwrappedData() {\n    invariant(this.data !== null && this.done, \"Can only unwrap data on initialized and settled deferreds\");\n    return Object.entries(this.data).reduce((acc, _ref3) => {\n      let [key, value] = _ref3;\n      return Object.assign(acc, {\n        [key]: unwrapTrackedPromise(value)\n      });\n    }, {});\n  }\n  get pendingKeys() {\n    return Array.from(this.pendingKeysSet);\n  }\n}\nfunction isTrackedPromise(value) {\n  return value instanceof Promise && value._tracked === true;\n}\nfunction unwrapTrackedPromise(value) {\n  if (!isTrackedPromise(value)) {\n    return value;\n  }\n  if (value._error) {\n    throw value._error;\n  }\n  return value._data;\n}\nconst defer = function defer(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  return new DeferredData(data, responseInit);\n};\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst redirect = function redirect(url, init) {\n  if (init === void 0) {\n    init = 302;\n  }\n  let responseInit = init;\n  if (typeof responseInit === \"number\") {\n    responseInit = {\n      status: responseInit\n    };\n  } else if (typeof responseInit.status === \"undefined\") {\n    responseInit.status = 302;\n  }\n  let headers = new Headers(responseInit.headers);\n  headers.set(\"Location\", url);\n  return new Response(null, _extends({}, responseInit, {\n    headers\n  }));\n};\n/**\n * A redirect response that will force a document reload to the new location.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst redirectDocument = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Reload-Document\", \"true\");\n  return response;\n};\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n *\n * We don't export the class for public use since it's an implementation\n * detail, but we export the interface above so folks can build their own\n * abstractions around instances via isRouteErrorResponse()\n */\nclass ErrorResponseImpl {\n  constructor(status, statusText, data, internal) {\n    if (internal === void 0) {\n      internal = false;\n    }\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.internal = internal;\n    if (data instanceof Error) {\n      this.data = data.toString();\n      this.error = data;\n    } else {\n      this.data = data;\n    }\n  }\n}\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\nfunction isRouteErrorResponse(error) {\n  return error != null && typeof error.status === \"number\" && typeof error.statusText === \"string\" && typeof error.internal === \"boolean\" && \"data\" in error;\n}\n\nconst validMutationMethodsArr = [\"post\", \"put\", \"patch\", \"delete\"];\nconst validMutationMethods = new Set(validMutationMethodsArr);\nconst validRequestMethodsArr = [\"get\", ...validMutationMethodsArr];\nconst validRequestMethods = new Set(validRequestMethodsArr);\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\nconst IDLE_NAVIGATION = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined\n};\nconst IDLE_FETCHER = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined\n};\nconst IDLE_BLOCKER = {\n  state: \"unblocked\",\n  proceed: undefined,\n  reset: undefined,\n  location: undefined\n};\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\nconst defaultMapRouteProperties = route => ({\n  hasErrorBoundary: Boolean(route.hasErrorBoundary)\n});\nconst TRANSITIONS_STORAGE_KEY = \"remix-router-transitions\";\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Create a router and listen to history POP navigations\n */\nfunction createRouter(init) {\n  const routerWindow = init.window ? init.window : typeof window !== \"undefined\" ? window : undefined;\n  const isBrowser = typeof routerWindow !== \"undefined\" && typeof routerWindow.document !== \"undefined\" && typeof routerWindow.document.createElement !== \"undefined\";\n  const isServer = !isBrowser;\n  invariant(init.routes.length > 0, \"You must provide a non-empty routes array to createRouter\");\n  let mapRouteProperties;\n  if (init.mapRouteProperties) {\n    mapRouteProperties = init.mapRouteProperties;\n  } else if (init.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = init.detectErrorBoundary;\n    mapRouteProperties = route => ({\n      hasErrorBoundary: detectErrorBoundary(route)\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Routes keyed by ID\n  let manifest = {};\n  // Routes in tree format for matching\n  let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties, undefined, manifest);\n  let inFlightDataRoutes;\n  let basename = init.basename || \"/\";\n  // 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  }, init.future);\n  // Cleanup function for history\n  let unlistenHistory = null;\n  // Externally-provided functions to call on all state changes\n  let subscribers = new Set();\n  // Externally-provided object to hold scroll restoration locations during routing\n  let savedScrollPositions = null;\n  // Externally-provided function to get scroll restoration keys\n  let getScrollRestorationKey = null;\n  // Externally-provided function to get current scroll position\n  let getScrollPosition = null;\n  // One-time flag to control the initial hydration scroll restoration.  Because\n  // we don't get the saved positions from <ScrollRestoration /> until _after_\n  // the initial render, we need to manually trigger a separate updateState to\n  // send along the restoreScrollPosition\n  // Set to true if we have `hydrationData` since we assume we were SSR'd and that\n  // SSR did the initial scroll restoration.\n  let initialScrollRestored = init.hydrationData != null;\n  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);\n  let initialErrors = null;\n  if (initialMatches == null) {\n    // If we do not match a user-provided-route, fall back to the root\n    // to allow the error boundary to take over\n    let error = getInternalRouterError(404, {\n      pathname: init.history.location.pathname\n    });\n    let {\n      matches,\n      route\n    } = getShortCircuitMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = {\n      [route.id]: error\n    };\n  }\n  let initialized;\n  let hasLazyRoutes = initialMatches.some(m => m.route.lazy);\n  let hasLoaders = initialMatches.some(m => m.route.loader);\n  if (hasLazyRoutes) {\n    // All initialMatches need to be loaded before we're ready.  If we have lazy\n    // functions around still then we'll need to run them in initialize()\n    initialized = false;\n  } else if (!hasLoaders) {\n    // If we've got no loaders to run, then we're good to go\n    initialized = true;\n  } else if (future.v7_partialHydration) {\n    // If partial hydration is enabled, we're initialized so long as we were\n    // provided with hydrationData for every route with a loader, and no loaders\n    // were marked for explicit hydration\n    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;\n    let errors = init.hydrationData ? init.hydrationData.errors : null;\n    initialized = initialMatches.every(m => m.route.loader && m.route.loader.hydrate !== true && (loaderData && loaderData[m.route.id] !== undefined || errors && errors[m.route.id] !== undefined));\n  } else {\n    // Without partial hydration - we're initialized if we were provided any\n    // hydrationData - which is expected to be complete\n    initialized = init.hydrationData != null;\n  }\n  let router;\n  let state = {\n    historyAction: init.history.action,\n    location: init.history.location,\n    matches: initialMatches,\n    initialized,\n    navigation: IDLE_NAVIGATION,\n    // Don't restore on initial updateState() if we were SSR'd\n    restoreScrollPosition: init.hydrationData != null ? false : null,\n    preventScrollReset: false,\n    revalidation: \"idle\",\n    loaderData: init.hydrationData && init.hydrationData.loaderData || {},\n    actionData: init.hydrationData && init.hydrationData.actionData || null,\n    errors: init.hydrationData && init.hydrationData.errors || initialErrors,\n    fetchers: new Map(),\n    blockers: new Map()\n  };\n  // -- Stateful internal variables to manage navigations --\n  // Current navigation in progress (to be committed in completeNavigation)\n  let pendingAction = Action.Pop;\n  // Should the current navigation prevent the scroll reset if scroll cannot\n  // be restored?\n  let pendingPreventScrollReset = false;\n  // AbortController for the active navigation\n  let pendingNavigationController;\n  // Should the current navigation enable document.startViewTransition?\n  let pendingViewTransitionEnabled = false;\n  // Store applied view transitions so we can apply them on POP\n  let appliedViewTransitions = new Map();\n  // Cleanup function for persisting applied transitions to sessionStorage\n  let removePageHideEventListener = null;\n  // We use this to avoid touching history in completeNavigation if a\n  // revalidation is entirely uninterrupted\n  let isUninterruptedRevalidation = false;\n  // Use this internal flag to force revalidation of all loaders:\n  //  - submissions (completed or interrupted)\n  //  - useRevalidator()\n  //  - X-Remix-Revalidate (from redirect)\n  let isRevalidationRequired = false;\n  // Use this internal array to capture routes that require revalidation due\n  // to a cancelled deferred on action submission\n  let cancelledDeferredRoutes = [];\n  // Use this internal array to capture fetcher loads that were cancelled by an\n  // action navigation and require revalidation\n  let cancelledFetcherLoads = [];\n  // AbortControllers for any in-flight fetchers\n  let fetchControllers = new Map();\n  // Track loads based on the order in which they started\n  let incrementingLoadId = 0;\n  // Track the outstanding pending navigation data load to be compared against\n  // the globally incrementing load when a fetcher load lands after a completed\n  // navigation\n  let pendingNavigationLoadId = -1;\n  // Fetchers that triggered data reloads as a result of their actions\n  let fetchReloadIds = new Map();\n  // Fetchers that triggered redirect navigations\n  let fetchRedirectIds = new Set();\n  // Most recent href/match for fetcher.load calls for fetchers\n  let fetchLoadMatches = new Map();\n  // Ref-count mounted fetchers so we know when it's ok to clean them up\n  let activeFetchers = new Map();\n  // Fetchers that have requested a delete when using v7_fetcherPersist,\n  // they'll be officially removed after they return to idle\n  let deletedFetchers = new Set();\n  // Store DeferredData instances for active route matches.  When a\n  // route loader returns defer() we stick one in here.  Then, when a nested\n  // promise resolves we update loaderData.  If a new navigation starts we\n  // cancel active deferreds for eliminated routes.\n  let activeDeferreds = new Map();\n  // Store blocker functions in a separate Map outside of router state since\n  // we don't need to update UI state if they change\n  let blockerFunctions = new Map();\n  // Flag to ignore the next history update, so we can revert the URL change on\n  // a POP navigation that was blocked by the user without touching router state\n  let ignoreNextHistoryUpdate = false;\n  // Initialize the router, all side effects should be kicked off from here.\n  // Implemented as a Fluent API for ease of:\n  //   let router = createRouter(init).initialize();\n  function initialize() {\n    // If history informs us of a POP navigation, start the navigation but do not update\n    // state.  We'll update our own state once the navigation completes\n    unlistenHistory = init.history.listen(_ref => {\n      let {\n        action: historyAction,\n        location,\n        delta\n      } = _ref;\n      // Ignore this event if it was just us resetting the URL from a\n      // blocked POP navigation\n      if (ignoreNextHistoryUpdate) {\n        ignoreNextHistoryUpdate = false;\n        return;\n      }\n      warning(blockerFunctions.size === 0 || delta != null, \"You are trying to use a blocker on a POP navigation to a location \" + \"that was not created by @remix-run/router. This will fail silently in \" + \"production. This can happen if you are navigating outside the router \" + \"via `window.history.pushState`/`window.location.hash` instead of using \" + \"router navigation APIs.  This can also happen if you are using \" + \"createHashRouter and the user manually changes the URL.\");\n      let blockerKey = shouldBlockNavigation({\n        currentLocation: state.location,\n        nextLocation: location,\n        historyAction\n      });\n      if (blockerKey && delta != null) {\n        // Restore the URL to match the current UI, but don't update router state\n        ignoreNextHistoryUpdate = true;\n        init.history.go(delta * -1);\n        // Put the blocker into a blocked state\n        updateBlocker(blockerKey, {\n          state: \"blocked\",\n          location,\n          proceed() {\n            updateBlocker(blockerKey, {\n              state: \"proceeding\",\n              proceed: undefined,\n              reset: undefined,\n              location\n            });\n            // Re-do the same POP navigation we just blocked\n            init.history.go(delta);\n          },\n          reset() {\n            let blockers = new Map(state.blockers);\n            blockers.set(blockerKey, IDLE_BLOCKER);\n            updateState({\n              blockers\n            });\n          }\n        });\n        return;\n      }\n      return startNavigation(historyAction, location);\n    });\n    if (isBrowser) {\n      // FIXME: This feels gross.  How can we cleanup the lines between\n      // scrollRestoration/appliedTransitions persistance?\n      restoreAppliedTransitions(routerWindow, appliedViewTransitions);\n      let _saveAppliedTransitions = () => persistAppliedTransitions(routerWindow, appliedViewTransitions);\n      routerWindow.addEventListener(\"pagehide\", _saveAppliedTransitions);\n      removePageHideEventListener = () => routerWindow.removeEventListener(\"pagehide\", _saveAppliedTransitions);\n    }\n    // Kick off initial data load if needed.  Use Pop to avoid modifying history\n    // Note we don't do any handling of lazy here.  For SPA's it'll get handled\n    // in the normal navigation flow.  For SSR it's expected that lazy modules are\n    // resolved prior to router creation since we can't go into a fallbackElement\n    // UI for SSR'd apps\n    if (!state.initialized) {\n      startNavigation(Action.Pop, state.location, {\n        initialHydration: true\n      });\n    }\n    return router;\n  }\n  // Clean up a router and it's side effects\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\n    }\n    if (removePageHideEventListener) {\n      removePageHideEventListener();\n    }\n    subscribers.clear();\n    pendingNavigationController && pendingNavigationController.abort();\n    state.fetchers.forEach((_, key) => deleteFetcher(key));\n    state.blockers.forEach((_, key) => deleteBlocker(key));\n  }\n  // Subscribe to state updates for the router\n  function subscribe(fn) {\n    subscribers.add(fn);\n    return () => subscribers.delete(fn);\n  }\n  // Update our state and notify the calling context of the change\n  function updateState(newState, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    state = _extends({}, state, newState);\n    // Prep fetcher cleanup so we can tell the UI which fetcher data entries\n    // can be removed\n    let completedFetchers = [];\n    let deletedFetchersKeys = [];\n    if (future.v7_fetcherPersist) {\n      state.fetchers.forEach((fetcher, key) => {\n        if (fetcher.state === \"idle\") {\n          if (deletedFetchers.has(key)) {\n            // Unmounted from the UI and can be totally removed\n            deletedFetchersKeys.push(key);\n          } else {\n            // Returned to idle but still mounted in the UI, so semi-remains for\n            // revalidations and such\n            completedFetchers.push(key);\n          }\n        }\n      });\n    }\n    // Iterate over a local copy so that if flushSync is used and we end up\n    // removing and adding a new subscriber due to the useCallback dependencies,\n    // we don't get ourselves into a loop calling the new subscriber immediately\n    [...subscribers].forEach(subscriber => subscriber(state, {\n      deletedFetchers: deletedFetchersKeys,\n      unstable_viewTransitionOpts: opts.viewTransitionOpts,\n      unstable_flushSync: opts.flushSync === true\n    }));\n    // Remove idle fetchers from state since we only care about in-flight fetchers.\n    if (future.v7_fetcherPersist) {\n      completedFetchers.forEach(key => state.fetchers.delete(key));\n      deletedFetchersKeys.forEach(key => deleteFetcher(key));\n    }\n  }\n  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION\n  // and setting state.[historyAction/location/matches] to the new route.\n  // - Location is a required param\n  // - Navigation will always be set to IDLE_NAVIGATION\n  // - Can pass any other state in newState\n  function completeNavigation(location, newState, _temp) {\n    var _location$state, _location$state2;\n    let {\n      flushSync\n    } = _temp === void 0 ? {} : _temp;\n    // Deduce if we're in a loading/actionReload state:\n    // - We have committed actionData in the store\n    // - The current navigation was a mutation submission\n    // - We're past the submitting state and into the loading state\n    // - The location being loaded is not the result of a redirect\n    let isActionReload = state.actionData != null && state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && state.navigation.state === \"loading\" && ((_location$state = location.state) == null ? void 0 : _location$state._isRedirect) !== true;\n    let actionData;\n    if (newState.actionData) {\n      if (Object.keys(newState.actionData).length > 0) {\n        actionData = newState.actionData;\n      } else {\n        // Empty actionData -> clear prior actionData due to an action error\n        actionData = null;\n      }\n    } else if (isActionReload) {\n      // Keep the current data if we're wrapping up the action reload\n      actionData = state.actionData;\n    } else {\n      // Clear actionData on any other completed navigations\n      actionData = null;\n    }\n    // Always preserve any existing loaderData from re-used routes\n    let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;\n    // On a successful navigation we can assume we got through all blockers\n    // so we can start fresh\n    let blockers = state.blockers;\n    if (blockers.size > 0) {\n      blockers = new Map(blockers);\n      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));\n    }\n    // Always respect the user flag.  Otherwise don't reset on mutation\n    // submission navigations unless they redirect\n    let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;\n    if (inFlightDataRoutes) {\n      dataRoutes = inFlightDataRoutes;\n      inFlightDataRoutes = undefined;\n    }\n    if (isUninterruptedRevalidation) ; else if (pendingAction === Action.Pop) ; else if (pendingAction === Action.Push) {\n      init.history.push(location, location.state);\n    } else if (pendingAction === Action.Replace) {\n      init.history.replace(location, location.state);\n    }\n    let viewTransitionOpts;\n    // On POP, enable transitions if they were enabled on the original navigation\n    if (pendingAction === Action.Pop) {\n      // Forward takes precedence so they behave like the original navigation\n      let priorPaths = appliedViewTransitions.get(state.location.pathname);\n      if (priorPaths && priorPaths.has(location.pathname)) {\n        viewTransitionOpts = {\n          currentLocation: state.location,\n          nextLocation: location\n        };\n      } else if (appliedViewTransitions.has(location.pathname)) {\n        // If we don't have a previous forward nav, assume we're popping back to\n        // the new location and enable if that location previously enabled\n        viewTransitionOpts = {\n          currentLocation: location,\n          nextLocation: state.location\n        };\n      }\n    } else if (pendingViewTransitionEnabled) {\n      // Store the applied transition on PUSH/REPLACE\n      let toPaths = appliedViewTransitions.get(state.location.pathname);\n      if (toPaths) {\n        toPaths.add(location.pathname);\n      } else {\n        toPaths = new Set([location.pathname]);\n        appliedViewTransitions.set(state.location.pathname, toPaths);\n      }\n      viewTransitionOpts = {\n        currentLocation: state.location,\n        nextLocation: location\n      };\n    }\n    updateState(_extends({}, newState, {\n      actionData,\n      loaderData,\n      historyAction: pendingAction,\n      location,\n      initialized: true,\n      navigation: IDLE_NAVIGATION,\n      revalidation: \"idle\",\n      restoreScrollPosition: getSavedScrollPosition(location, newState.matches || state.matches),\n      preventScrollReset,\n      blockers\n    }), {\n      viewTransitionOpts,\n      flushSync: flushSync === true\n    });\n    // Reset stateful navigation vars\n    pendingAction = Action.Pop;\n    pendingPreventScrollReset = false;\n    pendingViewTransitionEnabled = false;\n    isUninterruptedRevalidation = false;\n    isRevalidationRequired = false;\n    cancelledDeferredRoutes = [];\n    cancelledFetcherLoads = [];\n  }\n  // Trigger a navigation event, which can either be a numerical POP or a PUSH\n  // replace with an optional submission\n  async function navigate(to, opts) {\n    if (typeof to === \"number\") {\n      init.history.go(to);\n      return;\n    }\n    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, to, future.v7_relativeSplatPath, opts == null ? void 0 : opts.fromRouteId, opts == null ? void 0 : opts.relative);\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, false, normalizedPath, opts);\n    let currentLocation = state.location;\n    let nextLocation = createLocation(state.location, path, opts && opts.state);\n    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded\n    // URL from window.location, so we need to encode it here so the behavior\n    // remains the same as POP and non-data-router usages.  new URL() does all\n    // the same encoding we'd get from a history.pushState/window.location read\n    // without having to touch history\n    nextLocation = _extends({}, nextLocation, init.history.encodeLocation(nextLocation));\n    let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n    let historyAction = Action.Push;\n    if (userReplace === true) {\n      historyAction = Action.Replace;\n    } else if (userReplace === false) ; else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) {\n      // By default on submissions to the current location we REPLACE so that\n      // users don't have to double-click the back button to get to the prior\n      // location.  If the user redirects to a different location from the\n      // action/loader this will be ignored and the redirect will be a PUSH\n      historyAction = Action.Replace;\n    }\n    let preventScrollReset = opts && \"preventScrollReset\" in opts ? opts.preventScrollReset === true : undefined;\n    let flushSync = (opts && opts.unstable_flushSync) === true;\n    let blockerKey = shouldBlockNavigation({\n      currentLocation,\n      nextLocation,\n      historyAction\n    });\n    if (blockerKey) {\n      // Put the blocker into a blocked state\n      updateBlocker(blockerKey, {\n        state: \"blocked\",\n        location: nextLocation,\n        proceed() {\n          updateBlocker(blockerKey, {\n            state: \"proceeding\",\n            proceed: undefined,\n            reset: undefined,\n            location: nextLocation\n          });\n          // Send the same navigation through\n          navigate(to, opts);\n        },\n        reset() {\n          let blockers = new Map(state.blockers);\n          blockers.set(blockerKey, IDLE_BLOCKER);\n          updateState({\n            blockers\n          });\n        }\n      });\n      return;\n    }\n    return await startNavigation(historyAction, nextLocation, {\n      submission,\n      // Send through the formData serialization error if we have one so we can\n      // render at the right error boundary after we match routes\n      pendingError: error,\n      preventScrollReset,\n      replace: opts && opts.replace,\n      enableViewTransition: opts && opts.unstable_viewTransition,\n      flushSync\n    });\n  }\n  // Revalidate all current loaders.  If a navigation is in progress or if this\n  // is interrupted by a navigation, allow this to \"succeed\" by calling all\n  // loaders during the next loader round\n  function revalidate() {\n    interruptActiveLoads();\n    updateState({\n      revalidation: \"loading\"\n    });\n    // If we're currently submitting an action, we don't need to start a new\n    // navigation, we'll just let the follow up loader execution call all loaders\n    if (state.navigation.state === \"submitting\") {\n      return;\n    }\n    // If we're currently in an idle state, start a new navigation for the current\n    // action/location and mark it as uninterrupted, which will skip the history\n    // update in completeNavigation\n    if (state.navigation.state === \"idle\") {\n      startNavigation(state.historyAction, state.location, {\n        startUninterruptedRevalidation: true\n      });\n      return;\n    }\n    // Otherwise, if we're currently in a loading state, just start a new\n    // navigation to the navigation.location but do not trigger an uninterrupted\n    // revalidation so that history correctly updates once the navigation completes\n    startNavigation(pendingAction || state.historyAction, state.navigation.location, {\n      overrideNavigation: state.navigation\n    });\n  }\n  // Start a navigation to the given action/location.  Can optionally provide a\n  // overrideNavigation which will override the normalLoad in the case of a redirect\n  // navigation\n  async function startNavigation(historyAction, location, opts) {\n    // Abort any in-progress navigations and start a new one. Unset any ongoing\n    // uninterrupted revalidations unless told otherwise, since we want this\n    // new navigation to update history normally\n    pendingNavigationController && pendingNavigationController.abort();\n    pendingNavigationController = null;\n    pendingAction = historyAction;\n    isUninterruptedRevalidation = (opts && opts.startUninterruptedRevalidation) === true;\n    // Save the current scroll position every time we start a new navigation,\n    // and track whether we should reset scroll on completion\n    saveScrollPosition(state.location, state.matches);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches = matchRoutes(routesToUse, location, basename);\n    let flushSync = (opts && opts.flushSync) === true;\n    // Short circuit with a 404 on the root error boundary if we match nothing\n    if (!matches) {\n      let error = getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n      let {\n        matches: notFoundMatches,\n        route\n      } = getShortCircuitMatches(routesToUse);\n      // Cancel all pending deferred on 404s since we don't keep any routes\n      cancelActiveDeferreds();\n      completeNavigation(location, {\n        matches: notFoundMatches,\n        loaderData: {},\n        errors: {\n          [route.id]: error\n        }\n      }, {\n        flushSync\n      });\n      return;\n    }\n    // Short circuit if it's only a hash change and not a revalidation or\n    // mutation submission.\n    //\n    // Ignore on initial page loads because since the initial load will always\n    // be \"same hash\".  For example, on /page#hash and submit a <Form method=\"post\">\n    // which will default to a navigation to /page\n    if (state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {\n      completeNavigation(location, {\n        matches\n      }, {\n        flushSync\n      });\n      return;\n    }\n    // Create a controller/Request for this navigation\n    pendingNavigationController = new AbortController();\n    let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);\n    let pendingActionData;\n    let pendingError;\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      pendingError = {\n        [findNearestBoundary(matches).route.id]: opts.pendingError\n      };\n    } else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {\n      // Call action if we received an action submission\n      let actionOutput = await handleAction(request, location, opts.submission, matches, {\n        replace: opts.replace,\n        flushSync\n      });\n      if (actionOutput.shortCircuited) {\n        return;\n      }\n      pendingActionData = actionOutput.pendingActionData;\n      pendingError = actionOutput.pendingActionError;\n      loadingNavigation = getLoadingNavigation(location, opts.submission);\n      flushSync = false;\n      // Create a GET request for the loaders\n      request = new Request(request.url, {\n        signal: request.signal\n      });\n    }\n    // Call loaders\n    let {\n      shortCircuited,\n      loaderData,\n      errors\n    } = await handleLoaders(request, location, matches, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionData, pendingError);\n    if (shortCircuited) {\n      return;\n    }\n    // Clean up now that the action/loaders have completed.  Don't clean up if\n    // we short circuited because pendingNavigationController will have already\n    // been assigned to a new controller for the next navigation\n    pendingNavigationController = null;\n    completeNavigation(location, _extends({\n      matches\n    }, pendingActionData ? {\n      actionData: pendingActionData\n    } : {}, {\n      loaderData,\n      errors\n    }));\n  }\n  // Call the action matched by the leaf route for this navigation and handle\n  // redirects/errors\n  async function handleAction(request, location, submission, matches, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    interruptActiveLoads();\n    // Put us in a submitting state\n    let navigation = getSubmittingNavigation(location, submission);\n    updateState({\n      navigation\n    }, {\n      flushSync: opts.flushSync === true\n    });\n    // Call our action and get the result\n    let result;\n    let actionMatch = getTargetMatch(matches, location);\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      result = {\n        type: ResultType.error,\n        error: getInternalRouterError(405, {\n          method: request.method,\n          pathname: location.pathname,\n          routeId: actionMatch.route.id\n        })\n      };\n    } else {\n      result = await callLoaderOrAction(\"action\", request, actionMatch, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);\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        replace = result.location === state.location.pathname + state.location.search;\n      }\n      await startRedirectNavigation(state, result, {\n        submission,\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n      // By default, all submissions are REPLACE navigations, but if the\n      // action threw an error that'll be rendered in an errorElement, we fall\n      // back to PUSH so that the user can use the back button to get back to\n      // the pre-submission form location to try again\n      if ((opts && opts.replace) !== true) {\n        pendingAction = Action.Push;\n      }\n      return {\n        // Send back an empty object we can use to clear out any prior actionData\n        pendingActionData: {},\n        pendingActionError: {\n          [boundaryMatch.route.id]: result.error\n        }\n      };\n    }\n    if (isDeferredResult(result)) {\n      throw getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n    }\n    return {\n      pendingActionData: {\n        [actionMatch.route.id]: result.data\n      }\n    };\n  }\n  // Call all applicable loaders for the given matches, handling redirects,\n  // errors, etc.\n  async function handleLoaders(request, location, matches, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionData, pendingError) {\n    // Figure out the right navigation we want to use for data loading\n    let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);\n    // If this was a redirect from an action we don't have a \"submission\" but\n    // we have it on the loading navigation so use that if available\n    let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionData, pendingError);\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: pendingError || null\n      }, pendingActionData ? {\n        actionData: pendingActionData\n      } : {}, updatedFetchers ? {\n        fetchers: new Map(state.fetchers)\n      } : {}), {\n        flushSync\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    // If this is an uninterrupted revalidation, we remain in our current idle\n    // state.  If not, we need to switch to our loading state and load data,\n    // preserving any new action data or existing action data (in the case of\n    // a revalidation interrupting an actionReload)\n    // If we have partialHydration enabled, then don't update the state for the\n    // initial data load since iot's not a \"navigation\"\n    if (!isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration)) {\n      revalidatingFetchers.forEach(rf => {\n        let fetcher = state.fetchers.get(rf.key);\n        let revalidatingFetcher = getLoadingFetcher(undefined, fetcher ? fetcher.data : undefined);\n        state.fetchers.set(rf.key, revalidatingFetcher);\n      });\n      let actionData = pendingActionData || state.actionData;\n      updateState(_extends({\n        navigation: loadingNavigation\n      }, actionData ? Object.keys(actionData).length === 0 ? {\n        actionData: null\n      } : {\n        actionData\n      } : {}, revalidatingFetchers.length > 0 ? {\n        fetchers: new Map(state.fetchers)\n      } : {}), {\n        flushSync\n      });\n    }\n    revalidatingFetchers.forEach(rf => {\n      if (fetchControllers.has(rf.key)) {\n        abortFetcher(rf.key);\n      }\n      if (rf.controller) {\n        // Fetchers use an independent AbortController so that aborting a fetcher\n        // (via deleteFetcher) does not abort the triggering navigation that\n        // triggered the revalidation\n        fetchControllers.set(rf.key, rf.controller);\n      }\n    });\n    // Proxy navigation abort through to revalidation fetchers\n    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(f => abortFetcher(f.key));\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.addEventListener(\"abort\", abortPendingFetchRevalidations);\n    }\n    let {\n      results,\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, request);\n    if (request.signal.aborted) {\n      return {\n        shortCircuited: true\n      };\n    }\n    // Clean up _after_ loaders have completed.  Don't clean up if we short\n    // circuited because fetchControllers would have been aborted and\n    // reassigned to new controllers for the next navigation\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.removeEventListener(\"abort\", abortPendingFetchRevalidations);\n    }\n    revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key));\n    // If any loaders returned a redirect Response, start a new REPLACE navigation\n    let redirect = findRedirect(results);\n    if (redirect) {\n      if (redirect.idx >= matchesToLoad.length) {\n        // If this redirect came from a fetcher make sure we mark it in\n        // fetchRedirectIds so it doesn't get revalidated on the next set of\n        // loader executions\n        let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n        fetchRedirectIds.add(fetcherKey);\n      }\n      await startRedirectNavigation(state, redirect.result, {\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    // Process and commit output from loaders\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, matches, matchesToLoad, loaderResults, pendingError, 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    let updatedFetchers = markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n    return _extends({\n      loaderData,\n      errors\n    }, shouldUpdateFetchers ? {\n      fetchers: new Map(state.fetchers)\n    } : {});\n  }\n  // Trigger a fetcher load/submit for the given fetcher key\n  function fetch(key, routeId, href, opts) {\n    if (isServer) {\n      throw new Error(\"router.fetch() was called during the server render, but it shouldn't be. \" + \"You are likely calling a useFetcher() method in the body of your component. \" + \"Try moving it to a useEffect or a callback.\");\n    }\n    if (fetchControllers.has(key)) abortFetcher(key);\n    let flushSync = (opts && opts.unstable_flushSync) === true;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, future.v7_relativeSplatPath, routeId, opts == null ? void 0 : opts.relative);\n    let matches = matchRoutes(routesToUse, normalizedPath, basename);\n    if (!matches) {\n      setFetcherError(key, routeId, getInternalRouterError(404, {\n        pathname: normalizedPath\n      }), {\n        flushSync\n      });\n      return;\n    }\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, true, normalizedPath, opts);\n    if (error) {\n      setFetcherError(key, routeId, error, {\n        flushSync\n      });\n      return;\n    }\n    let match = getTargetMatch(matches, path);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n    if (submission && isMutationMethod(submission.formMethod)) {\n      handleFetcherAction(key, routeId, path, match, matches, flushSync, submission);\n      return;\n    }\n    // Store off the match so we can call it's shouldRevalidate on subsequent\n    // revalidations\n    fetchLoadMatches.set(key, {\n      routeId,\n      path\n    });\n    handleFetcherLoader(key, routeId, path, match, matches, flushSync, submission);\n  }\n  // Call the action for the matched fetcher.submit(), and then handle redirects,\n  // errors, and revalidation\n  async function handleFetcherAction(key, routeId, path, match, requestMatches, flushSync, submission) {\n    interruptActiveLoads();\n    fetchLoadMatches.delete(key);\n    if (!match.route.action && !match.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: submission.formMethod,\n        pathname: path,\n        routeId: routeId\n      });\n      setFetcherError(key, routeId, error, {\n        flushSync\n      });\n      return;\n    }\n    // Put this fetcher into it's submitting state\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {\n      flushSync\n    });\n    // Call the action for the fetcher\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);\n    fetchControllers.set(key, abortController);\n    let originatingLoadId = incrementingLoadId;\n    let actionResult = await callLoaderOrAction(\"action\", fetchRequest, match, requestMatches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);\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    if (deletedFetchers.has(key)) {\n      updateFetcherState(key, getDoneFetcher(undefined));\n      return;\n    }\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(state, actionResult, {\n          fetcherSubmission: submission\n        });\n      }\n    }\n    // Process any non-redirect errors thrown\n    if (isErrorResult(actionResult)) {\n      setFetcherError(key, routeId, actionResult.error);\n      return;\n    }\n    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, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, {\n      [match.route.id]: actionResult.data\n    }, undefined // No need to send through errors since we short circuit above\n    );\n    // Put all revalidating fetchers into the loading state, except for the\n    // current fetcher which we want to keep in it's current loading state which\n    // contains it's action submission info + action data\n    revalidatingFetchers.filter(rf => rf.key !== key).forEach(rf => {\n      let staleKey = rf.key;\n      let existingFetcher = state.fetchers.get(staleKey);\n      let revalidatingFetcher = getLoadingFetcher(undefined, existingFetcher ? existingFetcher.data : undefined);\n      state.fetchers.set(staleKey, revalidatingFetcher);\n      if (fetchControllers.has(staleKey)) {\n        abortFetcher(staleKey);\n      }\n      if (rf.controller) {\n        fetchControllers.set(staleKey, rf.controller);\n      }\n    });\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(rf => abortFetcher(rf.key));\n    abortController.signal.addEventListener(\"abort\", abortPendingFetchRevalidations);\n    let {\n      results,\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);\n    if (abortController.signal.aborted) {\n      return;\n    }\n    abortController.signal.removeEventListener(\"abort\", abortPendingFetchRevalidations);\n    fetchReloadIds.delete(key);\n    fetchControllers.delete(key);\n    revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));\n    let redirect = findRedirect(results);\n    if (redirect) {\n      if (redirect.idx >= matchesToLoad.length) {\n        // If this redirect came from a fetcher make sure we mark it in\n        // fetchRedirectIds so it doesn't get revalidated on the next set of\n        // loader executions\n        let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n        fetchRedirectIds.add(fetcherKey);\n      }\n      return startRedirectNavigation(state, redirect.result);\n    }\n    // Process and commit output from loaders\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, state.matches, matchesToLoad, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);\n    // Since we let revalidations complete even if the submitting fetcher was\n    // deleted, only put it back to idle if it hasn't been deleted\n    if (state.fetchers.has(key)) {\n      let doneFetcher = getDoneFetcher(actionResult.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n    abortStaleFetchLoads(loadId);\n    // If we are currently in a navigation loading state and this fetcher is\n    // more recent than the navigation, we want the newer data so abort the\n    // navigation and complete it with the fetcher data\n    if (state.navigation.state === \"loading\" && loadId > pendingNavigationLoadId) {\n      invariant(pendingAction, \"Expected pending action\");\n      pendingNavigationController && pendingNavigationController.abort();\n      completeNavigation(state.navigation.location, {\n        matches,\n        loaderData,\n        errors,\n        fetchers: new Map(state.fetchers)\n      });\n    } else {\n      // otherwise just update with the fetcher data, preserving any existing\n      // loaderData for loaders that did not need to reload.  We have to\n      // manually merge here since we aren't going through completeNavigation\n      updateState({\n        errors,\n        loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors),\n        fetchers: new Map(state.fetchers)\n      });\n      isRevalidationRequired = false;\n    }\n  }\n  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n  async function handleFetcherLoader(key, routeId, path, match, matches, flushSync, submission) {\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : undefined), {\n      flushSync\n    });\n    // Call the loader for this fetcher route match\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);\n    fetchControllers.set(key, abortController);\n    let originatingLoadId = incrementingLoadId;\n    let result = await callLoaderOrAction(\"loader\", fetchRequest, match, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);\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    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(state, result);\n        return;\n      }\n    }\n    // Process any non-redirect errors thrown\n    if (isErrorResult(result)) {\n      setFetcherError(key, routeId, result.error);\n      return;\n    }\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n    // Put the fetcher back into an idle state\n    updateFetcherState(key, getDoneFetcher(result.data));\n  }\n  /**\n   * Utility function to handle redirects returned from an action or loader.\n   * Normally, a redirect \"replaces\" the navigation that triggered it.  So, for\n   * example:\n   *\n   *  - user is on /a\n   *  - user clicks a link to /b\n   *  - loader for /b redirects to /c\n   *\n   * In a non-JS app the browser would track the in-flight navigation to /b and\n   * then replace it with /c when it encountered the redirect response.  In\n   * the end it would only ever update the URL bar with /c.\n   *\n   * In client-side routing using pushState/replaceState, we aim to emulate\n   * this behavior and we also do not update history until the end of the\n   * navigation (including processed redirects).  This means that we never\n   * actually touch history until we've processed redirects, so we just use\n   * the history action from the original navigation (PUSH or REPLACE).\n   */\n  async function startRedirectNavigation(state, redirect, _temp2) {\n    let {\n      submission,\n      fetcherSubmission,\n      replace\n    } = _temp2 === void 0 ? {} : _temp2;\n    if (redirect.revalidate) {\n      isRevalidationRequired = true;\n    }\n    let redirectLocation = createLocation(state.location, redirect.location, {\n      _isRedirect: true\n    });\n    invariant(redirectLocation, \"Expected a location on the redirect navigation\");\n    if (isBrowser) {\n      let isDocumentReload = false;\n      if (redirect.reloadDocument) {\n        // Hard reload if the response contained X-Remix-Reload-Document\n        isDocumentReload = true;\n      } else if (ABSOLUTE_URL_REGEX.test(redirect.location)) {\n        const url = init.history.createURL(redirect.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(redirect.location);\n        } else {\n          routerWindow.location.assign(redirect.location);\n        }\n        return;\n      }\n    }\n    // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n    pendingNavigationController = null;\n    let redirectHistoryAction = replace === true ? Action.Replace : Action.Push;\n    // Use the incoming submission if provided, fallback on the active one in\n    // state.navigation\n    let {\n      formMethod,\n      formAction,\n      formEncType\n    } = state.navigation;\n    if (!submission && !fetcherSubmission && formMethod && formAction && formEncType) {\n      submission = getSubmissionFromNavigation(state.navigation);\n    }\n    // If this was a 307/308 submission we want to preserve the HTTP method and\n    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the\n    // redirected location\n    let activeSubmission = submission || fetcherSubmission;\n    if (redirectPreserveMethodStatusCodes.has(redirect.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        submission: _extends({}, activeSubmission, {\n          formAction: redirect.location\n        }),\n        // Preserve this flag across redirects\n        preventScrollReset: pendingPreventScrollReset\n      });\n    } else {\n      // If we have a navigation submission, we will preserve it through the\n      // redirect navigation\n      let overrideNavigation = getLoadingNavigation(redirectLocation, submission);\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        overrideNavigation,\n        // Send fetcher submissions through for shouldRevalidate\n        fetcherSubmission,\n        // Preserve this flag across redirects\n        preventScrollReset: pendingPreventScrollReset\n      });\n    }\n  }\n  async function callLoadersAndMaybeResolveData(currentMatches, matches, matchesToLoad, fetchersToLoad, request) {\n    // Call all navigation loaders and revalidating fetcher loaders in parallel,\n    // then slice off the results into separate arrays so we can handle them\n    // accordingly\n    let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction(\"loader\", request, match, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath)), ...fetchersToLoad.map(f => {\n      if (f.matches && f.match && f.controller) {\n        return callLoaderOrAction(\"loader\", createClientSideRequest(init.history, f.path, f.controller.signal), f.match, f.matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);\n      } else {\n        let error = {\n          type: ResultType.error,\n          error: getInternalRouterError(404, {\n            pathname: f.path\n          })\n        };\n        return error;\n      }\n    })]);\n    let loaderResults = results.slice(0, matchesToLoad.length);\n    let fetcherResults = results.slice(matchesToLoad.length);\n    await Promise.all([resolveDeferredResults(currentMatches, matchesToLoad, loaderResults, loaderResults.map(() => request.signal), false, state.loaderData), resolveDeferredResults(currentMatches, fetchersToLoad.map(f => f.match), fetcherResults, fetchersToLoad.map(f => f.controller ? f.controller.signal : null), true)]);\n    return {\n      results,\n      loaderResults,\n      fetcherResults\n    };\n  }\n  function interruptActiveLoads() {\n    // Every interruption triggers a revalidation\n    isRevalidationRequired = true;\n    // Cancel pending route-level deferreds and mark cancelled routes for\n    // revalidation\n    cancelledDeferredRoutes.push(...cancelActiveDeferreds());\n    // Abort in-flight fetcher loads\n    fetchLoadMatches.forEach((_, key) => {\n      if (fetchControllers.has(key)) {\n        cancelledFetcherLoads.push(key);\n        abortFetcher(key);\n      }\n    });\n  }\n  function updateFetcherState(key, fetcher, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    state.fetchers.set(key, fetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    }, {\n      flushSync: (opts && opts.flushSync) === true\n    });\n  }\n  function setFetcherError(key, routeId, error, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    let boundaryMatch = findNearestBoundary(state.matches, routeId);\n    deleteFetcher(key);\n    updateState({\n      errors: {\n        [boundaryMatch.route.id]: error\n      },\n      fetchers: new Map(state.fetchers)\n    }, {\n      flushSync: (opts && opts.flushSync) === true\n    });\n  }\n  function getFetcher(key) {\n    if (future.v7_fetcherPersist) {\n      activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);\n      // If this fetcher was previously marked for deletion, unmark it since we\n      // have a new instance\n      if (deletedFetchers.has(key)) {\n        deletedFetchers.delete(key);\n      }\n    }\n    return state.fetchers.get(key) || IDLE_FETCHER;\n  }\n  function deleteFetcher(key) {\n    let fetcher = state.fetchers.get(key);\n    // Don't abort the controller if this is a deletion of a fetcher.submit()\n    // in it's loading phase since - we don't want to abort the corresponding\n    // revalidation and want them to complete and land\n    if (fetchControllers.has(key) && !(fetcher && fetcher.state === \"loading\" && fetchReloadIds.has(key))) {\n      abortFetcher(key);\n    }\n    fetchLoadMatches.delete(key);\n    fetchReloadIds.delete(key);\n    fetchRedirectIds.delete(key);\n    deletedFetchers.delete(key);\n    state.fetchers.delete(key);\n  }\n  function deleteFetcherAndUpdateState(key) {\n    if (future.v7_fetcherPersist) {\n      let count = (activeFetchers.get(key) || 0) - 1;\n      if (count <= 0) {\n        activeFetchers.delete(key);\n        deletedFetchers.add(key);\n      } else {\n        activeFetchers.set(key, count);\n      }\n    } else {\n      deleteFetcher(key);\n    }\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n  }\n  function abortFetcher(key) {\n    let controller = fetchControllers.get(key);\n    invariant(controller, \"Expected fetch controller: \" + key);\n    controller.abort();\n    fetchControllers.delete(key);\n  }\n  function markFetchersDone(keys) {\n    for (let key of keys) {\n      let fetcher = getFetcher(key);\n      let doneFetcher = getDoneFetcher(fetcher.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n  function markFetchRedirectsDone() {\n    let doneKeys = [];\n    let updatedFetchers = false;\n    for (let key of fetchRedirectIds) {\n      let fetcher = state.fetchers.get(key);\n      invariant(fetcher, \"Expected fetcher: \" + key);\n      if (fetcher.state === \"loading\") {\n        fetchRedirectIds.delete(key);\n        doneKeys.push(key);\n        updatedFetchers = true;\n      }\n    }\n    markFetchersDone(doneKeys);\n    return updatedFetchers;\n  }\n  function abortStaleFetchLoads(landedId) {\n    let yeetedKeys = [];\n    for (let [key, id] of fetchReloadIds) {\n      if (id < landedId) {\n        let fetcher = state.fetchers.get(key);\n        invariant(fetcher, \"Expected fetcher: \" + key);\n        if (fetcher.state === \"loading\") {\n          abortFetcher(key);\n          fetchReloadIds.delete(key);\n          yeetedKeys.push(key);\n        }\n      }\n    }\n    markFetchersDone(yeetedKeys);\n    return yeetedKeys.length > 0;\n  }\n  function getBlocker(key, fn) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n    if (blockerFunctions.get(key) !== fn) {\n      blockerFunctions.set(key, fn);\n    }\n    return blocker;\n  }\n  function deleteBlocker(key) {\n    state.blockers.delete(key);\n    blockerFunctions.delete(key);\n  }\n  // Utility function to update blockers, ensuring valid state transitions\n  function updateBlocker(key, newBlocker) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n    // Poor mans state machine :)\n    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n    invariant(blocker.state === \"unblocked\" && newBlocker.state === \"blocked\" || blocker.state === \"blocked\" && newBlocker.state === \"blocked\" || blocker.state === \"blocked\" && newBlocker.state === \"proceeding\" || blocker.state === \"blocked\" && newBlocker.state === \"unblocked\" || blocker.state === \"proceeding\" && newBlocker.state === \"unblocked\", \"Invalid blocker state transition: \" + blocker.state + \" -> \" + newBlocker.state);\n    let blockers = new Map(state.blockers);\n    blockers.set(key, newBlocker);\n    updateState({\n      blockers\n    });\n  }\n  function shouldBlockNavigation(_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 cancelActiveDeferreds(predicate) {\n    let cancelledRouteIds = [];\n    activeDeferreds.forEach((dfd, routeId) => {\n      if (!predicate || predicate(routeId)) {\n        // Cancel the deferred - but do not remove from activeDeferreds here -\n        // we rely on the subscribers to do that so our tests can assert proper\n        // cleanup via _internalActiveDeferreds\n        dfd.cancel();\n        cancelledRouteIds.push(routeId);\n        activeDeferreds.delete(routeId);\n      }\n    });\n    return cancelledRouteIds;\n  }\n  // Opt in to capturing and reporting scroll positions during navigations,\n  // used by the <ScrollRestoration> component\n  function enableScrollRestoration(positions, getPosition, getKey) {\n    savedScrollPositions = positions;\n    getScrollPosition = getPosition;\n    getScrollRestorationKey = getKey || null;\n    // Perform initial hydration scroll restoration, since we miss the boat on\n    // the initial updateState() because we've not yet rendered <ScrollRestoration/>\n    // and therefore have no savedScrollPositions available\n    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n      initialScrollRestored = true;\n      let y = getSavedScrollPosition(state.location, state.matches);\n      if (y != null) {\n        updateState({\n          restoreScrollPosition: y\n        });\n      }\n    }\n    return () => {\n      savedScrollPositions = null;\n      getScrollPosition = null;\n      getScrollRestorationKey = null;\n    };\n  }\n  function getScrollKey(location, matches) {\n    if (getScrollRestorationKey) {\n      let key = getScrollRestorationKey(location, matches.map(m => convertRouteMatchToUiMatch(m, state.loaderData)));\n      return key || location.key;\n    }\n    return location.key;\n  }\n  function saveScrollPosition(location, matches) {\n    if (savedScrollPositions && getScrollPosition) {\n      let key = getScrollKey(location, matches);\n      savedScrollPositions[key] = getScrollPosition();\n    }\n  }\n  function getSavedScrollPosition(location, matches) {\n    if (savedScrollPositions) {\n      let key = getScrollKey(location, matches);\n      let y = savedScrollPositions[key];\n      if (typeof y === \"number\") {\n        return y;\n      }\n    }\n    return null;\n  }\n  function _internalSetRoutes(newRoutes) {\n    manifest = {};\n    inFlightDataRoutes = convertRoutesToDataRoutes(newRoutes, mapRouteProperties, undefined, manifest);\n  }\n  router = {\n    get basename() {\n      return basename;\n    },\n    get future() {\n      return future;\n    },\n    get state() {\n      return state;\n    },\n    get routes() {\n      return dataRoutes;\n    },\n    get window() {\n      return routerWindow;\n    },\n    initialize,\n    subscribe,\n    enableScrollRestoration,\n    navigate,\n    fetch,\n    revalidate,\n    // Passthrough to history-aware createHref used by useHref so we get proper\n    // hash-aware URLs in DOM paths\n    createHref: to => init.history.createHref(to),\n    encodeLocation: to => init.history.encodeLocation(to),\n    getFetcher,\n    deleteFetcher: deleteFetcherAndUpdateState,\n    dispose,\n    getBlocker,\n    deleteBlocker,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds,\n    // TODO: Remove setRoutes, it's temporary to avoid dealing with\n    // updating the tree while validating the update algorithm.\n    _internalSetRoutes\n  };\n  return router;\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\nconst UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\nfunction createStaticHandler(routes, opts) {\n  invariant(routes.length > 0, \"You must provide a non-empty routes array to createStaticHandler\");\n  let manifest = {};\n  let basename = (opts ? opts.basename : null) || \"/\";\n  let mapRouteProperties;\n  if (opts != null && opts.mapRouteProperties) {\n    mapRouteProperties = opts.mapRouteProperties;\n  } else if (opts != null && opts.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = opts.detectErrorBoundary;\n    mapRouteProperties = route => ({\n      hasErrorBoundary: detectErrorBoundary(route)\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Config driven behavior flags\n  let future = _extends({\n    v7_relativeSplatPath: false\n  }, 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  async function query(request, _temp3) {\n    let {\n      requestContext\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);\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  async function queryRoute(request, _temp4) {\n    let {\n      routeId,\n      requestContext\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, 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, 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, routeMatch != null);\n        return result;\n      }\n      let result = await loadRouteData(request, matches, requestContext, 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, we throw\n      // it to bail out and then return or throw here based on whether the user\n      // returned or threw\n      if (isQueryRouteResponse(e)) {\n        if (e.type === ResultType.error) {\n          throw e.response;\n        }\n        return e.response;\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, 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      result = await callLoaderOrAction(\"action\", request, actionMatch, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath, {\n        isStaticRequest: true,\n        isRouteRequest,\n        requestContext\n      });\n      if (request.signal.aborted) {\n        let method = isRouteRequest ? \"queryRoute\" : \"query\";\n        throw new Error(method + \"() call aborted: \" + request.method + \" \" + request.url);\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.status,\n        headers: {\n          Location: result.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    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      let context = await loadRouteData(request, matches, requestContext, undefined, {\n        [boundaryMatch.route.id]: result.error\n      });\n      // action status codes take precedence over loader status codes\n      return _extends({}, context, {\n        statusCode: isRouteErrorResponse(result.error) ? result.error.status : 500,\n        actionData: null,\n        actionHeaders: _extends({}, result.headers ? {\n          [actionMatch.route.id]: result.headers\n        } : {})\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    let context = await loadRouteData(loaderRequest, matches, requestContext);\n    return _extends({}, context, result.statusCode ? {\n      statusCode: result.statusCode\n    } : {}, {\n      actionData: {\n        [actionMatch.route.id]: result.data\n      },\n      actionHeaders: _extends({}, result.headers ? {\n        [actionMatch.route.id]: result.headers\n      } : {})\n    });\n  }\n  async function loadRouteData(request, matches, requestContext, routeMatch, pendingActionError) {\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] : getLoaderMatchesUntilBoundary(matches, Object.keys(pendingActionError || {})[0]);\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: pendingActionError || null,\n        statusCode: 200,\n        loaderHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction(\"loader\", request, match, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath, {\n      isStaticRequest: true,\n      isRouteRequest,\n      requestContext\n    }))]);\n    if (request.signal.aborted) {\n      let method = isRouteRequest ? \"queryRoute\" : \"query\";\n      throw new Error(method + \"() call aborted: \" + request.method + \" \" + request.url);\n    }\n    // Process and commit output from loaders\n    let activeDeferreds = new Map();\n    let context = processRouteLoaderData(matches, matchesToLoad, results, pendingActionError, activeDeferreds);\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  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: 500,\n    errors: {\n      [context._deepestRenderedBoundaryId || routes[0].id]: error\n    }\n  });\n  return newContext;\n}\nfunction isSubmissionNavigation(opts) {\n  return opts != null && (\"formData\" in opts && opts.formData != null || \"body\" in opts && opts.body !== undefined);\n}\nfunction normalizeTo(location, matches, basename, prependBasename, to, v7_relativeSplatPath, fromRouteId, relative) {\n  let contextualMatches;\n  let activeRouteMatch;\n  if (fromRouteId) {\n    // Grab matches up to the calling route so our route-relative logic is\n    // relative to the correct source route\n    contextualMatches = [];\n    for (let match of matches) {\n      contextualMatches.push(match);\n      if (match.route.id === fromRouteId) {\n        activeRouteMatch = match;\n        break;\n      }\n    }\n  } else {\n    contextualMatches = matches;\n    activeRouteMatch = matches[matches.length - 1];\n  }\n  // Resolve the relative path\n  let path = resolveTo(to ? to : \".\", getResolveToMatches(contextualMatches, v7_relativeSplatPath), stripBasename(location.pathname, basename) || location.pathname, relative === \"path\");\n  // When `to` is not specified we inherit search/hash from the current\n  // location, unlike when to=\".\" and we just inherit the path.\n  // See https://github.com/remix-run/remix/issues/927\n  if (to == null) {\n    path.search = location.search;\n    path.hash = location.hash;\n  }\n  // Add an ?index param for matched index routes if we don't already have one\n  if ((to == null || to === \"\" || to === \".\") && activeRouteMatch && activeRouteMatch.route.index && !hasNakedIndexQuery(path.search)) {\n    path.search = path.search ? path.search.replace(/^\\?/, \"?index&\") : \"?index\";\n  }\n  // If we're operating within a basename, prepend it to the pathname.  If\n  // this is a root navigation, then just use the raw basename which allows\n  // the basename to have full control over the presence of a trailing slash\n  // on root actions\n  if (prependBasename && basename !== \"/\") {\n    path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n  return createPath(path);\n}\n// Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\nfunction normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {\n  // Return location verbatim on non-submission navigations\n  if (!opts || !isSubmissionNavigation(opts)) {\n    return {\n      path\n    };\n  }\n  if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n    return {\n      path,\n      error: getInternalRouterError(405, {\n        method: opts.formMethod\n      })\n    };\n  }\n  let getInvalidBodyError = () => ({\n    path,\n    error: getInternalRouterError(400, {\n      type: \"invalid-body\"\n    })\n  });\n  // Create a Submission on non-GET navigations\n  let rawFormMethod = opts.formMethod || \"get\";\n  let formMethod = normalizeFormMethod ? rawFormMethod.toUpperCase() : rawFormMethod.toLowerCase();\n  let formAction = stripHashFromPath(path);\n  if (opts.body !== undefined) {\n    if (opts.formEncType === \"text/plain\") {\n      // text only support POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n      let text = typeof opts.body === \"string\" ? opts.body : opts.body instanceof FormData || opts.body instanceof URLSearchParams ?\n      // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data\n      Array.from(opts.body.entries()).reduce((acc, _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 below any caught error as they aren't going to\n// render so we don't need to load them\nfunction getLoaderMatchesUntilBoundary(matches, boundaryId) {\n  let boundaryMatches = matches;\n  if (boundaryId) {\n    let index = matches.findIndex(m => m.route.id === boundaryId);\n    if (index >= 0) {\n      boundaryMatches = matches.slice(0, index);\n    }\n  }\n  return boundaryMatches;\n}\nfunction getMatchesToLoad(history, state, matches, submission, location, isInitialLoad, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionData, pendingError) {\n  let actionResult = pendingError ? Object.values(pendingError)[0] : pendingActionData ? Object.values(pendingActionData)[0] : undefined;\n  let currentUrl = history.createURL(state.location);\n  let nextUrl = history.createURL(location);\n  // Pick navigation matches that are net-new or qualify for revalidation\n  let boundaryId = pendingError ? Object.keys(pendingError)[0] : undefined;\n  let boundaryMatches = getLoaderMatchesUntilBoundary(matches, boundaryId);\n  let navigationMatches = boundaryMatches.filter((match, index) => {\n    if (isInitialLoad) {\n      // On initial hydration we don't do any shouldRevalidate stuff - we just\n      // call the unhydrated loaders\n      return isUnhydratedRoute(state, match.route);\n    }\n    if (match.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 (match.route.loader == null) {\n      return false;\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      defaultShouldRevalidate:\n      // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate\n      isRevalidationRequired ||\n      // Clicked the same link, resubmitted a GET form\n      currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search ||\n      // Search params affect all loaders\n      currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)\n    }));\n  });\n  // Pick fetcher.loads that need to be revalidated\n  let revalidatingFetchers = [];\n  fetchLoadMatches.forEach((f, key) => {\n    // Don't revalidate:\n    //  - on initial load (shouldn't be any fetchers then anyway)\n    //  - if fetcher won't be present in the subsequent render\n    //    - no longer matches the URL (v7_fetcherPersist=false)\n    //    - was unmounted but persisted due to v7_fetcherPersist=true\n    if (isInitialLoad || !matches.some(m => m.route.id === f.routeId) || deletedFetchers.has(key)) {\n      return;\n    }\n    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);\n    // If the fetcher path no longer matches, push it in with null matches so\n    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is\n    // currently only a use-case for Remix HMR where the route tree can change\n    // at runtime and remove a route previously loaded via a fetcher\n    if (!fetcherMatches) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: null,\n        match: null,\n        controller: null\n      });\n      return;\n    }\n    // Revalidating fetchers are decoupled from the route matches since they\n    // load from a static href.  They revalidate based on explicit revalidation\n    // (submission, useRevalidator, or X-Remix-Revalidate)\n    let fetcher = state.fetchers.get(key);\n    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);\n    let shouldRevalidate = false;\n    if (fetchRedirectIds.has(key)) {\n      // Never trigger a revalidation of an actively redirecting fetcher\n      shouldRevalidate = false;\n    } else if (cancelledFetcherLoads.includes(key)) {\n      // Always revalidate if the fetcher was cancelled\n      shouldRevalidate = true;\n    } else if (fetcher && fetcher.state !== \"idle\" && fetcher.data === undefined) {\n      // If the fetcher hasn't ever completed loading yet, then this isn't a\n      // revalidation, it would just be a brand new load if an explicit\n      // revalidation is required\n      shouldRevalidate = isRevalidationRequired;\n    } else {\n      // Otherwise fall back on any user-defined shouldRevalidate, defaulting\n      // to explicit revalidations only\n      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({\n        currentUrl,\n        currentParams: state.matches[state.matches.length - 1].params,\n        nextUrl,\n        nextParams: matches[matches.length - 1].params\n      }, submission, {\n        actionResult,\n        defaultShouldRevalidate: 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}\n// Is this route unhydrated (when v7_partialHydration=true) such that we need\n// to call it's loader on the initial router creation\nfunction isUnhydratedRoute(state, route) {\n  if (!route.loader) {\n    return false;\n  }\n  if (route.loader.hydrate) {\n    return true;\n  }\n  return state.loaderData[route.id] === undefined && (!state.errors ||\n  // Loader ran but errored - don't re-run\n  state.errors[route.id] === undefined);\n}\nfunction isNewLoader(currentLoaderData, currentMatch, match) {\n  let isNew =\n  // [a] -> [a, b]\n  !currentMatch ||\n  // [a, b] -> [a, c]\n  match.route.id !== currentMatch.route.id;\n  // Handle the case that we don't have data for a re-used route, potentially\n  // from a prior error or from a cancelled pending deferred\n  let isMissingData = currentLoaderData[match.route.id] === undefined;\n  // Always load if this is a net-new route or we don't yet have data\n  return isNew || isMissingData;\n}\nfunction isNewRouteInstance(currentMatch, match) {\n  let currentPath = currentMatch.route.path;\n  return (\n    // param change for this match, /users/123 -> /users/456\n    currentMatch.pathname !== match.pathname ||\n    // splat param changed, which is not present in match.path\n    // e.g. /files/images/avatar.jpg -> files/finances.xls\n    currentPath != null && currentPath.endsWith(\"*\") && currentMatch.params[\"*\"] !== match.params[\"*\"]\n  );\n}\nfunction shouldRevalidateLoader(loaderMatch, arg) {\n  if (loaderMatch.route.shouldRevalidate) {\n    let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n  return arg.defaultShouldRevalidate;\n}\n/**\n * Execute route.lazy() methods to lazily load route modules (loader, action,\n * shouldRevalidate) and update the routeManifest in place which shares objects\n * with dataRoutes so those get updated as well.\n */\nasync function loadLazyRouteModule(route, mapRouteProperties, manifest) {\n  if (!route.lazy) {\n    return;\n  }\n  let lazyRoute = await route.lazy();\n  // If the lazy route function was executed and removed by another parallel\n  // call then we can return - first lazy() to finish wins because the return\n  // value of lazy is expected to be static\n  if (!route.lazy) {\n    return;\n  }\n  let routeToUpdate = manifest[route.id];\n  invariant(routeToUpdate, \"No route found in manifest\");\n  // Update the route in place.  This should be safe because there's no way\n  // we could yet be sitting on this route as we can't get there without\n  // resolving lazy() first.\n  //\n  // This is different than the HMR \"update\" use-case where we may actively be\n  // on the route being updated.  The main concern boils down to \"does this\n  // mutation affect any ongoing navigations or any current state.matches\n  // values?\".  If not, it should be safe to update in place.\n  let routeUpdates = {};\n  for (let lazyRouteProperty in lazyRoute) {\n    let staticRouteValue = routeToUpdate[lazyRouteProperty];\n    let isPropertyStaticallyDefined = staticRouteValue !== undefined &&\n    // This property isn't static since it should always be updated based\n    // on the route updates\n    lazyRouteProperty !== \"hasErrorBoundary\";\n    warning(!isPropertyStaticallyDefined, \"Route \\\"\" + routeToUpdate.id + \"\\\" has a static property \\\"\" + lazyRouteProperty + \"\\\" \" + \"defined but its lazy function is also returning a value for this property. \" + (\"The lazy route property \\\"\" + lazyRouteProperty + \"\\\" will be ignored.\"));\n    if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {\n      routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];\n    }\n  }\n  // Mutate the route with the provided updates.  Do this first so we pass\n  // the updated version to mapRouteProperties\n  Object.assign(routeToUpdate, routeUpdates);\n  // Mutate the `hasErrorBoundary` property on the route based on the route\n  // updates and remove the `lazy` function so we don't resolve the lazy\n  // route again.\n  Object.assign(routeToUpdate, _extends({}, mapRouteProperties(routeToUpdate), {\n    lazy: undefined\n  }));\n}\nasync function callLoaderOrAction(type, request, match, matches, manifest, mapRouteProperties, basename, v7_relativeSplatPath, opts) {\n  if (opts === void 0) {\n    opts = {};\n  }\n  let resultType;\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    let abortPromise = new Promise((_, r) => reject = r);\n    onReject = () => reject();\n    request.signal.addEventListener(\"abort\", onReject);\n    return Promise.race([handler({\n      request,\n      params: match.params,\n      context: opts.requestContext\n    }), abortPromise]);\n  };\n  try {\n    let handler = match.route[type];\n    if (match.route.lazy) {\n      if (handler) {\n        // Run statically defined handler in parallel with lazy()\n        let handlerError;\n        let values = await Promise.all([\n        // If the handler throws, don't let it immediately bubble out,\n        // since we need to let the lazy() execution finish so we know if this\n        // route has a boundary that can handle the error\n        runHandler(handler).catch(e => {\n          handlerError = e;\n        }), loadLazyRouteModule(match.route, mapRouteProperties, manifest)]);\n        if (handlerError) {\n          throw handlerError;\n        }\n        result = values[0];\n      } else {\n        // Load lazy route module, then run any returned handler\n        await loadLazyRouteModule(match.route, mapRouteProperties, manifest);\n        handler = match.route[type];\n        if (handler) {\n          // Handler still run 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            data: 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 !== 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    resultType = ResultType.error;\n    result = e;\n  } finally {\n    if (onReject) {\n      request.signal.removeEventListener(\"abort\", onReject);\n    }\n  }\n  if (isResponse(result)) {\n    let status = result.status;\n    // Process redirects\n    if (redirectStatusCodes.has(status)) {\n      let location = result.headers.get(\"Location\");\n      invariant(location, \"Redirects returned/thrown from loaders/actions must have a Location header\");\n      // Support relative routing in internal redirects\n      if (!ABSOLUTE_URL_REGEX.test(location)) {\n        location = normalizeTo(new URL(request.url), matches.slice(0, matches.indexOf(match) + 1), basename, true, location, v7_relativeSplatPath);\n      } else if (!opts.isStaticRequest) {\n        // Strip off the protocol+origin for same-origin + same-basename absolute\n        // redirects. If this is a static request, we can let it go back to the\n        // browser as-is\n        let currentUrl = new URL(request.url);\n        let url = location.startsWith(\"//\") ? new URL(currentUrl.protocol + location) : new URL(location);\n        let isSameBasename = stripBasename(url.pathname, basename) != null;\n        if (url.origin === currentUrl.origin && isSameBasename) {\n          location = url.pathname + url.search + url.hash;\n        }\n      }\n      // Don't process redirects in the router during static requests requests.\n      // Instead, throw the Response and let the server handle it with an HTTP\n      // redirect.  We also update the Location header in place in this flow so\n      // basename and relative routing is taken into account\n      if (opts.isStaticRequest) {\n        result.headers.set(\"Location\", location);\n        throw result;\n      }\n      return {\n        type: ResultType.redirect,\n        status,\n        location,\n        revalidate: result.headers.get(\"X-Remix-Revalidate\") !== null,\n        reloadDocument: result.headers.get(\"X-Remix-Reload-Document\") !== null\n      };\n    }\n    // For SSR single-route requests, we want to hand Responses back directly\n    // without unwrapping.  We do this with the QueryRouteResponse wrapper\n    // interface so we can know whether it was returned or thrown\n    if (opts.isRouteRequest) {\n      let queryRouteResponse = {\n        type: resultType === ResultType.error ? ResultType.error : ResultType.data,\n        response: result\n      };\n      throw queryRouteResponse;\n    }\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        data = await result.json();\n      } else {\n        data = await result.text();\n      }\n    } catch (e) {\n      return {\n        type: ResultType.error,\n        error: e\n      };\n    }\n    if (resultType === ResultType.error) {\n      return {\n        type: resultType,\n        error: new ErrorResponseImpl(status, result.statusText, data),\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 (resultType === ResultType.error) {\n    return {\n      type: resultType,\n      error: result\n    };\n  }\n  if (isDeferredData(result)) {\n    var _result$init, _result$init2;\n    return {\n      type: ResultType.deferred,\n      deferredData: result,\n      statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status,\n      headers: ((_result$init2 = result.init) == null ? void 0 : _result$init2.headers) && new Headers(result.init.headers)\n    };\n  }\n  return {\n    type: ResultType.data,\n    data: result\n  };\n}\n// Utility method for creating the Request instances for loaders/actions during\n// client-side navigations and fetches.  During SSR we will always have a\n// Request instance from the static handler (query/queryRoute)\nfunction createClientSideRequest(history, location, signal, submission) {\n  let url = history.createURL(stripHashFromPath(location)).toString();\n  let init = {\n    signal\n  };\n  if (submission && isMutationMethod(submission.formMethod)) {\n    let {\n      formMethod,\n      formEncType\n    } = submission;\n    // Didn't think we needed this but it turns out unlike other methods, patch\n    // won't be properly normalized to uppercase and results in a 405 error.\n    // See: https://fetch.spec.whatwg.org/#concept-method\n    init.method = formMethod.toUpperCase();\n    if (formEncType === \"application/json\") {\n      init.headers = new Headers({\n        \"Content-Type\": formEncType\n      });\n      init.body = JSON.stringify(submission.json);\n    } else if (formEncType === \"text/plain\") {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.text;\n    } else if (formEncType === \"application/x-www-form-urlencoded\" && submission.formData) {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = convertFormDataToSearchParams(submission.formData);\n    } else {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.formData;\n    }\n  }\n  return new Request(url, init);\n}\nfunction convertFormDataToSearchParams(formData) {\n  let searchParams = new URLSearchParams();\n  for (let [key, value] of formData.entries()) {\n    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs\n    searchParams.append(key, typeof value === \"string\" ? value : value.name);\n  }\n  return searchParams;\n}\nfunction convertSearchParamsToFormData(searchParams) {\n  let formData = new FormData();\n  for (let [key, value] of searchParams.entries()) {\n    formData.append(key, value);\n  }\n  return formData;\n}\nfunction processRouteLoaderData(matches, matchesToLoad, results, pendingError, activeDeferreds) {\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  // Process loader results into state.loaderData/state.errors\n  results.forEach((result, index) => {\n    let id = matchesToLoad[index].route.id;\n    invariant(!isRedirectResult(result), \"Cannot handle redirect results in processLoaderData\");\n    if (isErrorResult(result)) {\n      // Look upwards from the matched route for the closest ancestor\n      // error boundary, defaulting to the root match\n      let boundaryMatch = findNearestBoundary(matches, id);\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) {\n        error = Object.values(pendingError)[0];\n        pendingError = undefined;\n      }\n      errors = errors || {};\n      // Prefer higher error values if lower errors bubble to the same boundary\n      if (errors[boundaryMatch.route.id] == null) {\n        errors[boundaryMatch.route.id] = error;\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      } else {\n        loaderData[id] = result.data;\n      }\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    }\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) {\n    errors = pendingError;\n    loaderData[Object.keys(pendingError)[0]] = undefined;\n  }\n  return {\n    loaderData,\n    errors,\n    statusCode: statusCode || 200,\n    loaderHeaders\n  };\n}\nfunction processLoaderData(state, matches, matchesToLoad, results, pendingError, revalidatingFetchers, fetcherResults, activeDeferreds) {\n  let {\n    loaderData,\n    errors\n  } = processRouteLoaderData(matches, matchesToLoad, results, pendingError, activeDeferreds);\n  // Process results from our revalidating fetchers\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let {\n      key,\n      match,\n      controller\n    } = revalidatingFetchers[index];\n    invariant(fetcherResults !== undefined && fetcherResults[index] !== undefined, \"Did not find corresponding fetcher result\");\n    let result = fetcherResults[index];\n    // Process fetcher non-redirect errors\n    if (controller && controller.signal.aborted) {\n      // Nothing to do for aborted fetchers\n      continue;\n    } else if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);\n      if (!(errors && errors[boundaryMatch.route.id])) {\n        errors = _extends({}, errors, {\n          [boundaryMatch.route.id]: result.error\n        });\n      }\n      state.fetchers.delete(key);\n    } else if (isRedirectResult(result)) {\n      // Should never get here, redirects should get processed above, but we\n      // keep this to type narrow to a success result in the else\n      invariant(false, \"Unhandled fetcher revalidation redirect\");\n    } else if (isDeferredResult(result)) {\n      // Should never get here, deferred data should be awaited for fetchers\n      // in resolveDeferredResults\n      invariant(false, \"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = getDoneFetcher(result.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n  return {\n    loaderData,\n    errors\n  };\n}\nfunction mergeLoaderData(loaderData, newLoaderData, matches, errors) {\n  let mergedLoaderData = _extends({}, newLoaderData);\n  for (let match of matches) {\n    let id = match.route.id;\n    if (newLoaderData.hasOwnProperty(id)) {\n      if (newLoaderData[id] !== undefined) {\n        mergedLoaderData[id] = newLoaderData[id];\n      }\n    } else if (loaderData[id] !== undefined && match.route.loader) {\n      // Preserve existing keys not included in newLoaderData and where a loader\n      // wasn't removed by HMR\n      mergedLoaderData[id] = loaderData[id];\n    }\n    if (errors && errors.hasOwnProperty(id)) {\n      // Don't keep any loader data below the boundary\n      break;\n    }\n  }\n  return mergedLoaderData;\n}\n// Find the nearest error boundary, looking upwards from the leaf route (or the\n// route specified by routeId) for the closest ancestor error boundary,\n// defaulting to the root match\nfunction findNearestBoundary(matches, routeId) {\n  let eligibleMatches = routeId ? matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1) : [...matches];\n  return eligibleMatches.reverse().find(m => m.route.hasErrorBoundary === true) || matches[0];\n}\nfunction getShortCircuitMatches(routes) {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route = routes.length === 1 ? routes[0] : routes.find(r => r.index || !r.path || r.path === \"/\") || {\n    id: \"__shim-error-route__\"\n  };\n  return {\n    matches: [{\n      params: {},\n      pathname: \"\",\n      pathnameBase: \"\",\n      route\n    }],\n    route\n  };\n}\nfunction getInternalRouterError(status, _temp5) {\n  let {\n    pathname,\n    routeId,\n    method,\n    type\n  } = _temp5 === void 0 ? {} : _temp5;\n  let statusText = \"Unknown Server Error\";\n  let errorMessage = \"Unknown @remix-run/router error\";\n  if (status === 400) {\n    statusText = \"Bad Request\";\n    if (method && pathname && routeId) {\n      errorMessage = \"You made a \" + method + \" request to \\\"\" + pathname + \"\\\" but \" + (\"did not provide a `loader` for route \\\"\" + routeId + \"\\\", \") + \"so there is no way to handle the request.\";\n    } else if (type === \"defer-action\") {\n      errorMessage = \"defer() is not supported in actions\";\n    } else if (type === \"invalid-body\") {\n      errorMessage = \"Unable to encode submission body\";\n    }\n  } else if (status === 403) {\n    statusText = \"Forbidden\";\n    errorMessage = \"Route \\\"\" + routeId + \"\\\" does not match URL \\\"\" + pathname + \"\\\"\";\n  } else if (status === 404) {\n    statusText = \"Not Found\";\n    errorMessage = \"No route matches URL \\\"\" + pathname + \"\\\"\";\n  } else if (status === 405) {\n    statusText = \"Method Not Allowed\";\n    if (method && pathname && routeId) {\n      errorMessage = \"You made a \" + method.toUpperCase() + \" request to \\\"\" + pathname + \"\\\" but \" + (\"did not provide an `action` for route \\\"\" + routeId + \"\\\", \") + \"so there is no way to handle the request.\";\n    } else if (method) {\n      errorMessage = \"Invalid request method \\\"\" + method.toUpperCase() + \"\\\"\";\n    }\n  }\n  return new ErrorResponseImpl(status || 500, statusText, new Error(errorMessage), true);\n}\n// Find any returned redirect errors, starting from the lowest match\nfunction findRedirect(results) {\n  for (let i = results.length - 1; i >= 0; i--) {\n    let result = results[i];\n    if (isRedirectResult(result)) {\n      return {\n        result,\n        idx: i\n      };\n    }\n  }\n}\nfunction stripHashFromPath(path) {\n  let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n  return createPath(_extends({}, parsedPath, {\n    hash: \"\"\n  }));\n}\nfunction isHashChangeOnly(a, b) {\n  if (a.pathname !== b.pathname || a.search !== b.search) {\n    return false;\n  }\n  if (a.hash === \"\") {\n    // /page -> /page#hash\n    return b.hash !== \"\";\n  } else if (a.hash === b.hash) {\n    // /page#hash -> /page#hash\n    return true;\n  } else if (b.hash !== \"\") {\n    // /page#hash -> /page#other\n    return true;\n  }\n  // If the hash is removed the browser will re-perform a request to the server\n  // /page#hash -> /page\n  return false;\n}\nfunction isDeferredResult(result) {\n  return result.type === ResultType.deferred;\n}\nfunction isErrorResult(result) {\n  return result.type === ResultType.error;\n}\nfunction isRedirectResult(result) {\n  return (result && result.type) === ResultType.redirect;\n}\nfunction isDeferredData(value) {\n  let deferred = value;\n  return deferred && typeof deferred === \"object\" && typeof deferred.data === \"object\" && typeof deferred.subscribe === \"function\" && typeof deferred.cancel === \"function\" && typeof deferred.resolveData === \"function\";\n}\nfunction isResponse(value) {\n  return value != null && typeof value.status === \"number\" && typeof value.statusText === \"string\" && typeof value.headers === \"object\" && typeof value.body !== \"undefined\";\n}\nfunction isRedirectResponse(result) {\n  if (!isResponse(result)) {\n    return false;\n  }\n  let status = result.status;\n  let location = result.headers.get(\"Location\");\n  return status >= 300 && status <= 399 && location != null;\n}\nfunction isQueryRouteResponse(obj) {\n  return obj && isResponse(obj.response) && (obj.type === ResultType.data || obj.type === ResultType.error);\n}\nfunction isValidMethod(method) {\n  return validRequestMethods.has(method.toLowerCase());\n}\nfunction isMutationMethod(method) {\n  return validMutationMethods.has(method.toLowerCase());\n}\nasync function resolveDeferredResults(currentMatches, matchesToLoad, results, signals, isFetcher, currentLoaderData) {\n  for (let index = 0; index < results.length; index++) {\n    let result = results[index];\n    let match = matchesToLoad[index];\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n    let currentMatch = currentMatches.find(m => m.route.id === match.route.id);\n    let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\n    if (isDeferredResult(result) && (isFetcher || isRevalidatingLoader)) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      let signal = signals[index];\n      invariant(signal, \"Expected an AbortSignal for revalidating fetcher deferred result\");\n      await resolveDeferredData(result, signal, isFetcher).then(result => {\n        if (result) {\n          results[index] = result || results[index];\n        }\n      });\n    }\n  }\n}\nasync function resolveDeferredData(result, signal, unwrap) {\n  if (unwrap === void 0) {\n    unwrap = false;\n  }\n  let aborted = await result.deferredData.resolveData(signal);\n  if (aborted) {\n    return;\n  }\n  if (unwrap) {\n    try {\n      return {\n        type: ResultType.data,\n        data: result.deferredData.unwrappedData\n      };\n    } catch (e) {\n      // Handle any TrackedPromise._error values encountered while unwrapping\n      return {\n        type: ResultType.error,\n        error: e\n      };\n    }\n  }\n  return {\n    type: ResultType.data,\n    data: result.deferredData.data\n  };\n}\nfunction hasNakedIndexQuery(search) {\n  return new URLSearchParams(search).getAll(\"index\").some(v => v === \"\");\n}\nfunction getTargetMatch(matches, location) {\n  let search = typeof location === \"string\" ? parsePath(location).search : location.search;\n  if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || \"\")) {\n    // Return the leaf index route when index is present\n    return matches[matches.length - 1];\n  }\n  // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n  // pathless layout routes)\n  let pathMatches = getPathContributingMatches(matches);\n  return pathMatches[pathMatches.length - 1];\n}\nfunction getSubmissionFromNavigation(navigation) {\n  let {\n    formMethod,\n    formAction,\n    formEncType,\n    text,\n    formData,\n    json\n  } = navigation;\n  if (!formMethod || !formAction || !formEncType) {\n    return;\n  }\n  if (text != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json: undefined,\n      text\n    };\n  } else if (formData != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData,\n      json: undefined,\n      text: undefined\n    };\n  } else if (json !== undefined) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json,\n      text: undefined\n    };\n  }\n}\nfunction getLoadingNavigation(location, submission) {\n  if (submission) {\n    let navigation = {\n      state: \"loading\",\n      location,\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text\n    };\n    return navigation;\n  } else {\n    let navigation = {\n      state: \"loading\",\n      location,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined\n    };\n    return navigation;\n  }\n}\nfunction getSubmittingNavigation(location, submission) {\n  let navigation = {\n    state: \"submitting\",\n    location,\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text\n  };\n  return navigation;\n}\nfunction getLoadingFetcher(submission, data) {\n  if (submission) {\n    let fetcher = {\n      state: \"loading\",\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n      data\n    };\n    return fetcher;\n  } else {\n    let fetcher = {\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n      data\n    };\n    return fetcher;\n  }\n}\nfunction getSubmittingFetcher(submission, existingFetcher) {\n  let fetcher = {\n    state: \"submitting\",\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n    data: existingFetcher ? existingFetcher.data : undefined\n  };\n  return fetcher;\n}\nfunction getDoneFetcher(data) {\n  let fetcher = {\n    state: \"idle\",\n    formMethod: undefined,\n    formAction: undefined,\n    formEncType: undefined,\n    formData: undefined,\n    json: undefined,\n    text: undefined,\n    data\n  };\n  return fetcher;\n}\nfunction restoreAppliedTransitions(_window, transitions) {\n  try {\n    let sessionPositions = _window.sessionStorage.getItem(TRANSITIONS_STORAGE_KEY);\n    if (sessionPositions) {\n      let json = JSON.parse(sessionPositions);\n      for (let [k, v] of Object.entries(json || {})) {\n        if (v && Array.isArray(v)) {\n          transitions.set(k, new Set(v || []));\n        }\n      }\n    }\n  } catch (e) {\n    // no-op, use default empty object\n  }\n}\nfunction persistAppliedTransitions(_window, transitions) {\n  if (transitions.size > 0) {\n    let json = {};\n    for (let [k, v] of transitions) {\n      json[k] = [...v];\n    }\n    try {\n      _window.sessionStorage.setItem(TRANSITIONS_STORAGE_KEY, JSON.stringify(json));\n    } catch (error) {\n      warning(false, \"Failed to save applied view transitions in sessionStorage (\" + error + \").\");\n    }\n  }\n}\n//#endregion\n\nexport { AbortedDeferredError, Action, IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, UNSAFE_DEFERRED_SYMBOL, DeferredData as UNSAFE_DeferredData, ErrorResponseImpl as UNSAFE_ErrorResponseImpl, convertRouteMatchToUiMatch as UNSAFE_convertRouteMatchToUiMatch, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, getResolveToMatches as UNSAFE_getResolveToMatches, invariant as UNSAFE_invariant, warning as UNSAFE_warning, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, createRouter, createStaticHandler, defer, generatePath, getStaticContextFromError, getToPathname, isDeferredData, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, parsePath, redirect, redirectDocument, resolvePath, resolveTo, stripBasename };\n//# sourceMappingURL=router.js.map\n"],"names":["_extends","target","i","source","key","Action","PopStateEventType","createMemoryHistory","options","initialEntries","initialIndex","v5Compat","entries","entry","index","createMemoryLocation","clampIndex","action","listener","n","getCurrentLocation","to","state","location","createLocation","warning","createHref","createPath","path","parsePath","nextLocation","delta","nextIndex","fn","createBrowserHistory","createBrowserLocation","window","globalHistory","pathname","search","hash","createBrowserHref","getUrlBasedHistory","createHashHistory","createHashLocation","createHashHref","base","href","url","hashIndex","validateHashLocation","invariant","value","message","cond","createKey","getHistoryState","current","_ref","parsedPath","searchIndex","getLocation","validateLocation","getIndex","handlePop","history","push","historyState","error","replace","createURL","ResultType","immutableRouteKeys","isIndexRoute","route","convertRoutesToDataRoutes","routes","mapRouteProperties","parentPath","manifest","treePath","id","indexRoute","pathOrLayoutRoute","matchRoutes","locationArg","basename","stripBasename","branches","flattenRoutes","rankRouteBranches","matches","matchRouteBranch","safelyDecodeURI","convertRouteMatchToUiMatch","match","loaderData","params","parentsMeta","flattenRoute","relativePath","meta","joinPaths","routesMeta","computeScore","_route$path","exploded","explodeOptionalSegments","segments","first","rest","isOptional","required","restExploded","result","subpath","a","b","compareIndexes","paramRe","dynamicSegmentValue","indexRouteValue","emptySegmentValue","staticSegmentValue","splatPenalty","isSplat","s","initialScore","score","segment","branch","matchedParams","matchedPathname","end","remainingPathname","matchPath","normalizePathname","generatePath","originalPath","prefix","stringify","p","array","keyMatch","optional","param","pattern","matcher","compiledParams","compilePath","pathnameBase","captureGroups","memo","paramName","splatValue","safelyDecodeURIComponent","caseSensitive","regexpSource","_","startIndex","nextChar","resolvePath","fromPathname","toPathname","resolvePathname","normalizeSearch","normalizeHash","getInvalidPathError","char","field","dest","getPathContributingMatches","getResolveToMatches","v7_relativeSplatPath","pathMatches","idx","resolveTo","toArg","routePathnames","locationPathname","isPathRelative","isEmptyPath","from","fromSegments","toSegments","routePathnameIndex","hasExplicitTrailingSlash","hasCurrentTrailingSlash","getToPathname","paths","json","data","init","responseInit","headers","AbortedDeferredError","DeferredData","reject","r","onAbort","acc","_ref2","promise","undefinedError","aborted","settledKey","subscriber","v","k","signal","resolve","_ref3","unwrapTrackedPromise","isTrackedPromise","defer","redirect","redirectDocument","response","ErrorResponseImpl","status","statusText","internal","isRouteErrorResponse","validMutationMethodsArr","validMutationMethods","validRequestMethodsArr","validRequestMethods","redirectStatusCodes","redirectPreserveMethodStatusCodes","IDLE_NAVIGATION","IDLE_FETCHER","IDLE_BLOCKER","ABSOLUTE_URL_REGEX","defaultMapRouteProperties","TRANSITIONS_STORAGE_KEY","createRouter","routerWindow","isBrowser","isServer","detectErrorBoundary","dataRoutes","inFlightDataRoutes","future","unlistenHistory","subscribers","savedScrollPositions","getScrollRestorationKey","getScrollPosition","initialScrollRestored","initialMatches","initialErrors","getInternalRouterError","getShortCircuitMatches","initialized","hasLazyRoutes","m","hasLoaders","errors","router","pendingAction","pendingPreventScrollReset","pendingNavigationController","pendingViewTransitionEnabled","appliedViewTransitions","removePageHideEventListener","isUninterruptedRevalidation","isRevalidationRequired","cancelledDeferredRoutes","cancelledFetcherLoads","fetchControllers","incrementingLoadId","pendingNavigationLoadId","fetchReloadIds","fetchRedirectIds","fetchLoadMatches","activeFetchers","deletedFetchers","activeDeferreds","blockerFunctions","ignoreNextHistoryUpdate","initialize","historyAction","blockerKey","shouldBlockNavigation","updateBlocker","blockers","updateState","startNavigation","restoreAppliedTransitions","_saveAppliedTransitions","persistAppliedTransitions","dispose","deleteFetcher","deleteBlocker","subscribe","newState","opts","completedFetchers","deletedFetchersKeys","fetcher","completeNavigation","_temp","_location$state","_location$state2","flushSync","isActionReload","isMutationMethod","actionData","mergeLoaderData","preventScrollReset","viewTransitionOpts","priorPaths","toPaths","getSavedScrollPosition","navigate","normalizedPath","normalizeTo","submission","normalizeNavigateOptions","currentLocation","userReplace","revalidate","interruptActiveLoads","saveScrollPosition","routesToUse","loadingNavigation","notFoundMatches","cancelActiveDeferreds","isHashChangeOnly","request","createClientSideRequest","pendingActionData","pendingError","findNearestBoundary","actionOutput","handleAction","getLoadingNavigation","shortCircuited","handleLoaders","navigation","getSubmittingNavigation","actionMatch","getTargetMatch","callLoaderOrAction","isRedirectResult","startRedirectNavigation","isErrorResult","boundaryMatch","isDeferredResult","overrideNavigation","fetcherSubmission","initialHydration","activeSubmission","getSubmissionFromNavigation","matchesToLoad","revalidatingFetchers","getMatchesToLoad","routeId","updatedFetchers","markFetchRedirectsDone","rf","revalidatingFetcher","getLoadingFetcher","abortFetcher","abortPendingFetchRevalidations","f","results","loaderResults","fetcherResults","callLoadersAndMaybeResolveData","findRedirect","fetcherKey","processLoaderData","deferredData","didAbortFetchLoads","abortStaleFetchLoads","shouldUpdateFetchers","fetch","setFetcherError","handleFetcherAction","handleFetcherLoader","requestMatches","existingFetcher","updateFetcherState","getSubmittingFetcher","abortController","fetchRequest","originatingLoadId","actionResult","getDoneFetcher","revalidationRequest","loadId","loadFetcher","staleKey","doneFetcher","resolveDeferredData","_temp2","redirectLocation","isDocumentReload","redirectHistoryAction","formMethod","formAction","formEncType","currentMatches","fetchersToLoad","resolveDeferredResults","getFetcher","deleteFetcherAndUpdateState","count","controller","markFetchersDone","keys","doneKeys","landedId","yeetedKeys","getBlocker","blocker","newBlocker","blockerFunction","predicate","cancelledRouteIds","dfd","enableScrollRestoration","positions","getPosition","getKey","y","getScrollKey","_internalSetRoutes","newRoutes","UNSAFE_DEFERRED_SYMBOL","createStaticHandler","query","_temp3","requestContext","method","isValidMethod","methodNotAllowedMatches","queryImpl","isResponse","queryRoute","_temp4","_result$activeDeferre","routeMatch","submit","loadRouteData","e","isQueryRouteResponse","isRedirectResponse","isRouteRequest","context","loaderRequest","pendingActionError","getLoaderMatchesUntilBoundary","processRouteLoaderData","executedLoaders","getStaticContextFromError","isSubmissionNavigation","prependBasename","fromRouteId","relative","contextualMatches","activeRouteMatch","hasNakedIndexQuery","normalizeFormMethod","isFetcher","getInvalidBodyError","rawFormMethod","stripHashFromPath","text","name","searchParams","formData","convertFormDataToSearchParams","convertSearchParamsToFormData","boundaryId","boundaryMatches","isInitialLoad","currentUrl","nextUrl","navigationMatches","isUnhydratedRoute","isNewLoader","currentRouteMatch","nextRouteMatch","shouldRevalidateLoader","isNewRouteInstance","fetcherMatches","fetcherMatch","shouldRevalidate","currentLoaderData","currentMatch","isNew","isMissingData","currentPath","loaderMatch","arg","routeChoice","loadLazyRouteModule","lazyRoute","routeToUpdate","routeUpdates","lazyRouteProperty","isPropertyStaticallyDefined","type","resultType","onReject","runHandler","handler","abortPromise","handlerError","values","isSameBasename","contentType","isDeferredData","_result$init","_result$init2","statusCode","foundError","loaderHeaders","newLoaderData","mergedLoaderData","_temp5","errorMessage","deferred","obj","signals","isRevalidatingLoader","unwrap","_window","transitions","sessionPositions"],"sourceRoot":""}