{"version":3,"file":"static/js/795_5be40ed658ac75ea8968.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@remix-run+router@1.8.0/node_modules/@remix-run/router/dist/router.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/reselect@4.1.8/node_modules/reselect/es/defaultMemoize.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/reselect@4.1.8/node_modules/reselect/es/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/remark-gfm@3.0.1/node_modules/remark-gfm/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/remark-parse@10.0.2/node_modules/remark-parse/lib/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/remark-rehype@10.1.0/node_modules/remark-rehype/lib/index.js"],"sourcesContent":["/**\n * @remix-run/router v1.8.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 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 explodes _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, paramNames] = 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 = paramNames.reduce((memo, paramName, index) => {\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    memo[paramName] = safelyDecodeURIComponent(captureGroups[index] || \"\", paramName);\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 paramNames = [];\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) => {\n    paramNames.push(paramName);\n    return \"/([^\\\\/]+)\";\n  });\n  if (path.endsWith(\"*\")) {\n    paramNames.push(\"*\");\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, paramNames];\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/**\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 (isPathRelative || toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n    if (toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\n      // Each leading .. segment means \"go up one route\" instead of \"go up one\n      // URL segment\".  This is a key difference from how <a href> works and a\n      // major reason we call this a \"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, _ref) => {\n      let [key, value] = _ref;\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, _ref2) => {\n      let [key, value] = _ref2;\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 */\nclass ErrorResponse {\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});\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_normalizeFormMethod: false,\n    v7_prependBasename: 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  // 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  !initialMatches.some(m => m.route.lazy) && (\n  // And we have to either have no loaders or have been provided hydrationData\n  !initialMatches.some(m => m.route.loader) || init.hydrationData != null);\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  // 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  // 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    // 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    }\n    return router;\n  }\n  // Clean up a router and it's side effects\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\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) {\n    state = _extends({}, state, newState);\n    subscribers.forEach(subscriber => subscriber(state));\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) {\n    var _location$state, _location$state2;\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    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    // Reset stateful navigation vars\n    pendingAction = Action.Pop;\n    pendingPreventScrollReset = 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, 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 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    });\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    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches = matchRoutes(routesToUse, location, basename);\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      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      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      });\n      if (actionOutput.shortCircuited) {\n        return;\n      }\n      pendingActionData = actionOutput.pendingActionData;\n      pendingError = actionOutput.pendingActionError;\n      loadingNavigation = getLoadingNavigation(location, opts.submission);\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, 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    // 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);\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, 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, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, 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      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 (!isUninterruptedRevalidation) {\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    }\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  function getFetcher(key) {\n    return state.fetchers.get(key) || IDLE_FETCHER;\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 routesToUse = inFlightDataRoutes || dataRoutes;\n    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, 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      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      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, 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, 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, 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      return;\n    }\n    // Put this fetcher into it's submitting state\n    let existingFetcher = state.fetchers.get(key);\n    let fetcher = getSubmittingFetcher(submission, existingFetcher);\n    state.fetchers.set(key, fetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\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);\n    if (fetchRequest.signal.aborted) {\n      // We can delete this so long as we weren't aborted by ou 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 (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        let doneFetcher = getDoneFetcher(undefined);\n        state.fetchers.set(key, doneFetcher);\n        updateState({\n          fetchers: new Map(state.fetchers)\n        });\n        return;\n      } else {\n        fetchRedirectIds.add(key);\n        let loadingFetcher = getLoadingFetcher(submission);\n        state.fetchers.set(key, loadingFetcher);\n        updateState({\n          fetchers: new Map(state.fetchers)\n        });\n        return startRedirectNavigation(state, actionResult, {\n          submission,\n          isFetchActionRedirect: true\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, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, 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    let didAbortFetchLoads = 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(_extends({\n        errors,\n        loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors)\n      }, didAbortFetchLoads || revalidatingFetchers.length > 0 ? {\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, submission) {\n    let existingFetcher = state.fetchers.get(key);\n    // Put this fetcher into it's loading state\n    let loadingFetcher = getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : undefined);\n    state.fetchers.set(key, loadingFetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\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);\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 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        let doneFetcher = getDoneFetcher(undefined);\n        state.fetchers.set(key, doneFetcher);\n        updateState({\n          fetchers: new Map(state.fetchers)\n        });\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      let boundaryMatch = findNearestBoundary(state.matches, routeId);\n      state.fetchers.delete(key);\n      // TODO: In remix, this would reset to IDLE_NAVIGATION if it was a catch -\n      // do we need to behave any differently with our non-redirect errors?\n      // What if it was a non-redirect Response?\n      updateState({\n        fetchers: new Map(state.fetchers),\n        errors: {\n          [boundaryMatch.route.id]: result.error\n        }\n      });\n      return;\n    }\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n    // Put the fetcher back into an idle state\n    let doneFetcher = getDoneFetcher(result.data);\n    state.fetchers.set(key, doneFetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\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, _temp) {\n    let {\n      submission,\n      replace,\n      isFetchActionRedirect\n    } = _temp === void 0 ? {} : _temp;\n    if (redirect.revalidate) {\n      isRevalidationRequired = true;\n    }\n    let redirectLocation = createLocation(state.location, redirect.location, // TODO: This can be removed once we get rid of useTransition in Remix v2\n    _extends({\n      _isRedirect: true\n    }, isFetchActionRedirect ? {\n      _isFetchActionRedirect: 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 activeSubmission = submission || getSubmissionFromNavigation(state.navigation);\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    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 if (isFetchActionRedirect) {\n      // For a fetch action redirect, we kick off a new loading navigation\n      // without the fetcher submission, but we send it along for shouldRevalidate\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        overrideNavigation: getLoadingNavigation(redirectLocation),\n        fetcherSubmission: activeSubmission,\n        // Preserve this flag across redirects\n        preventScrollReset: pendingPreventScrollReset\n      });\n    } else {\n      // If we have a submission, we will preserve it through the redirect navigation\n      let overrideNavigation = getLoadingNavigation(redirectLocation, activeSubmission);\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        overrideNavigation,\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)), ...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);\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 setFetcherError(key, routeId, error) {\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  }\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    state.fetchers.delete(key);\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 => createUseMatchesMatch(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 state() {\n      return state;\n    },\n    get routes() {\n      return dataRoutes;\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,\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  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, _temp2) {\n    let {\n      requestContext\n    } = _temp2 === void 0 ? {} : _temp2;\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, _temp3) {\n    let {\n      routeId,\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\" && 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, {\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\");\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, {\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\");\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, fromRouteId, relative) {\n  let contextualMatches;\n  let activeRouteMatch;\n  if (fromRouteId != null && relative !== \"path\") {\n    // Grab matches up to the calling route so our route-relative logic is\n    // relative to the correct source route.  When using relative:path,\n    // fromRouteId is ignored since that is always relative to the current\n    // location path\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 : \".\", getPathContributingMatches(contextualMatches).map(m => m.pathnameBase), 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, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, 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 (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 if fetcher won't be present in the subsequent render\n    if (!matches.some(m => m.route.id === f.routeId)) {\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}\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, 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 values = await Promise.all([runHandler(handler), loadLazyRouteModule(match.route, mapRouteProperties, manifest)]);\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);\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    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    if (resultType === ResultType.error) {\n      return {\n        type: resultType,\n        error: new ErrorResponse(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.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, _temp4) {\n  let {\n    pathname,\n    routeId,\n    method,\n    type\n  } = _temp4 === void 0 ? {} : _temp4;\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 ErrorResponse(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}\n// Note: This should match the format exported by useMatches, so if you change\n// this please also change that :)  Eventually we'll DRY this up\nfunction createUseMatchesMatch(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 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      \" _hasFetcherDoneAnything \": true\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      \" _hasFetcherDoneAnything \": true\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    \" _hasFetcherDoneAnything \": true\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    \" _hasFetcherDoneAnything \": true\n  };\n  return fetcher;\n}\n//#endregion\n\nexport { AbortedDeferredError, Action, ErrorResponse, IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, UNSAFE_DEFERRED_SYMBOL, DeferredData as UNSAFE_DeferredData, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, getPathContributingMatches as UNSAFE_getPathContributingMatches, 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","// Cache implementation based on Erik Rasmussen's `lru-memoize`:\n// https://github.com/erikras/lru-memoize\nvar NOT_FOUND = 'NOT_FOUND';\n\nfunction createSingletonCache(equals) {\n  var entry;\n  return {\n    get: function get(key) {\n      if (entry && equals(entry.key, key)) {\n        return entry.value;\n      }\n\n      return NOT_FOUND;\n    },\n    put: function put(key, value) {\n      entry = {\n        key: key,\n        value: value\n      };\n    },\n    getEntries: function getEntries() {\n      return entry ? [entry] : [];\n    },\n    clear: function clear() {\n      entry = undefined;\n    }\n  };\n}\n\nfunction createLruCache(maxSize, equals) {\n  var entries = [];\n\n  function get(key) {\n    var cacheIndex = entries.findIndex(function (entry) {\n      return equals(key, entry.key);\n    }); // We found a cached entry\n\n    if (cacheIndex > -1) {\n      var entry = entries[cacheIndex]; // Cached entry not at top of cache, move it to the top\n\n      if (cacheIndex > 0) {\n        entries.splice(cacheIndex, 1);\n        entries.unshift(entry);\n      }\n\n      return entry.value;\n    } // No entry found in cache, return sentinel\n\n\n    return NOT_FOUND;\n  }\n\n  function put(key, value) {\n    if (get(key) === NOT_FOUND) {\n      // TODO Is unshift slow?\n      entries.unshift({\n        key: key,\n        value: value\n      });\n\n      if (entries.length > maxSize) {\n        entries.pop();\n      }\n    }\n  }\n\n  function getEntries() {\n    return entries;\n  }\n\n  function clear() {\n    entries = [];\n  }\n\n  return {\n    get: get,\n    put: put,\n    getEntries: getEntries,\n    clear: clear\n  };\n}\n\nexport var defaultEqualityCheck = function defaultEqualityCheck(a, b) {\n  return a === b;\n};\nexport function createCacheKeyComparator(equalityCheck) {\n  return function areArgumentsShallowlyEqual(prev, next) {\n    if (prev === null || next === null || prev.length !== next.length) {\n      return false;\n    } // Do this in a for loop (and not a `forEach` or an `every`) so we can determine equality as fast as possible.\n\n\n    var length = prev.length;\n\n    for (var i = 0; i < length; i++) {\n      if (!equalityCheck(prev[i], next[i])) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n}\n// defaultMemoize now supports a configurable cache size with LRU behavior,\n// and optional comparison of the result value with existing values\nexport function defaultMemoize(func, equalityCheckOrOptions) {\n  var providedOptions = typeof equalityCheckOrOptions === 'object' ? equalityCheckOrOptions : {\n    equalityCheck: equalityCheckOrOptions\n  };\n  var _providedOptions$equa = providedOptions.equalityCheck,\n      equalityCheck = _providedOptions$equa === void 0 ? defaultEqualityCheck : _providedOptions$equa,\n      _providedOptions$maxS = providedOptions.maxSize,\n      maxSize = _providedOptions$maxS === void 0 ? 1 : _providedOptions$maxS,\n      resultEqualityCheck = providedOptions.resultEqualityCheck;\n  var comparator = createCacheKeyComparator(equalityCheck);\n  var cache = maxSize === 1 ? createSingletonCache(comparator) : createLruCache(maxSize, comparator); // we reference arguments instead of spreading them for performance reasons\n\n  function memoized() {\n    var value = cache.get(arguments);\n\n    if (value === NOT_FOUND) {\n      // @ts-ignore\n      value = func.apply(null, arguments);\n\n      if (resultEqualityCheck) {\n        var entries = cache.getEntries();\n        var matchingEntry = entries.find(function (entry) {\n          return resultEqualityCheck(entry.value, value);\n        });\n\n        if (matchingEntry) {\n          value = matchingEntry.value;\n        }\n      }\n\n      cache.put(arguments, value);\n    }\n\n    return value;\n  }\n\n  memoized.clearCache = function () {\n    return cache.clear();\n  };\n\n  return memoized;\n}","import { defaultMemoize, defaultEqualityCheck } from './defaultMemoize';\nexport { defaultMemoize, defaultEqualityCheck };\n\nfunction getDependencies(funcs) {\n  var dependencies = Array.isArray(funcs[0]) ? funcs[0] : funcs;\n\n  if (!dependencies.every(function (dep) {\n    return typeof dep === 'function';\n  })) {\n    var dependencyTypes = dependencies.map(function (dep) {\n      return typeof dep === 'function' ? \"function \" + (dep.name || 'unnamed') + \"()\" : typeof dep;\n    }).join(', ');\n    throw new Error(\"createSelector expects all input-selectors to be functions, but received the following types: [\" + dependencyTypes + \"]\");\n  }\n\n  return dependencies;\n}\n\nexport function createSelectorCreator(memoize) {\n  for (var _len = arguments.length, memoizeOptionsFromArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    memoizeOptionsFromArgs[_key - 1] = arguments[_key];\n  }\n\n  var createSelector = function createSelector() {\n    for (var _len2 = arguments.length, funcs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      funcs[_key2] = arguments[_key2];\n    }\n\n    var _recomputations = 0;\n\n    var _lastResult; // Due to the intricacies of rest params, we can't do an optional arg after `...funcs`.\n    // So, start by declaring the default value here.\n    // (And yes, the words 'memoize' and 'options' appear too many times in this next sequence.)\n\n\n    var directlyPassedOptions = {\n      memoizeOptions: undefined\n    }; // Normally, the result func or \"output selector\" is the last arg\n\n    var resultFunc = funcs.pop(); // If the result func is actually an _object_, assume it's our options object\n\n    if (typeof resultFunc === 'object') {\n      directlyPassedOptions = resultFunc; // and pop the real result func off\n\n      resultFunc = funcs.pop();\n    }\n\n    if (typeof resultFunc !== 'function') {\n      throw new Error(\"createSelector expects an output function after the inputs, but received: [\" + typeof resultFunc + \"]\");\n    } // Determine which set of options we're using. Prefer options passed directly,\n    // but fall back to options given to createSelectorCreator.\n\n\n    var _directlyPassedOption = directlyPassedOptions,\n        _directlyPassedOption2 = _directlyPassedOption.memoizeOptions,\n        memoizeOptions = _directlyPassedOption2 === void 0 ? memoizeOptionsFromArgs : _directlyPassedOption2; // Simplifying assumption: it's unlikely that the first options arg of the provided memoizer\n    // is an array. In most libs I've looked at, it's an equality function or options object.\n    // Based on that, if `memoizeOptions` _is_ an array, we assume it's a full\n    // user-provided array of options. Otherwise, it must be just the _first_ arg, and so\n    // we wrap it in an array so we can apply it.\n\n    var finalMemoizeOptions = Array.isArray(memoizeOptions) ? memoizeOptions : [memoizeOptions];\n    var dependencies = getDependencies(funcs);\n    var memoizedResultFunc = memoize.apply(void 0, [function recomputationWrapper() {\n      _recomputations++; // apply arguments instead of spreading for performance.\n\n      return resultFunc.apply(null, arguments);\n    }].concat(finalMemoizeOptions)); // If a selector is called with the exact same arguments we don't need to traverse our dependencies again.\n\n    var selector = memoize(function dependenciesChecker() {\n      var params = [];\n      var length = dependencies.length;\n\n      for (var i = 0; i < length; i++) {\n        // apply arguments instead of spreading and mutate a local list of params for performance.\n        // @ts-ignore\n        params.push(dependencies[i].apply(null, arguments));\n      } // apply arguments instead of spreading for performance.\n\n\n      _lastResult = memoizedResultFunc.apply(null, params);\n      return _lastResult;\n    });\n    Object.assign(selector, {\n      resultFunc: resultFunc,\n      memoizedResultFunc: memoizedResultFunc,\n      dependencies: dependencies,\n      lastResult: function lastResult() {\n        return _lastResult;\n      },\n      recomputations: function recomputations() {\n        return _recomputations;\n      },\n      resetRecomputations: function resetRecomputations() {\n        return _recomputations = 0;\n      }\n    });\n    return selector;\n  }; // @ts-ignore\n\n\n  return createSelector;\n}\nexport var createSelector = /* #__PURE__ */createSelectorCreator(defaultMemoize);\n// Manual definition of state and output arguments\nexport var createStructuredSelector = function createStructuredSelector(selectors, selectorCreator) {\n  if (selectorCreator === void 0) {\n    selectorCreator = createSelector;\n  }\n\n  if (typeof selectors !== 'object') {\n    throw new Error('createStructuredSelector expects first argument to be an object ' + (\"where each property is a selector, instead received a \" + typeof selectors));\n  }\n\n  var objectKeys = Object.keys(selectors);\n  var resultSelector = selectorCreator( // @ts-ignore\n  objectKeys.map(function (key) {\n    return selectors[key];\n  }), function () {\n    for (var _len3 = arguments.length, values = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n      values[_key3] = arguments[_key3];\n    }\n\n    return values.reduce(function (composition, value, index) {\n      composition[objectKeys[index]] = value;\n      return composition;\n    }, {});\n  });\n  return resultSelector;\n};","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('micromark-extension-gfm').Options & import('mdast-util-gfm').Options} Options\n */\n\nimport {gfm} from 'micromark-extension-gfm'\nimport {gfmFromMarkdown, gfmToMarkdown} from 'mdast-util-gfm'\n\n/**\n * Plugin to support GFM (autolink literals, footnotes, strikethrough, tables, tasklists).\n *\n * @type {import('unified').Plugin<[Options?]|void[], Root>}\n */\nexport default function remarkGfm(options = {}) {\n  const data = this.data()\n\n  add('micromarkExtensions', gfm(options))\n  add('fromMarkdownExtensions', gfmFromMarkdown())\n  add('toMarkdownExtensions', gfmToMarkdown(options))\n\n  /**\n   * @param {string} field\n   * @param {unknown} value\n   */\n  function add(field, value) {\n    const list = /** @type {unknown[]} */ (\n      // Other extensions\n      /* c8 ignore next 2 */\n      data[field] ? data[field] : (data[field] = [])\n    )\n\n    list.push(value)\n  }\n}\n","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast-util-from-markdown').Options} Options\n */\n\nimport {fromMarkdown} from 'mdast-util-from-markdown'\n\n/**\n * @this {import('unified').Processor}\n * @type {import('unified').Plugin<[Options?] | void[], string, Root>}\n */\nexport default function remarkParse(options) {\n  /** @type {import('unified').ParserFunction<Root>} */\n  const parser = (doc) => {\n    // Assume options.\n    const settings = /** @type {Options} */ (this.data('settings'))\n\n    return fromMarkdown(\n      doc,\n      Object.assign({}, settings, options, {\n        // Note: these options are not in the readme.\n        // The goal is for them to be set by plugins on `data` instead of being\n        // passed by users.\n        extensions: this.data('micromarkExtensions') || [],\n        mdastExtensions: this.data('fromMarkdownExtensions') || []\n      })\n    )\n  }\n\n  Object.assign(this, {Parser: parser})\n}\n","/**\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('mdast-util-to-hast').Options} Options\n * @typedef {import('unified').Processor<any, any, any, any>} Processor\n *\n * @typedef {import('mdast-util-to-hast')} DoNotTouchAsThisImportIncludesRawInTree\n */\n\nimport {toHast} from 'mdast-util-to-hast'\n\n// Note: the `<MdastRoot, HastRoot>` overload doesn’t seem to work :'(\n\n/**\n * Plugin that turns markdown into HTML to support rehype.\n *\n * *   If a destination processor is given, that processor runs with a new HTML\n *     (hast) tree (bridge-mode).\n *     As the given processor runs with a hast tree, and rehype plugins support\n *     hast, that means rehype plugins can be used with the given processor.\n *     The hast tree is discarded in the end.\n *     It’s highly unlikely that you want to do this.\n * *   The common case is to not pass a destination processor, in which case the\n *     current processor continues running with a new HTML (hast) tree\n *     (mutate-mode).\n *     As the current processor continues with a hast tree, and rehype plugins\n *     support hast, that means rehype plugins can be used after\n *     `remark-rehype`.\n *     It’s likely that this is what you want to do.\n *\n * @param destination\n *   Optional unified processor.\n * @param options\n *   Options passed to `mdast-util-to-hast`.\n */\nconst remarkRehype =\n  /** @type {(import('unified').Plugin<[Processor, Options?]|[null|undefined, Options?]|[Options]|[], MdastRoot>)} */\n  (\n    function (destination, options) {\n      return destination && 'run' in destination\n        ? bridge(destination, options)\n        : mutate(destination || options)\n    }\n  )\n\nexport default remarkRehype\n\n/**\n * Bridge-mode.\n * Runs the destination with the new hast tree.\n *\n * @type {import('unified').Plugin<[Processor, Options?], MdastRoot>}\n */\nfunction bridge(destination, options) {\n  return (node, file, next) => {\n    destination.run(toHast(node, options), file, (error) => {\n      next(error)\n    })\n  }\n}\n\n/**\n * Mutate-mode.\n * Further plugins run on the hast tree.\n *\n * @type {import('unified').Plugin<[Options?]|void[], MdastRoot, HastRoot>}\n */\nfunction mutate(options) {\n  // @ts-expect-error: assume a corresponding node is returned by `toHast`.\n  return (node) => toHast(node, options)\n}\n"],"names":["_extends","Object","assign","bind","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","apply","this","Action","PopStateEventType","createMemoryHistory","options","entries","initialEntries","initialIndex","v5Compat","map","entry","index","createMemoryLocation","state","undefined","clampIndex","action","Pop","listener","n","Math","min","max","getCurrentLocation","to","location","createLocation","pathname","warning","charAt","JSON","stringify","createHref","createPath","createURL","URL","encodeLocation","path","parsePath","search","hash","push","Push","nextLocation","splice","delta","replace","Replace","go","nextIndex","listen","fn","createBrowserHistory","getUrlBasedHistory","window","globalHistory","usr","createHashHistory","substr","startsWith","base","document","querySelector","href","getAttribute","url","hashIndex","indexOf","slice","invariant","value","message","Error","cond","console","warn","e","getHistoryState","idx","current","random","toString","_ref","parsedPath","searchIndex","getLocation","validateLocation","defaultView","history","getIndex","handlePop","origin","replaceState","addEventListener","removeEventListener","historyState","pushState","error","DOMException","name","ResultType","immutableRouteKeys","Set","convertRoutesToDataRoutes","routes","mapRouteProperties","parentPath","manifest","route","treePath","id","join","children","isIndexRoute","indexRoute","pathOrLayoutRoute","matchRoutes","locationArg","basename","stripBasename","branches","flattenRoutes","sort","a","b","score","siblings","every","compareIndexes","routesMeta","meta","childrenIndex","rankRouteBranches","matches","matchRouteBranch","safelyDecodeURI","parentsMeta","flattenRoute","relativePath","caseSensitive","joinPaths","concat","computeScore","forEach","_route$path","includes","exploded","explodeOptionalSegments","segments","split","first","rest","isOptional","endsWith","required","restExploded","result","subpath","paramRe","dynamicSegmentValue","indexRouteValue","emptySegmentValue","staticSegmentValue","splatPenalty","isSplat","s","initialScore","some","filter","reduce","segment","test","branch","matchedParams","matchedPathname","end","remainingPathname","match","matchPath","params","pathnameBase","normalizePathname","generatePath","originalPath","prefix","p","String","array","keyMatch","optional","param","pattern","matcher","paramNames","regexpSource","_","paramName","RegExp","compilePath","captureGroups","memo","splatValue","decodeURIComponent","safelyDecodeURIComponent","decodeURI","toLowerCase","startIndex","nextChar","resolvePath","fromPathname","toPathname","pop","resolvePathname","normalizeSearch","normalizeHash","getInvalidPathError","char","field","dest","getPathContributingMatches","resolveTo","toArg","routePathnames","locationPathname","isPathRelative","from","isEmptyPath","routePathnameIndex","toSegments","shift","hasExplicitTrailingSlash","hasCurrentTrailingSlash","paths","json","data","init","responseInit","status","headers","Headers","has","set","Response","AbortedDeferredError","DeferredData","constructor","reject","pendingKeysSet","subscribers","deferredKeys","Array","isArray","abortPromise","Promise","r","controller","AbortController","onAbort","unlistenAbortSignal","signal","acc","trackPromise","done","add","promise","race","then","onSettle","catch","defineProperty","get","aborted","delete","undefinedError","emit","settledKey","subscriber","subscribe","cancel","abort","v","k","resolveData","resolve","size","unwrappedData","_ref2","unwrapTrackedPromise","pendingKeys","_tracked","isTrackedPromise","_error","_data","defer","redirect","redirectDocument","response","ErrorResponse","statusText","internal","isRouteErrorResponse","validMutationMethodsArr","validMutationMethods","validRequestMethodsArr","validRequestMethods","redirectStatusCodes","redirectPreserveMethodStatusCodes","IDLE_NAVIGATION","formMethod","formAction","formEncType","formData","text","IDLE_FETCHER","IDLE_BLOCKER","proceed","reset","ABSOLUTE_URL_REGEX","defaultMapRouteProperties","hasErrorBoundary","Boolean","createRouter","routerWindow","isBrowser","createElement","isServer","detectErrorBoundary","inFlightDataRoutes","dataRoutes","future","v7_normalizeFormMethod","v7_prependBasename","unlistenHistory","savedScrollPositions","getScrollRestorationKey","getScrollPosition","initialScrollRestored","hydrationData","initialMatches","initialErrors","getInternalRouterError","getShortCircuitMatches","router","pendingNavigationController","initialized","m","lazy","loader","historyAction","navigation","restoreScrollPosition","preventScrollReset","revalidation","loaderData","actionData","errors","fetchers","Map","blockers","pendingAction","pendingPreventScrollReset","isUninterruptedRevalidation","isRevalidationRequired","cancelledDeferredRoutes","cancelledFetcherLoads","fetchControllers","incrementingLoadId","pendingNavigationLoadId","fetchReloadIds","fetchRedirectIds","fetchLoadMatches","activeDeferreds","blockerFunctions","ignoreNextHistoryUpdate","updateState","newState","completeNavigation","_location$state","_location$state2","isActionReload","isMutationMethod","_isRedirect","keys","mergeLoaderData","getSavedScrollPosition","async","startNavigation","opts","startUninterruptedRevalidation","getScrollKey","saveScrollPosition","routesToUse","loadingNavigation","overrideNavigation","notFoundMatches","cancelActiveDeferreds","isHashChangeOnly","submission","pendingActionData","pendingError","request","createClientSideRequest","findNearestBoundary","actionOutput","interruptActiveLoads","getSubmittingNavigation","actionMatch","getTargetMatch","callLoaderOrAction","shortCircuited","type","method","routeId","isRedirectResult","startRedirectNavigation","isErrorResult","boundaryMatch","pendingActionError","isDeferredResult","handleAction","getLoadingNavigation","Request","fetcherSubmission","activeSubmission","getSubmissionFromNavigation","matchesToLoad","revalidatingFetchers","getMatchesToLoad","updatedFetchers","markFetchRedirectsDone","rf","fetcher","revalidatingFetcher","getLoadingFetcher","abortFetcher","abortPendingFetchRevalidations","f","results","loaderResults","fetcherResults","callLoadersAndMaybeResolveData","findRedirect","fetcherKey","processLoaderData","deferredData","didAbortFetchLoads","abortStaleFetchLoads","shouldUpdateFetchers","handleLoaders","getFetcher","_temp","isFetchActionRedirect","revalidate","redirectLocation","_isFetchActionRedirect","isDocumentReload","reloadDocument","redirectHistoryAction","currentMatches","fetchersToLoad","all","resolveDeferredResults","setFetcherError","deleteFetcher","markFetchersDone","doneFetcher","getDoneFetcher","doneKeys","landedId","yeetedKeys","deleteBlocker","updateBlocker","newBlocker","blocker","shouldBlockNavigation","currentLocation","blockerKey","blockerFunction","predicate","cancelledRouteIds","dfd","handle","createUseMatchesMatch","y","initialize","enableScrollRestoration","positions","getPosition","getKey","navigate","normalizedPath","normalizeTo","fromRouteId","relative","normalizeNavigateOptions","userReplace","fetch","requestMatches","existingFetcher","getSubmittingFetcher","abortController","fetchRequest","originatingLoadId","actionResult","loadingFetcher","revalidationRequest","loadId","loadFetcher","staleKey","handleFetcherAction","resolveDeferredData","handleFetcherLoader","dispose","clear","getBlocker","_internalFetchControllers","_internalActiveDeferreds","_internalSetRoutes","newRoutes","Symbol","prependBasename","contextualMatches","activeRouteMatch","hasNakedIndexQuery","normalizeFormMethod","isFetcher","body","isSubmissionNavigation","isValidMethod","searchParams","getInvalidBodyError","rawFormMethod","toUpperCase","stripHashFromPath","FormData","URLSearchParams","_ref3","parse","convertFormDataToSearchParams","convertSearchParamsToFormData","append","getLoaderMatchesUntilBoundary","boundaryId","boundaryMatches","findIndex","values","currentUrl","nextUrl","navigationMatches","currentLoaderData","currentMatch","isNew","isMissingData","isNewLoader","currentRouteMatch","nextRouteMatch","shouldRevalidateLoader","currentParams","nextParams","defaultShouldRevalidate","isNewRouteInstance","fetcherMatches","fetcherMatch","shouldRevalidate","currentPath","loaderMatch","arg","routeChoice","loadLazyRouteModule","lazyRoute","routeToUpdate","routeUpdates","lazyRouteProperty","isPropertyStaticallyDefined","resultType","onReject","runHandler","handler","context","requestContext","isResponse","isStaticRequest","protocol","isSameBasename","isRouteRequest","contentType","statusCode","deferred","isDeferredData","_result$init","_result$init2","processRouteLoaderData","foundError","loaderHeaders","newLoaderData","mergedLoaderData","reverse","find","_temp4","errorMessage","signals","isRevalidatingLoader","unwrap","getAll","pathMatches","NOT_FOUND","defaultEqualityCheck","defaultMemoize","func","equalityCheckOrOptions","equals","providedOptions","equalityCheck","_providedOptions$equa","_providedOptions$maxS","maxSize","resultEqualityCheck","comparator","prev","next","createCacheKeyComparator","cache","put","getEntries","cacheIndex","unshift","createLruCache","memoized","matchingEntry","clearCache","createSelectorCreator","memoize","_len","memoizeOptionsFromArgs","_key","_len2","funcs","_key2","_lastResult","_recomputations","directlyPassedOptions","memoizeOptions","resultFunc","_directlyPassedOption2","finalMemoizeOptions","dependencies","dep","dependencyTypes","getDependencies","memoizedResultFunc","selector","lastResult","recomputations","resetRecomputations","createSelector","remarkGfm","remarkParse","Parser","doc","settings","extensions","mdastExtensions","destination","node","file","run","bridge","mutate"],"sourceRoot":""}