{"version":3,"file":"static/js/648.76d629ed.chunk.js","mappings":"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","sources":["webpack://portcodashboards-ui-module/./node_modules/@remix-run/router/dist/router.js","webpack://portcodashboards-ui-module/./node_modules/react-router/dist/index.js","webpack://portcodashboards-ui-module/./node_modules/react-router-dom/dist/index.js"],"sourcesContent":["/**\n * @remix-run/router v1.15.3\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Actions represent the type of change to a location value.\n */\nvar Action;\n(function (Action) {\n  /**\n   * A POP indicates a change to an arbitrary index in the history stack, such\n   * as a back or forward navigation. It does not describe the direction of the\n   * navigation, only that the current index changed.\n   *\n   * Note: This is the default action for newly created history objects.\n   */\n  Action[\"Pop\"] = \"POP\";\n  /**\n   * A PUSH indicates a new entry being added to the history stack, such as when\n   * a link is clicked and a new page loads. When this happens, all subsequent\n   * entries in the stack are lost.\n   */\n  Action[\"Push\"] = \"PUSH\";\n  /**\n   * A REPLACE indicates the entry at the current index in the history stack\n   * being replaced by a new one.\n   */\n  Action[\"Replace\"] = \"REPLACE\";\n})(Action || (Action = {}));\nconst PopStateEventType = \"popstate\";\n/**\n * Memory history stores the current location in memory. It is designed for use\n * in stateful non-browser environments like tests and React Native.\n */\nfunction createMemoryHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  let {\n    initialEntries = [\"/\"],\n    initialIndex,\n    v5Compat = false\n  } = options;\n  let entries; // Declare so we can access from createMemoryLocation\n  entries = initialEntries.map((entry, index) => createMemoryLocation(entry, typeof entry === \"string\" ? null : entry.state, index === 0 ? \"default\" : undefined));\n  let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);\n  let action = Action.Pop;\n  let listener = null;\n  function clampIndex(n) {\n    return Math.min(Math.max(n, 0), entries.length - 1);\n  }\n  function getCurrentLocation() {\n    return entries[index];\n  }\n  function createMemoryLocation(to, state, key) {\n    if (state === void 0) {\n      state = null;\n    }\n    let location = createLocation(entries ? getCurrentLocation().pathname : \"/\", to, state, key);\n    warning(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in memory history: \" + JSON.stringify(to));\n    return location;\n  }\n  function createHref(to) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n  let history = {\n    get index() {\n      return index;\n    },\n    get action() {\n      return action;\n    },\n    get location() {\n      return getCurrentLocation();\n    },\n    createHref,\n    createURL(to) {\n      return new URL(createHref(to), \"http://localhost\");\n    },\n    encodeLocation(to) {\n      let path = typeof to === \"string\" ? parsePath(to) : to;\n      return {\n        pathname: path.pathname || \"\",\n        search: path.search || \"\",\n        hash: path.hash || \"\"\n      };\n    },\n    push(to, state) {\n      action = Action.Push;\n      let nextLocation = createMemoryLocation(to, state);\n      index += 1;\n      entries.splice(index, entries.length, nextLocation);\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta: 1\n        });\n      }\n    },\n    replace(to, state) {\n      action = Action.Replace;\n      let nextLocation = createMemoryLocation(to, state);\n      entries[index] = nextLocation;\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta: 0\n        });\n      }\n    },\n    go(delta) {\n      action = Action.Pop;\n      let nextIndex = clampIndex(index + delta);\n      let nextLocation = entries[nextIndex];\n      index = nextIndex;\n      if (listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta\n        });\n      }\n    },\n    listen(fn) {\n      listener = fn;\n      return () => {\n        listener = null;\n      };\n    }\n  };\n  return history;\n}\n/**\n * Browser history stores the location in regular URLs. This is the standard for\n * most web apps, but it requires some configuration on the server to ensure you\n * serve the same app at multiple URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\n */\nfunction createBrowserHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  function createBrowserLocation(window, globalHistory) {\n    let {\n      pathname,\n      search,\n      hash\n    } = window.location;\n    return createLocation(\"\", {\n      pathname,\n      search,\n      hash\n    },\n    // state defaults to `null` because `window.history.state` does\n    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n  }\n  function createBrowserHref(window, to) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n  return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);\n}\n/**\n * Hash history stores the location in window.location.hash. This makes it ideal\n * for situations where you don't want to send the location to the server for\n * some reason, either because you do cannot configure it or the URL space is\n * reserved for something else.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\n */\nfunction createHashHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  function createHashLocation(window, globalHistory) {\n    let {\n      pathname = \"/\",\n      search = \"\",\n      hash = \"\"\n    } = parsePath(window.location.hash.substr(1));\n    // Hash URL should always have a leading / just like window.location.pathname\n    // does, so if an app ends up at a route like /#something then we add a\n    // leading slash so all of our path-matching behaves the same as if it would\n    // in a browser router.  This is particularly important when there exists a\n    // root splat route (<Route path=\"*\">) since that matches internally against\n    // \"/*\" and we'd expect /#something to 404 in a hash router app.\n    if (!pathname.startsWith(\"/\") && !pathname.startsWith(\".\")) {\n      pathname = \"/\" + pathname;\n    }\n    return createLocation(\"\", {\n      pathname,\n      search,\n      hash\n    },\n    // state defaults to `null` because `window.history.state` does\n    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n  }\n  function createHashHref(window, to) {\n    let base = window.document.querySelector(\"base\");\n    let href = \"\";\n    if (base && base.getAttribute(\"href\")) {\n      let url = window.location.href;\n      let hashIndex = url.indexOf(\"#\");\n      href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n    }\n    return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n  }\n  function validateHashLocation(location, to) {\n    warning(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in hash history.push(\" + JSON.stringify(to) + \")\");\n  }\n  return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);\n}\nfunction invariant(value, message) {\n  if (value === false || value === null || typeof value === \"undefined\") {\n    throw new Error(message);\n  }\n}\nfunction warning(cond, message) {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== \"undefined\") console.warn(message);\n    try {\n      // Welcome to debugging history!\n      //\n      // This error is thrown as a convenience, so you can more easily\n      // find the source for a warning that appears in the console by\n      // enabling \"pause on exceptions\" in your JavaScript debugger.\n      throw new Error(message);\n      // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\nfunction createKey() {\n  return Math.random().toString(36).substr(2, 8);\n}\n/**\n * For browser-based histories, we combine the state and key into an object\n */\nfunction getHistoryState(location, index) {\n  return {\n    usr: location.state,\n    key: location.key,\n    idx: index\n  };\n}\n/**\n * Creates a Location object with a unique key from the given Path\n */\nfunction createLocation(current, to, state, key) {\n  if (state === void 0) {\n    state = null;\n  }\n  let location = _extends({\n    pathname: typeof current === \"string\" ? current : current.pathname,\n    search: \"\",\n    hash: \"\"\n  }, typeof to === \"string\" ? parsePath(to) : to, {\n    state,\n    // TODO: This could be cleaned up.  push/replace should probably just take\n    // full Locations now and avoid the need to run through this flow at all\n    // But that's a pretty big refactor to the current test suite so going to\n    // keep as is for the time being and just let any incoming keys take precedence\n    key: to && to.key || key || createKey()\n  });\n  return location;\n}\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\nfunction createPath(_ref) {\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\"\n  } = _ref;\n  if (search && search !== \"?\") pathname += search.charAt(0) === \"?\" ? search : \"?\" + search;\n  if (hash && hash !== \"#\") pathname += hash.charAt(0) === \"#\" ? hash : \"#\" + hash;\n  return pathname;\n}\n/**\n * Parses a string URL path into its separate pathname, search, and hash components.\n */\nfunction parsePath(path) {\n  let parsedPath = {};\n  if (path) {\n    let hashIndex = path.indexOf(\"#\");\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n    let searchIndex = path.indexOf(\"?\");\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n  return parsedPath;\n}\nfunction getUrlBasedHistory(getLocation, createHref, validateLocation, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  let {\n    window = document.defaultView,\n    v5Compat = false\n  } = options;\n  let globalHistory = window.history;\n  let action = Action.Pop;\n  let listener = null;\n  let index = getIndex();\n  // Index should only be null when we initialize. If not, it's because the\n  // user called history.pushState or history.replaceState directly, in which\n  // case we should log a warning as it will result in bugs.\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState(_extends({}, globalHistory.state, {\n      idx: index\n    }), \"\");\n  }\n  function getIndex() {\n    let state = globalHistory.state || {\n      idx: null\n    };\n    return state.idx;\n  }\n  function handlePop() {\n    action = Action.Pop;\n    let nextIndex = getIndex();\n    let delta = nextIndex == null ? null : nextIndex - index;\n    index = nextIndex;\n    if (listener) {\n      listener({\n        action,\n        location: history.location,\n        delta\n      });\n    }\n  }\n  function push(to, state) {\n    action = Action.Push;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n    index = getIndex() + 1;\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    // try...catch because iOS limits us to 100 pushState calls :/\n    try {\n      globalHistory.pushState(historyState, \"\", url);\n    } catch (error) {\n      // If the exception is because `state` can't be serialized, let that throw\n      // outwards just like a replace call would so the dev knows the cause\n      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps\n      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal\n      if (error instanceof DOMException && error.name === \"DataCloneError\") {\n        throw error;\n      }\n      // They are going to lose state here, but there is no real\n      // way to warn them about it since the page will refresh...\n      window.location.assign(url);\n    }\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location,\n        delta: 1\n      });\n    }\n  }\n  function replace(to, state) {\n    action = Action.Replace;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n    index = getIndex();\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    globalHistory.replaceState(historyState, \"\", url);\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location,\n        delta: 0\n      });\n    }\n  }\n  function createURL(to) {\n    // window.location.origin is \"null\" (the literal string value) in Firefox\n    // under certain conditions, notably when serving from a local HTML file\n    // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n    let base = window.location.origin !== \"null\" ? window.location.origin : window.location.href;\n    let href = typeof to === \"string\" ? to : createPath(to);\n    // Treating this as a full URL will strip any trailing spaces so we need to\n    // pre-encode them since they might be part of a matching splat param from\n    // an ancestor route\n    href = href.replace(/ $/, \"%20\");\n    invariant(base, \"No window.location.(origin|href) available to create URL for href: \" + href);\n    return new URL(href, base);\n  }\n  let history = {\n    get action() {\n      return action;\n    },\n    get location() {\n      return getLocation(window, globalHistory);\n    },\n    listen(fn) {\n      if (listener) {\n        throw new Error(\"A history only accepts one active listener\");\n      }\n      window.addEventListener(PopStateEventType, handlePop);\n      listener = fn;\n      return () => {\n        window.removeEventListener(PopStateEventType, handlePop);\n        listener = null;\n      };\n    },\n    createHref(to) {\n      return createHref(window, to);\n    },\n    createURL,\n    encodeLocation(to) {\n      // Encode a Location the same way window.location would\n      let url = createURL(to);\n      return {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash\n      };\n    },\n    push,\n    replace,\n    go(n) {\n      return globalHistory.go(n);\n    }\n  };\n  return history;\n}\n//#endregion\n\nvar ResultType;\n(function (ResultType) {\n  ResultType[\"data\"] = \"data\";\n  ResultType[\"deferred\"] = \"deferred\";\n  ResultType[\"redirect\"] = \"redirect\";\n  ResultType[\"error\"] = \"error\";\n})(ResultType || (ResultType = {}));\nconst immutableRouteKeys = new Set([\"lazy\", \"caseSensitive\", \"path\", \"id\", \"index\", \"children\"]);\nfunction isIndexRoute(route) {\n  return route.index === true;\n}\n// Walk the route tree generating unique IDs where necessary, so we are working\n// solely with AgnosticDataRouteObject's within the Router\nfunction convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath, manifest) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\n  if (manifest === void 0) {\n    manifest = {};\n  }\n  return routes.map((route, index) => {\n    let treePath = [...parentPath, index];\n    let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n    invariant(route.index !== true || !route.children, \"Cannot specify children on an index route\");\n    invariant(!manifest[id], \"Found a route id collision on id \\\"\" + id + \"\\\".  Route \" + \"id's must be globally unique within Data Router usages\");\n    if (isIndexRoute(route)) {\n      let indexRoute = _extends({}, route, mapRouteProperties(route), {\n        id\n      });\n      manifest[id] = indexRoute;\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute = _extends({}, route, mapRouteProperties(route), {\n        id,\n        children: undefined\n      });\n      manifest[id] = pathOrLayoutRoute;\n      if (route.children) {\n        pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties, treePath, manifest);\n      }\n      return pathOrLayoutRoute;\n    }\n  });\n}\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/utils/match-routes\n */\nfunction matchRoutes(routes, locationArg, basename) {\n  if (basename === void 0) {\n    basename = \"/\";\n  }\n  let location = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n  let pathname = stripBasename(location.pathname || \"/\", basename);\n  if (pathname == null) {\n    return null;\n  }\n  let branches = flattenRoutes(routes);\n  rankRouteBranches(branches);\n  let matches = null;\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    // Incoming pathnames are generally encoded from either window.location\n    // or from router.navigate, but we want to match against the unencoded\n    // paths in the route definitions.  Memory router locations won't be\n    // encoded here but there also shouldn't be anything to decode so this\n    // should be a safe operation.  This avoids needing matchRoutes to be\n    // history-aware.\n    let decoded = decodePath(pathname);\n    matches = matchRouteBranch(branches[i], decoded);\n  }\n  return matches;\n}\nfunction convertRouteMatchToUiMatch(match, loaderData) {\n  let {\n    route,\n    pathname,\n    params\n  } = match;\n  return {\n    id: route.id,\n    pathname,\n    params,\n    data: loaderData[route.id],\n    handle: route.handle\n  };\n}\nfunction flattenRoutes(routes, branches, parentsMeta, parentPath) {\n  if (branches === void 0) {\n    branches = [];\n  }\n  if (parentsMeta === void 0) {\n    parentsMeta = [];\n  }\n  if (parentPath === void 0) {\n    parentPath = \"\";\n  }\n  let flattenRoute = (route, index, relativePath) => {\n    let meta = {\n      relativePath: relativePath === undefined ? route.path || \"\" : relativePath,\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route\n    };\n    if (meta.relativePath.startsWith(\"/\")) {\n      invariant(meta.relativePath.startsWith(parentPath), \"Absolute route path \\\"\" + meta.relativePath + \"\\\" nested under path \" + (\"\\\"\" + parentPath + \"\\\" is not valid. An absolute child route path \") + \"must start with the combined path of all its parent routes.\");\n      meta.relativePath = meta.relativePath.slice(parentPath.length);\n    }\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta);\n    // Add the children before adding this route to the array, so we traverse the\n    // route tree depth-first and child routes appear before their parents in\n    // the \"flattened\" version.\n    if (route.children && route.children.length > 0) {\n      invariant(\n      // Our types know better, but runtime JS may not!\n      // @ts-expect-error\n      route.index !== true, \"Index routes must not have child routes. Please remove \" + (\"all child routes from route path \\\"\" + path + \"\\\".\"));\n      flattenRoutes(route.children, branches, routesMeta, path);\n    }\n    // Routes without a path shouldn't ever match by themselves unless they are\n    // index routes, so don't add them to the list of possible branches.\n    if (route.path == null && !route.index) {\n      return;\n    }\n    branches.push({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta\n    });\n  };\n  routes.forEach((route, index) => {\n    var _route$path;\n    // coarse-grain check for optional params\n    if (route.path === \"\" || !((_route$path = route.path) != null && _route$path.includes(\"?\"))) {\n      flattenRoute(route, index);\n    } else {\n      for (let exploded of explodeOptionalSegments(route.path)) {\n        flattenRoute(route, index, exploded);\n      }\n    }\n  });\n  return branches;\n}\n/**\n * Computes all combinations of optional path segments for a given path,\n * excluding combinations that are ambiguous and of lower priority.\n *\n * For example, `/one/:two?/three/:four?/:five?` explodes to:\n * - `/one/three`\n * - `/one/:two/three`\n * - `/one/three/:four`\n * - `/one/three/:five`\n * - `/one/:two/three/:four`\n * - `/one/:two/three/:five`\n * - `/one/three/:four/:five`\n * - `/one/:two/three/:four/:five`\n */\nfunction explodeOptionalSegments(path) {\n  let segments = path.split(\"/\");\n  if (segments.length === 0) return [];\n  let [first, ...rest] = segments;\n  // Optional path segments are denoted by a trailing `?`\n  let isOptional = first.endsWith(\"?\");\n  // Compute the corresponding required segment: `foo?` -> `foo`\n  let required = first.replace(/\\?$/, \"\");\n  if (rest.length === 0) {\n    // Intepret empty string as omitting an optional segment\n    // `[\"one\", \"\", \"three\"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`\n    return isOptional ? [required, \"\"] : [required];\n  }\n  let restExploded = explodeOptionalSegments(rest.join(\"/\"));\n  let result = [];\n  // All child paths with the prefix.  Do this for all children before the\n  // optional version for all children, so we get consistent ordering where the\n  // parent optional aspect is preferred as required.  Otherwise, we can get\n  // child sections interspersed where deeper optional segments are higher than\n  // parent optional segments, where for example, /:two would explode _earlier_\n  // then /:one.  By always including the parent as required _for all children_\n  // first, we avoid this issue\n  result.push(...restExploded.map(subpath => subpath === \"\" ? required : [required, subpath].join(\"/\")));\n  // Then, if this is an optional value, add all child versions without\n  if (isOptional) {\n    result.push(...restExploded);\n  }\n  // for absolute paths, ensure `/` instead of empty segment\n  return result.map(exploded => path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded);\n}\nfunction rankRouteBranches(branches) {\n  branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first\n  : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));\n}\nconst paramRe = /^:[\\w-]+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = s => s === \"*\";\nfunction computeScore(path, index) {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n  return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === \"\" ? emptySegmentValue : staticSegmentValue), initialScore);\n}\nfunction compareIndexes(a, b) {\n  let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n  return siblings ?\n  // If two routes are siblings, we should try to match the earlier sibling\n  // first. This allows people to have fine-grained control over the matching\n  // behavior by simply putting routes with identical paths in the order they\n  // want them tried.\n  a[a.length - 1] - b[b.length - 1] :\n  // Otherwise, it doesn't really make sense to rank non-siblings by index,\n  // so they sort equally.\n  0;\n}\nfunction matchRouteBranch(branch, pathname) {\n  let {\n    routesMeta\n  } = branch;\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches = [];\n  for (let i = 0; i < routesMeta.length; ++i) {\n    let meta = routesMeta[i];\n    let end = i === routesMeta.length - 1;\n    let remainingPathname = matchedPathname === \"/\" ? pathname : pathname.slice(matchedPathname.length) || \"/\";\n    let match = matchPath({\n      path: meta.relativePath,\n      caseSensitive: meta.caseSensitive,\n      end\n    }, remainingPathname);\n    if (!match) return null;\n    Object.assign(matchedParams, match.params);\n    let route = meta.route;\n    matches.push({\n      // TODO: Can this as be avoided?\n      params: matchedParams,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),\n      route\n    });\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n  return matches;\n}\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/utils/generate-path\n */\nfunction generatePath(originalPath, params) {\n  if (params === void 0) {\n    params = {};\n  }\n  let path = originalPath;\n  if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n    warning(false, \"Route path \\\"\" + path + \"\\\" will be treated as if it were \" + (\"\\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\" because the `*` character must \") + \"always follow a `/` in the pattern. To get rid of this warning, \" + (\"please change the route path to \\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\".\"));\n    path = path.replace(/\\*$/, \"/*\");\n  }\n  // ensure `/` is added at the beginning if the path is absolute\n  const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n  const stringify = p => p == null ? \"\" : typeof p === \"string\" ? p : String(p);\n  const segments = path.split(/\\/+/).map((segment, index, array) => {\n    const isLastSegment = index === array.length - 1;\n    // only apply the splat if it's the last segment\n    if (isLastSegment && segment === \"*\") {\n      const star = \"*\";\n      // Apply the splat\n      return stringify(params[star]);\n    }\n    const keyMatch = segment.match(/^:([\\w-]+)(\\??)$/);\n    if (keyMatch) {\n      const [, key, optional] = keyMatch;\n      let param = params[key];\n      invariant(optional === \"?\" || param != null, \"Missing \\\":\" + key + \"\\\" param\");\n      return stringify(param);\n    }\n    // Remove any optional markers from optional static segments\n    return segment.replace(/\\?$/g, \"\");\n  })\n  // Remove empty segments\n  .filter(segment => !!segment);\n  return prefix + segments.join(\"/\");\n}\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/utils/match-path\n */\nfunction matchPath(pattern, pathname) {\n  if (typeof pattern === \"string\") {\n    pattern = {\n      path: pattern,\n      caseSensitive: false,\n      end: true\n    };\n  }\n  let [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);\n  let match = pathname.match(matcher);\n  if (!match) return null;\n  let matchedPathname = match[0];\n  let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n  let captureGroups = match.slice(1);\n  let params = compiledParams.reduce((memo, _ref, index) => {\n    let {\n      paramName,\n      isOptional\n    } = _ref;\n    // We need to compute the pathnameBase here using the raw splat value\n    // instead of using params[\"*\"] later because it will be decoded then\n    if (paramName === \"*\") {\n      let splatValue = captureGroups[index] || \"\";\n      pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\\/+$/, \"$1\");\n    }\n    const value = captureGroups[index];\n    if (isOptional && !value) {\n      memo[paramName] = undefined;\n    } else {\n      memo[paramName] = (value || \"\").replace(/%2F/g, \"/\");\n    }\n    return memo;\n  }, {});\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern\n  };\n}\nfunction compilePath(path, caseSensitive, end) {\n  if (caseSensitive === void 0) {\n    caseSensitive = false;\n  }\n  if (end === void 0) {\n    end = true;\n  }\n  warning(path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"), \"Route path \\\"\" + path + \"\\\" will be treated as if it were \" + (\"\\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\" because the `*` character must \") + \"always follow a `/` in the pattern. To get rid of this warning, \" + (\"please change the route path to \\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\".\"));\n  let params = [];\n  let regexpSource = \"^\" + path.replace(/\\/*\\*?$/, \"\") // Ignore trailing / and /*, we'll handle it below\n  .replace(/^\\/*/, \"/\") // Make sure it has a leading /\n  .replace(/[\\\\.*+^${}|()[\\]]/g, \"\\\\$&\") // Escape special regex chars\n  .replace(/\\/:([\\w-]+)(\\?)?/g, (_, paramName, isOptional) => {\n    params.push({\n      paramName,\n      isOptional: isOptional != null\n    });\n    return isOptional ? \"/?([^\\\\/]+)?\" : \"/([^\\\\/]+)\";\n  });\n  if (path.endsWith(\"*\")) {\n    params.push({\n      paramName: \"*\"\n    });\n    regexpSource += path === \"*\" || path === \"/*\" ? \"(.*)$\" // Already matched the initial /, just match the rest\n    : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else if (end) {\n    // When matching to the end, ignore trailing slashes\n    regexpSource += \"\\\\/*$\";\n  } else if (path !== \"\" && path !== \"/\") {\n    // If our path is non-empty and contains anything beyond an initial slash,\n    // then we have _some_ form of path in our regex, so we should expect to\n    // match only if we find the end of this path segment.  Look for an optional\n    // non-captured trailing slash (to match a portion of the URL) or the end\n    // of the path (if we've matched to the end).  We used to do this with a\n    // word boundary but that gives false positives on routes like\n    // /user-preferences since `-` counts as a word boundary.\n    regexpSource += \"(?:(?=\\\\/|$))\";\n  } else ;\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n  return [matcher, params];\n}\nfunction decodePath(value) {\n  try {\n    return value.split(\"/\").map(v => decodeURIComponent(v).replace(/\\//g, \"%2F\")).join(\"/\");\n  } catch (error) {\n    warning(false, \"The URL path \\\"\" + value + \"\\\" could not be decoded because it is is a \" + \"malformed URL segment. This is probably due to a bad percent \" + (\"encoding (\" + error + \").\"));\n    return value;\n  }\n}\n/**\n * @private\n */\nfunction stripBasename(pathname, basename) {\n  if (basename === \"/\") return pathname;\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n  // We want to leave trailing slash behavior in the user's control, so if they\n  // specify a basename with a trailing slash, we should support it\n  let startIndex = basename.endsWith(\"/\") ? basename.length - 1 : basename.length;\n  let nextChar = pathname.charAt(startIndex);\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n  return pathname.slice(startIndex) || \"/\";\n}\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/utils/resolve-path\n */\nfunction resolvePath(to, fromPathname) {\n  if (fromPathname === void 0) {\n    fromPathname = \"/\";\n  }\n  let {\n    pathname: toPathname,\n    search = \"\",\n    hash = \"\"\n  } = typeof to === \"string\" ? parsePath(to) : to;\n  let pathname = toPathname ? toPathname.startsWith(\"/\") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;\n  return {\n    pathname,\n    search: normalizeSearch(search),\n    hash: normalizeHash(hash)\n  };\n}\nfunction resolvePathname(relativePath, fromPathname) {\n  let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n  let relativeSegments = relativePath.split(\"/\");\n  relativeSegments.forEach(segment => {\n    if (segment === \"..\") {\n      // Keep the root \"\" segment so the pathname starts at /\n      if (segments.length > 1) segments.pop();\n    } else if (segment !== \".\") {\n      segments.push(segment);\n    }\n  });\n  return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\nfunction getInvalidPathError(char, field, dest, path) {\n  return \"Cannot include a '\" + char + \"' character in a manually specified \" + (\"`to.\" + field + \"` field [\" + JSON.stringify(path) + \"].  Please separate it out to the \") + (\"`to.\" + dest + \"` field. Alternatively you may provide the full path as \") + \"a string in <Link to=\\\"...\\\"> and the router will parse it for you.\";\n}\n/**\n * @private\n *\n * When processing relative navigation we want to ignore ancestor routes that\n * do not contribute to the path, such that index/pathless layout routes don't\n * interfere.\n *\n * For example, when moving a route element into an index route and/or a\n * pathless layout route, relative link behavior contained within should stay\n * the same.  Both of the following examples should link back to the root:\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\" element={<Link to=\"..\"}>\n *   </Route>\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\">\n *       <Route element={<AccountsLayout />}>       // <-- Does not contribute\n *         <Route index element={<Link to=\"..\"} />  // <-- Does not contribute\n *       </Route\n *     </Route>\n *   </Route>\n */\nfunction getPathContributingMatches(matches) {\n  return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);\n}\n// Return the array of pathnames for the current route matches - used to\n// generate the routePathnames input for resolveTo()\nfunction getResolveToMatches(matches, v7_relativeSplatPath) {\n  let pathMatches = getPathContributingMatches(matches);\n  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf\n  // match so we include splat values for \".\" links.  See:\n  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329\n  if (v7_relativeSplatPath) {\n    return pathMatches.map((match, idx) => idx === matches.length - 1 ? match.pathname : match.pathnameBase);\n  }\n  return pathMatches.map(match => match.pathnameBase);\n}\n/**\n * @private\n */\nfunction resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {\n  if (isPathRelative === void 0) {\n    isPathRelative = false;\n  }\n  let to;\n  if (typeof toArg === \"string\") {\n    to = parsePath(toArg);\n  } else {\n    to = _extends({}, toArg);\n    invariant(!to.pathname || !to.pathname.includes(\"?\"), getInvalidPathError(\"?\", \"pathname\", \"search\", to));\n    invariant(!to.pathname || !to.pathname.includes(\"#\"), getInvalidPathError(\"#\", \"pathname\", \"hash\", to));\n    invariant(!to.search || !to.search.includes(\"#\"), getInvalidPathError(\"#\", \"search\", \"hash\", to));\n  }\n  let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n  let toPathname = isEmptyPath ? \"/\" : to.pathname;\n  let from;\n  // Routing is relative to the current pathname if explicitly requested.\n  //\n  // If a pathname is explicitly provided in `to`, it should be relative to the\n  // route context. This is explained in `Note on `<Link to>` values` in our\n  // migration guide from v5 as a means of disambiguation between `to` values\n  // that begin with `/` and those that do not. However, this is problematic for\n  // `to` values that do not provide a pathname. `to` can simply be a search or\n  // hash string, in which case we should assume that the navigation is relative\n  // to the current location's pathname and *not* the route pathname.\n  if (toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n    // With relative=\"route\" (the default), each leading .. segment means\n    // \"go up one route\" instead of \"go up one URL segment\".  This is a key\n    // difference from how <a href> works and a major reason we call this a\n    // \"to\" value instead of a \"href\".\n    if (!isPathRelative && toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n      to.pathname = toSegments.join(\"/\");\n    }\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n  let path = resolvePath(to, from);\n  // Ensure the pathname has a trailing slash if the original \"to\" had one\n  let hasExplicitTrailingSlash = toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\");\n  // Or if this was a link to the current path which has a trailing slash\n  let hasCurrentTrailingSlash = (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n  if (!path.pathname.endsWith(\"/\") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {\n    path.pathname += \"/\";\n  }\n  return path;\n}\n/**\n * @private\n */\nfunction getToPathname(to) {\n  // Empty strings should be treated the same as / paths\n  return to === \"\" || to.pathname === \"\" ? \"/\" : typeof to === \"string\" ? parsePath(to).pathname : to.pathname;\n}\n/**\n * @private\n */\nconst joinPaths = paths => paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n/**\n * @private\n */\nconst normalizePathname = pathname => pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n/**\n * @private\n */\nconst normalizeSearch = search => !search || search === \"?\" ? \"\" : search.startsWith(\"?\") ? search : \"?\" + search;\n/**\n * @private\n */\nconst normalizeHash = hash => !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n */\nconst json = function json(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  let headers = new Headers(responseInit.headers);\n  if (!headers.has(\"Content-Type\")) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n  }\n  return new Response(JSON.stringify(data), _extends({}, responseInit, {\n    headers\n  }));\n};\nclass AbortedDeferredError extends Error {}\nclass DeferredData {\n  constructor(data, responseInit) {\n    this.pendingKeysSet = new Set();\n    this.subscribers = new Set();\n    this.deferredKeys = [];\n    invariant(data && typeof data === \"object\" && !Array.isArray(data), \"defer() only accepts plain objects\");\n    // Set up an AbortController + Promise we can race against to exit early\n    // cancellation\n    let reject;\n    this.abortPromise = new Promise((_, r) => reject = r);\n    this.controller = new AbortController();\n    let onAbort = () => reject(new AbortedDeferredError(\"Deferred data aborted\"));\n    this.unlistenAbortSignal = () => this.controller.signal.removeEventListener(\"abort\", onAbort);\n    this.controller.signal.addEventListener(\"abort\", onAbort);\n    this.data = Object.entries(data).reduce((acc, _ref2) => {\n      let [key, value] = _ref2;\n      return Object.assign(acc, {\n        [key]: this.trackPromise(key, value)\n      });\n    }, {});\n    if (this.done) {\n      // All incoming values were resolved\n      this.unlistenAbortSignal();\n    }\n    this.init = responseInit;\n  }\n  trackPromise(key, value) {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n    this.deferredKeys.push(key);\n    this.pendingKeysSet.add(key);\n    // We store a little wrapper promise that will be extended with\n    // _data/_error props upon resolve/reject\n    let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, undefined, data), error => this.onSettle(promise, key, error));\n    // Register rejection listeners to avoid uncaught promise rejections on\n    // errors or aborted deferred values\n    promise.catch(() => {});\n    Object.defineProperty(promise, \"_tracked\", {\n      get: () => true\n    });\n    return promise;\n  }\n  onSettle(promise, key, error, data) {\n    if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {\n      this.unlistenAbortSignal();\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      return Promise.reject(error);\n    }\n    this.pendingKeysSet.delete(key);\n    if (this.done) {\n      // Nothing left to abort!\n      this.unlistenAbortSignal();\n    }\n    // If the promise was resolved/rejected with undefined, we'll throw an error as you\n    // should always resolve with a value or null\n    if (error === undefined && data === undefined) {\n      let undefinedError = new Error(\"Deferred data for key \\\"\" + key + \"\\\" resolved/rejected with `undefined`, \" + \"you must resolve/reject with a value or `null`.\");\n      Object.defineProperty(promise, \"_error\", {\n        get: () => undefinedError\n      });\n      this.emit(false, key);\n      return Promise.reject(undefinedError);\n    }\n    if (data === undefined) {\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      this.emit(false, key);\n      return Promise.reject(error);\n    }\n    Object.defineProperty(promise, \"_data\", {\n      get: () => data\n    });\n    this.emit(false, key);\n    return data;\n  }\n  emit(aborted, settledKey) {\n    this.subscribers.forEach(subscriber => subscriber(aborted, settledKey));\n  }\n  subscribe(fn) {\n    this.subscribers.add(fn);\n    return () => this.subscribers.delete(fn);\n  }\n  cancel() {\n    this.controller.abort();\n    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));\n    this.emit(true);\n  }\n  async resolveData(signal) {\n    let aborted = false;\n    if (!this.done) {\n      let onAbort = () => this.cancel();\n      signal.addEventListener(\"abort\", onAbort);\n      aborted = await new Promise(resolve => {\n        this.subscribe(aborted => {\n          signal.removeEventListener(\"abort\", onAbort);\n          if (aborted || this.done) {\n            resolve(aborted);\n          }\n        });\n      });\n    }\n    return aborted;\n  }\n  get done() {\n    return this.pendingKeysSet.size === 0;\n  }\n  get unwrappedData() {\n    invariant(this.data !== null && this.done, \"Can only unwrap data on initialized and settled deferreds\");\n    return Object.entries(this.data).reduce((acc, _ref3) => {\n      let [key, value] = _ref3;\n      return Object.assign(acc, {\n        [key]: unwrapTrackedPromise(value)\n      });\n    }, {});\n  }\n  get pendingKeys() {\n    return Array.from(this.pendingKeysSet);\n  }\n}\nfunction isTrackedPromise(value) {\n  return value instanceof Promise && value._tracked === true;\n}\nfunction unwrapTrackedPromise(value) {\n  if (!isTrackedPromise(value)) {\n    return value;\n  }\n  if (value._error) {\n    throw value._error;\n  }\n  return value._data;\n}\nconst defer = function defer(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  return new DeferredData(data, responseInit);\n};\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst redirect = function redirect(url, init) {\n  if (init === void 0) {\n    init = 302;\n  }\n  let responseInit = init;\n  if (typeof responseInit === \"number\") {\n    responseInit = {\n      status: responseInit\n    };\n  } else if (typeof responseInit.status === \"undefined\") {\n    responseInit.status = 302;\n  }\n  let headers = new Headers(responseInit.headers);\n  headers.set(\"Location\", url);\n  return new Response(null, _extends({}, responseInit, {\n    headers\n  }));\n};\n/**\n * A redirect response that will force a document reload to the new location.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst redirectDocument = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Reload-Document\", \"true\");\n  return response;\n};\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n *\n * We don't export the class for public use since it's an implementation\n * detail, but we export the interface above so folks can build their own\n * abstractions around instances via isRouteErrorResponse()\n */\nclass ErrorResponseImpl {\n  constructor(status, statusText, data, internal) {\n    if (internal === void 0) {\n      internal = false;\n    }\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.internal = internal;\n    if (data instanceof Error) {\n      this.data = data.toString();\n      this.error = data;\n    } else {\n      this.data = data;\n    }\n  }\n}\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\nfunction isRouteErrorResponse(error) {\n  return error != null && typeof error.status === \"number\" && typeof error.statusText === \"string\" && typeof error.internal === \"boolean\" && \"data\" in error;\n}\n\nconst validMutationMethodsArr = [\"post\", \"put\", \"patch\", \"delete\"];\nconst validMutationMethods = new Set(validMutationMethodsArr);\nconst validRequestMethodsArr = [\"get\", ...validMutationMethodsArr];\nconst validRequestMethods = new Set(validRequestMethodsArr);\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\nconst IDLE_NAVIGATION = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined\n};\nconst IDLE_FETCHER = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined\n};\nconst IDLE_BLOCKER = {\n  state: \"unblocked\",\n  proceed: undefined,\n  reset: undefined,\n  location: undefined\n};\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\nconst defaultMapRouteProperties = route => ({\n  hasErrorBoundary: Boolean(route.hasErrorBoundary)\n});\nconst TRANSITIONS_STORAGE_KEY = \"remix-router-transitions\";\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Create a router and listen to history POP navigations\n */\nfunction createRouter(init) {\n  const routerWindow = init.window ? init.window : typeof window !== \"undefined\" ? window : undefined;\n  const isBrowser = typeof routerWindow !== \"undefined\" && typeof routerWindow.document !== \"undefined\" && typeof routerWindow.document.createElement !== \"undefined\";\n  const isServer = !isBrowser;\n  invariant(init.routes.length > 0, \"You must provide a non-empty routes array to createRouter\");\n  let mapRouteProperties;\n  if (init.mapRouteProperties) {\n    mapRouteProperties = init.mapRouteProperties;\n  } else if (init.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = init.detectErrorBoundary;\n    mapRouteProperties = route => ({\n      hasErrorBoundary: detectErrorBoundary(route)\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Routes keyed by ID\n  let manifest = {};\n  // Routes in tree format for matching\n  let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties, undefined, manifest);\n  let inFlightDataRoutes;\n  let basename = init.basename || \"/\";\n  // Config driven behavior flags\n  let future = _extends({\n    v7_fetcherPersist: false,\n    v7_normalizeFormMethod: false,\n    v7_partialHydration: false,\n    v7_prependBasename: false,\n    v7_relativeSplatPath: false\n  }, init.future);\n  // Cleanup function for history\n  let unlistenHistory = null;\n  // Externally-provided functions to call on all state changes\n  let subscribers = new Set();\n  // Externally-provided object to hold scroll restoration locations during routing\n  let savedScrollPositions = null;\n  // Externally-provided function to get scroll restoration keys\n  let getScrollRestorationKey = null;\n  // Externally-provided function to get current scroll position\n  let getScrollPosition = null;\n  // One-time flag to control the initial hydration scroll restoration.  Because\n  // we don't get the saved positions from <ScrollRestoration /> until _after_\n  // the initial render, we need to manually trigger a separate updateState to\n  // send along the restoreScrollPosition\n  // Set to true if we have `hydrationData` since we assume we were SSR'd and that\n  // SSR did the initial scroll restoration.\n  let initialScrollRestored = init.hydrationData != null;\n  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);\n  let initialErrors = null;\n  if (initialMatches == null) {\n    // If we do not match a user-provided-route, fall back to the root\n    // to allow the error boundary to take over\n    let error = getInternalRouterError(404, {\n      pathname: init.history.location.pathname\n    });\n    let {\n      matches,\n      route\n    } = getShortCircuitMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = {\n      [route.id]: error\n    };\n  }\n  let initialized;\n  let hasLazyRoutes = initialMatches.some(m => m.route.lazy);\n  let hasLoaders = initialMatches.some(m => m.route.loader);\n  if (hasLazyRoutes) {\n    // All initialMatches need to be loaded before we're ready.  If we have lazy\n    // functions around still then we'll need to run them in initialize()\n    initialized = false;\n  } else if (!hasLoaders) {\n    // If we've got no loaders to run, then we're good to go\n    initialized = true;\n  } else if (future.v7_partialHydration) {\n    // If partial hydration is enabled, we're initialized so long as we were\n    // provided with hydrationData for every route with a loader, and no loaders\n    // were marked for explicit hydration\n    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;\n    let errors = init.hydrationData ? init.hydrationData.errors : null;\n    let isRouteInitialized = m => {\n      // No loader, nothing to initialize\n      if (!m.route.loader) return true;\n      // Explicitly opting-in to running on hydration\n      if (m.route.loader.hydrate === true) return false;\n      // Otherwise, initialized if hydrated with data or an error\n      return loaderData && loaderData[m.route.id] !== undefined || errors && errors[m.route.id] !== undefined;\n    };\n    // If errors exist, don't consider routes below the boundary\n    if (errors) {\n      let idx = initialMatches.findIndex(m => errors[m.route.id] !== undefined);\n      initialized = initialMatches.slice(0, idx + 1).every(isRouteInitialized);\n    } else {\n      initialized = initialMatches.every(isRouteInitialized);\n    }\n  } else {\n    // Without partial hydration - we're initialized if we were provided any\n    // hydrationData - which is expected to be complete\n    initialized = init.hydrationData != null;\n  }\n  let router;\n  let state = {\n    historyAction: init.history.action,\n    location: init.history.location,\n    matches: initialMatches,\n    initialized,\n    navigation: IDLE_NAVIGATION,\n    // Don't restore on initial updateState() if we were SSR'd\n    restoreScrollPosition: init.hydrationData != null ? false : null,\n    preventScrollReset: false,\n    revalidation: \"idle\",\n    loaderData: init.hydrationData && init.hydrationData.loaderData || {},\n    actionData: init.hydrationData && init.hydrationData.actionData || null,\n    errors: init.hydrationData && init.hydrationData.errors || initialErrors,\n    fetchers: new Map(),\n    blockers: new Map()\n  };\n  // -- Stateful internal variables to manage navigations --\n  // Current navigation in progress (to be committed in completeNavigation)\n  let pendingAction = Action.Pop;\n  // Should the current navigation prevent the scroll reset if scroll cannot\n  // be restored?\n  let pendingPreventScrollReset = false;\n  // AbortController for the active navigation\n  let pendingNavigationController;\n  // Should the current navigation enable document.startViewTransition?\n  let pendingViewTransitionEnabled = false;\n  // Store applied view transitions so we can apply them on POP\n  let appliedViewTransitions = new Map();\n  // Cleanup function for persisting applied transitions to sessionStorage\n  let removePageHideEventListener = null;\n  // We use this to avoid touching history in completeNavigation if a\n  // revalidation is entirely uninterrupted\n  let isUninterruptedRevalidation = false;\n  // Use this internal flag to force revalidation of all loaders:\n  //  - submissions (completed or interrupted)\n  //  - useRevalidator()\n  //  - X-Remix-Revalidate (from redirect)\n  let isRevalidationRequired = false;\n  // Use this internal array to capture routes that require revalidation due\n  // to a cancelled deferred on action submission\n  let cancelledDeferredRoutes = [];\n  // Use this internal array to capture fetcher loads that were cancelled by an\n  // action navigation and require revalidation\n  let cancelledFetcherLoads = [];\n  // AbortControllers for any in-flight fetchers\n  let fetchControllers = new Map();\n  // Track loads based on the order in which they started\n  let incrementingLoadId = 0;\n  // Track the outstanding pending navigation data load to be compared against\n  // the globally incrementing load when a fetcher load lands after a completed\n  // navigation\n  let pendingNavigationLoadId = -1;\n  // Fetchers that triggered data reloads as a result of their actions\n  let fetchReloadIds = new Map();\n  // Fetchers that triggered redirect navigations\n  let fetchRedirectIds = new Set();\n  // Most recent href/match for fetcher.load calls for fetchers\n  let fetchLoadMatches = new Map();\n  // Ref-count mounted fetchers so we know when it's ok to clean them up\n  let activeFetchers = new Map();\n  // Fetchers that have requested a delete when using v7_fetcherPersist,\n  // they'll be officially removed after they return to idle\n  let deletedFetchers = new Set();\n  // Store DeferredData instances for active route matches.  When a\n  // route loader returns defer() we stick one in here.  Then, when a nested\n  // promise resolves we update loaderData.  If a new navigation starts we\n  // cancel active deferreds for eliminated routes.\n  let activeDeferreds = new Map();\n  // Store blocker functions in a separate Map outside of router state since\n  // we don't need to update UI state if they change\n  let blockerFunctions = new Map();\n  // Flag to ignore the next history update, so we can revert the URL change on\n  // a POP navigation that was blocked by the user without touching router state\n  let ignoreNextHistoryUpdate = false;\n  // Initialize the router, all side effects should be kicked off from here.\n  // Implemented as a Fluent API for ease of:\n  //   let router = createRouter(init).initialize();\n  function initialize() {\n    // If history informs us of a POP navigation, start the navigation but do not update\n    // state.  We'll update our own state once the navigation completes\n    unlistenHistory = init.history.listen(_ref => {\n      let {\n        action: historyAction,\n        location,\n        delta\n      } = _ref;\n      // Ignore this event if it was just us resetting the URL from a\n      // blocked POP navigation\n      if (ignoreNextHistoryUpdate) {\n        ignoreNextHistoryUpdate = false;\n        return;\n      }\n      warning(blockerFunctions.size === 0 || delta != null, \"You are trying to use a blocker on a POP navigation to a location \" + \"that was not created by @remix-run/router. This will fail silently in \" + \"production. This can happen if you are navigating outside the router \" + \"via `window.history.pushState`/`window.location.hash` instead of using \" + \"router navigation APIs.  This can also happen if you are using \" + \"createHashRouter and the user manually changes the URL.\");\n      let blockerKey = shouldBlockNavigation({\n        currentLocation: state.location,\n        nextLocation: location,\n        historyAction\n      });\n      if (blockerKey && delta != null) {\n        // Restore the URL to match the current UI, but don't update router state\n        ignoreNextHistoryUpdate = true;\n        init.history.go(delta * -1);\n        // Put the blocker into a blocked state\n        updateBlocker(blockerKey, {\n          state: \"blocked\",\n          location,\n          proceed() {\n            updateBlocker(blockerKey, {\n              state: \"proceeding\",\n              proceed: undefined,\n              reset: undefined,\n              location\n            });\n            // Re-do the same POP navigation we just blocked\n            init.history.go(delta);\n          },\n          reset() {\n            let blockers = new Map(state.blockers);\n            blockers.set(blockerKey, IDLE_BLOCKER);\n            updateState({\n              blockers\n            });\n          }\n        });\n        return;\n      }\n      return startNavigation(historyAction, location);\n    });\n    if (isBrowser) {\n      // FIXME: This feels gross.  How can we cleanup the lines between\n      // scrollRestoration/appliedTransitions persistance?\n      restoreAppliedTransitions(routerWindow, appliedViewTransitions);\n      let _saveAppliedTransitions = () => persistAppliedTransitions(routerWindow, appliedViewTransitions);\n      routerWindow.addEventListener(\"pagehide\", _saveAppliedTransitions);\n      removePageHideEventListener = () => routerWindow.removeEventListener(\"pagehide\", _saveAppliedTransitions);\n    }\n    // Kick off initial data load if needed.  Use Pop to avoid modifying history\n    // Note we don't do any handling of lazy here.  For SPA's it'll get handled\n    // in the normal navigation flow.  For SSR it's expected that lazy modules are\n    // resolved prior to router creation since we can't go into a fallbackElement\n    // UI for SSR'd apps\n    if (!state.initialized) {\n      startNavigation(Action.Pop, state.location, {\n        initialHydration: true\n      });\n    }\n    return router;\n  }\n  // Clean up a router and it's side effects\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\n    }\n    if (removePageHideEventListener) {\n      removePageHideEventListener();\n    }\n    subscribers.clear();\n    pendingNavigationController && pendingNavigationController.abort();\n    state.fetchers.forEach((_, key) => deleteFetcher(key));\n    state.blockers.forEach((_, key) => deleteBlocker(key));\n  }\n  // Subscribe to state updates for the router\n  function subscribe(fn) {\n    subscribers.add(fn);\n    return () => subscribers.delete(fn);\n  }\n  // Update our state and notify the calling context of the change\n  function updateState(newState, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    state = _extends({}, state, newState);\n    // Prep fetcher cleanup so we can tell the UI which fetcher data entries\n    // can be removed\n    let completedFetchers = [];\n    let deletedFetchersKeys = [];\n    if (future.v7_fetcherPersist) {\n      state.fetchers.forEach((fetcher, key) => {\n        if (fetcher.state === \"idle\") {\n          if (deletedFetchers.has(key)) {\n            // Unmounted from the UI and can be totally removed\n            deletedFetchersKeys.push(key);\n          } else {\n            // Returned to idle but still mounted in the UI, so semi-remains for\n            // revalidations and such\n            completedFetchers.push(key);\n          }\n        }\n      });\n    }\n    // Iterate over a local copy so that if flushSync is used and we end up\n    // removing and adding a new subscriber due to the useCallback dependencies,\n    // we don't get ourselves into a loop calling the new subscriber immediately\n    [...subscribers].forEach(subscriber => subscriber(state, {\n      deletedFetchers: deletedFetchersKeys,\n      unstable_viewTransitionOpts: opts.viewTransitionOpts,\n      unstable_flushSync: opts.flushSync === true\n    }));\n    // Remove idle fetchers from state since we only care about in-flight fetchers.\n    if (future.v7_fetcherPersist) {\n      completedFetchers.forEach(key => state.fetchers.delete(key));\n      deletedFetchersKeys.forEach(key => deleteFetcher(key));\n    }\n  }\n  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION\n  // and setting state.[historyAction/location/matches] to the new route.\n  // - Location is a required param\n  // - Navigation will always be set to IDLE_NAVIGATION\n  // - Can pass any other state in newState\n  function completeNavigation(location, newState, _temp) {\n    var _location$state, _location$state2;\n    let {\n      flushSync\n    } = _temp === void 0 ? {} : _temp;\n    // Deduce if we're in a loading/actionReload state:\n    // - We have committed actionData in the store\n    // - The current navigation was a mutation submission\n    // - We're past the submitting state and into the loading state\n    // - The location being loaded is not the result of a redirect\n    let isActionReload = state.actionData != null && state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && state.navigation.state === \"loading\" && ((_location$state = location.state) == null ? void 0 : _location$state._isRedirect) !== true;\n    let actionData;\n    if (newState.actionData) {\n      if (Object.keys(newState.actionData).length > 0) {\n        actionData = newState.actionData;\n      } else {\n        // Empty actionData -> clear prior actionData due to an action error\n        actionData = null;\n      }\n    } else if (isActionReload) {\n      // Keep the current data if we're wrapping up the action reload\n      actionData = state.actionData;\n    } else {\n      // Clear actionData on any other completed navigations\n      actionData = null;\n    }\n    // Always preserve any existing loaderData from re-used routes\n    let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;\n    // On a successful navigation we can assume we got through all blockers\n    // so we can start fresh\n    let blockers = state.blockers;\n    if (blockers.size > 0) {\n      blockers = new Map(blockers);\n      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));\n    }\n    // Always respect the user flag.  Otherwise don't reset on mutation\n    // submission navigations unless they redirect\n    let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;\n    if (inFlightDataRoutes) {\n      dataRoutes = inFlightDataRoutes;\n      inFlightDataRoutes = undefined;\n    }\n    if (isUninterruptedRevalidation) ; else if (pendingAction === Action.Pop) ; else if (pendingAction === Action.Push) {\n      init.history.push(location, location.state);\n    } else if (pendingAction === Action.Replace) {\n      init.history.replace(location, location.state);\n    }\n    let viewTransitionOpts;\n    // On POP, enable transitions if they were enabled on the original navigation\n    if (pendingAction === Action.Pop) {\n      // Forward takes precedence so they behave like the original navigation\n      let priorPaths = appliedViewTransitions.get(state.location.pathname);\n      if (priorPaths && priorPaths.has(location.pathname)) {\n        viewTransitionOpts = {\n          currentLocation: state.location,\n          nextLocation: location\n        };\n      } else if (appliedViewTransitions.has(location.pathname)) {\n        // If we don't have a previous forward nav, assume we're popping back to\n        // the new location and enable if that location previously enabled\n        viewTransitionOpts = {\n          currentLocation: location,\n          nextLocation: state.location\n        };\n      }\n    } else if (pendingViewTransitionEnabled) {\n      // Store the applied transition on PUSH/REPLACE\n      let toPaths = appliedViewTransitions.get(state.location.pathname);\n      if (toPaths) {\n        toPaths.add(location.pathname);\n      } else {\n        toPaths = new Set([location.pathname]);\n        appliedViewTransitions.set(state.location.pathname, toPaths);\n      }\n      viewTransitionOpts = {\n        currentLocation: state.location,\n        nextLocation: location\n      };\n    }\n    updateState(_extends({}, newState, {\n      actionData,\n      loaderData,\n      historyAction: pendingAction,\n      location,\n      initialized: true,\n      navigation: IDLE_NAVIGATION,\n      revalidation: \"idle\",\n      restoreScrollPosition: getSavedScrollPosition(location, newState.matches || state.matches),\n      preventScrollReset,\n      blockers\n    }), {\n      viewTransitionOpts,\n      flushSync: flushSync === true\n    });\n    // Reset stateful navigation vars\n    pendingAction = Action.Pop;\n    pendingPreventScrollReset = false;\n    pendingViewTransitionEnabled = false;\n    isUninterruptedRevalidation = false;\n    isRevalidationRequired = false;\n    cancelledDeferredRoutes = [];\n    cancelledFetcherLoads = [];\n  }\n  // Trigger a navigation event, which can either be a numerical POP or a PUSH\n  // replace with an optional submission\n  async function navigate(to, opts) {\n    if (typeof to === \"number\") {\n      init.history.go(to);\n      return;\n    }\n    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, to, future.v7_relativeSplatPath, opts == null ? void 0 : opts.fromRouteId, opts == null ? void 0 : opts.relative);\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, false, normalizedPath, opts);\n    let currentLocation = state.location;\n    let nextLocation = createLocation(state.location, path, opts && opts.state);\n    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded\n    // URL from window.location, so we need to encode it here so the behavior\n    // remains the same as POP and non-data-router usages.  new URL() does all\n    // the same encoding we'd get from a history.pushState/window.location read\n    // without having to touch history\n    nextLocation = _extends({}, nextLocation, init.history.encodeLocation(nextLocation));\n    let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n    let historyAction = Action.Push;\n    if (userReplace === true) {\n      historyAction = Action.Replace;\n    } else if (userReplace === false) ; else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) {\n      // By default on submissions to the current location we REPLACE so that\n      // users don't have to double-click the back button to get to the prior\n      // location.  If the user redirects to a different location from the\n      // action/loader this will be ignored and the redirect will be a PUSH\n      historyAction = Action.Replace;\n    }\n    let preventScrollReset = opts && \"preventScrollReset\" in opts ? opts.preventScrollReset === true : undefined;\n    let flushSync = (opts && opts.unstable_flushSync) === true;\n    let blockerKey = shouldBlockNavigation({\n      currentLocation,\n      nextLocation,\n      historyAction\n    });\n    if (blockerKey) {\n      // Put the blocker into a blocked state\n      updateBlocker(blockerKey, {\n        state: \"blocked\",\n        location: nextLocation,\n        proceed() {\n          updateBlocker(blockerKey, {\n            state: \"proceeding\",\n            proceed: undefined,\n            reset: undefined,\n            location: nextLocation\n          });\n          // Send the same navigation through\n          navigate(to, opts);\n        },\n        reset() {\n          let blockers = new Map(state.blockers);\n          blockers.set(blockerKey, IDLE_BLOCKER);\n          updateState({\n            blockers\n          });\n        }\n      });\n      return;\n    }\n    return await startNavigation(historyAction, nextLocation, {\n      submission,\n      // Send through the formData serialization error if we have one so we can\n      // render at the right error boundary after we match routes\n      pendingError: error,\n      preventScrollReset,\n      replace: opts && opts.replace,\n      enableViewTransition: opts && opts.unstable_viewTransition,\n      flushSync\n    });\n  }\n  // Revalidate all current loaders.  If a navigation is in progress or if this\n  // is interrupted by a navigation, allow this to \"succeed\" by calling all\n  // loaders during the next loader round\n  function revalidate() {\n    interruptActiveLoads();\n    updateState({\n      revalidation: \"loading\"\n    });\n    // If we're currently submitting an action, we don't need to start a new\n    // navigation, we'll just let the follow up loader execution call all loaders\n    if (state.navigation.state === \"submitting\") {\n      return;\n    }\n    // If we're currently in an idle state, start a new navigation for the current\n    // action/location and mark it as uninterrupted, which will skip the history\n    // update in completeNavigation\n    if (state.navigation.state === \"idle\") {\n      startNavigation(state.historyAction, state.location, {\n        startUninterruptedRevalidation: true\n      });\n      return;\n    }\n    // Otherwise, if we're currently in a loading state, just start a new\n    // navigation to the navigation.location but do not trigger an uninterrupted\n    // revalidation so that history correctly updates once the navigation completes\n    startNavigation(pendingAction || state.historyAction, state.navigation.location, {\n      overrideNavigation: state.navigation\n    });\n  }\n  // Start a navigation to the given action/location.  Can optionally provide a\n  // overrideNavigation which will override the normalLoad in the case of a redirect\n  // navigation\n  async function startNavigation(historyAction, location, opts) {\n    // Abort any in-progress navigations and start a new one. Unset any ongoing\n    // uninterrupted revalidations unless told otherwise, since we want this\n    // new navigation to update history normally\n    pendingNavigationController && pendingNavigationController.abort();\n    pendingNavigationController = null;\n    pendingAction = historyAction;\n    isUninterruptedRevalidation = (opts && opts.startUninterruptedRevalidation) === true;\n    // Save the current scroll position every time we start a new navigation,\n    // and track whether we should reset scroll on completion\n    saveScrollPosition(state.location, state.matches);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches = matchRoutes(routesToUse, location, basename);\n    let flushSync = (opts && opts.flushSync) === true;\n    // Short circuit with a 404 on the root error boundary if we match nothing\n    if (!matches) {\n      let error = getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n      let {\n        matches: notFoundMatches,\n        route\n      } = getShortCircuitMatches(routesToUse);\n      // Cancel all pending deferred on 404s since we don't keep any routes\n      cancelActiveDeferreds();\n      completeNavigation(location, {\n        matches: notFoundMatches,\n        loaderData: {},\n        errors: {\n          [route.id]: error\n        }\n      }, {\n        flushSync\n      });\n      return;\n    }\n    // Short circuit if it's only a hash change and not a revalidation or\n    // mutation submission.\n    //\n    // Ignore on initial page loads because since the initial load will always\n    // be \"same hash\".  For example, on /page#hash and submit a <Form method=\"post\">\n    // which will default to a navigation to /page\n    if (state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {\n      completeNavigation(location, {\n        matches\n      }, {\n        flushSync\n      });\n      return;\n    }\n    // Create a controller/Request for this navigation\n    pendingNavigationController = new AbortController();\n    let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);\n    let pendingActionData;\n    let pendingError;\n    if (opts && opts.pendingError) {\n      // If we have a pendingError, it means the user attempted a GET submission\n      // with binary FormData so assign here and skip to handleLoaders.  That\n      // way we handle calling loaders above the boundary etc.  It's not really\n      // different from an actionError in that sense.\n      pendingError = {\n        [findNearestBoundary(matches).route.id]: opts.pendingError\n      };\n    } else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {\n      // Call action if we received an action submission\n      let actionOutput = await handleAction(request, location, opts.submission, matches, {\n        replace: opts.replace,\n        flushSync\n      });\n      if (actionOutput.shortCircuited) {\n        return;\n      }\n      pendingActionData = actionOutput.pendingActionData;\n      pendingError = actionOutput.pendingActionError;\n      loadingNavigation = getLoadingNavigation(location, opts.submission);\n      flushSync = false;\n      // Create a GET request for the loaders\n      request = new Request(request.url, {\n        signal: request.signal\n      });\n    }\n    // Call loaders\n    let {\n      shortCircuited,\n      loaderData,\n      errors\n    } = await handleLoaders(request, location, matches, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionData, pendingError);\n    if (shortCircuited) {\n      return;\n    }\n    // Clean up now that the action/loaders have completed.  Don't clean up if\n    // we short circuited because pendingNavigationController will have already\n    // been assigned to a new controller for the next navigation\n    pendingNavigationController = null;\n    completeNavigation(location, _extends({\n      matches\n    }, pendingActionData ? {\n      actionData: pendingActionData\n    } : {}, {\n      loaderData,\n      errors\n    }));\n  }\n  // Call the action matched by the leaf route for this navigation and handle\n  // redirects/errors\n  async function handleAction(request, location, submission, matches, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    interruptActiveLoads();\n    // Put us in a submitting state\n    let navigation = getSubmittingNavigation(location, submission);\n    updateState({\n      navigation\n    }, {\n      flushSync: opts.flushSync === true\n    });\n    // Call our action and get the result\n    let result;\n    let actionMatch = getTargetMatch(matches, location);\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      result = {\n        type: ResultType.error,\n        error: getInternalRouterError(405, {\n          method: request.method,\n          pathname: location.pathname,\n          routeId: actionMatch.route.id\n        })\n      };\n    } else {\n      result = await callLoaderOrAction(\"action\", request, actionMatch, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);\n      if (request.signal.aborted) {\n        return {\n          shortCircuited: true\n        };\n      }\n    }\n    if (isRedirectResult(result)) {\n      let replace;\n      if (opts && opts.replace != null) {\n        replace = opts.replace;\n      } else {\n        // If the user didn't explicity indicate replace behavior, replace if\n        // we redirected to the exact same location we're currently at to avoid\n        // double back-buttons\n        replace = result.location === state.location.pathname + state.location.search;\n      }\n      await startRedirectNavigation(state, result, {\n        submission,\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n      // By default, all submissions are REPLACE navigations, but if the\n      // action threw an error that'll be rendered in an errorElement, we fall\n      // back to PUSH so that the user can use the back button to get back to\n      // the pre-submission form location to try again\n      if ((opts && opts.replace) !== true) {\n        pendingAction = Action.Push;\n      }\n      return {\n        // Send back an empty object we can use to clear out any prior actionData\n        pendingActionData: {},\n        pendingActionError: {\n          [boundaryMatch.route.id]: result.error\n        }\n      };\n    }\n    if (isDeferredResult(result)) {\n      throw getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n    }\n    return {\n      pendingActionData: {\n        [actionMatch.route.id]: result.data\n      }\n    };\n  }\n  // Call all applicable loaders for the given matches, handling redirects,\n  // errors, etc.\n  async function handleLoaders(request, location, matches, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionData, pendingError) {\n    // Figure out the right navigation we want to use for data loading\n    let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);\n    // If this was a redirect from an action we don't have a \"submission\" but\n    // we have it on the loading navigation so use that if available\n    let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionData, pendingError);\n    // Cancel pending deferreds for no-longer-matched routes or routes we're\n    // about to reload.  Note that if this is an action reload we would have\n    // already cancelled all pending deferreds so this would be a no-op\n    cancelActiveDeferreds(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId));\n    pendingNavigationLoadId = ++incrementingLoadId;\n    // Short circuit if we have no loaders to run\n    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n      let updatedFetchers = markFetchRedirectsDone();\n      completeNavigation(location, _extends({\n        matches,\n        loaderData: {},\n        // Commit pending error if we're short circuiting\n        errors: pendingError || null\n      }, pendingActionData ? {\n        actionData: pendingActionData\n      } : {}, updatedFetchers ? {\n        fetchers: new Map(state.fetchers)\n      } : {}), {\n        flushSync\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    // If this is an uninterrupted revalidation, we remain in our current idle\n    // state.  If not, we need to switch to our loading state and load data,\n    // preserving any new action data or existing action data (in the case of\n    // a revalidation interrupting an actionReload)\n    // If we have partialHydration enabled, then don't update the state for the\n    // initial data load since it's not a \"navigation\"\n    if (!isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration)) {\n      revalidatingFetchers.forEach(rf => {\n        let fetcher = state.fetchers.get(rf.key);\n        let revalidatingFetcher = getLoadingFetcher(undefined, fetcher ? fetcher.data : undefined);\n        state.fetchers.set(rf.key, revalidatingFetcher);\n      });\n      let actionData = pendingActionData || state.actionData;\n      updateState(_extends({\n        navigation: loadingNavigation\n      }, actionData ? Object.keys(actionData).length === 0 ? {\n        actionData: null\n      } : {\n        actionData\n      } : {}, revalidatingFetchers.length > 0 ? {\n        fetchers: new Map(state.fetchers)\n      } : {}), {\n        flushSync\n      });\n    }\n    revalidatingFetchers.forEach(rf => {\n      if (fetchControllers.has(rf.key)) {\n        abortFetcher(rf.key);\n      }\n      if (rf.controller) {\n        // Fetchers use an independent AbortController so that aborting a fetcher\n        // (via deleteFetcher) does not abort the triggering navigation that\n        // triggered the revalidation\n        fetchControllers.set(rf.key, rf.controller);\n      }\n    });\n    // Proxy navigation abort through to revalidation fetchers\n    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(f => abortFetcher(f.key));\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.addEventListener(\"abort\", abortPendingFetchRevalidations);\n    }\n    let {\n      results,\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, request);\n    if (request.signal.aborted) {\n      return {\n        shortCircuited: true\n      };\n    }\n    // Clean up _after_ loaders have completed.  Don't clean up if we short\n    // circuited because fetchControllers would have been aborted and\n    // reassigned to new controllers for the next navigation\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.removeEventListener(\"abort\", abortPendingFetchRevalidations);\n    }\n    revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key));\n    // If any loaders returned a redirect Response, start a new REPLACE navigation\n    let redirect = findRedirect(results);\n    if (redirect) {\n      if (redirect.idx >= matchesToLoad.length) {\n        // If this redirect came from a fetcher make sure we mark it in\n        // fetchRedirectIds so it doesn't get revalidated on the next set of\n        // loader executions\n        let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n        fetchRedirectIds.add(fetcherKey);\n      }\n      await startRedirectNavigation(state, redirect.result, {\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    // Process and commit output from loaders\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, matches, matchesToLoad, loaderResults, pendingError, revalidatingFetchers, fetcherResults, activeDeferreds);\n    // Wire up subscribers to update loaderData as promises settle\n    activeDeferreds.forEach((deferredData, routeId) => {\n      deferredData.subscribe(aborted => {\n        // Note: No need to updateState here since the TrackedPromise on\n        // loaderData is stable across resolve/reject\n        // Remove this instance if we were aborted or if promises have settled\n        if (aborted || deferredData.done) {\n          activeDeferreds.delete(routeId);\n        }\n      });\n    });\n    // During partial hydration, preserve SSR errors for routes that don't re-run\n    if (future.v7_partialHydration && initialHydration && state.errors) {\n      Object.entries(state.errors).filter(_ref2 => {\n        let [id] = _ref2;\n        return !matchesToLoad.some(m => m.route.id === id);\n      }).forEach(_ref3 => {\n        let [routeId, error] = _ref3;\n        errors = Object.assign(errors || {}, {\n          [routeId]: error\n        });\n      });\n    }\n    let updatedFetchers = markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n    return _extends({\n      loaderData,\n      errors\n    }, shouldUpdateFetchers ? {\n      fetchers: new Map(state.fetchers)\n    } : {});\n  }\n  // Trigger a fetcher load/submit for the given fetcher key\n  function fetch(key, routeId, href, opts) {\n    if (isServer) {\n      throw new Error(\"router.fetch() was called during the server render, but it shouldn't be. \" + \"You are likely calling a useFetcher() method in the body of your component. \" + \"Try moving it to a useEffect or a callback.\");\n    }\n    if (fetchControllers.has(key)) abortFetcher(key);\n    let flushSync = (opts && opts.unstable_flushSync) === true;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, future.v7_relativeSplatPath, routeId, opts == null ? void 0 : opts.relative);\n    let matches = matchRoutes(routesToUse, normalizedPath, basename);\n    if (!matches) {\n      setFetcherError(key, routeId, getInternalRouterError(404, {\n        pathname: normalizedPath\n      }), {\n        flushSync\n      });\n      return;\n    }\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, true, normalizedPath, opts);\n    if (error) {\n      setFetcherError(key, routeId, error, {\n        flushSync\n      });\n      return;\n    }\n    let match = getTargetMatch(matches, path);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n    if (submission && isMutationMethod(submission.formMethod)) {\n      handleFetcherAction(key, routeId, path, match, matches, flushSync, submission);\n      return;\n    }\n    // Store off the match so we can call it's shouldRevalidate on subsequent\n    // revalidations\n    fetchLoadMatches.set(key, {\n      routeId,\n      path\n    });\n    handleFetcherLoader(key, routeId, path, match, matches, flushSync, submission);\n  }\n  // Call the action for the matched fetcher.submit(), and then handle redirects,\n  // errors, and revalidation\n  async function handleFetcherAction(key, routeId, path, match, requestMatches, flushSync, submission) {\n    interruptActiveLoads();\n    fetchLoadMatches.delete(key);\n    if (!match.route.action && !match.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: submission.formMethod,\n        pathname: path,\n        routeId: routeId\n      });\n      setFetcherError(key, routeId, error, {\n        flushSync\n      });\n      return;\n    }\n    // Put this fetcher into it's submitting state\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {\n      flushSync\n    });\n    // Call the action for the fetcher\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);\n    fetchControllers.set(key, abortController);\n    let originatingLoadId = incrementingLoadId;\n    let actionResult = await callLoaderOrAction(\"action\", fetchRequest, match, requestMatches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);\n    if (fetchRequest.signal.aborted) {\n      // We can delete this so long as we weren't aborted by our own fetcher\n      // re-submit which would have put _new_ controller is in fetchControllers\n      if (fetchControllers.get(key) === abortController) {\n        fetchControllers.delete(key);\n      }\n      return;\n    }\n    // When using v7_fetcherPersist, we don't want errors bubbling up to the UI\n    // or redirects processed for unmounted fetchers so we just revert them to\n    // idle\n    if (future.v7_fetcherPersist && deletedFetchers.has(key)) {\n      if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      }\n      // Let SuccessResult's fall through for revalidation\n    } else {\n      if (isRedirectResult(actionResult)) {\n        fetchControllers.delete(key);\n        if (pendingNavigationLoadId > originatingLoadId) {\n          // A new navigation was kicked off after our action started, so that\n          // should take precedence over this redirect navigation.  We already\n          // set isRevalidationRequired so all loaders for the new route should\n          // fire unless opted out via shouldRevalidate\n          updateFetcherState(key, getDoneFetcher(undefined));\n          return;\n        } else {\n          fetchRedirectIds.add(key);\n          updateFetcherState(key, getLoadingFetcher(submission));\n          return startRedirectNavigation(state, actionResult, {\n            fetcherSubmission: submission\n          });\n        }\n      }\n      // Process any non-redirect errors thrown\n      if (isErrorResult(actionResult)) {\n        setFetcherError(key, routeId, actionResult.error);\n        return;\n      }\n    }\n    if (isDeferredResult(actionResult)) {\n      throw getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n    }\n    // Start the data load for current matches, or the next location if we're\n    // in the middle of a navigation\n    let nextLocation = state.navigation.location || state.location;\n    let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let matches = state.navigation.state !== \"idle\" ? matchRoutes(routesToUse, state.navigation.location, basename) : state.matches;\n    invariant(matches, \"Didn't find any matches after fetcher action\");\n    let loadId = ++incrementingLoadId;\n    fetchReloadIds.set(key, loadId);\n    let loadFetcher = getLoadingFetcher(submission, actionResult.data);\n    state.fetchers.set(key, loadFetcher);\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, false, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, {\n      [match.route.id]: actionResult.data\n    }, undefined // No need to send through errors since we short circuit above\n    );\n    // Put all revalidating fetchers into the loading state, except for the\n    // current fetcher which we want to keep in it's current loading state which\n    // contains it's action submission info + action data\n    revalidatingFetchers.filter(rf => rf.key !== key).forEach(rf => {\n      let staleKey = rf.key;\n      let existingFetcher = state.fetchers.get(staleKey);\n      let revalidatingFetcher = getLoadingFetcher(undefined, existingFetcher ? existingFetcher.data : undefined);\n      state.fetchers.set(staleKey, revalidatingFetcher);\n      if (fetchControllers.has(staleKey)) {\n        abortFetcher(staleKey);\n      }\n      if (rf.controller) {\n        fetchControllers.set(staleKey, rf.controller);\n      }\n    });\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(rf => abortFetcher(rf.key));\n    abortController.signal.addEventListener(\"abort\", abortPendingFetchRevalidations);\n    let {\n      results,\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);\n    if (abortController.signal.aborted) {\n      return;\n    }\n    abortController.signal.removeEventListener(\"abort\", abortPendingFetchRevalidations);\n    fetchReloadIds.delete(key);\n    fetchControllers.delete(key);\n    revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));\n    let redirect = findRedirect(results);\n    if (redirect) {\n      if (redirect.idx >= matchesToLoad.length) {\n        // If this redirect came from a fetcher make sure we mark it in\n        // fetchRedirectIds so it doesn't get revalidated on the next set of\n        // loader executions\n        let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n        fetchRedirectIds.add(fetcherKey);\n      }\n      return startRedirectNavigation(state, redirect.result);\n    }\n    // Process and commit output from loaders\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, state.matches, matchesToLoad, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);\n    // Since we let revalidations complete even if the submitting fetcher was\n    // deleted, only put it back to idle if it hasn't been deleted\n    if (state.fetchers.has(key)) {\n      let doneFetcher = getDoneFetcher(actionResult.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n    abortStaleFetchLoads(loadId);\n    // If we are currently in a navigation loading state and this fetcher is\n    // more recent than the navigation, we want the newer data so abort the\n    // navigation and complete it with the fetcher data\n    if (state.navigation.state === \"loading\" && loadId > pendingNavigationLoadId) {\n      invariant(pendingAction, \"Expected pending action\");\n      pendingNavigationController && pendingNavigationController.abort();\n      completeNavigation(state.navigation.location, {\n        matches,\n        loaderData,\n        errors,\n        fetchers: new Map(state.fetchers)\n      });\n    } else {\n      // otherwise just update with the fetcher data, preserving any existing\n      // loaderData for loaders that did not need to reload.  We have to\n      // manually merge here since we aren't going through completeNavigation\n      updateState({\n        errors,\n        loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors),\n        fetchers: new Map(state.fetchers)\n      });\n      isRevalidationRequired = false;\n    }\n  }\n  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n  async function handleFetcherLoader(key, routeId, path, match, matches, flushSync, submission) {\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : undefined), {\n      flushSync\n    });\n    // Call the loader for this fetcher route match\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);\n    fetchControllers.set(key, abortController);\n    let originatingLoadId = incrementingLoadId;\n    let result = await callLoaderOrAction(\"loader\", fetchRequest, match, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);\n    // Deferred isn't supported for fetcher loads, await everything and treat it\n    // as a normal load.  resolveDeferredData will return undefined if this\n    // fetcher gets aborted, so we just leave result untouched and short circuit\n    // below if that happens\n    if (isDeferredResult(result)) {\n      result = (await resolveDeferredData(result, fetchRequest.signal, true)) || result;\n    }\n    // We can delete this so long as we weren't aborted by our our own fetcher\n    // re-load which would have put _new_ controller is in fetchControllers\n    if (fetchControllers.get(key) === abortController) {\n      fetchControllers.delete(key);\n    }\n    if (fetchRequest.signal.aborted) {\n      return;\n    }\n    // We don't want errors bubbling up or redirects followed for unmounted\n    // fetchers, so short circuit here if it was removed from the UI\n    if (deletedFetchers.has(key)) {\n      updateFetcherState(key, getDoneFetcher(undefined));\n      return;\n    }\n    // If the loader threw a redirect Response, start a new REPLACE navigation\n    if (isRedirectResult(result)) {\n      if (pendingNavigationLoadId > originatingLoadId) {\n        // A new navigation was kicked off after our loader started, so that\n        // should take precedence over this redirect navigation\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      } else {\n        fetchRedirectIds.add(key);\n        await startRedirectNavigation(state, result);\n        return;\n      }\n    }\n    // Process any non-redirect errors thrown\n    if (isErrorResult(result)) {\n      setFetcherError(key, routeId, result.error);\n      return;\n    }\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n    // Put the fetcher back into an idle state\n    updateFetcherState(key, getDoneFetcher(result.data));\n  }\n  /**\n   * Utility function to handle redirects returned from an action or loader.\n   * Normally, a redirect \"replaces\" the navigation that triggered it.  So, for\n   * example:\n   *\n   *  - user is on /a\n   *  - user clicks a link to /b\n   *  - loader for /b redirects to /c\n   *\n   * In a non-JS app the browser would track the in-flight navigation to /b and\n   * then replace it with /c when it encountered the redirect response.  In\n   * the end it would only ever update the URL bar with /c.\n   *\n   * In client-side routing using pushState/replaceState, we aim to emulate\n   * this behavior and we also do not update history until the end of the\n   * navigation (including processed redirects).  This means that we never\n   * actually touch history until we've processed redirects, so we just use\n   * the history action from the original navigation (PUSH or REPLACE).\n   */\n  async function startRedirectNavigation(state, redirect, _temp2) {\n    let {\n      submission,\n      fetcherSubmission,\n      replace\n    } = _temp2 === void 0 ? {} : _temp2;\n    if (redirect.revalidate) {\n      isRevalidationRequired = true;\n    }\n    let redirectLocation = createLocation(state.location, redirect.location, {\n      _isRedirect: true\n    });\n    invariant(redirectLocation, \"Expected a location on the redirect navigation\");\n    if (isBrowser) {\n      let isDocumentReload = false;\n      if (redirect.reloadDocument) {\n        // Hard reload if the response contained X-Remix-Reload-Document\n        isDocumentReload = true;\n      } else if (ABSOLUTE_URL_REGEX.test(redirect.location)) {\n        const url = init.history.createURL(redirect.location);\n        isDocumentReload =\n        // Hard reload if it's an absolute URL to a new origin\n        url.origin !== routerWindow.location.origin ||\n        // Hard reload if it's an absolute URL that does not match our basename\n        stripBasename(url.pathname, basename) == null;\n      }\n      if (isDocumentReload) {\n        if (replace) {\n          routerWindow.location.replace(redirect.location);\n        } else {\n          routerWindow.location.assign(redirect.location);\n        }\n        return;\n      }\n    }\n    // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n    pendingNavigationController = null;\n    let redirectHistoryAction = replace === true ? Action.Replace : Action.Push;\n    // Use the incoming submission if provided, fallback on the active one in\n    // state.navigation\n    let {\n      formMethod,\n      formAction,\n      formEncType\n    } = state.navigation;\n    if (!submission && !fetcherSubmission && formMethod && formAction && formEncType) {\n      submission = getSubmissionFromNavigation(state.navigation);\n    }\n    // If this was a 307/308 submission we want to preserve the HTTP method and\n    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the\n    // redirected location\n    let activeSubmission = submission || fetcherSubmission;\n    if (redirectPreserveMethodStatusCodes.has(redirect.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        submission: _extends({}, activeSubmission, {\n          formAction: redirect.location\n        }),\n        // Preserve this flag across redirects\n        preventScrollReset: pendingPreventScrollReset\n      });\n    } else {\n      // If we have a navigation submission, we will preserve it through the\n      // redirect navigation\n      let overrideNavigation = getLoadingNavigation(redirectLocation, submission);\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        overrideNavigation,\n        // Send fetcher submissions through for shouldRevalidate\n        fetcherSubmission,\n        // Preserve this flag across redirects\n        preventScrollReset: pendingPreventScrollReset\n      });\n    }\n  }\n  async function callLoadersAndMaybeResolveData(currentMatches, matches, matchesToLoad, fetchersToLoad, request) {\n    // Call all navigation loaders and revalidating fetcher loaders in parallel,\n    // then slice off the results into separate arrays so we can handle them\n    // accordingly\n    let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction(\"loader\", request, match, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath)), ...fetchersToLoad.map(f => {\n      if (f.matches && f.match && f.controller) {\n        return callLoaderOrAction(\"loader\", createClientSideRequest(init.history, f.path, f.controller.signal), f.match, f.matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);\n      } else {\n        let error = {\n          type: ResultType.error,\n          error: getInternalRouterError(404, {\n            pathname: f.path\n          })\n        };\n        return error;\n      }\n    })]);\n    let loaderResults = results.slice(0, matchesToLoad.length);\n    let fetcherResults = results.slice(matchesToLoad.length);\n    await Promise.all([resolveDeferredResults(currentMatches, matchesToLoad, loaderResults, loaderResults.map(() => request.signal), false, state.loaderData), resolveDeferredResults(currentMatches, fetchersToLoad.map(f => f.match), fetcherResults, fetchersToLoad.map(f => f.controller ? f.controller.signal : null), true)]);\n    return {\n      results,\n      loaderResults,\n      fetcherResults\n    };\n  }\n  function interruptActiveLoads() {\n    // Every interruption triggers a revalidation\n    isRevalidationRequired = true;\n    // Cancel pending route-level deferreds and mark cancelled routes for\n    // revalidation\n    cancelledDeferredRoutes.push(...cancelActiveDeferreds());\n    // Abort in-flight fetcher loads\n    fetchLoadMatches.forEach((_, key) => {\n      if (fetchControllers.has(key)) {\n        cancelledFetcherLoads.push(key);\n        abortFetcher(key);\n      }\n    });\n  }\n  function updateFetcherState(key, fetcher, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    state.fetchers.set(key, fetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    }, {\n      flushSync: (opts && opts.flushSync) === true\n    });\n  }\n  function setFetcherError(key, routeId, error, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    let boundaryMatch = findNearestBoundary(state.matches, routeId);\n    deleteFetcher(key);\n    updateState({\n      errors: {\n        [boundaryMatch.route.id]: error\n      },\n      fetchers: new Map(state.fetchers)\n    }, {\n      flushSync: (opts && opts.flushSync) === true\n    });\n  }\n  function getFetcher(key) {\n    if (future.v7_fetcherPersist) {\n      activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);\n      // If this fetcher was previously marked for deletion, unmark it since we\n      // have a new instance\n      if (deletedFetchers.has(key)) {\n        deletedFetchers.delete(key);\n      }\n    }\n    return state.fetchers.get(key) || IDLE_FETCHER;\n  }\n  function deleteFetcher(key) {\n    let fetcher = state.fetchers.get(key);\n    // Don't abort the controller if this is a deletion of a fetcher.submit()\n    // in it's loading phase since - we don't want to abort the corresponding\n    // revalidation and want them to complete and land\n    if (fetchControllers.has(key) && !(fetcher && fetcher.state === \"loading\" && fetchReloadIds.has(key))) {\n      abortFetcher(key);\n    }\n    fetchLoadMatches.delete(key);\n    fetchReloadIds.delete(key);\n    fetchRedirectIds.delete(key);\n    deletedFetchers.delete(key);\n    state.fetchers.delete(key);\n  }\n  function deleteFetcherAndUpdateState(key) {\n    if (future.v7_fetcherPersist) {\n      let count = (activeFetchers.get(key) || 0) - 1;\n      if (count <= 0) {\n        activeFetchers.delete(key);\n        deletedFetchers.add(key);\n      } else {\n        activeFetchers.set(key, count);\n      }\n    } else {\n      deleteFetcher(key);\n    }\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n  }\n  function abortFetcher(key) {\n    let controller = fetchControllers.get(key);\n    invariant(controller, \"Expected fetch controller: \" + key);\n    controller.abort();\n    fetchControllers.delete(key);\n  }\n  function markFetchersDone(keys) {\n    for (let key of keys) {\n      let fetcher = getFetcher(key);\n      let doneFetcher = getDoneFetcher(fetcher.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n  function markFetchRedirectsDone() {\n    let doneKeys = [];\n    let updatedFetchers = false;\n    for (let key of fetchRedirectIds) {\n      let fetcher = state.fetchers.get(key);\n      invariant(fetcher, \"Expected fetcher: \" + key);\n      if (fetcher.state === \"loading\") {\n        fetchRedirectIds.delete(key);\n        doneKeys.push(key);\n        updatedFetchers = true;\n      }\n    }\n    markFetchersDone(doneKeys);\n    return updatedFetchers;\n  }\n  function abortStaleFetchLoads(landedId) {\n    let yeetedKeys = [];\n    for (let [key, id] of fetchReloadIds) {\n      if (id < landedId) {\n        let fetcher = state.fetchers.get(key);\n        invariant(fetcher, \"Expected fetcher: \" + key);\n        if (fetcher.state === \"loading\") {\n          abortFetcher(key);\n          fetchReloadIds.delete(key);\n          yeetedKeys.push(key);\n        }\n      }\n    }\n    markFetchersDone(yeetedKeys);\n    return yeetedKeys.length > 0;\n  }\n  function getBlocker(key, fn) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n    if (blockerFunctions.get(key) !== fn) {\n      blockerFunctions.set(key, fn);\n    }\n    return blocker;\n  }\n  function deleteBlocker(key) {\n    state.blockers.delete(key);\n    blockerFunctions.delete(key);\n  }\n  // Utility function to update blockers, ensuring valid state transitions\n  function updateBlocker(key, newBlocker) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n    // Poor mans state machine :)\n    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n    invariant(blocker.state === \"unblocked\" && newBlocker.state === \"blocked\" || blocker.state === \"blocked\" && newBlocker.state === \"blocked\" || blocker.state === \"blocked\" && newBlocker.state === \"proceeding\" || blocker.state === \"blocked\" && newBlocker.state === \"unblocked\" || blocker.state === \"proceeding\" && newBlocker.state === \"unblocked\", \"Invalid blocker state transition: \" + blocker.state + \" -> \" + newBlocker.state);\n    let blockers = new Map(state.blockers);\n    blockers.set(key, newBlocker);\n    updateState({\n      blockers\n    });\n  }\n  function shouldBlockNavigation(_ref4) {\n    let {\n      currentLocation,\n      nextLocation,\n      historyAction\n    } = _ref4;\n    if (blockerFunctions.size === 0) {\n      return;\n    }\n    // We ony support a single active blocker at the moment since we don't have\n    // any compelling use cases for multi-blocker yet\n    if (blockerFunctions.size > 1) {\n      warning(false, \"A router only supports one blocker at a time\");\n    }\n    let entries = Array.from(blockerFunctions.entries());\n    let [blockerKey, blockerFunction] = entries[entries.length - 1];\n    let blocker = state.blockers.get(blockerKey);\n    if (blocker && blocker.state === \"proceeding\") {\n      // If the blocker is currently proceeding, we don't need to re-check\n      // it and can let this navigation continue\n      return;\n    }\n    // At this point, we know we're unblocked/blocked so we need to check the\n    // user-provided blocker function\n    if (blockerFunction({\n      currentLocation,\n      nextLocation,\n      historyAction\n    })) {\n      return blockerKey;\n    }\n  }\n  function cancelActiveDeferreds(predicate) {\n    let cancelledRouteIds = [];\n    activeDeferreds.forEach((dfd, routeId) => {\n      if (!predicate || predicate(routeId)) {\n        // Cancel the deferred - but do not remove from activeDeferreds here -\n        // we rely on the subscribers to do that so our tests can assert proper\n        // cleanup via _internalActiveDeferreds\n        dfd.cancel();\n        cancelledRouteIds.push(routeId);\n        activeDeferreds.delete(routeId);\n      }\n    });\n    return cancelledRouteIds;\n  }\n  // Opt in to capturing and reporting scroll positions during navigations,\n  // used by the <ScrollRestoration> component\n  function enableScrollRestoration(positions, getPosition, getKey) {\n    savedScrollPositions = positions;\n    getScrollPosition = getPosition;\n    getScrollRestorationKey = getKey || null;\n    // Perform initial hydration scroll restoration, since we miss the boat on\n    // the initial updateState() because we've not yet rendered <ScrollRestoration/>\n    // and therefore have no savedScrollPositions available\n    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n      initialScrollRestored = true;\n      let y = getSavedScrollPosition(state.location, state.matches);\n      if (y != null) {\n        updateState({\n          restoreScrollPosition: y\n        });\n      }\n    }\n    return () => {\n      savedScrollPositions = null;\n      getScrollPosition = null;\n      getScrollRestorationKey = null;\n    };\n  }\n  function getScrollKey(location, matches) {\n    if (getScrollRestorationKey) {\n      let key = getScrollRestorationKey(location, matches.map(m => convertRouteMatchToUiMatch(m, state.loaderData)));\n      return key || location.key;\n    }\n    return location.key;\n  }\n  function saveScrollPosition(location, matches) {\n    if (savedScrollPositions && getScrollPosition) {\n      let key = getScrollKey(location, matches);\n      savedScrollPositions[key] = getScrollPosition();\n    }\n  }\n  function getSavedScrollPosition(location, matches) {\n    if (savedScrollPositions) {\n      let key = getScrollKey(location, matches);\n      let y = savedScrollPositions[key];\n      if (typeof y === \"number\") {\n        return y;\n      }\n    }\n    return null;\n  }\n  function _internalSetRoutes(newRoutes) {\n    manifest = {};\n    inFlightDataRoutes = convertRoutesToDataRoutes(newRoutes, mapRouteProperties, undefined, manifest);\n  }\n  router = {\n    get basename() {\n      return basename;\n    },\n    get future() {\n      return future;\n    },\n    get state() {\n      return state;\n    },\n    get routes() {\n      return dataRoutes;\n    },\n    get window() {\n      return routerWindow;\n    },\n    initialize,\n    subscribe,\n    enableScrollRestoration,\n    navigate,\n    fetch,\n    revalidate,\n    // Passthrough to history-aware createHref used by useHref so we get proper\n    // hash-aware URLs in DOM paths\n    createHref: to => init.history.createHref(to),\n    encodeLocation: to => init.history.encodeLocation(to),\n    getFetcher,\n    deleteFetcher: deleteFetcherAndUpdateState,\n    dispose,\n    getBlocker,\n    deleteBlocker,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds,\n    // TODO: Remove setRoutes, it's temporary to avoid dealing with\n    // updating the tree while validating the update algorithm.\n    _internalSetRoutes\n  };\n  return router;\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\nconst UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\nfunction createStaticHandler(routes, opts) {\n  invariant(routes.length > 0, \"You must provide a non-empty routes array to createStaticHandler\");\n  let manifest = {};\n  let basename = (opts ? opts.basename : null) || \"/\";\n  let mapRouteProperties;\n  if (opts != null && opts.mapRouteProperties) {\n    mapRouteProperties = opts.mapRouteProperties;\n  } else if (opts != null && opts.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = opts.detectErrorBoundary;\n    mapRouteProperties = route => ({\n      hasErrorBoundary: detectErrorBoundary(route)\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Config driven behavior flags\n  let future = _extends({\n    v7_relativeSplatPath: false,\n    v7_throwAbortReason: false\n  }, opts ? opts.future : null);\n  let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, undefined, manifest);\n  /**\n   * The query() method is intended for document requests, in which we want to\n   * call an optional action and potentially multiple loaders for all nested\n   * routes.  It returns a StaticHandlerContext object, which is very similar\n   * to the router state (location, loaderData, actionData, errors, etc.) and\n   * also adds SSR-specific information such as the statusCode and headers\n   * from action/loaders Responses.\n   *\n   * It _should_ never throw and should report all errors through the\n   * returned context.errors object, properly associating errors to their error\n   * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be\n   * used to emulate React error boundaries during SSr by performing a second\n   * pass only down to the boundaryId.\n   *\n   * The one exception where we do not return a StaticHandlerContext is when a\n   * redirect response is returned or thrown from any action/loader.  We\n   * propagate that out and return the raw Response so the HTTP server can\n   * return it directly.\n   */\n  async function query(request, _temp3) {\n    let {\n      requestContext\n    } = _temp3 === void 0 ? {} : _temp3;\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\") {\n      let error = getInternalRouterError(405, {\n        method\n      });\n      let {\n        matches: methodNotAllowedMatches,\n        route\n      } = getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: methodNotAllowedMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    } else if (!matches) {\n      let error = getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n      let {\n        matches: notFoundMatches,\n        route\n      } = getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: notFoundMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    let result = await queryImpl(request, location, matches, requestContext);\n    if (isResponse(result)) {\n      return result;\n    }\n    // When returning StaticHandlerContext, we patch back in the location here\n    // since we need it for React Context.  But this helps keep our submit and\n    // loadRouteData operating on a Request instead of a Location\n    return _extends({\n      location,\n      basename\n    }, result);\n  }\n  /**\n   * The queryRoute() method is intended for targeted route requests, either\n   * for fetch ?_data requests or resource route requests.  In this case, we\n   * are only ever calling a single action or loader, and we are returning the\n   * returned value directly.  In most cases, this will be a Response returned\n   * from the action/loader, but it may be a primitive or other value as well -\n   * and in such cases the calling context should handle that accordingly.\n   *\n   * We do respect the throw/return differentiation, so if an action/loader\n   * throws, then this method will throw the value.  This is important so we\n   * can do proper boundary identification in Remix where a thrown Response\n   * must go to the Catch Boundary but a returned Response is happy-path.\n   *\n   * One thing to note is that any Router-initiated Errors that make sense\n   * to associate with a status code will be thrown as an ErrorResponse\n   * instance which include the raw Error, such that the calling context can\n   * serialize the error as they see fit while including the proper response\n   * code.  Examples here are 404 and 405 errors that occur prior to reaching\n   * any user-defined loaders.\n   */\n  async function queryRoute(request, _temp4) {\n    let {\n      routeId,\n      requestContext\n    } = _temp4 === void 0 ? {} : _temp4;\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\" && method !== \"OPTIONS\") {\n      throw getInternalRouterError(405, {\n        method\n      });\n    } else if (!matches) {\n      throw getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n    }\n    let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);\n    if (routeId && !match) {\n      throw getInternalRouterError(403, {\n        pathname: location.pathname,\n        routeId\n      });\n    } else if (!match) {\n      // This should never hit I don't think?\n      throw getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n    }\n    let result = await queryImpl(request, location, matches, requestContext, match);\n    if (isResponse(result)) {\n      return result;\n    }\n    let error = result.errors ? Object.values(result.errors)[0] : undefined;\n    if (error !== undefined) {\n      // If we got back result.errors, that means the loader/action threw\n      // _something_ that wasn't a Response, but it's not guaranteed/required\n      // to be an `instanceof Error` either, so we have to use throw here to\n      // preserve the \"error\" state outside of queryImpl.\n      throw error;\n    }\n    // Pick off the right state value to return\n    if (result.actionData) {\n      return Object.values(result.actionData)[0];\n    }\n    if (result.loaderData) {\n      var _result$activeDeferre;\n      let data = Object.values(result.loaderData)[0];\n      if ((_result$activeDeferre = result.activeDeferreds) != null && _result$activeDeferre[match.route.id]) {\n        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];\n      }\n      return data;\n    }\n    return undefined;\n  }\n  async function queryImpl(request, location, matches, requestContext, routeMatch) {\n    invariant(request.signal, \"query()/queryRoute() requests must contain an AbortController signal\");\n    try {\n      if (isMutationMethod(request.method.toLowerCase())) {\n        let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, routeMatch != null);\n        return result;\n      }\n      let result = await loadRouteData(request, matches, requestContext, routeMatch);\n      return isResponse(result) ? result : _extends({}, result, {\n        actionData: null,\n        actionHeaders: {}\n      });\n    } catch (e) {\n      // If the user threw/returned a Response in callLoaderOrAction, we throw\n      // it to bail out and then return or throw here based on whether the user\n      // returned or threw\n      if (isQueryRouteResponse(e)) {\n        if (e.type === ResultType.error) {\n          throw e.response;\n        }\n        return e.response;\n      }\n      // Redirects are always returned since they don't propagate to catch\n      // boundaries\n      if (isRedirectResponse(e)) {\n        return e;\n      }\n      throw e;\n    }\n  }\n  async function submit(request, matches, actionMatch, requestContext, isRouteRequest) {\n    let result;\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: actionMatch.route.id\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error\n      };\n    } else {\n      result = await callLoaderOrAction(\"action\", request, actionMatch, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath, {\n        isStaticRequest: true,\n        isRouteRequest,\n        requestContext\n      });\n      if (request.signal.aborted) {\n        throwStaticHandlerAbortedError(request, isRouteRequest, future);\n      }\n    }\n    if (isRedirectResult(result)) {\n      // Uhhhh - this should never happen, we should always throw these from\n      // callLoaderOrAction, but the type narrowing here keeps TS happy and we\n      // can get back on the \"throw all redirect responses\" train here should\n      // this ever happen :/\n      throw new Response(null, {\n        status: result.status,\n        headers: {\n          Location: result.location\n        }\n      });\n    }\n    if (isDeferredResult(result)) {\n      let error = getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error\n      };\n    }\n    if (isRouteRequest) {\n      // Note: This should only be non-Response values if we get here, since\n      // isRouteRequest should throw any Response received in callLoaderOrAction\n      if (isErrorResult(result)) {\n        throw result.error;\n      }\n      return {\n        matches: [actionMatch],\n        loaderData: {},\n        actionData: {\n          [actionMatch.route.id]: result.data\n        },\n        errors: null,\n        // Note: statusCode + headers are unused here since queryRoute will\n        // return the raw Response or value\n        statusCode: 200,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n      let context = await loadRouteData(request, matches, requestContext, undefined, {\n        [boundaryMatch.route.id]: result.error\n      });\n      // action status codes take precedence over loader status codes\n      return _extends({}, context, {\n        statusCode: isRouteErrorResponse(result.error) ? result.error.status : 500,\n        actionData: null,\n        actionHeaders: _extends({}, result.headers ? {\n          [actionMatch.route.id]: result.headers\n        } : {})\n      });\n    }\n    // Create a GET request for the loaders\n    let loaderRequest = new Request(request.url, {\n      headers: request.headers,\n      redirect: request.redirect,\n      signal: request.signal\n    });\n    let context = await loadRouteData(loaderRequest, matches, requestContext);\n    return _extends({}, context, result.statusCode ? {\n      statusCode: result.statusCode\n    } : {}, {\n      actionData: {\n        [actionMatch.route.id]: result.data\n      },\n      actionHeaders: _extends({}, result.headers ? {\n        [actionMatch.route.id]: result.headers\n      } : {})\n    });\n  }\n  async function loadRouteData(request, matches, requestContext, routeMatch, pendingActionError) {\n    let isRouteRequest = routeMatch != null;\n    // Short circuit if we have no loaders to run (queryRoute())\n    if (isRouteRequest && !(routeMatch != null && routeMatch.route.loader) && !(routeMatch != null && routeMatch.route.lazy)) {\n      throw getInternalRouterError(400, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: routeMatch == null ? void 0 : routeMatch.route.id\n      });\n    }\n    let requestMatches = routeMatch ? [routeMatch] : getLoaderMatchesUntilBoundary(matches, Object.keys(pendingActionError || {})[0]);\n    let matchesToLoad = requestMatches.filter(m => m.route.loader || m.route.lazy);\n    // Short circuit if we have no loaders to run (query())\n    if (matchesToLoad.length === 0) {\n      return {\n        matches,\n        // Add a null for all matched routes for proper revalidation on the client\n        loaderData: matches.reduce((acc, m) => Object.assign(acc, {\n          [m.route.id]: null\n        }), {}),\n        errors: pendingActionError || null,\n        statusCode: 200,\n        loaderHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction(\"loader\", request, match, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath, {\n      isStaticRequest: true,\n      isRouteRequest,\n      requestContext\n    }))]);\n    if (request.signal.aborted) {\n      throwStaticHandlerAbortedError(request, isRouteRequest, future);\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: isRouteErrorResponse(error) ? error.status : 500,\n    errors: {\n      [context._deepestRenderedBoundaryId || routes[0].id]: error\n    }\n  });\n  return newContext;\n}\nfunction throwStaticHandlerAbortedError(request, isRouteRequest, future) {\n  if (future.v7_throwAbortReason && request.signal.reason !== undefined) {\n    throw request.signal.reason;\n  }\n  let method = isRouteRequest ? \"queryRoute\" : \"query\";\n  throw new Error(method + \"() call aborted: \" + request.method + \" \" + request.url);\n}\nfunction isSubmissionNavigation(opts) {\n  return opts != null && (\"formData\" in opts && opts.formData != null || \"body\" in opts && opts.body !== undefined);\n}\nfunction normalizeTo(location, matches, basename, prependBasename, to, v7_relativeSplatPath, fromRouteId, relative) {\n  let contextualMatches;\n  let activeRouteMatch;\n  if (fromRouteId) {\n    // Grab matches up to the calling route so our route-relative logic is\n    // relative to the correct source route\n    contextualMatches = [];\n    for (let match of matches) {\n      contextualMatches.push(match);\n      if (match.route.id === fromRouteId) {\n        activeRouteMatch = match;\n        break;\n      }\n    }\n  } else {\n    contextualMatches = matches;\n    activeRouteMatch = matches[matches.length - 1];\n  }\n  // Resolve the relative path\n  let path = resolveTo(to ? to : \".\", getResolveToMatches(contextualMatches, v7_relativeSplatPath), stripBasename(location.pathname, basename) || location.pathname, relative === \"path\");\n  // When `to` is not specified we inherit search/hash from the current\n  // location, unlike when to=\".\" and we just inherit the path.\n  // See https://github.com/remix-run/remix/issues/927\n  if (to == null) {\n    path.search = location.search;\n    path.hash = location.hash;\n  }\n  // Add an ?index param for matched index routes if we don't already have one\n  if ((to == null || to === \"\" || to === \".\") && activeRouteMatch && activeRouteMatch.route.index && !hasNakedIndexQuery(path.search)) {\n    path.search = path.search ? path.search.replace(/^\\?/, \"?index&\") : \"?index\";\n  }\n  // If we're operating within a basename, prepend it to the pathname.  If\n  // this is a root navigation, then just use the raw basename which allows\n  // the basename to have full control over the presence of a trailing slash\n  // on root actions\n  if (prependBasename && basename !== \"/\") {\n    path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n  return createPath(path);\n}\n// Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\nfunction normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {\n  // Return location verbatim on non-submission navigations\n  if (!opts || !isSubmissionNavigation(opts)) {\n    return {\n      path\n    };\n  }\n  if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n    return {\n      path,\n      error: getInternalRouterError(405, {\n        method: opts.formMethod\n      })\n    };\n  }\n  let getInvalidBodyError = () => ({\n    path,\n    error: getInternalRouterError(400, {\n      type: \"invalid-body\"\n    })\n  });\n  // Create a Submission on non-GET navigations\n  let rawFormMethod = opts.formMethod || \"get\";\n  let formMethod = normalizeFormMethod ? rawFormMethod.toUpperCase() : rawFormMethod.toLowerCase();\n  let formAction = stripHashFromPath(path);\n  if (opts.body !== undefined) {\n    if (opts.formEncType === \"text/plain\") {\n      // text only support POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n      let text = typeof opts.body === \"string\" ? opts.body : opts.body instanceof FormData || opts.body instanceof URLSearchParams ?\n      // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data\n      Array.from(opts.body.entries()).reduce((acc, _ref5) => {\n        let [name, value] = _ref5;\n        return \"\" + acc + name + \"=\" + value + \"\\n\";\n      }, \"\") : String(opts.body);\n      return {\n        path,\n        submission: {\n          formMethod,\n          formAction,\n          formEncType: opts.formEncType,\n          formData: undefined,\n          json: undefined,\n          text\n        }\n      };\n    } else if (opts.formEncType === \"application/json\") {\n      // json only supports POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n      try {\n        let json = typeof opts.body === \"string\" ? JSON.parse(opts.body) : opts.body;\n        return {\n          path,\n          submission: {\n            formMethod,\n            formAction,\n            formEncType: opts.formEncType,\n            formData: undefined,\n            json,\n            text: undefined\n          }\n        };\n      } catch (e) {\n        return getInvalidBodyError();\n      }\n    }\n  }\n  invariant(typeof FormData === \"function\", \"FormData is not available in this environment\");\n  let searchParams;\n  let formData;\n  if (opts.formData) {\n    searchParams = convertFormDataToSearchParams(opts.formData);\n    formData = opts.formData;\n  } else if (opts.body instanceof FormData) {\n    searchParams = convertFormDataToSearchParams(opts.body);\n    formData = opts.body;\n  } else if (opts.body instanceof URLSearchParams) {\n    searchParams = opts.body;\n    formData = convertSearchParamsToFormData(searchParams);\n  } else if (opts.body == null) {\n    searchParams = new URLSearchParams();\n    formData = new FormData();\n  } else {\n    try {\n      searchParams = new URLSearchParams(opts.body);\n      formData = convertSearchParamsToFormData(searchParams);\n    } catch (e) {\n      return getInvalidBodyError();\n    }\n  }\n  let submission = {\n    formMethod,\n    formAction,\n    formEncType: opts && opts.formEncType || \"application/x-www-form-urlencoded\",\n    formData,\n    json: undefined,\n    text: undefined\n  };\n  if (isMutationMethod(submission.formMethod)) {\n    return {\n      path,\n      submission\n    };\n  }\n  // Flatten submission onto URLSearchParams for GET submissions\n  let parsedPath = parsePath(path);\n  // On GET navigation submissions we can drop the ?index param from the\n  // resulting location since all loaders will run.  But fetcher GET submissions\n  // only run a single loader so we need to preserve any incoming ?index params\n  if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n    searchParams.append(\"index\", \"\");\n  }\n  parsedPath.search = \"?\" + searchParams;\n  return {\n    path: createPath(parsedPath),\n    submission\n  };\n}\n// Filter out all routes below any caught error as they aren't going to\n// render so we don't need to load them\nfunction getLoaderMatchesUntilBoundary(matches, boundaryId) {\n  let boundaryMatches = matches;\n  if (boundaryId) {\n    let index = matches.findIndex(m => m.route.id === boundaryId);\n    if (index >= 0) {\n      boundaryMatches = matches.slice(0, index);\n    }\n  }\n  return boundaryMatches;\n}\nfunction getMatchesToLoad(history, state, matches, submission, location, isInitialLoad, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionData, pendingError) {\n  let actionResult = pendingError ? Object.values(pendingError)[0] : pendingActionData ? Object.values(pendingActionData)[0] : undefined;\n  let currentUrl = history.createURL(state.location);\n  let nextUrl = history.createURL(location);\n  // Pick navigation matches that are net-new or qualify for revalidation\n  let boundaryId = pendingError ? Object.keys(pendingError)[0] : undefined;\n  let boundaryMatches = getLoaderMatchesUntilBoundary(matches, boundaryId);\n  let navigationMatches = boundaryMatches.filter((match, index) => {\n    let {\n      route\n    } = match;\n    if (route.lazy) {\n      // We haven't loaded this route yet so we don't know if it's got a loader!\n      return true;\n    }\n    if (route.loader == null) {\n      return false;\n    }\n    if (isInitialLoad) {\n      if (route.loader.hydrate) {\n        return true;\n      }\n      return state.loaderData[route.id] === undefined && (\n      // Don't re-run if the loader ran and threw an error\n      !state.errors || state.errors[route.id] === undefined);\n    }\n    // Always call the loader on new route instances and pending defer cancellations\n    if (isNewLoader(state.loaderData, state.matches[index], match) || cancelledDeferredRoutes.some(id => id === match.route.id)) {\n      return true;\n    }\n    // This is the default implementation for when we revalidate.  If the route\n    // provides it's own implementation, then we give them full control but\n    // provide this value so they can leverage it if needed after they check\n    // their own specific use cases\n    let currentRouteMatch = state.matches[index];\n    let nextRouteMatch = match;\n    return shouldRevalidateLoader(match, _extends({\n      currentUrl,\n      currentParams: currentRouteMatch.params,\n      nextUrl,\n      nextParams: nextRouteMatch.params\n    }, submission, {\n      actionResult,\n      defaultShouldRevalidate:\n      // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate\n      isRevalidationRequired ||\n      // Clicked the same link, resubmitted a GET form\n      currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search ||\n      // Search params affect all loaders\n      currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)\n    }));\n  });\n  // Pick fetcher.loads that need to be revalidated\n  let revalidatingFetchers = [];\n  fetchLoadMatches.forEach((f, key) => {\n    // Don't revalidate:\n    //  - on initial load (shouldn't be any fetchers then anyway)\n    //  - if fetcher won't be present in the subsequent render\n    //    - no longer matches the URL (v7_fetcherPersist=false)\n    //    - was unmounted but persisted due to v7_fetcherPersist=true\n    if (isInitialLoad || !matches.some(m => m.route.id === f.routeId) || deletedFetchers.has(key)) {\n      return;\n    }\n    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);\n    // If the fetcher path no longer matches, push it in with null matches so\n    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is\n    // currently only a use-case for Remix HMR where the route tree can change\n    // at runtime and remove a route previously loaded via a fetcher\n    if (!fetcherMatches) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: null,\n        match: null,\n        controller: null\n      });\n      return;\n    }\n    // Revalidating fetchers are decoupled from the route matches since they\n    // load from a static href.  They revalidate based on explicit revalidation\n    // (submission, useRevalidator, or X-Remix-Revalidate)\n    let fetcher = state.fetchers.get(key);\n    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);\n    let shouldRevalidate = false;\n    if (fetchRedirectIds.has(key)) {\n      // Never trigger a revalidation of an actively redirecting fetcher\n      shouldRevalidate = false;\n    } else if (cancelledFetcherLoads.includes(key)) {\n      // Always revalidate if the fetcher was cancelled\n      shouldRevalidate = true;\n    } else if (fetcher && fetcher.state !== \"idle\" && fetcher.data === undefined) {\n      // If the fetcher hasn't ever completed loading yet, then this isn't a\n      // revalidation, it would just be a brand new load if an explicit\n      // revalidation is required\n      shouldRevalidate = isRevalidationRequired;\n    } else {\n      // Otherwise fall back on any user-defined shouldRevalidate, defaulting\n      // to explicit revalidations only\n      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({\n        currentUrl,\n        currentParams: state.matches[state.matches.length - 1].params,\n        nextUrl,\n        nextParams: matches[matches.length - 1].params\n      }, submission, {\n        actionResult,\n        defaultShouldRevalidate: isRevalidationRequired\n      }));\n    }\n    if (shouldRevalidate) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: fetcherMatches,\n        match: fetcherMatch,\n        controller: new AbortController()\n      });\n    }\n  });\n  return [navigationMatches, revalidatingFetchers];\n}\nfunction isNewLoader(currentLoaderData, currentMatch, match) {\n  let isNew =\n  // [a] -> [a, b]\n  !currentMatch ||\n  // [a, b] -> [a, c]\n  match.route.id !== currentMatch.route.id;\n  // Handle the case that we don't have data for a re-used route, potentially\n  // from a prior error or from a cancelled pending deferred\n  let isMissingData = currentLoaderData[match.route.id] === undefined;\n  // Always load if this is a net-new route or we don't yet have data\n  return isNew || isMissingData;\n}\nfunction isNewRouteInstance(currentMatch, match) {\n  let currentPath = currentMatch.route.path;\n  return (\n    // param change for this match, /users/123 -> /users/456\n    currentMatch.pathname !== match.pathname ||\n    // splat param changed, which is not present in match.path\n    // e.g. /files/images/avatar.jpg -> files/finances.xls\n    currentPath != null && currentPath.endsWith(\"*\") && currentMatch.params[\"*\"] !== match.params[\"*\"]\n  );\n}\nfunction shouldRevalidateLoader(loaderMatch, arg) {\n  if (loaderMatch.route.shouldRevalidate) {\n    let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n  return arg.defaultShouldRevalidate;\n}\n/**\n * Execute route.lazy() methods to lazily load route modules (loader, action,\n * shouldRevalidate) and update the routeManifest in place which shares objects\n * with dataRoutes so those get updated as well.\n */\nasync function loadLazyRouteModule(route, mapRouteProperties, manifest) {\n  if (!route.lazy) {\n    return;\n  }\n  let lazyRoute = await route.lazy();\n  // If the lazy route function was executed and removed by another parallel\n  // call then we can return - first lazy() to finish wins because the return\n  // value of lazy is expected to be static\n  if (!route.lazy) {\n    return;\n  }\n  let routeToUpdate = manifest[route.id];\n  invariant(routeToUpdate, \"No route found in manifest\");\n  // Update the route in place.  This should be safe because there's no way\n  // we could yet be sitting on this route as we can't get there without\n  // resolving lazy() first.\n  //\n  // This is different than the HMR \"update\" use-case where we may actively be\n  // on the route being updated.  The main concern boils down to \"does this\n  // mutation affect any ongoing navigations or any current state.matches\n  // values?\".  If not, it should be safe to update in place.\n  let routeUpdates = {};\n  for (let lazyRouteProperty in lazyRoute) {\n    let staticRouteValue = routeToUpdate[lazyRouteProperty];\n    let isPropertyStaticallyDefined = staticRouteValue !== undefined &&\n    // This property isn't static since it should always be updated based\n    // on the route updates\n    lazyRouteProperty !== \"hasErrorBoundary\";\n    warning(!isPropertyStaticallyDefined, \"Route \\\"\" + routeToUpdate.id + \"\\\" has a static property \\\"\" + lazyRouteProperty + \"\\\" \" + \"defined but its lazy function is also returning a value for this property. \" + (\"The lazy route property \\\"\" + lazyRouteProperty + \"\\\" will be ignored.\"));\n    if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {\n      routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];\n    }\n  }\n  // Mutate the route with the provided updates.  Do this first so we pass\n  // the updated version to mapRouteProperties\n  Object.assign(routeToUpdate, routeUpdates);\n  // Mutate the `hasErrorBoundary` property on the route based on the route\n  // updates and remove the `lazy` function so we don't resolve the lazy\n  // route again.\n  Object.assign(routeToUpdate, _extends({}, mapRouteProperties(routeToUpdate), {\n    lazy: undefined\n  }));\n}\nasync function callLoaderOrAction(type, request, match, matches, manifest, mapRouteProperties, basename, v7_relativeSplatPath, opts) {\n  if (opts === void 0) {\n    opts = {};\n  }\n  let resultType;\n  let result;\n  let onReject;\n  let runHandler = handler => {\n    // Setup a promise we can race against so that abort signals short circuit\n    let reject;\n    let abortPromise = new Promise((_, r) => reject = r);\n    onReject = () => reject();\n    request.signal.addEventListener(\"abort\", onReject);\n    return Promise.race([handler({\n      request,\n      params: match.params,\n      context: opts.requestContext\n    }), abortPromise]);\n  };\n  try {\n    let handler = match.route[type];\n    if (match.route.lazy) {\n      if (handler) {\n        // Run statically defined handler in parallel with lazy()\n        let handlerError;\n        let values = await Promise.all([\n        // If the handler throws, don't let it immediately bubble out,\n        // since we need to let the lazy() execution finish so we know if this\n        // route has a boundary that can handle the error\n        runHandler(handler).catch(e => {\n          handlerError = e;\n        }), loadLazyRouteModule(match.route, mapRouteProperties, manifest)]);\n        if (handlerError) {\n          throw handlerError;\n        }\n        result = values[0];\n      } else {\n        // Load lazy route module, then run any returned handler\n        await loadLazyRouteModule(match.route, mapRouteProperties, manifest);\n        handler = match.route[type];\n        if (handler) {\n          // Handler still run even if we got interrupted to maintain consistency\n          // with un-abortable behavior of handler execution on non-lazy or\n          // previously-lazy-loaded routes\n          result = await runHandler(handler);\n        } else if (type === \"action\") {\n          let url = new URL(request.url);\n          let pathname = url.pathname + url.search;\n          throw getInternalRouterError(405, {\n            method: request.method,\n            pathname,\n            routeId: match.route.id\n          });\n        } else {\n          // lazy() route has no loader to run.  Short circuit here so we don't\n          // hit the invariant below that errors on returning undefined.\n          return {\n            type: ResultType.data,\n            data: undefined\n          };\n        }\n      }\n    } else if (!handler) {\n      let url = new URL(request.url);\n      let pathname = url.pathname + url.search;\n      throw getInternalRouterError(404, {\n        pathname\n      });\n    } else {\n      result = await runHandler(handler);\n    }\n    invariant(result !== undefined, \"You defined \" + (type === \"action\" ? \"an action\" : \"a loader\") + \" for route \" + (\"\\\"\" + match.route.id + \"\\\" but didn't return anything from your `\" + type + \"` \") + \"function. Please return a value or `null`.\");\n  } catch (e) {\n    resultType = ResultType.error;\n    result = e;\n  } finally {\n    if (onReject) {\n      request.signal.removeEventListener(\"abort\", onReject);\n    }\n  }\n  if (isResponse(result)) {\n    let status = result.status;\n    // Process redirects\n    if (redirectStatusCodes.has(status)) {\n      let location = result.headers.get(\"Location\");\n      invariant(location, \"Redirects returned/thrown from loaders/actions must have a Location header\");\n      // Support relative routing in internal redirects\n      if (!ABSOLUTE_URL_REGEX.test(location)) {\n        location = normalizeTo(new URL(request.url), matches.slice(0, matches.indexOf(match) + 1), basename, true, location, v7_relativeSplatPath);\n      } else if (!opts.isStaticRequest) {\n        // Strip off the protocol+origin for same-origin + same-basename absolute\n        // redirects. If this is a static request, we can let it go back to the\n        // browser as-is\n        let currentUrl = new URL(request.url);\n        let url = location.startsWith(\"//\") ? new URL(currentUrl.protocol + location) : new URL(location);\n        let isSameBasename = stripBasename(url.pathname, basename) != null;\n        if (url.origin === currentUrl.origin && isSameBasename) {\n          location = url.pathname + url.search + url.hash;\n        }\n      }\n      // Don't process redirects in the router during static requests requests.\n      // Instead, throw the Response and let the server handle it with an HTTP\n      // redirect.  We also update the Location header in place in this flow so\n      // basename and relative routing is taken into account\n      if (opts.isStaticRequest) {\n        result.headers.set(\"Location\", location);\n        throw result;\n      }\n      return {\n        type: ResultType.redirect,\n        status,\n        location,\n        revalidate: result.headers.get(\"X-Remix-Revalidate\") !== null,\n        reloadDocument: result.headers.get(\"X-Remix-Reload-Document\") !== null\n      };\n    }\n    // For SSR single-route requests, we want to hand Responses back directly\n    // without unwrapping.  We do this with the QueryRouteResponse wrapper\n    // interface so we can know whether it was returned or thrown\n    if (opts.isRouteRequest) {\n      let queryRouteResponse = {\n        type: resultType === ResultType.error ? ResultType.error : ResultType.data,\n        response: result\n      };\n      throw queryRouteResponse;\n    }\n    let data;\n    try {\n      let contentType = result.headers.get(\"Content-Type\");\n      // Check between word boundaries instead of startsWith() due to the last\n      // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type\n      if (contentType && /\\bapplication\\/json\\b/.test(contentType)) {\n        if (result.body == null) {\n          data = null;\n        } else {\n          data = await result.json();\n        }\n      } else {\n        data = await result.text();\n      }\n    } catch (e) {\n      return {\n        type: ResultType.error,\n        error: e\n      };\n    }\n    if (resultType === ResultType.error) {\n      return {\n        type: resultType,\n        error: new ErrorResponseImpl(status, result.statusText, data),\n        headers: result.headers\n      };\n    }\n    return {\n      type: ResultType.data,\n      data,\n      statusCode: result.status,\n      headers: result.headers\n    };\n  }\n  if (resultType === ResultType.error) {\n    return {\n      type: resultType,\n      error: result\n    };\n  }\n  if (isDeferredData(result)) {\n    var _result$init, _result$init2;\n    return {\n      type: ResultType.deferred,\n      deferredData: result,\n      statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status,\n      headers: ((_result$init2 = result.init) == null ? void 0 : _result$init2.headers) && new Headers(result.init.headers)\n    };\n  }\n  return {\n    type: ResultType.data,\n    data: result\n  };\n}\n// Utility method for creating the Request instances for loaders/actions during\n// client-side navigations and fetches.  During SSR we will always have a\n// Request instance from the static handler (query/queryRoute)\nfunction createClientSideRequest(history, location, signal, submission) {\n  let url = history.createURL(stripHashFromPath(location)).toString();\n  let init = {\n    signal\n  };\n  if (submission && isMutationMethod(submission.formMethod)) {\n    let {\n      formMethod,\n      formEncType\n    } = submission;\n    // Didn't think we needed this but it turns out unlike other methods, patch\n    // won't be properly normalized to uppercase and results in a 405 error.\n    // See: https://fetch.spec.whatwg.org/#concept-method\n    init.method = formMethod.toUpperCase();\n    if (formEncType === \"application/json\") {\n      init.headers = new Headers({\n        \"Content-Type\": formEncType\n      });\n      init.body = JSON.stringify(submission.json);\n    } else if (formEncType === \"text/plain\") {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.text;\n    } else if (formEncType === \"application/x-www-form-urlencoded\" && submission.formData) {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = convertFormDataToSearchParams(submission.formData);\n    } else {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.formData;\n    }\n  }\n  return new Request(url, init);\n}\nfunction convertFormDataToSearchParams(formData) {\n  let searchParams = new URLSearchParams();\n  for (let [key, value] of formData.entries()) {\n    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs\n    searchParams.append(key, typeof value === \"string\" ? value : value.name);\n  }\n  return searchParams;\n}\nfunction convertSearchParamsToFormData(searchParams) {\n  let formData = new FormData();\n  for (let [key, value] of searchParams.entries()) {\n    formData.append(key, value);\n  }\n  return formData;\n}\nfunction processRouteLoaderData(matches, matchesToLoad, results, pendingError, activeDeferreds) {\n  // Fill in loaderData/errors from our loaders\n  let loaderData = {};\n  let errors = null;\n  let statusCode;\n  let foundError = false;\n  let loaderHeaders = {};\n  // Process loader results into state.loaderData/state.errors\n  results.forEach((result, index) => {\n    let id = matchesToLoad[index].route.id;\n    invariant(!isRedirectResult(result), \"Cannot handle redirect results in processLoaderData\");\n    if (isErrorResult(result)) {\n      // Look upwards from the matched route for the closest ancestor\n      // error boundary, defaulting to the root match\n      let boundaryMatch = findNearestBoundary(matches, id);\n      let error = result.error;\n      // If we have a pending action error, we report it at the highest-route\n      // that throws a loader error, and then clear it out to indicate that\n      // it was consumed\n      if (pendingError) {\n        error = Object.values(pendingError)[0];\n        pendingError = undefined;\n      }\n      errors = errors || {};\n      // Prefer higher error values if lower errors bubble to the same boundary\n      if (errors[boundaryMatch.route.id] == null) {\n        errors[boundaryMatch.route.id] = error;\n      }\n      // Clear our any prior loaderData for the throwing route\n      loaderData[id] = undefined;\n      // Once we find our first (highest) error, we set the status code and\n      // prevent deeper status codes from overriding\n      if (!foundError) {\n        foundError = true;\n        statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;\n      }\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    } else {\n      if (isDeferredResult(result)) {\n        activeDeferreds.set(id, result.deferredData);\n        loaderData[id] = result.deferredData.data;\n      } else {\n        loaderData[id] = result.data;\n      }\n      // Error status codes always override success status codes, but if all\n      // loaders are successful we take the deepest status code.\n      if (result.statusCode != null && result.statusCode !== 200 && !foundError) {\n        statusCode = result.statusCode;\n      }\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    }\n  });\n  // If we didn't consume the pending action error (i.e., all loaders\n  // resolved), then consume it here.  Also clear out any loaderData for the\n  // throwing route\n  if (pendingError) {\n    errors = pendingError;\n    loaderData[Object.keys(pendingError)[0]] = undefined;\n  }\n  return {\n    loaderData,\n    errors,\n    statusCode: statusCode || 200,\n    loaderHeaders\n  };\n}\nfunction processLoaderData(state, matches, matchesToLoad, results, pendingError, revalidatingFetchers, fetcherResults, activeDeferreds) {\n  let {\n    loaderData,\n    errors\n  } = processRouteLoaderData(matches, matchesToLoad, results, pendingError, activeDeferreds);\n  // Process results from our revalidating fetchers\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let {\n      key,\n      match,\n      controller\n    } = revalidatingFetchers[index];\n    invariant(fetcherResults !== undefined && fetcherResults[index] !== undefined, \"Did not find corresponding fetcher result\");\n    let result = fetcherResults[index];\n    // Process fetcher non-redirect errors\n    if (controller && controller.signal.aborted) {\n      // Nothing to do for aborted fetchers\n      continue;\n    } else if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);\n      if (!(errors && errors[boundaryMatch.route.id])) {\n        errors = _extends({}, errors, {\n          [boundaryMatch.route.id]: result.error\n        });\n      }\n      state.fetchers.delete(key);\n    } else if (isRedirectResult(result)) {\n      // Should never get here, redirects should get processed above, but we\n      // keep this to type narrow to a success result in the else\n      invariant(false, \"Unhandled fetcher revalidation redirect\");\n    } else if (isDeferredResult(result)) {\n      // Should never get here, deferred data should be awaited for fetchers\n      // in resolveDeferredResults\n      invariant(false, \"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = getDoneFetcher(result.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n  return {\n    loaderData,\n    errors\n  };\n}\nfunction mergeLoaderData(loaderData, newLoaderData, matches, errors) {\n  let mergedLoaderData = _extends({}, newLoaderData);\n  for (let match of matches) {\n    let id = match.route.id;\n    if (newLoaderData.hasOwnProperty(id)) {\n      if (newLoaderData[id] !== undefined) {\n        mergedLoaderData[id] = newLoaderData[id];\n      }\n    } else if (loaderData[id] !== undefined && match.route.loader) {\n      // Preserve existing keys not included in newLoaderData and where a loader\n      // wasn't removed by HMR\n      mergedLoaderData[id] = loaderData[id];\n    }\n    if (errors && errors.hasOwnProperty(id)) {\n      // Don't keep any loader data below the boundary\n      break;\n    }\n  }\n  return mergedLoaderData;\n}\n// Find the nearest error boundary, looking upwards from the leaf route (or the\n// route specified by routeId) for the closest ancestor error boundary,\n// defaulting to the root match\nfunction findNearestBoundary(matches, routeId) {\n  let eligibleMatches = routeId ? matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1) : [...matches];\n  return eligibleMatches.reverse().find(m => m.route.hasErrorBoundary === true) || matches[0];\n}\nfunction getShortCircuitMatches(routes) {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route = routes.length === 1 ? routes[0] : routes.find(r => r.index || !r.path || r.path === \"/\") || {\n    id: \"__shim-error-route__\"\n  };\n  return {\n    matches: [{\n      params: {},\n      pathname: \"\",\n      pathnameBase: \"\",\n      route\n    }],\n    route\n  };\n}\nfunction getInternalRouterError(status, _temp5) {\n  let {\n    pathname,\n    routeId,\n    method,\n    type\n  } = _temp5 === void 0 ? {} : _temp5;\n  let statusText = \"Unknown Server Error\";\n  let errorMessage = \"Unknown @remix-run/router error\";\n  if (status === 400) {\n    statusText = \"Bad Request\";\n    if (method && pathname && routeId) {\n      errorMessage = \"You made a \" + method + \" request to \\\"\" + pathname + \"\\\" but \" + (\"did not provide a `loader` for route \\\"\" + routeId + \"\\\", \") + \"so there is no way to handle the request.\";\n    } else if (type === \"defer-action\") {\n      errorMessage = \"defer() is not supported in actions\";\n    } else if (type === \"invalid-body\") {\n      errorMessage = \"Unable to encode submission body\";\n    }\n  } else if (status === 403) {\n    statusText = \"Forbidden\";\n    errorMessage = \"Route \\\"\" + routeId + \"\\\" does not match URL \\\"\" + pathname + \"\\\"\";\n  } else if (status === 404) {\n    statusText = \"Not Found\";\n    errorMessage = \"No route matches URL \\\"\" + pathname + \"\\\"\";\n  } else if (status === 405) {\n    statusText = \"Method Not Allowed\";\n    if (method && pathname && routeId) {\n      errorMessage = \"You made a \" + method.toUpperCase() + \" request to \\\"\" + pathname + \"\\\" but \" + (\"did not provide an `action` for route \\\"\" + routeId + \"\\\", \") + \"so there is no way to handle the request.\";\n    } else if (method) {\n      errorMessage = \"Invalid request method \\\"\" + method.toUpperCase() + \"\\\"\";\n    }\n  }\n  return new ErrorResponseImpl(status || 500, statusText, new Error(errorMessage), true);\n}\n// Find any returned redirect errors, starting from the lowest match\nfunction findRedirect(results) {\n  for (let i = results.length - 1; i >= 0; i--) {\n    let result = results[i];\n    if (isRedirectResult(result)) {\n      return {\n        result,\n        idx: i\n      };\n    }\n  }\n}\nfunction stripHashFromPath(path) {\n  let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n  return createPath(_extends({}, parsedPath, {\n    hash: \"\"\n  }));\n}\nfunction isHashChangeOnly(a, b) {\n  if (a.pathname !== b.pathname || a.search !== b.search) {\n    return false;\n  }\n  if (a.hash === \"\") {\n    // /page -> /page#hash\n    return b.hash !== \"\";\n  } else if (a.hash === b.hash) {\n    // /page#hash -> /page#hash\n    return true;\n  } else if (b.hash !== \"\") {\n    // /page#hash -> /page#other\n    return true;\n  }\n  // If the hash is removed the browser will re-perform a request to the server\n  // /page#hash -> /page\n  return false;\n}\nfunction isDeferredResult(result) {\n  return result.type === ResultType.deferred;\n}\nfunction isErrorResult(result) {\n  return result.type === ResultType.error;\n}\nfunction isRedirectResult(result) {\n  return (result && result.type) === ResultType.redirect;\n}\nfunction isDeferredData(value) {\n  let deferred = value;\n  return deferred && typeof deferred === \"object\" && typeof deferred.data === \"object\" && typeof deferred.subscribe === \"function\" && typeof deferred.cancel === \"function\" && typeof deferred.resolveData === \"function\";\n}\nfunction isResponse(value) {\n  return value != null && typeof value.status === \"number\" && typeof value.statusText === \"string\" && typeof value.headers === \"object\" && typeof value.body !== \"undefined\";\n}\nfunction isRedirectResponse(result) {\n  if (!isResponse(result)) {\n    return false;\n  }\n  let status = result.status;\n  let location = result.headers.get(\"Location\");\n  return status >= 300 && status <= 399 && location != null;\n}\nfunction isQueryRouteResponse(obj) {\n  return obj && isResponse(obj.response) && (obj.type === ResultType.data || obj.type === ResultType.error);\n}\nfunction isValidMethod(method) {\n  return validRequestMethods.has(method.toLowerCase());\n}\nfunction isMutationMethod(method) {\n  return validMutationMethods.has(method.toLowerCase());\n}\nasync function resolveDeferredResults(currentMatches, matchesToLoad, results, signals, isFetcher, currentLoaderData) {\n  for (let index = 0; index < results.length; index++) {\n    let result = results[index];\n    let match = matchesToLoad[index];\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n    let currentMatch = currentMatches.find(m => m.route.id === match.route.id);\n    let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\n    if (isDeferredResult(result) && (isFetcher || isRevalidatingLoader)) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      let signal = signals[index];\n      invariant(signal, \"Expected an AbortSignal for revalidating fetcher deferred result\");\n      await resolveDeferredData(result, signal, isFetcher).then(result => {\n        if (result) {\n          results[index] = result || results[index];\n        }\n      });\n    }\n  }\n}\nasync function resolveDeferredData(result, signal, unwrap) {\n  if (unwrap === void 0) {\n    unwrap = false;\n  }\n  let aborted = await result.deferredData.resolveData(signal);\n  if (aborted) {\n    return;\n  }\n  if (unwrap) {\n    try {\n      return {\n        type: ResultType.data,\n        data: result.deferredData.unwrappedData\n      };\n    } catch (e) {\n      // Handle any TrackedPromise._error values encountered while unwrapping\n      return {\n        type: ResultType.error,\n        error: e\n      };\n    }\n  }\n  return {\n    type: ResultType.data,\n    data: result.deferredData.data\n  };\n}\nfunction hasNakedIndexQuery(search) {\n  return new URLSearchParams(search).getAll(\"index\").some(v => v === \"\");\n}\nfunction getTargetMatch(matches, location) {\n  let search = typeof location === \"string\" ? parsePath(location).search : location.search;\n  if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || \"\")) {\n    // Return the leaf index route when index is present\n    return matches[matches.length - 1];\n  }\n  // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n  // pathless layout routes)\n  let pathMatches = getPathContributingMatches(matches);\n  return pathMatches[pathMatches.length - 1];\n}\nfunction getSubmissionFromNavigation(navigation) {\n  let {\n    formMethod,\n    formAction,\n    formEncType,\n    text,\n    formData,\n    json\n  } = navigation;\n  if (!formMethod || !formAction || !formEncType) {\n    return;\n  }\n  if (text != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json: undefined,\n      text\n    };\n  } else if (formData != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData,\n      json: undefined,\n      text: undefined\n    };\n  } else if (json !== undefined) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json,\n      text: undefined\n    };\n  }\n}\nfunction getLoadingNavigation(location, submission) {\n  if (submission) {\n    let navigation = {\n      state: \"loading\",\n      location,\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text\n    };\n    return navigation;\n  } else {\n    let navigation = {\n      state: \"loading\",\n      location,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined\n    };\n    return navigation;\n  }\n}\nfunction getSubmittingNavigation(location, submission) {\n  let navigation = {\n    state: \"submitting\",\n    location,\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text\n  };\n  return navigation;\n}\nfunction getLoadingFetcher(submission, data) {\n  if (submission) {\n    let fetcher = {\n      state: \"loading\",\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n      data\n    };\n    return fetcher;\n  } else {\n    let fetcher = {\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n      data\n    };\n    return fetcher;\n  }\n}\nfunction getSubmittingFetcher(submission, existingFetcher) {\n  let fetcher = {\n    state: \"submitting\",\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n    data: existingFetcher ? existingFetcher.data : undefined\n  };\n  return fetcher;\n}\nfunction getDoneFetcher(data) {\n  let fetcher = {\n    state: \"idle\",\n    formMethod: undefined,\n    formAction: undefined,\n    formEncType: undefined,\n    formData: undefined,\n    json: undefined,\n    text: undefined,\n    data\n  };\n  return fetcher;\n}\nfunction restoreAppliedTransitions(_window, transitions) {\n  try {\n    let sessionPositions = _window.sessionStorage.getItem(TRANSITIONS_STORAGE_KEY);\n    if (sessionPositions) {\n      let json = JSON.parse(sessionPositions);\n      for (let [k, v] of Object.entries(json || {})) {\n        if (v && Array.isArray(v)) {\n          transitions.set(k, new Set(v || []));\n        }\n      }\n    }\n  } catch (e) {\n    // no-op, use default empty object\n  }\n}\nfunction persistAppliedTransitions(_window, transitions) {\n  if (transitions.size > 0) {\n    let json = {};\n    for (let [k, v] of transitions) {\n      json[k] = [...v];\n    }\n    try {\n      _window.sessionStorage.setItem(TRANSITIONS_STORAGE_KEY, JSON.stringify(json));\n    } catch (error) {\n      warning(false, \"Failed to save applied view transitions in sessionStorage (\" + error + \").\");\n    }\n  }\n}\n//#endregion\n\nexport { AbortedDeferredError, Action, IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, UNSAFE_DEFERRED_SYMBOL, DeferredData as UNSAFE_DeferredData, ErrorResponseImpl as UNSAFE_ErrorResponseImpl, convertRouteMatchToUiMatch as UNSAFE_convertRouteMatchToUiMatch, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, getResolveToMatches as UNSAFE_getResolveToMatches, invariant as UNSAFE_invariant, warning as UNSAFE_warning, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, createRouter, createStaticHandler, defer, generatePath, getStaticContextFromError, getToPathname, isDeferredData, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, parsePath, redirect, redirectDocument, resolvePath, resolveTo, stripBasename };\n//# sourceMappingURL=router.js.map\n","/**\n * React Router v6.22.3\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 */\nimport * as React from 'react';\nimport { UNSAFE_invariant, joinPaths, matchPath, UNSAFE_getResolveToMatches, UNSAFE_warning, resolveTo, parsePath, matchRoutes, Action, UNSAFE_convertRouteMatchToUiMatch, stripBasename, IDLE_BLOCKER, isRouteErrorResponse, createMemoryHistory, AbortedDeferredError, createRouter } from '@remix-run/router';\nexport { AbortedDeferredError, Action as NavigationType, createPath, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, resolvePath } from '@remix-run/router';\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// Create react-specific types from the agnostic types in @remix-run/router to\n// export from react-router\nconst DataRouterContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  DataRouterContext.displayName = \"DataRouter\";\n}\nconst DataRouterStateContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  DataRouterStateContext.displayName = \"DataRouterState\";\n}\nconst AwaitContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  AwaitContext.displayName = \"Await\";\n}\n\n/**\n * A Navigator is a \"location changer\"; it's how you get to different locations.\n *\n * Every history instance conforms to the Navigator interface, but the\n * distinction is useful primarily when it comes to the low-level `<Router>` API\n * where both the location and a navigator must be provided separately in order\n * to avoid \"tearing\" that may occur in a suspense-enabled app if the action\n * and/or location were to be read directly from the history instance.\n */\n\nconst NavigationContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  NavigationContext.displayName = \"Navigation\";\n}\nconst LocationContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  LocationContext.displayName = \"Location\";\n}\nconst RouteContext = /*#__PURE__*/React.createContext({\n  outlet: null,\n  matches: [],\n  isDataRoute: false\n});\nif (process.env.NODE_ENV !== \"production\") {\n  RouteContext.displayName = \"Route\";\n}\nconst RouteErrorContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  RouteErrorContext.displayName = \"RouteError\";\n}\n\n/**\n * Returns the full href for the given \"to\" value. This is useful for building\n * custom links that are also accessible and preserve right-click behavior.\n *\n * @see https://reactrouter.com/hooks/use-href\n */\nfunction useHref(to, _temp) {\n  let {\n    relative\n  } = _temp === void 0 ? {} : _temp;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useHref() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    basename,\n    navigator\n  } = React.useContext(NavigationContext);\n  let {\n    hash,\n    pathname,\n    search\n  } = useResolvedPath(to, {\n    relative\n  });\n  let joinedPathname = pathname;\n\n  // If we're operating within a basename, prepend it to the pathname prior\n  // to creating the href.  If this is a root navigation, then just use the raw\n  // basename which allows the basename to have full control over the presence\n  // of a trailing slash on root links\n  if (basename !== \"/\") {\n    joinedPathname = pathname === \"/\" ? basename : joinPaths([basename, pathname]);\n  }\n  return navigator.createHref({\n    pathname: joinedPathname,\n    search,\n    hash\n  });\n}\n\n/**\n * Returns true if this component is a descendant of a `<Router>`.\n *\n * @see https://reactrouter.com/hooks/use-in-router-context\n */\nfunction useInRouterContext() {\n  return React.useContext(LocationContext) != null;\n}\n\n/**\n * Returns the current location object, which represents the current URL in web\n * browsers.\n *\n * Note: If you're using this it may mean you're doing some of your own\n * \"routing\" in your app, and we'd like to know what your use case is. We may\n * be able to provide something higher-level to better suit your needs.\n *\n * @see https://reactrouter.com/hooks/use-location\n */\nfunction useLocation() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useLocation() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  return React.useContext(LocationContext).location;\n}\n\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/hooks/use-navigation-type\n */\nfunction useNavigationType() {\n  return React.useContext(LocationContext).navigationType;\n}\n\n/**\n * Returns a PathMatch object if the given pattern matches the current URL.\n * This is useful for components that need to know \"active\" state, e.g.\n * `<NavLink>`.\n *\n * @see https://reactrouter.com/hooks/use-match\n */\nfunction useMatch(pattern) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useMatch() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    pathname\n  } = useLocation();\n  return React.useMemo(() => matchPath(pattern, pathname), [pathname, pattern]);\n}\n\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\n\nconst navigateEffectWarning = \"You should call navigate() in a React.useEffect(), not when \" + \"your component is first rendered.\";\n\n// Mute warnings for calls to useNavigate in SSR environments\nfunction useIsomorphicLayoutEffect(cb) {\n  let isStatic = React.useContext(NavigationContext).static;\n  if (!isStatic) {\n    // We should be able to get rid of this once react 18.3 is released\n    // See: https://github.com/facebook/react/pull/26395\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(cb);\n  }\n}\n\n/**\n * Returns an imperative method for changing the location. Used by `<Link>`s, but\n * may also be used by other elements to change the location.\n *\n * @see https://reactrouter.com/hooks/use-navigate\n */\nfunction useNavigate() {\n  let {\n    isDataRoute\n  } = React.useContext(RouteContext);\n  // Conditional usage is OK here because the usage of a data router is static\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return isDataRoute ? useNavigateStable() : useNavigateUnstable();\n}\nfunction useNavigateUnstable() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useNavigate() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let dataRouterContext = React.useContext(DataRouterContext);\n  let {\n    basename,\n    future,\n    navigator\n  } = React.useContext(NavigationContext);\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let routePathnamesJson = JSON.stringify(UNSAFE_getResolveToMatches(matches, future.v7_relativeSplatPath));\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n  let navigate = React.useCallback(function (to, options) {\n    if (options === void 0) {\n      options = {};\n    }\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(activeRef.current, navigateEffectWarning) : void 0;\n\n    // Short circuit here since if this happens on first render the navigate\n    // is useless because we haven't wired up our history listener yet\n    if (!activeRef.current) return;\n    if (typeof to === \"number\") {\n      navigator.go(to);\n      return;\n    }\n    let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, options.relative === \"path\");\n\n    // If we're operating within a basename, prepend it to the pathname prior\n    // to handing off to history (but only if we're not in a data router,\n    // otherwise it'll prepend the basename inside of the router).\n    // If this is a root navigation, then we navigate to the raw basename\n    // which allows the basename to have full control over the presence of a\n    // trailing slash on root links\n    if (dataRouterContext == null && basename !== \"/\") {\n      path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n    }\n    (!!options.replace ? navigator.replace : navigator.push)(path, options.state, options);\n  }, [basename, navigator, routePathnamesJson, locationPathname, dataRouterContext]);\n  return navigate;\n}\nconst OutletContext = /*#__PURE__*/React.createContext(null);\n\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/hooks/use-outlet-context\n */\nfunction useOutletContext() {\n  return React.useContext(OutletContext);\n}\n\n/**\n * Returns the element for the child route at this level of the route\n * hierarchy. Used internally by `<Outlet>` to render child routes.\n *\n * @see https://reactrouter.com/hooks/use-outlet\n */\nfunction useOutlet(context) {\n  let outlet = React.useContext(RouteContext).outlet;\n  if (outlet) {\n    return /*#__PURE__*/React.createElement(OutletContext.Provider, {\n      value: context\n    }, outlet);\n  }\n  return outlet;\n}\n\n/**\n * Returns an object of key/value pairs of the dynamic params from the current\n * URL that were matched by the route path.\n *\n * @see https://reactrouter.com/hooks/use-params\n */\nfunction useParams() {\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let routeMatch = matches[matches.length - 1];\n  return routeMatch ? routeMatch.params : {};\n}\n\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/hooks/use-resolved-path\n */\nfunction useResolvedPath(to, _temp2) {\n  let {\n    relative\n  } = _temp2 === void 0 ? {} : _temp2;\n  let {\n    future\n  } = React.useContext(NavigationContext);\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let routePathnamesJson = JSON.stringify(UNSAFE_getResolveToMatches(matches, future.v7_relativeSplatPath));\n  return React.useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, relative === \"path\"), [to, routePathnamesJson, locationPathname, relative]);\n}\n\n/**\n * Returns the element of the route that matched the current location, prepared\n * with the correct context to render the remainder of the route tree. Route\n * elements in the tree must render an `<Outlet>` to render their child route's\n * element.\n *\n * @see https://reactrouter.com/hooks/use-routes\n */\nfunction useRoutes(routes, locationArg) {\n  return useRoutesImpl(routes, locationArg);\n}\n\n// Internal implementation with accept optional param for RouterProvider usage\nfunction useRoutesImpl(routes, locationArg, dataRouterState, future) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useRoutes() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    navigator\n  } = React.useContext(NavigationContext);\n  let {\n    matches: parentMatches\n  } = React.useContext(RouteContext);\n  let routeMatch = parentMatches[parentMatches.length - 1];\n  let parentParams = routeMatch ? routeMatch.params : {};\n  let parentPathname = routeMatch ? routeMatch.pathname : \"/\";\n  let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : \"/\";\n  let parentRoute = routeMatch && routeMatch.route;\n  if (process.env.NODE_ENV !== \"production\") {\n    // You won't get a warning about 2 different <Routes> under a <Route>\n    // without a trailing *, but this is a best-effort warning anyway since we\n    // cannot even give the warning unless they land at the parent route.\n    //\n    // Example:\n    //\n    // <Routes>\n    //   {/* This route path MUST end with /* because otherwise\n    //       it will never match /blog/post/123 */}\n    //   <Route path=\"blog\" element={<Blog />} />\n    //   <Route path=\"blog/feed\" element={<BlogFeed />} />\n    // </Routes>\n    //\n    // function Blog() {\n    //   return (\n    //     <Routes>\n    //       <Route path=\"post/:id\" element={<Post />} />\n    //     </Routes>\n    //   );\n    // }\n    let parentPath = parentRoute && parentRoute.path || \"\";\n    warningOnce(parentPathname, !parentRoute || parentPath.endsWith(\"*\"), \"You rendered descendant <Routes> (or called `useRoutes()`) at \" + (\"\\\"\" + parentPathname + \"\\\" (under <Route path=\\\"\" + parentPath + \"\\\">) but the \") + \"parent route path has no trailing \\\"*\\\". This means if you navigate \" + \"deeper, the parent won't match anymore and therefore the child \" + \"routes will never render.\\n\\n\" + (\"Please change the parent <Route path=\\\"\" + parentPath + \"\\\"> to <Route \") + (\"path=\\\"\" + (parentPath === \"/\" ? \"*\" : parentPath + \"/*\") + \"\\\">.\"));\n  }\n  let locationFromContext = useLocation();\n  let location;\n  if (locationArg) {\n    var _parsedLocationArg$pa;\n    let parsedLocationArg = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n    !(parentPathnameBase === \"/\" || ((_parsedLocationArg$pa = parsedLocationArg.pathname) == null ? void 0 : _parsedLocationArg$pa.startsWith(parentPathnameBase))) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"When overriding the location using `<Routes location>` or `useRoutes(routes, location)`, \" + \"the location pathname must begin with the portion of the URL pathname that was \" + (\"matched by all parent routes. The current pathname base is \\\"\" + parentPathnameBase + \"\\\" \") + (\"but pathname \\\"\" + parsedLocationArg.pathname + \"\\\" was given in the `location` prop.\")) : UNSAFE_invariant(false) : void 0;\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\n  let pathname = location.pathname || \"/\";\n  let remainingPathname = pathname;\n  if (parentPathnameBase !== \"/\") {\n    // Determine the remaining pathname by removing the # of URL segments the\n    // parentPathnameBase has, instead of removing based on character count.\n    // This is because we can't guarantee that incoming/outgoing encodings/\n    // decodings will match exactly.\n    // We decode paths before matching on a per-segment basis with\n    // decodeURIComponent(), but we re-encode pathnames via `new URL()` so they\n    // match what `window.location.pathname` would reflect.  Those don't 100%\n    // align when it comes to encoded URI characters such as % and &.\n    //\n    // So we may end up with:\n    //   pathname:           \"/descendant/a%25b/match\"\n    //   parentPathnameBase: \"/descendant/a%b\"\n    //\n    // And the direct substring removal approach won't work :/\n    let parentSegments = parentPathnameBase.replace(/^\\//, \"\").split(\"/\");\n    let segments = pathname.replace(/^\\//, \"\").split(\"/\");\n    remainingPathname = \"/\" + segments.slice(parentSegments.length).join(\"/\");\n  }\n  let matches = matchRoutes(routes, {\n    pathname: remainingPathname\n  });\n  if (process.env.NODE_ENV !== \"production\") {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(parentRoute || matches != null, \"No routes matched location \\\"\" + location.pathname + location.search + location.hash + \"\\\" \") : void 0;\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(matches == null || matches[matches.length - 1].route.element !== undefined || matches[matches.length - 1].route.Component !== undefined || matches[matches.length - 1].route.lazy !== undefined, \"Matched leaf route at location \\\"\" + location.pathname + location.search + location.hash + \"\\\" \" + \"does not have an element or Component. This means it will render an <Outlet /> with a \" + \"null value by default resulting in an \\\"empty\\\" page.\") : void 0;\n  }\n  let renderedMatches = _renderMatches(matches && matches.map(match => Object.assign({}, match, {\n    params: Object.assign({}, parentParams, match.params),\n    pathname: joinPaths([parentPathnameBase,\n    // Re-encode pathnames that were decoded inside matchRoutes\n    navigator.encodeLocation ? navigator.encodeLocation(match.pathname).pathname : match.pathname]),\n    pathnameBase: match.pathnameBase === \"/\" ? parentPathnameBase : joinPaths([parentPathnameBase,\n    // Re-encode pathnames that were decoded inside matchRoutes\n    navigator.encodeLocation ? navigator.encodeLocation(match.pathnameBase).pathname : match.pathnameBase])\n  })), parentMatches, dataRouterState, future);\n\n  // When a user passes in a `locationArg`, the associated routes need to\n  // be wrapped in a new `LocationContext.Provider` in order for `useLocation`\n  // to use the scoped location instead of the global location.\n  if (locationArg && renderedMatches) {\n    return /*#__PURE__*/React.createElement(LocationContext.Provider, {\n      value: {\n        location: _extends({\n          pathname: \"/\",\n          search: \"\",\n          hash: \"\",\n          state: null,\n          key: \"default\"\n        }, location),\n        navigationType: Action.Pop\n      }\n    }, renderedMatches);\n  }\n  return renderedMatches;\n}\nfunction DefaultErrorComponent() {\n  let error = useRouteError();\n  let message = isRouteErrorResponse(error) ? error.status + \" \" + error.statusText : error instanceof Error ? error.message : JSON.stringify(error);\n  let stack = error instanceof Error ? error.stack : null;\n  let lightgrey = \"rgba(200,200,200, 0.5)\";\n  let preStyles = {\n    padding: \"0.5rem\",\n    backgroundColor: lightgrey\n  };\n  let codeStyles = {\n    padding: \"2px 4px\",\n    backgroundColor: lightgrey\n  };\n  let devInfo = null;\n  if (process.env.NODE_ENV !== \"production\") {\n    console.error(\"Error handled by React Router default ErrorBoundary:\", error);\n    devInfo = /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"p\", null, \"\\uD83D\\uDCBF Hey developer \\uD83D\\uDC4B\"), /*#__PURE__*/React.createElement(\"p\", null, \"You can provide a way better UX than this when your app throws errors by providing your own \", /*#__PURE__*/React.createElement(\"code\", {\n      style: codeStyles\n    }, \"ErrorBoundary\"), \" or\", \" \", /*#__PURE__*/React.createElement(\"code\", {\n      style: codeStyles\n    }, \"errorElement\"), \" prop on your route.\"));\n  }\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"h2\", null, \"Unexpected Application Error!\"), /*#__PURE__*/React.createElement(\"h3\", {\n    style: {\n      fontStyle: \"italic\"\n    }\n  }, message), stack ? /*#__PURE__*/React.createElement(\"pre\", {\n    style: preStyles\n  }, stack) : null, devInfo);\n}\nconst defaultErrorElement = /*#__PURE__*/React.createElement(DefaultErrorComponent, null);\nclass RenderErrorBoundary extends React.Component {\n  constructor(props) {\n    super(props);\n    this.state = {\n      location: props.location,\n      revalidation: props.revalidation,\n      error: props.error\n    };\n  }\n  static getDerivedStateFromError(error) {\n    return {\n      error: error\n    };\n  }\n  static getDerivedStateFromProps(props, state) {\n    // When we get into an error state, the user will likely click \"back\" to the\n    // previous page that didn't have an error. Because this wraps the entire\n    // application, that will have no effect--the error page continues to display.\n    // This gives us a mechanism to recover from the error when the location changes.\n    //\n    // Whether we're in an error state or not, we update the location in state\n    // so that when we are in an error state, it gets reset when a new location\n    // comes in and the user recovers from the error.\n    if (state.location !== props.location || state.revalidation !== \"idle\" && props.revalidation === \"idle\") {\n      return {\n        error: props.error,\n        location: props.location,\n        revalidation: props.revalidation\n      };\n    }\n\n    // If we're not changing locations, preserve the location but still surface\n    // any new errors that may come through. We retain the existing error, we do\n    // this because the error provided from the app state may be cleared without\n    // the location changing.\n    return {\n      error: props.error !== undefined ? props.error : state.error,\n      location: state.location,\n      revalidation: props.revalidation || state.revalidation\n    };\n  }\n  componentDidCatch(error, errorInfo) {\n    console.error(\"React Router caught the following error during render\", error, errorInfo);\n  }\n  render() {\n    return this.state.error !== undefined ? /*#__PURE__*/React.createElement(RouteContext.Provider, {\n      value: this.props.routeContext\n    }, /*#__PURE__*/React.createElement(RouteErrorContext.Provider, {\n      value: this.state.error,\n      children: this.props.component\n    })) : this.props.children;\n  }\n}\nfunction RenderedRoute(_ref) {\n  let {\n    routeContext,\n    match,\n    children\n  } = _ref;\n  let dataRouterContext = React.useContext(DataRouterContext);\n\n  // Track how deep we got in our render pass to emulate SSR componentDidCatch\n  // in a DataStaticRouter\n  if (dataRouterContext && dataRouterContext.static && dataRouterContext.staticContext && (match.route.errorElement || match.route.ErrorBoundary)) {\n    dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;\n  }\n  return /*#__PURE__*/React.createElement(RouteContext.Provider, {\n    value: routeContext\n  }, children);\n}\nfunction _renderMatches(matches, parentMatches, dataRouterState, future) {\n  var _dataRouterState2;\n  if (parentMatches === void 0) {\n    parentMatches = [];\n  }\n  if (dataRouterState === void 0) {\n    dataRouterState = null;\n  }\n  if (future === void 0) {\n    future = null;\n  }\n  if (matches == null) {\n    var _dataRouterState;\n    if ((_dataRouterState = dataRouterState) != null && _dataRouterState.errors) {\n      // Don't bail if we have data router errors so we can render them in the\n      // boundary.  Use the pre-matched (or shimmed) matches\n      matches = dataRouterState.matches;\n    } else {\n      return null;\n    }\n  }\n  let renderedMatches = matches;\n\n  // If we have data errors, trim matches to the highest error boundary\n  let errors = (_dataRouterState2 = dataRouterState) == null ? void 0 : _dataRouterState2.errors;\n  if (errors != null) {\n    let errorIndex = renderedMatches.findIndex(m => m.route.id && (errors == null ? void 0 : errors[m.route.id]));\n    !(errorIndex >= 0) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"Could not find a matching route for errors on route IDs: \" + Object.keys(errors).join(\",\")) : UNSAFE_invariant(false) : void 0;\n    renderedMatches = renderedMatches.slice(0, Math.min(renderedMatches.length, errorIndex + 1));\n  }\n\n  // If we're in a partial hydration mode, detect if we need to render down to\n  // a given HydrateFallback while we load the rest of the hydration data\n  let renderFallback = false;\n  let fallbackIndex = -1;\n  if (dataRouterState && future && future.v7_partialHydration) {\n    for (let i = 0; i < renderedMatches.length; i++) {\n      let match = renderedMatches[i];\n      // Track the deepest fallback up until the first route without data\n      if (match.route.HydrateFallback || match.route.hydrateFallbackElement) {\n        fallbackIndex = i;\n      }\n      if (match.route.id) {\n        let {\n          loaderData,\n          errors\n        } = dataRouterState;\n        let needsToRunLoader = match.route.loader && loaderData[match.route.id] === undefined && (!errors || errors[match.route.id] === undefined);\n        if (match.route.lazy || needsToRunLoader) {\n          // We found the first route that's not ready to render (waiting on\n          // lazy, or has a loader that hasn't run yet).  Flag that we need to\n          // render a fallback and render up until the appropriate fallback\n          renderFallback = true;\n          if (fallbackIndex >= 0) {\n            renderedMatches = renderedMatches.slice(0, fallbackIndex + 1);\n          } else {\n            renderedMatches = [renderedMatches[0]];\n          }\n          break;\n        }\n      }\n    }\n  }\n  return renderedMatches.reduceRight((outlet, match, index) => {\n    // Only data routers handle errors/fallbacks\n    let error;\n    let shouldRenderHydrateFallback = false;\n    let errorElement = null;\n    let hydrateFallbackElement = null;\n    if (dataRouterState) {\n      error = errors && match.route.id ? errors[match.route.id] : undefined;\n      errorElement = match.route.errorElement || defaultErrorElement;\n      if (renderFallback) {\n        if (fallbackIndex < 0 && index === 0) {\n          warningOnce(\"route-fallback\", false, \"No `HydrateFallback` element provided to render during initial hydration\");\n          shouldRenderHydrateFallback = true;\n          hydrateFallbackElement = null;\n        } else if (fallbackIndex === index) {\n          shouldRenderHydrateFallback = true;\n          hydrateFallbackElement = match.route.hydrateFallbackElement || null;\n        }\n      }\n    }\n    let matches = parentMatches.concat(renderedMatches.slice(0, index + 1));\n    let getChildren = () => {\n      let children;\n      if (error) {\n        children = errorElement;\n      } else if (shouldRenderHydrateFallback) {\n        children = hydrateFallbackElement;\n      } else if (match.route.Component) {\n        // Note: This is a de-optimized path since React won't re-use the\n        // ReactElement since it's identity changes with each new\n        // React.createElement call.  We keep this so folks can use\n        // `<Route Component={...}>` in `<Routes>` but generally `Component`\n        // usage is only advised in `RouterProvider` when we can convert it to\n        // `element` ahead of time.\n        children = /*#__PURE__*/React.createElement(match.route.Component, null);\n      } else if (match.route.element) {\n        children = match.route.element;\n      } else {\n        children = outlet;\n      }\n      return /*#__PURE__*/React.createElement(RenderedRoute, {\n        match: match,\n        routeContext: {\n          outlet,\n          matches,\n          isDataRoute: dataRouterState != null\n        },\n        children: children\n      });\n    };\n    // Only wrap in an error boundary within data router usages when we have an\n    // ErrorBoundary/errorElement on this route.  Otherwise let it bubble up to\n    // an ancestor ErrorBoundary/errorElement\n    return dataRouterState && (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? /*#__PURE__*/React.createElement(RenderErrorBoundary, {\n      location: dataRouterState.location,\n      revalidation: dataRouterState.revalidation,\n      component: errorElement,\n      error: error,\n      children: getChildren(),\n      routeContext: {\n        outlet: null,\n        matches,\n        isDataRoute: true\n      }\n    }) : getChildren();\n  }, null);\n}\nvar DataRouterHook = /*#__PURE__*/function (DataRouterHook) {\n  DataRouterHook[\"UseBlocker\"] = \"useBlocker\";\n  DataRouterHook[\"UseRevalidator\"] = \"useRevalidator\";\n  DataRouterHook[\"UseNavigateStable\"] = \"useNavigate\";\n  return DataRouterHook;\n}(DataRouterHook || {});\nvar DataRouterStateHook = /*#__PURE__*/function (DataRouterStateHook) {\n  DataRouterStateHook[\"UseBlocker\"] = \"useBlocker\";\n  DataRouterStateHook[\"UseLoaderData\"] = \"useLoaderData\";\n  DataRouterStateHook[\"UseActionData\"] = \"useActionData\";\n  DataRouterStateHook[\"UseRouteError\"] = \"useRouteError\";\n  DataRouterStateHook[\"UseNavigation\"] = \"useNavigation\";\n  DataRouterStateHook[\"UseRouteLoaderData\"] = \"useRouteLoaderData\";\n  DataRouterStateHook[\"UseMatches\"] = \"useMatches\";\n  DataRouterStateHook[\"UseRevalidator\"] = \"useRevalidator\";\n  DataRouterStateHook[\"UseNavigateStable\"] = \"useNavigate\";\n  DataRouterStateHook[\"UseRouteId\"] = \"useRouteId\";\n  return DataRouterStateHook;\n}(DataRouterStateHook || {});\nfunction getDataRouterConsoleError(hookName) {\n  return hookName + \" must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.\";\n}\nfunction useDataRouterContext(hookName) {\n  let ctx = React.useContext(DataRouterContext);\n  !ctx ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return ctx;\n}\nfunction useDataRouterState(hookName) {\n  let state = React.useContext(DataRouterStateContext);\n  !state ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return state;\n}\nfunction useRouteContext(hookName) {\n  let route = React.useContext(RouteContext);\n  !route ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return route;\n}\n\n// Internal version with hookName-aware debugging\nfunction useCurrentRouteId(hookName) {\n  let route = useRouteContext(hookName);\n  let thisRoute = route.matches[route.matches.length - 1];\n  !thisRoute.route.id ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, hookName + \" can only be used on routes that contain a unique \\\"id\\\"\") : UNSAFE_invariant(false) : void 0;\n  return thisRoute.route.id;\n}\n\n/**\n * Returns the ID for the nearest contextual route\n */\nfunction useRouteId() {\n  return useCurrentRouteId(DataRouterStateHook.UseRouteId);\n}\n\n/**\n * Returns the current navigation, defaulting to an \"idle\" navigation when\n * no navigation is in progress\n */\nfunction useNavigation() {\n  let state = useDataRouterState(DataRouterStateHook.UseNavigation);\n  return state.navigation;\n}\n\n/**\n * Returns a revalidate function for manually triggering revalidation, as well\n * as the current state of any manual revalidations\n */\nfunction useRevalidator() {\n  let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);\n  let state = useDataRouterState(DataRouterStateHook.UseRevalidator);\n  return React.useMemo(() => ({\n    revalidate: dataRouterContext.router.revalidate,\n    state: state.revalidation\n  }), [dataRouterContext.router.revalidate, state.revalidation]);\n}\n\n/**\n * Returns the active route matches, useful for accessing loaderData for\n * parent/child routes or the route \"handle\" property\n */\nfunction useMatches() {\n  let {\n    matches,\n    loaderData\n  } = useDataRouterState(DataRouterStateHook.UseMatches);\n  return React.useMemo(() => matches.map(m => UNSAFE_convertRouteMatchToUiMatch(m, loaderData)), [matches, loaderData]);\n}\n\n/**\n * Returns the loader data for the nearest ancestor Route loader\n */\nfunction useLoaderData() {\n  let state = useDataRouterState(DataRouterStateHook.UseLoaderData);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n  if (state.errors && state.errors[routeId] != null) {\n    console.error(\"You cannot `useLoaderData` in an errorElement (routeId: \" + routeId + \")\");\n    return undefined;\n  }\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the loaderData for the given routeId\n */\nfunction useRouteLoaderData(routeId) {\n  let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the action data for the nearest ancestor Route action\n */\nfunction useActionData() {\n  let state = useDataRouterState(DataRouterStateHook.UseActionData);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n  return state.actionData ? state.actionData[routeId] : undefined;\n}\n\n/**\n * Returns the nearest ancestor Route error, which could be a loader/action\n * error or a render error.  This is intended to be called from your\n * ErrorBoundary/errorElement to display a proper error message.\n */\nfunction useRouteError() {\n  var _state$errors;\n  let error = React.useContext(RouteErrorContext);\n  let state = useDataRouterState(DataRouterStateHook.UseRouteError);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseRouteError);\n\n  // If this was a render error, we put it in a RouteError context inside\n  // of RenderErrorBoundary\n  if (error !== undefined) {\n    return error;\n  }\n\n  // Otherwise look for errors from our data router state\n  return (_state$errors = state.errors) == null ? void 0 : _state$errors[routeId];\n}\n\n/**\n * Returns the happy-path data from the nearest ancestor `<Await />` value\n */\nfunction useAsyncValue() {\n  let value = React.useContext(AwaitContext);\n  return value == null ? void 0 : value._data;\n}\n\n/**\n * Returns the error from the nearest ancestor `<Await />` value\n */\nfunction useAsyncError() {\n  let value = React.useContext(AwaitContext);\n  return value == null ? void 0 : value._error;\n}\nlet blockerId = 0;\n\n/**\n * Allow the application to block navigations within the SPA and present the\n * user a confirmation dialog to confirm the navigation.  Mostly used to avoid\n * using half-filled form data.  This does not handle hard-reloads or\n * cross-origin navigations.\n */\nfunction useBlocker(shouldBlock) {\n  let {\n    router,\n    basename\n  } = useDataRouterContext(DataRouterHook.UseBlocker);\n  let state = useDataRouterState(DataRouterStateHook.UseBlocker);\n  let [blockerKey, setBlockerKey] = React.useState(\"\");\n  let blockerFunction = React.useCallback(arg => {\n    if (typeof shouldBlock !== \"function\") {\n      return !!shouldBlock;\n    }\n    if (basename === \"/\") {\n      return shouldBlock(arg);\n    }\n\n    // If they provided us a function and we've got an active basename, strip\n    // it from the locations we expose to the user to match the behavior of\n    // useLocation\n    let {\n      currentLocation,\n      nextLocation,\n      historyAction\n    } = arg;\n    return shouldBlock({\n      currentLocation: _extends({}, currentLocation, {\n        pathname: stripBasename(currentLocation.pathname, basename) || currentLocation.pathname\n      }),\n      nextLocation: _extends({}, nextLocation, {\n        pathname: stripBasename(nextLocation.pathname, basename) || nextLocation.pathname\n      }),\n      historyAction\n    });\n  }, [basename, shouldBlock]);\n\n  // This effect is in charge of blocker key assignment and deletion (which is\n  // tightly coupled to the key)\n  React.useEffect(() => {\n    let key = String(++blockerId);\n    setBlockerKey(key);\n    return () => router.deleteBlocker(key);\n  }, [router]);\n\n  // This effect handles assigning the blockerFunction.  This is to handle\n  // unstable blocker function identities, and happens only after the prior\n  // effect so we don't get an orphaned blockerFunction in the router with a\n  // key of \"\".  Until then we just have the IDLE_BLOCKER.\n  React.useEffect(() => {\n    if (blockerKey !== \"\") {\n      router.getBlocker(blockerKey, blockerFunction);\n    }\n  }, [router, blockerKey, blockerFunction]);\n\n  // Prefer the blocker from `state` not `router.state` since DataRouterContext\n  // is memoized so this ensures we update on blocker state updates\n  return blockerKey && state.blockers.has(blockerKey) ? state.blockers.get(blockerKey) : IDLE_BLOCKER;\n}\n\n/**\n * Stable version of useNavigate that is used when we are in the context of\n * a RouterProvider.\n */\nfunction useNavigateStable() {\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseNavigateStable);\n  let id = useCurrentRouteId(DataRouterStateHook.UseNavigateStable);\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n  let navigate = React.useCallback(function (to, options) {\n    if (options === void 0) {\n      options = {};\n    }\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(activeRef.current, navigateEffectWarning) : void 0;\n\n    // Short circuit here since if this happens on first render the navigate\n    // is useless because we haven't wired up our router subscriber yet\n    if (!activeRef.current) return;\n    if (typeof to === \"number\") {\n      router.navigate(to);\n    } else {\n      router.navigate(to, _extends({\n        fromRouteId: id\n      }, options));\n    }\n  }, [router, id]);\n  return navigate;\n}\nconst alreadyWarned = {};\nfunction warningOnce(key, cond, message) {\n  if (!cond && !alreadyWarned[key]) {\n    alreadyWarned[key] = true;\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, message) : void 0;\n  }\n}\n\n/**\n  Webpack + React 17 fails to compile on any of the following because webpack\n  complains that `startTransition` doesn't exist in `React`:\n  * import { startTransition } from \"react\"\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n  Moving it to a constant such as the following solves the Webpack/React 17 issue:\n  * import * as React from from \"react\";\n    const START_TRANSITION = \"startTransition\";\n    START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n  However, that introduces webpack/terser minification issues in production builds\n  in React 18 where minification/obfuscation ends up removing the call of\n  React.startTransition entirely from the first half of the ternary.  Grabbing\n  this exported reference once up front resolves that issue.\n\n  See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\n\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nfunction RouterProvider(_ref) {\n  let {\n    fallbackElement,\n    router,\n    future\n  } = _ref;\n  let [state, setStateImpl] = React.useState(router.state);\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    if (v7_startTransition && startTransitionImpl) {\n      startTransitionImpl(() => setStateImpl(newState));\n    } else {\n      setStateImpl(newState);\n    }\n  }, [setStateImpl, v7_startTransition]);\n\n  // Need to use a layout effect here so we are subscribed early enough to\n  // pick up on any render-driven redirects/navigations (useEffect/<Navigate>)\n  React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);\n  React.useEffect(() => {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(fallbackElement == null || !router.future.v7_partialHydration, \"`<RouterProvider fallbackElement>` is deprecated when using \" + \"`v7_partialHydration`, use a `HydrateFallback` component instead\") : void 0;\n    // Only log this once on initial mount\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n  let navigator = React.useMemo(() => {\n    return {\n      createHref: router.createHref,\n      encodeLocation: router.encodeLocation,\n      go: n => router.navigate(n),\n      push: (to, state, opts) => router.navigate(to, {\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      }),\n      replace: (to, state, opts) => router.navigate(to, {\n        replace: true,\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      })\n    };\n  }, [router]);\n  let basename = router.basename || \"/\";\n  let dataRouterContext = React.useMemo(() => ({\n    router,\n    navigator,\n    static: false,\n    basename\n  }), [router, navigator, basename]);\n\n  // The fragment and {null} here are important!  We need them to keep React 18's\n  // useId happy when we are server-rendering since we may have a <script> here\n  // containing the hydrated server-side staticContext (from StaticRouterProvider).\n  // useId relies on the component tree structure to generate deterministic id's\n  // so we need to ensure it remains the same on the client even though\n  // we don't need the <script> tag\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(DataRouterContext.Provider, {\n    value: dataRouterContext\n  }, /*#__PURE__*/React.createElement(DataRouterStateContext.Provider, {\n    value: state\n  }, /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    location: state.location,\n    navigationType: state.historyAction,\n    navigator: navigator,\n    future: {\n      v7_relativeSplatPath: router.future.v7_relativeSplatPath\n    }\n  }, state.initialized || router.future.v7_partialHydration ? /*#__PURE__*/React.createElement(DataRoutes, {\n    routes: router.routes,\n    future: router.future,\n    state: state\n  }) : fallbackElement))), null);\n}\nfunction DataRoutes(_ref2) {\n  let {\n    routes,\n    future,\n    state\n  } = _ref2;\n  return useRoutesImpl(routes, undefined, state, future);\n}\n/**\n * A `<Router>` that stores all entries in memory.\n *\n * @see https://reactrouter.com/router-components/memory-router\n */\nfunction MemoryRouter(_ref3) {\n  let {\n    basename,\n    children,\n    initialEntries,\n    initialIndex,\n    future\n  } = _ref3;\n  let historyRef = React.useRef();\n  if (historyRef.current == null) {\n    historyRef.current = createMemoryHistory({\n      initialEntries,\n      initialIndex,\n      v5Compat: true\n    });\n  }\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history,\n    future: future\n  });\n}\n/**\n * Changes the current location.\n *\n * Note: This API is mostly useful in React.Component subclasses that are not\n * able to use hooks. In functional components, we recommend you use the\n * `useNavigate` hook instead.\n *\n * @see https://reactrouter.com/components/navigate\n */\nfunction Navigate(_ref4) {\n  let {\n    to,\n    replace,\n    state,\n    relative\n  } = _ref4;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of\n  // the router loaded. We can help them understand how to avoid that.\n  \"<Navigate> may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    future,\n    static: isStatic\n  } = React.useContext(NavigationContext);\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(!isStatic, \"<Navigate> must not be used on the initial render in a <StaticRouter>. \" + \"This is a no-op, but you should modify your code so the <Navigate> is \" + \"only ever rendered in response to some user interaction or state change.\") : void 0;\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let navigate = useNavigate();\n\n  // Resolve the path outside of the effect so that when effects run twice in\n  // StrictMode they navigate to the same place\n  let path = resolveTo(to, UNSAFE_getResolveToMatches(matches, future.v7_relativeSplatPath), locationPathname, relative === \"path\");\n  let jsonPath = JSON.stringify(path);\n  React.useEffect(() => navigate(JSON.parse(jsonPath), {\n    replace,\n    state,\n    relative\n  }), [navigate, jsonPath, relative, replace, state]);\n  return null;\n}\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/components/outlet\n */\nfunction Outlet(props) {\n  return useOutlet(props.context);\n}\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/components/route\n */\nfunction Route(_props) {\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"A <Route> is only ever to be used as the child of <Routes> element, \" + \"never rendered directly. Please wrap your <Route> in a <Routes>.\") : UNSAFE_invariant(false) ;\n}\n/**\n * Provides location context for the rest of the app.\n *\n * Note: You usually won't render a `<Router>` directly. Instead, you'll render a\n * router that is more specific to your environment such as a `<BrowserRouter>`\n * in web browsers or a `<StaticRouter>` for server rendering.\n *\n * @see https://reactrouter.com/router-components/router\n */\nfunction Router(_ref5) {\n  let {\n    basename: basenameProp = \"/\",\n    children = null,\n    location: locationProp,\n    navigationType = Action.Pop,\n    navigator,\n    static: staticProp = false,\n    future\n  } = _ref5;\n  !!useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"You cannot render a <Router> inside another <Router>.\" + \" You should never have more than one in your app.\") : UNSAFE_invariant(false) : void 0;\n\n  // Preserve trailing slashes on basename, so we can let the user control\n  // the enforcement of trailing slashes throughout the app\n  let basename = basenameProp.replace(/^\\/*/, \"/\");\n  let navigationContext = React.useMemo(() => ({\n    basename,\n    navigator,\n    static: staticProp,\n    future: _extends({\n      v7_relativeSplatPath: false\n    }, future)\n  }), [basename, future, navigator, staticProp]);\n  if (typeof locationProp === \"string\") {\n    locationProp = parsePath(locationProp);\n  }\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\",\n    state = null,\n    key = \"default\"\n  } = locationProp;\n  let locationContext = React.useMemo(() => {\n    let trailingPathname = stripBasename(pathname, basename);\n    if (trailingPathname == null) {\n      return null;\n    }\n    return {\n      location: {\n        pathname: trailingPathname,\n        search,\n        hash,\n        state,\n        key\n      },\n      navigationType\n    };\n  }, [basename, pathname, search, hash, state, key, navigationType]);\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(locationContext != null, \"<Router basename=\\\"\" + basename + \"\\\"> is not able to match the URL \" + (\"\\\"\" + pathname + search + hash + \"\\\" because it does not start with the \") + \"basename, so the <Router> won't render anything.\") : void 0;\n  if (locationContext == null) {\n    return null;\n  }\n  return /*#__PURE__*/React.createElement(NavigationContext.Provider, {\n    value: navigationContext\n  }, /*#__PURE__*/React.createElement(LocationContext.Provider, {\n    children: children,\n    value: locationContext\n  }));\n}\n/**\n * A container for a nested tree of `<Route>` elements that renders the branch\n * that best matches the current location.\n *\n * @see https://reactrouter.com/components/routes\n */\nfunction Routes(_ref6) {\n  let {\n    children,\n    location\n  } = _ref6;\n  return useRoutes(createRoutesFromChildren(children), location);\n}\n/**\n * Component to use for rendering lazily loaded data from returning defer()\n * in a loader function\n */\nfunction Await(_ref7) {\n  let {\n    children,\n    errorElement,\n    resolve\n  } = _ref7;\n  return /*#__PURE__*/React.createElement(AwaitErrorBoundary, {\n    resolve: resolve,\n    errorElement: errorElement\n  }, /*#__PURE__*/React.createElement(ResolveAwait, null, children));\n}\nvar AwaitRenderStatus = /*#__PURE__*/function (AwaitRenderStatus) {\n  AwaitRenderStatus[AwaitRenderStatus[\"pending\"] = 0] = \"pending\";\n  AwaitRenderStatus[AwaitRenderStatus[\"success\"] = 1] = \"success\";\n  AwaitRenderStatus[AwaitRenderStatus[\"error\"] = 2] = \"error\";\n  return AwaitRenderStatus;\n}(AwaitRenderStatus || {});\nconst neverSettledPromise = new Promise(() => {});\nclass AwaitErrorBoundary extends React.Component {\n  constructor(props) {\n    super(props);\n    this.state = {\n      error: null\n    };\n  }\n  static getDerivedStateFromError(error) {\n    return {\n      error\n    };\n  }\n  componentDidCatch(error, errorInfo) {\n    console.error(\"<Await> caught the following error during render\", error, errorInfo);\n  }\n  render() {\n    let {\n      children,\n      errorElement,\n      resolve\n    } = this.props;\n    let promise = null;\n    let status = AwaitRenderStatus.pending;\n    if (!(resolve instanceof Promise)) {\n      // Didn't get a promise - provide as a resolved promise\n      status = AwaitRenderStatus.success;\n      promise = Promise.resolve();\n      Object.defineProperty(promise, \"_tracked\", {\n        get: () => true\n      });\n      Object.defineProperty(promise, \"_data\", {\n        get: () => resolve\n      });\n    } else if (this.state.error) {\n      // Caught a render error, provide it as a rejected promise\n      status = AwaitRenderStatus.error;\n      let renderError = this.state.error;\n      promise = Promise.reject().catch(() => {}); // Avoid unhandled rejection warnings\n      Object.defineProperty(promise, \"_tracked\", {\n        get: () => true\n      });\n      Object.defineProperty(promise, \"_error\", {\n        get: () => renderError\n      });\n    } else if (resolve._tracked) {\n      // Already tracked promise - check contents\n      promise = resolve;\n      status = promise._error !== undefined ? AwaitRenderStatus.error : promise._data !== undefined ? AwaitRenderStatus.success : AwaitRenderStatus.pending;\n    } else {\n      // Raw (untracked) promise - track it\n      status = AwaitRenderStatus.pending;\n      Object.defineProperty(resolve, \"_tracked\", {\n        get: () => true\n      });\n      promise = resolve.then(data => Object.defineProperty(resolve, \"_data\", {\n        get: () => data\n      }), error => Object.defineProperty(resolve, \"_error\", {\n        get: () => error\n      }));\n    }\n    if (status === AwaitRenderStatus.error && promise._error instanceof AbortedDeferredError) {\n      // Freeze the UI by throwing a never resolved promise\n      throw neverSettledPromise;\n    }\n    if (status === AwaitRenderStatus.error && !errorElement) {\n      // No errorElement, throw to the nearest route-level error boundary\n      throw promise._error;\n    }\n    if (status === AwaitRenderStatus.error) {\n      // Render via our errorElement\n      return /*#__PURE__*/React.createElement(AwaitContext.Provider, {\n        value: promise,\n        children: errorElement\n      });\n    }\n    if (status === AwaitRenderStatus.success) {\n      // Render children with resolved value\n      return /*#__PURE__*/React.createElement(AwaitContext.Provider, {\n        value: promise,\n        children: children\n      });\n    }\n\n    // Throw to the suspense boundary\n    throw promise;\n  }\n}\n\n/**\n * @private\n * Indirection to leverage useAsyncValue for a render-prop API on `<Await>`\n */\nfunction ResolveAwait(_ref8) {\n  let {\n    children\n  } = _ref8;\n  let data = useAsyncValue();\n  let toRender = typeof children === \"function\" ? children(data) : children;\n  return /*#__PURE__*/React.createElement(React.Fragment, null, toRender);\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// UTILS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Creates a route config from a React \"children\" object, which is usually\n * either a `<Route>` element or an array of them. Used internally by\n * `<Routes>` to create a route config from its children.\n *\n * @see https://reactrouter.com/utils/create-routes-from-children\n */\nfunction createRoutesFromChildren(children, parentPath) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\n  let routes = [];\n  React.Children.forEach(children, (element, index) => {\n    if (! /*#__PURE__*/React.isValidElement(element)) {\n      // Ignore non-elements. This allows people to more easily inline\n      // conditionals in their route config.\n      return;\n    }\n    let treePath = [...parentPath, index];\n    if (element.type === React.Fragment) {\n      // Transparently support React.Fragment and its children.\n      routes.push.apply(routes, createRoutesFromChildren(element.props.children, treePath));\n      return;\n    }\n    !(element.type === Route) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"[\" + (typeof element.type === \"string\" ? element.type : element.type.name) + \"] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>\") : UNSAFE_invariant(false) : void 0;\n    !(!element.props.index || !element.props.children) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"An index route cannot have child routes.\") : UNSAFE_invariant(false) : void 0;\n    let route = {\n      id: element.props.id || treePath.join(\"-\"),\n      caseSensitive: element.props.caseSensitive,\n      element: element.props.element,\n      Component: element.props.Component,\n      index: element.props.index,\n      path: element.props.path,\n      loader: element.props.loader,\n      action: element.props.action,\n      errorElement: element.props.errorElement,\n      ErrorBoundary: element.props.ErrorBoundary,\n      hasErrorBoundary: element.props.ErrorBoundary != null || element.props.errorElement != null,\n      shouldRevalidate: element.props.shouldRevalidate,\n      handle: element.props.handle,\n      lazy: element.props.lazy\n    };\n    if (element.props.children) {\n      route.children = createRoutesFromChildren(element.props.children, treePath);\n    }\n    routes.push(route);\n  });\n  return routes;\n}\n\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\nfunction renderMatches(matches) {\n  return _renderMatches(matches);\n}\n\nfunction mapRouteProperties(route) {\n  let updates = {\n    // Note: this check also occurs in createRoutesFromChildren so update\n    // there if you change this -- please and thank you!\n    hasErrorBoundary: route.ErrorBoundary != null || route.errorElement != null\n  };\n  if (route.Component) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (route.element) {\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `Component` and `element` on your route - \" + \"`Component` will be used.\") : void 0;\n      }\n    }\n    Object.assign(updates, {\n      element: /*#__PURE__*/React.createElement(route.Component),\n      Component: undefined\n    });\n  }\n  if (route.HydrateFallback) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (route.hydrateFallbackElement) {\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `HydrateFallback` and `hydrateFallbackElement` on your route - \" + \"`HydrateFallback` will be used.\") : void 0;\n      }\n    }\n    Object.assign(updates, {\n      hydrateFallbackElement: /*#__PURE__*/React.createElement(route.HydrateFallback),\n      HydrateFallback: undefined\n    });\n  }\n  if (route.ErrorBoundary) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (route.errorElement) {\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `ErrorBoundary` and `errorElement` on your route - \" + \"`ErrorBoundary` will be used.\") : void 0;\n      }\n    }\n    Object.assign(updates, {\n      errorElement: /*#__PURE__*/React.createElement(route.ErrorBoundary),\n      ErrorBoundary: undefined\n    });\n  }\n  return updates;\n}\nfunction createMemoryRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    future: _extends({}, opts == null ? void 0 : opts.future, {\n      v7_prependBasename: true\n    }),\n    history: createMemoryHistory({\n      initialEntries: opts == null ? void 0 : opts.initialEntries,\n      initialIndex: opts == null ? void 0 : opts.initialIndex\n    }),\n    hydrationData: opts == null ? void 0 : opts.hydrationData,\n    routes,\n    mapRouteProperties\n  }).initialize();\n}\n\nexport { Await, MemoryRouter, Navigate, Outlet, Route, Router, RouterProvider, Routes, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RouteContext as UNSAFE_RouteContext, mapRouteProperties as UNSAFE_mapRouteProperties, useRouteId as UNSAFE_useRouteId, useRoutesImpl as UNSAFE_useRoutesImpl, createMemoryRouter, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, renderMatches, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };\n//# sourceMappingURL=index.js.map\n","/**\n * React Router DOM v6.22.3\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 */\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { UNSAFE_mapRouteProperties, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, Router, UNSAFE_useRoutesImpl, UNSAFE_NavigationContext, useHref, useResolvedPath, useLocation, useNavigate, createPath, UNSAFE_useRouteId, UNSAFE_RouteContext, useMatches, useNavigation, useBlocker } from 'react-router';\nexport { AbortedDeferredError, Await, MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, Routes, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RouteContext, UNSAFE_useRouteId, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromElements, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, resolvePath, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes } from 'react-router';\nimport { stripBasename, UNSAFE_warning, createRouter, createBrowserHistory, createHashHistory, UNSAFE_ErrorResponseImpl, UNSAFE_invariant, joinPaths, IDLE_FETCHER, matchPath } from '@remix-run/router';\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}\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}\n\nconst defaultMethod = \"get\";\nconst defaultEncType = \"application/x-www-form-urlencoded\";\nfunction isHtmlElement(object) {\n  return object != null && typeof object.tagName === \"string\";\n}\nfunction isButtonElement(object) {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"button\";\n}\nfunction isFormElement(object) {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"form\";\n}\nfunction isInputElement(object) {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"input\";\n}\nfunction isModifiedEvent(event) {\n  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\nfunction shouldProcessLinkClick(event, target) {\n  return event.button === 0 && (\n  // Ignore everything but left clicks\n  !target || target === \"_self\") &&\n  // Let browser handle \"target=_blank\" etc.\n  !isModifiedEvent(event) // Ignore clicks with modifier keys\n  ;\n}\n/**\n * Creates a URLSearchParams object using the given initializer.\n *\n * This is identical to `new URLSearchParams(init)` except it also\n * supports arrays as values in the object form of the initializer\n * instead of just strings. This is convenient when you need multiple\n * values for a given key, but don't want to use an array initializer.\n *\n * For example, instead of:\n *\n *   let searchParams = new URLSearchParams([\n *     ['sort', 'name'],\n *     ['sort', 'price']\n *   ]);\n *\n * you can do:\n *\n *   let searchParams = createSearchParams({\n *     sort: ['name', 'price']\n *   });\n */\nfunction createSearchParams(init) {\n  if (init === void 0) {\n    init = \"\";\n  }\n  return new URLSearchParams(typeof init === \"string\" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => {\n    let value = init[key];\n    return memo.concat(Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]);\n  }, []));\n}\nfunction getSearchParamsForLocation(locationSearch, defaultSearchParams) {\n  let searchParams = createSearchParams(locationSearch);\n  if (defaultSearchParams) {\n    // Use `defaultSearchParams.forEach(...)` here instead of iterating of\n    // `defaultSearchParams.keys()` to work-around a bug in Firefox related to\n    // web extensions. Relevant Bugzilla tickets:\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1414602\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1023984\n    defaultSearchParams.forEach((_, key) => {\n      if (!searchParams.has(key)) {\n        defaultSearchParams.getAll(key).forEach(value => {\n          searchParams.append(key, value);\n        });\n      }\n    });\n  }\n  return searchParams;\n}\n// One-time check for submitter support\nlet _formDataSupportsSubmitter = null;\nfunction isFormDataSubmitterSupported() {\n  if (_formDataSupportsSubmitter === null) {\n    try {\n      new FormData(document.createElement(\"form\"),\n      // @ts-expect-error if FormData supports the submitter parameter, this will throw\n      0);\n      _formDataSupportsSubmitter = false;\n    } catch (e) {\n      _formDataSupportsSubmitter = true;\n    }\n  }\n  return _formDataSupportsSubmitter;\n}\nconst supportedFormEncTypes = new Set([\"application/x-www-form-urlencoded\", \"multipart/form-data\", \"text/plain\"]);\nfunction getFormEncType(encType) {\n  if (encType != null && !supportedFormEncTypes.has(encType)) {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"\\\"\" + encType + \"\\\" is not a valid `encType` for `<Form>`/`<fetcher.Form>` \" + (\"and will default to \\\"\" + defaultEncType + \"\\\"\")) : void 0;\n    return null;\n  }\n  return encType;\n}\nfunction getFormSubmissionInfo(target, basename) {\n  let method;\n  let action;\n  let encType;\n  let formData;\n  let body;\n  if (isFormElement(target)) {\n    // When grabbing the action from the element, it will have had the basename\n    // prefixed to ensure non-JS scenarios work, so strip it since we'll\n    // re-prefix in the router\n    let attr = target.getAttribute(\"action\");\n    action = attr ? stripBasename(attr, basename) : null;\n    method = target.getAttribute(\"method\") || defaultMethod;\n    encType = getFormEncType(target.getAttribute(\"enctype\")) || defaultEncType;\n    formData = new FormData(target);\n  } else if (isButtonElement(target) || isInputElement(target) && (target.type === \"submit\" || target.type === \"image\")) {\n    let form = target.form;\n    if (form == null) {\n      throw new Error(\"Cannot submit a <button> or <input type=\\\"submit\\\"> without a <form>\");\n    }\n    // <button>/<input type=\"submit\"> may override attributes of <form>\n    // When grabbing the action from the element, it will have had the basename\n    // prefixed to ensure non-JS scenarios work, so strip it since we'll\n    // re-prefix in the router\n    let attr = target.getAttribute(\"formaction\") || form.getAttribute(\"action\");\n    action = attr ? stripBasename(attr, basename) : null;\n    method = target.getAttribute(\"formmethod\") || form.getAttribute(\"method\") || defaultMethod;\n    encType = getFormEncType(target.getAttribute(\"formenctype\")) || getFormEncType(form.getAttribute(\"enctype\")) || defaultEncType;\n    // Build a FormData object populated from a form and submitter\n    formData = new FormData(form, target);\n    // If this browser doesn't support the `FormData(el, submitter)` format,\n    // then tack on the submitter value at the end.  This is a lightweight\n    // solution that is not 100% spec compliant.  For complete support in older\n    // browsers, consider using the `formdata-submitter-polyfill` package\n    if (!isFormDataSubmitterSupported()) {\n      let {\n        name,\n        type,\n        value\n      } = target;\n      if (type === \"image\") {\n        let prefix = name ? name + \".\" : \"\";\n        formData.append(prefix + \"x\", \"0\");\n        formData.append(prefix + \"y\", \"0\");\n      } else if (name) {\n        formData.append(name, value);\n      }\n    }\n  } else if (isHtmlElement(target)) {\n    throw new Error(\"Cannot submit element that is not <form>, <button>, or \" + \"<input type=\\\"submit|image\\\">\");\n  } else {\n    method = defaultMethod;\n    action = null;\n    encType = defaultEncType;\n    body = target;\n  }\n  // Send body for <Form encType=\"text/plain\" so we encode it into text\n  if (formData && encType === \"text/plain\") {\n    body = formData;\n    formData = undefined;\n  }\n  return {\n    action,\n    method: method.toLowerCase(),\n    encType,\n    formData,\n    body\n  };\n}\n\nconst _excluded = [\"onClick\", \"relative\", \"reloadDocument\", \"replace\", \"state\", \"target\", \"to\", \"preventScrollReset\", \"unstable_viewTransition\"],\n  _excluded2 = [\"aria-current\", \"caseSensitive\", \"className\", \"end\", \"style\", \"to\", \"unstable_viewTransition\", \"children\"],\n  _excluded3 = [\"fetcherKey\", \"navigate\", \"reloadDocument\", \"replace\", \"state\", \"method\", \"action\", \"onSubmit\", \"relative\", \"preventScrollReset\", \"unstable_viewTransition\"];\n// HEY YOU! DON'T TOUCH THIS VARIABLE!\n//\n// It is replaced with the proper version at build time via a babel plugin in\n// the rollup config.\n//\n// Export a global property onto the window for React Router detection by the\n// Core Web Vitals Technology Report.  This way they can configure the `wappalyzer`\n// to detect and properly classify live websites as being built with React Router:\n// https://github.com/HTTPArchive/wappalyzer/blob/main/src/technologies/r.json\nconst REACT_ROUTER_VERSION = \"6\";\ntry {\n  window.__reactRouterVersion = REACT_ROUTER_VERSION;\n} catch (e) {\n  // no-op\n}\nfunction createBrowserRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    future: _extends({}, opts == null ? void 0 : opts.future, {\n      v7_prependBasename: true\n    }),\n    history: createBrowserHistory({\n      window: opts == null ? void 0 : opts.window\n    }),\n    hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(),\n    routes,\n    mapRouteProperties: UNSAFE_mapRouteProperties,\n    window: opts == null ? void 0 : opts.window\n  }).initialize();\n}\nfunction createHashRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    future: _extends({}, opts == null ? void 0 : opts.future, {\n      v7_prependBasename: true\n    }),\n    history: createHashHistory({\n      window: opts == null ? void 0 : opts.window\n    }),\n    hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(),\n    routes,\n    mapRouteProperties: UNSAFE_mapRouteProperties,\n    window: opts == null ? void 0 : opts.window\n  }).initialize();\n}\nfunction parseHydrationData() {\n  var _window;\n  let state = (_window = window) == null ? void 0 : _window.__staticRouterHydrationData;\n  if (state && state.errors) {\n    state = _extends({}, state, {\n      errors: deserializeErrors(state.errors)\n    });\n  }\n  return state;\n}\nfunction deserializeErrors(errors) {\n  if (!errors) return null;\n  let entries = Object.entries(errors);\n  let serialized = {};\n  for (let [key, val] of entries) {\n    // Hey you!  If you change this, please change the corresponding logic in\n    // serializeErrors in react-router-dom/server.tsx :)\n    if (val && val.__type === \"RouteErrorResponse\") {\n      serialized[key] = new UNSAFE_ErrorResponseImpl(val.status, val.statusText, val.data, val.internal === true);\n    } else if (val && val.__type === \"Error\") {\n      // Attempt to reconstruct the right type of Error (i.e., ReferenceError)\n      if (val.__subType) {\n        let ErrorConstructor = window[val.__subType];\n        if (typeof ErrorConstructor === \"function\") {\n          try {\n            // @ts-expect-error\n            let error = new ErrorConstructor(val.message);\n            // Wipe away the client-side stack trace.  Nothing to fill it in with\n            // because we don't serialize SSR stack traces for security reasons\n            error.stack = \"\";\n            serialized[key] = error;\n          } catch (e) {\n            // no-op - fall through and create a normal Error\n          }\n        }\n      }\n      if (serialized[key] == null) {\n        let error = new Error(val.message);\n        // Wipe away the client-side stack trace.  Nothing to fill it in with\n        // because we don't serialize SSR stack traces for security reasons\n        error.stack = \"\";\n        serialized[key] = error;\n      }\n    } else {\n      serialized[key] = val;\n    }\n  }\n  return serialized;\n}\nconst ViewTransitionContext = /*#__PURE__*/React.createContext({\n  isTransitioning: false\n});\nif (process.env.NODE_ENV !== \"production\") {\n  ViewTransitionContext.displayName = \"ViewTransition\";\n}\nconst FetchersContext = /*#__PURE__*/React.createContext(new Map());\nif (process.env.NODE_ENV !== \"production\") {\n  FetchersContext.displayName = \"Fetchers\";\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Components\n////////////////////////////////////////////////////////////////////////////////\n/**\n  Webpack + React 17 fails to compile on any of the following because webpack\n  complains that `startTransition` doesn't exist in `React`:\n  * import { startTransition } from \"react\"\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n  Moving it to a constant such as the following solves the Webpack/React 17 issue:\n  * import * as React from from \"react\";\n    const START_TRANSITION = \"startTransition\";\n    START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n  However, that introduces webpack/terser minification issues in production builds\n  in React 18 where minification/obfuscation ends up removing the call of\n  React.startTransition entirely from the first half of the ternary.  Grabbing\n  this exported reference once up front resolves that issue.\n\n  See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\nconst FLUSH_SYNC = \"flushSync\";\nconst flushSyncImpl = ReactDOM[FLUSH_SYNC];\nconst USE_ID = \"useId\";\nconst useIdImpl = React[USE_ID];\nfunction startTransitionSafe(cb) {\n  if (startTransitionImpl) {\n    startTransitionImpl(cb);\n  } else {\n    cb();\n  }\n}\nfunction flushSyncSafe(cb) {\n  if (flushSyncImpl) {\n    flushSyncImpl(cb);\n  } else {\n    cb();\n  }\n}\nclass Deferred {\n  constructor() {\n    this.status = \"pending\";\n    this.promise = new Promise((resolve, reject) => {\n      this.resolve = value => {\n        if (this.status === \"pending\") {\n          this.status = \"resolved\";\n          resolve(value);\n        }\n      };\n      this.reject = reason => {\n        if (this.status === \"pending\") {\n          this.status = \"rejected\";\n          reject(reason);\n        }\n      };\n    });\n  }\n}\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nfunction RouterProvider(_ref) {\n  let {\n    fallbackElement,\n    router,\n    future\n  } = _ref;\n  let [state, setStateImpl] = React.useState(router.state);\n  let [pendingState, setPendingState] = React.useState();\n  let [vtContext, setVtContext] = React.useState({\n    isTransitioning: false\n  });\n  let [renderDfd, setRenderDfd] = React.useState();\n  let [transition, setTransition] = React.useState();\n  let [interruption, setInterruption] = React.useState();\n  let fetcherData = React.useRef(new Map());\n  let {\n    v7_startTransition\n  } = future || {};\n  let optInStartTransition = React.useCallback(cb => {\n    if (v7_startTransition) {\n      startTransitionSafe(cb);\n    } else {\n      cb();\n    }\n  }, [v7_startTransition]);\n  let setState = React.useCallback((newState, _ref2) => {\n    let {\n      deletedFetchers,\n      unstable_flushSync: flushSync,\n      unstable_viewTransitionOpts: viewTransitionOpts\n    } = _ref2;\n    deletedFetchers.forEach(key => fetcherData.current.delete(key));\n    newState.fetchers.forEach((fetcher, key) => {\n      if (fetcher.data !== undefined) {\n        fetcherData.current.set(key, fetcher.data);\n      }\n    });\n    let isViewTransitionUnavailable = router.window == null || typeof router.window.document.startViewTransition !== \"function\";\n    // If this isn't a view transition or it's not available in this browser,\n    // just update and be done with it\n    if (!viewTransitionOpts || isViewTransitionUnavailable) {\n      if (flushSync) {\n        flushSyncSafe(() => setStateImpl(newState));\n      } else {\n        optInStartTransition(() => setStateImpl(newState));\n      }\n      return;\n    }\n    // flushSync + startViewTransition\n    if (flushSync) {\n      // Flush through the context to mark DOM elements as transition=ing\n      flushSyncSafe(() => {\n        // Cancel any pending transitions\n        if (transition) {\n          renderDfd && renderDfd.resolve();\n          transition.skipTransition();\n        }\n        setVtContext({\n          isTransitioning: true,\n          flushSync: true,\n          currentLocation: viewTransitionOpts.currentLocation,\n          nextLocation: viewTransitionOpts.nextLocation\n        });\n      });\n      // Update the DOM\n      let t = router.window.document.startViewTransition(() => {\n        flushSyncSafe(() => setStateImpl(newState));\n      });\n      // Clean up after the animation completes\n      t.finished.finally(() => {\n        flushSyncSafe(() => {\n          setRenderDfd(undefined);\n          setTransition(undefined);\n          setPendingState(undefined);\n          setVtContext({\n            isTransitioning: false\n          });\n        });\n      });\n      flushSyncSafe(() => setTransition(t));\n      return;\n    }\n    // startTransition + startViewTransition\n    if (transition) {\n      // Interrupting an in-progress transition, cancel and let everything flush\n      // out, and then kick off a new transition from the interruption state\n      renderDfd && renderDfd.resolve();\n      transition.skipTransition();\n      setInterruption({\n        state: newState,\n        currentLocation: viewTransitionOpts.currentLocation,\n        nextLocation: viewTransitionOpts.nextLocation\n      });\n    } else {\n      // Completed navigation update with opted-in view transitions, let 'er rip\n      setPendingState(newState);\n      setVtContext({\n        isTransitioning: true,\n        flushSync: false,\n        currentLocation: viewTransitionOpts.currentLocation,\n        nextLocation: viewTransitionOpts.nextLocation\n      });\n    }\n  }, [router.window, transition, renderDfd, fetcherData, optInStartTransition]);\n  // Need to use a layout effect here so we are subscribed early enough to\n  // pick up on any render-driven redirects/navigations (useEffect/<Navigate>)\n  React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);\n  // When we start a view transition, create a Deferred we can use for the\n  // eventual \"completed\" render\n  React.useEffect(() => {\n    if (vtContext.isTransitioning && !vtContext.flushSync) {\n      setRenderDfd(new Deferred());\n    }\n  }, [vtContext]);\n  // Once the deferred is created, kick off startViewTransition() to update the\n  // DOM and then wait on the Deferred to resolve (indicating the DOM update has\n  // happened)\n  React.useEffect(() => {\n    if (renderDfd && pendingState && router.window) {\n      let newState = pendingState;\n      let renderPromise = renderDfd.promise;\n      let transition = router.window.document.startViewTransition(async () => {\n        optInStartTransition(() => setStateImpl(newState));\n        await renderPromise;\n      });\n      transition.finished.finally(() => {\n        setRenderDfd(undefined);\n        setTransition(undefined);\n        setPendingState(undefined);\n        setVtContext({\n          isTransitioning: false\n        });\n      });\n      setTransition(transition);\n    }\n  }, [optInStartTransition, pendingState, renderDfd, router.window]);\n  // When the new location finally renders and is committed to the DOM, this\n  // effect will run to resolve the transition\n  React.useEffect(() => {\n    if (renderDfd && pendingState && state.location.key === pendingState.location.key) {\n      renderDfd.resolve();\n    }\n  }, [renderDfd, transition, state.location, pendingState]);\n  // If we get interrupted with a new navigation during a transition, we skip\n  // the active transition, let it cleanup, then kick it off again here\n  React.useEffect(() => {\n    if (!vtContext.isTransitioning && interruption) {\n      setPendingState(interruption.state);\n      setVtContext({\n        isTransitioning: true,\n        flushSync: false,\n        currentLocation: interruption.currentLocation,\n        nextLocation: interruption.nextLocation\n      });\n      setInterruption(undefined);\n    }\n  }, [vtContext.isTransitioning, interruption]);\n  React.useEffect(() => {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(fallbackElement == null || !router.future.v7_partialHydration, \"`<RouterProvider fallbackElement>` is deprecated when using \" + \"`v7_partialHydration`, use a `HydrateFallback` component instead\") : void 0;\n    // Only log this once on initial mount\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n  let navigator = React.useMemo(() => {\n    return {\n      createHref: router.createHref,\n      encodeLocation: router.encodeLocation,\n      go: n => router.navigate(n),\n      push: (to, state, opts) => router.navigate(to, {\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      }),\n      replace: (to, state, opts) => router.navigate(to, {\n        replace: true,\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      })\n    };\n  }, [router]);\n  let basename = router.basename || \"/\";\n  let dataRouterContext = React.useMemo(() => ({\n    router,\n    navigator,\n    static: false,\n    basename\n  }), [router, navigator, basename]);\n  // The fragment and {null} here are important!  We need them to keep React 18's\n  // useId happy when we are server-rendering since we may have a <script> here\n  // containing the hydrated server-side staticContext (from StaticRouterProvider).\n  // useId relies on the component tree structure to generate deterministic id's\n  // so we need to ensure it remains the same on the client even though\n  // we don't need the <script> tag\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(UNSAFE_DataRouterContext.Provider, {\n    value: dataRouterContext\n  }, /*#__PURE__*/React.createElement(UNSAFE_DataRouterStateContext.Provider, {\n    value: state\n  }, /*#__PURE__*/React.createElement(FetchersContext.Provider, {\n    value: fetcherData.current\n  }, /*#__PURE__*/React.createElement(ViewTransitionContext.Provider, {\n    value: vtContext\n  }, /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    location: state.location,\n    navigationType: state.historyAction,\n    navigator: navigator,\n    future: {\n      v7_relativeSplatPath: router.future.v7_relativeSplatPath\n    }\n  }, state.initialized || router.future.v7_partialHydration ? /*#__PURE__*/React.createElement(DataRoutes, {\n    routes: router.routes,\n    future: router.future,\n    state: state\n  }) : fallbackElement))))), null);\n}\nfunction DataRoutes(_ref3) {\n  let {\n    routes,\n    future,\n    state\n  } = _ref3;\n  return UNSAFE_useRoutesImpl(routes, undefined, state, future);\n}\n/**\n * A `<Router>` for use in web browsers. Provides the cleanest URLs.\n */\nfunction BrowserRouter(_ref4) {\n  let {\n    basename,\n    children,\n    future,\n    window\n  } = _ref4;\n  let historyRef = React.useRef();\n  if (historyRef.current == null) {\n    historyRef.current = createBrowserHistory({\n      window,\n      v5Compat: true\n    });\n  }\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history,\n    future: future\n  });\n}\n/**\n * A `<Router>` for use in web browsers. Stores the location in the hash\n * portion of the URL so it is not sent to the server.\n */\nfunction HashRouter(_ref5) {\n  let {\n    basename,\n    children,\n    future,\n    window\n  } = _ref5;\n  let historyRef = React.useRef();\n  if (historyRef.current == null) {\n    historyRef.current = createHashHistory({\n      window,\n      v5Compat: true\n    });\n  }\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history,\n    future: future\n  });\n}\n/**\n * A `<Router>` that accepts a pre-instantiated history object. It's important\n * to note that using your own history object is highly discouraged and may add\n * two versions of the history library to your bundles unless you use the same\n * version of the history library that React Router uses internally.\n */\nfunction HistoryRouter(_ref6) {\n  let {\n    basename,\n    children,\n    future,\n    history\n  } = _ref6;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history,\n    future: future\n  });\n}\nif (process.env.NODE_ENV !== \"production\") {\n  HistoryRouter.displayName = \"unstable_HistoryRouter\";\n}\nconst isBrowser = typeof window !== \"undefined\" && typeof window.document !== \"undefined\" && typeof window.document.createElement !== \"undefined\";\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n/**\n * The public API for rendering a history-aware `<a>`.\n */\nconst Link = /*#__PURE__*/React.forwardRef(function LinkWithRef(_ref7, ref) {\n  let {\n      onClick,\n      relative,\n      reloadDocument,\n      replace,\n      state,\n      target,\n      to,\n      preventScrollReset,\n      unstable_viewTransition\n    } = _ref7,\n    rest = _objectWithoutPropertiesLoose(_ref7, _excluded);\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  // Rendered into <a href> for absolute URLs\n  let absoluteHref;\n  let isExternal = false;\n  if (typeof to === \"string\" && ABSOLUTE_URL_REGEX.test(to)) {\n    // Render the absolute href server- and client-side\n    absoluteHref = to;\n    // Only check for external origins client-side\n    if (isBrowser) {\n      try {\n        let currentUrl = new URL(window.location.href);\n        let targetUrl = to.startsWith(\"//\") ? new URL(currentUrl.protocol + to) : new URL(to);\n        let path = stripBasename(targetUrl.pathname, basename);\n        if (targetUrl.origin === currentUrl.origin && path != null) {\n          // Strip the protocol/origin/basename for same-origin absolute URLs\n          to = path + targetUrl.search + targetUrl.hash;\n        } else {\n          isExternal = true;\n        }\n      } catch (e) {\n        // We can't do external URL detection without a valid URL\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"<Link to=\\\"\" + to + \"\\\"> contains an invalid URL which will probably break \" + \"when clicked - please update to a valid URL path.\") : void 0;\n      }\n    }\n  }\n  // Rendered into <a href> for relative URLs\n  let href = useHref(to, {\n    relative\n  });\n  let internalOnClick = useLinkClickHandler(to, {\n    replace,\n    state,\n    target,\n    preventScrollReset,\n    relative,\n    unstable_viewTransition\n  });\n  function handleClick(event) {\n    if (onClick) onClick(event);\n    if (!event.defaultPrevented) {\n      internalOnClick(event);\n    }\n  }\n  return (\n    /*#__PURE__*/\n    // eslint-disable-next-line jsx-a11y/anchor-has-content\n    React.createElement(\"a\", _extends({}, rest, {\n      href: absoluteHref || href,\n      onClick: isExternal || reloadDocument ? onClick : handleClick,\n      ref: ref,\n      target: target\n    }))\n  );\n});\nif (process.env.NODE_ENV !== \"production\") {\n  Link.displayName = \"Link\";\n}\n/**\n * A `<Link>` wrapper that knows if it's \"active\" or not.\n */\nconst NavLink = /*#__PURE__*/React.forwardRef(function NavLinkWithRef(_ref8, ref) {\n  let {\n      \"aria-current\": ariaCurrentProp = \"page\",\n      caseSensitive = false,\n      className: classNameProp = \"\",\n      end = false,\n      style: styleProp,\n      to,\n      unstable_viewTransition,\n      children\n    } = _ref8,\n    rest = _objectWithoutPropertiesLoose(_ref8, _excluded2);\n  let path = useResolvedPath(to, {\n    relative: rest.relative\n  });\n  let location = useLocation();\n  let routerState = React.useContext(UNSAFE_DataRouterStateContext);\n  let {\n    navigator,\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  let isTransitioning = routerState != null &&\n  // Conditional usage is OK here because the usage of a data router is static\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  useViewTransitionState(path) && unstable_viewTransition === true;\n  let toPathname = navigator.encodeLocation ? navigator.encodeLocation(path).pathname : path.pathname;\n  let locationPathname = location.pathname;\n  let nextLocationPathname = routerState && routerState.navigation && routerState.navigation.location ? routerState.navigation.location.pathname : null;\n  if (!caseSensitive) {\n    locationPathname = locationPathname.toLowerCase();\n    nextLocationPathname = nextLocationPathname ? nextLocationPathname.toLowerCase() : null;\n    toPathname = toPathname.toLowerCase();\n  }\n  if (nextLocationPathname && basename) {\n    nextLocationPathname = stripBasename(nextLocationPathname, basename) || nextLocationPathname;\n  }\n  // If the `to` has a trailing slash, look at that exact spot.  Otherwise,\n  // we're looking for a slash _after_ what's in `to`.  For example:\n  //\n  // <NavLink to=\"/users\"> and <NavLink to=\"/users/\">\n  // both want to look for a / at index 6 to match URL `/users/matt`\n  const endSlashPosition = toPathname !== \"/\" && toPathname.endsWith(\"/\") ? toPathname.length - 1 : toPathname.length;\n  let isActive = locationPathname === toPathname || !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(endSlashPosition) === \"/\";\n  let isPending = nextLocationPathname != null && (nextLocationPathname === toPathname || !end && nextLocationPathname.startsWith(toPathname) && nextLocationPathname.charAt(toPathname.length) === \"/\");\n  let renderProps = {\n    isActive,\n    isPending,\n    isTransitioning\n  };\n  let ariaCurrent = isActive ? ariaCurrentProp : undefined;\n  let className;\n  if (typeof classNameProp === \"function\") {\n    className = classNameProp(renderProps);\n  } else {\n    // If the className prop is not a function, we use a default `active`\n    // class for <NavLink />s that are active. In v5 `active` was the default\n    // value for `activeClassName`, but we are removing that API and can still\n    // use the old default behavior for a cleaner upgrade path and keep the\n    // simple styling rules working as they currently do.\n    className = [classNameProp, isActive ? \"active\" : null, isPending ? \"pending\" : null, isTransitioning ? \"transitioning\" : null].filter(Boolean).join(\" \");\n  }\n  let style = typeof styleProp === \"function\" ? styleProp(renderProps) : styleProp;\n  return /*#__PURE__*/React.createElement(Link, _extends({}, rest, {\n    \"aria-current\": ariaCurrent,\n    className: className,\n    ref: ref,\n    style: style,\n    to: to,\n    unstable_viewTransition: unstable_viewTransition\n  }), typeof children === \"function\" ? children(renderProps) : children);\n});\nif (process.env.NODE_ENV !== \"production\") {\n  NavLink.displayName = \"NavLink\";\n}\n/**\n * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except\n * that the interaction with the server is with `fetch` instead of new document\n * requests, allowing components to add nicer UX to the page as the form is\n * submitted and returns with data.\n */\nconst Form = /*#__PURE__*/React.forwardRef((_ref9, forwardedRef) => {\n  let {\n      fetcherKey,\n      navigate,\n      reloadDocument,\n      replace,\n      state,\n      method = defaultMethod,\n      action,\n      onSubmit,\n      relative,\n      preventScrollReset,\n      unstable_viewTransition\n    } = _ref9,\n    props = _objectWithoutPropertiesLoose(_ref9, _excluded3);\n  let submit = useSubmit();\n  let formAction = useFormAction(action, {\n    relative\n  });\n  let formMethod = method.toLowerCase() === \"get\" ? \"get\" : \"post\";\n  let submitHandler = event => {\n    onSubmit && onSubmit(event);\n    if (event.defaultPrevented) return;\n    event.preventDefault();\n    let submitter = event.nativeEvent.submitter;\n    let submitMethod = (submitter == null ? void 0 : submitter.getAttribute(\"formmethod\")) || method;\n    submit(submitter || event.currentTarget, {\n      fetcherKey,\n      method: submitMethod,\n      navigate,\n      replace,\n      state,\n      relative,\n      preventScrollReset,\n      unstable_viewTransition\n    });\n  };\n  return /*#__PURE__*/React.createElement(\"form\", _extends({\n    ref: forwardedRef,\n    method: formMethod,\n    action: formAction,\n    onSubmit: reloadDocument ? onSubmit : submitHandler\n  }, props));\n});\nif (process.env.NODE_ENV !== \"production\") {\n  Form.displayName = \"Form\";\n}\n/**\n * This component will emulate the browser's scroll restoration on location\n * changes.\n */\nfunction ScrollRestoration(_ref10) {\n  let {\n    getKey,\n    storageKey\n  } = _ref10;\n  useScrollRestoration({\n    getKey,\n    storageKey\n  });\n  return null;\n}\nif (process.env.NODE_ENV !== \"production\") {\n  ScrollRestoration.displayName = \"ScrollRestoration\";\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Hooks\n////////////////////////////////////////////////////////////////////////////////\nvar DataRouterHook;\n(function (DataRouterHook) {\n  DataRouterHook[\"UseScrollRestoration\"] = \"useScrollRestoration\";\n  DataRouterHook[\"UseSubmit\"] = \"useSubmit\";\n  DataRouterHook[\"UseSubmitFetcher\"] = \"useSubmitFetcher\";\n  DataRouterHook[\"UseFetcher\"] = \"useFetcher\";\n  DataRouterHook[\"useViewTransitionState\"] = \"useViewTransitionState\";\n})(DataRouterHook || (DataRouterHook = {}));\nvar DataRouterStateHook;\n(function (DataRouterStateHook) {\n  DataRouterStateHook[\"UseFetcher\"] = \"useFetcher\";\n  DataRouterStateHook[\"UseFetchers\"] = \"useFetchers\";\n  DataRouterStateHook[\"UseScrollRestoration\"] = \"useScrollRestoration\";\n})(DataRouterStateHook || (DataRouterStateHook = {}));\n// Internal hooks\nfunction getDataRouterConsoleError(hookName) {\n  return hookName + \" must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.\";\n}\nfunction useDataRouterContext(hookName) {\n  let ctx = React.useContext(UNSAFE_DataRouterContext);\n  !ctx ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return ctx;\n}\nfunction useDataRouterState(hookName) {\n  let state = React.useContext(UNSAFE_DataRouterStateContext);\n  !state ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return state;\n}\n// External hooks\n/**\n * Handles the click behavior for router `<Link>` components. This is useful if\n * you need to create custom `<Link>` components with the same click behavior we\n * use in our exported `<Link>`.\n */\nfunction useLinkClickHandler(to, _temp) {\n  let {\n    target,\n    replace: replaceProp,\n    state,\n    preventScrollReset,\n    relative,\n    unstable_viewTransition\n  } = _temp === void 0 ? {} : _temp;\n  let navigate = useNavigate();\n  let location = useLocation();\n  let path = useResolvedPath(to, {\n    relative\n  });\n  return React.useCallback(event => {\n    if (shouldProcessLinkClick(event, target)) {\n      event.preventDefault();\n      // If the URL hasn't changed, a regular <a> will do a replace instead of\n      // a push, so do the same here unless the replace prop is explicitly set\n      let replace = replaceProp !== undefined ? replaceProp : createPath(location) === createPath(path);\n      navigate(to, {\n        replace,\n        state,\n        preventScrollReset,\n        relative,\n        unstable_viewTransition\n      });\n    }\n  }, [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative, unstable_viewTransition]);\n}\n/**\n * A convenient wrapper for reading and writing search parameters via the\n * URLSearchParams interface.\n */\nfunction useSearchParams(defaultInit) {\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(typeof URLSearchParams !== \"undefined\", \"You cannot use the `useSearchParams` hook in a browser that does not \" + \"support the URLSearchParams API. If you need to support Internet \" + \"Explorer 11, we recommend you load a polyfill such as \" + \"https://github.com/ungap/url-search-params\\n\\n\" + \"If you're unsure how to load polyfills, we recommend you check out \" + \"https://polyfill.io/v3/ which provides some recommendations about how \" + \"to load polyfills only for users that need them, instead of for every \" + \"user.\") : void 0;\n  let defaultSearchParamsRef = React.useRef(createSearchParams(defaultInit));\n  let hasSetSearchParamsRef = React.useRef(false);\n  let location = useLocation();\n  let searchParams = React.useMemo(() =>\n  // Only merge in the defaults if we haven't yet called setSearchParams.\n  // Once we call that we want those to take precedence, otherwise you can't\n  // remove a param with setSearchParams({}) if it has an initial value\n  getSearchParamsForLocation(location.search, hasSetSearchParamsRef.current ? null : defaultSearchParamsRef.current), [location.search]);\n  let navigate = useNavigate();\n  let setSearchParams = React.useCallback((nextInit, navigateOptions) => {\n    const newSearchParams = createSearchParams(typeof nextInit === \"function\" ? nextInit(searchParams) : nextInit);\n    hasSetSearchParamsRef.current = true;\n    navigate(\"?\" + newSearchParams, navigateOptions);\n  }, [navigate, searchParams]);\n  return [searchParams, setSearchParams];\n}\nfunction validateClientSideSubmission() {\n  if (typeof document === \"undefined\") {\n    throw new Error(\"You are calling submit during the server render. \" + \"Try calling submit within a `useEffect` or callback instead.\");\n  }\n}\nlet fetcherId = 0;\nlet getUniqueFetcherId = () => \"__\" + String(++fetcherId) + \"__\";\n/**\n * Returns a function that may be used to programmatically submit a form (or\n * some arbitrary data) to the server.\n */\nfunction useSubmit() {\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseSubmit);\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  let currentRouteId = UNSAFE_useRouteId();\n  return React.useCallback(function (target, options) {\n    if (options === void 0) {\n      options = {};\n    }\n    validateClientSideSubmission();\n    let {\n      action,\n      method,\n      encType,\n      formData,\n      body\n    } = getFormSubmissionInfo(target, basename);\n    if (options.navigate === false) {\n      let key = options.fetcherKey || getUniqueFetcherId();\n      router.fetch(key, currentRouteId, options.action || action, {\n        preventScrollReset: options.preventScrollReset,\n        formData,\n        body,\n        formMethod: options.method || method,\n        formEncType: options.encType || encType,\n        unstable_flushSync: options.unstable_flushSync\n      });\n    } else {\n      router.navigate(options.action || action, {\n        preventScrollReset: options.preventScrollReset,\n        formData,\n        body,\n        formMethod: options.method || method,\n        formEncType: options.encType || encType,\n        replace: options.replace,\n        state: options.state,\n        fromRouteId: currentRouteId,\n        unstable_flushSync: options.unstable_flushSync,\n        unstable_viewTransition: options.unstable_viewTransition\n      });\n    }\n  }, [router, basename, currentRouteId]);\n}\n// v7: Eventually we should deprecate this entirely in favor of using the\n// router method directly?\nfunction useFormAction(action, _temp2) {\n  let {\n    relative\n  } = _temp2 === void 0 ? {} : _temp2;\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  let routeContext = React.useContext(UNSAFE_RouteContext);\n  !routeContext ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFormAction must be used inside a RouteContext\") : UNSAFE_invariant(false) : void 0;\n  let [match] = routeContext.matches.slice(-1);\n  // Shallow clone path so we can modify it below, otherwise we modify the\n  // object referenced by useMemo inside useResolvedPath\n  let path = _extends({}, useResolvedPath(action ? action : \".\", {\n    relative\n  }));\n  // If no action was specified, browsers will persist current search params\n  // when determining the path, so match that behavior\n  // https://github.com/remix-run/remix/issues/927\n  let location = useLocation();\n  if (action == null) {\n    // Safe to write to this directly here since if action was undefined, we\n    // would have called useResolvedPath(\".\") which will never include a search\n    path.search = location.search;\n    // When grabbing search params from the URL, remove any included ?index param\n    // since it might not apply to our contextual route.  We add it back based\n    // on match.route.index below\n    let params = new URLSearchParams(path.search);\n    if (params.has(\"index\") && params.get(\"index\") === \"\") {\n      params.delete(\"index\");\n      path.search = params.toString() ? \"?\" + params.toString() : \"\";\n    }\n  }\n  if ((!action || action === \".\") && match.route.index) {\n    path.search = path.search ? path.search.replace(/^\\?/, \"?index&\") : \"?index\";\n  }\n  // If we're operating within a basename, prepend it to the pathname prior\n  // to creating the form action.  If this is a root navigation, then just use\n  // the raw basename which allows the basename to have full control over the\n  // presence of a trailing slash on root actions\n  if (basename !== \"/\") {\n    path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n  return createPath(path);\n}\n// TODO: (v7) Change the useFetcher generic default from `any` to `unknown`\n/**\n * Interacts with route loaders and actions without causing a navigation. Great\n * for any interaction that stays on the same page.\n */\nfunction useFetcher(_temp3) {\n  var _route$matches;\n  let {\n    key\n  } = _temp3 === void 0 ? {} : _temp3;\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseFetcher);\n  let state = useDataRouterState(DataRouterStateHook.UseFetcher);\n  let fetcherData = React.useContext(FetchersContext);\n  let route = React.useContext(UNSAFE_RouteContext);\n  let routeId = (_route$matches = route.matches[route.matches.length - 1]) == null ? void 0 : _route$matches.route.id;\n  !fetcherData ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher must be used inside a FetchersContext\") : UNSAFE_invariant(false) : void 0;\n  !route ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher must be used inside a RouteContext\") : UNSAFE_invariant(false) : void 0;\n  !(routeId != null) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher can only be used on routes that contain a unique \\\"id\\\"\") : UNSAFE_invariant(false) : void 0;\n  // Fetcher key handling\n  // OK to call conditionally to feature detect `useId`\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  let defaultKey = useIdImpl ? useIdImpl() : \"\";\n  let [fetcherKey, setFetcherKey] = React.useState(key || defaultKey);\n  if (key && key !== fetcherKey) {\n    setFetcherKey(key);\n  } else if (!fetcherKey) {\n    // We will only fall through here when `useId` is not available\n    setFetcherKey(getUniqueFetcherId());\n  }\n  // Registration/cleanup\n  React.useEffect(() => {\n    router.getFetcher(fetcherKey);\n    return () => {\n      // Tell the router we've unmounted - if v7_fetcherPersist is enabled this\n      // will not delete immediately but instead queue up a delete after the\n      // fetcher returns to an `idle` state\n      router.deleteFetcher(fetcherKey);\n    };\n  }, [router, fetcherKey]);\n  // Fetcher additions\n  let load = React.useCallback((href, opts) => {\n    !routeId ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"No routeId available for fetcher.load()\") : UNSAFE_invariant(false) : void 0;\n    router.fetch(fetcherKey, routeId, href, opts);\n  }, [fetcherKey, routeId, router]);\n  let submitImpl = useSubmit();\n  let submit = React.useCallback((target, opts) => {\n    submitImpl(target, _extends({}, opts, {\n      navigate: false,\n      fetcherKey\n    }));\n  }, [fetcherKey, submitImpl]);\n  let FetcherForm = React.useMemo(() => {\n    let FetcherForm = /*#__PURE__*/React.forwardRef((props, ref) => {\n      return /*#__PURE__*/React.createElement(Form, _extends({}, props, {\n        navigate: false,\n        fetcherKey: fetcherKey,\n        ref: ref\n      }));\n    });\n    if (process.env.NODE_ENV !== \"production\") {\n      FetcherForm.displayName = \"fetcher.Form\";\n    }\n    return FetcherForm;\n  }, [fetcherKey]);\n  // Exposed FetcherWithComponents\n  let fetcher = state.fetchers.get(fetcherKey) || IDLE_FETCHER;\n  let data = fetcherData.get(fetcherKey);\n  let fetcherWithComponents = React.useMemo(() => _extends({\n    Form: FetcherForm,\n    submit,\n    load\n  }, fetcher, {\n    data\n  }), [FetcherForm, submit, load, fetcher, data]);\n  return fetcherWithComponents;\n}\n/**\n * Provides all fetchers currently on the page. Useful for layouts and parent\n * routes that need to provide pending/optimistic UI regarding the fetch.\n */\nfunction useFetchers() {\n  let state = useDataRouterState(DataRouterStateHook.UseFetchers);\n  return Array.from(state.fetchers.entries()).map(_ref11 => {\n    let [key, fetcher] = _ref11;\n    return _extends({}, fetcher, {\n      key\n    });\n  });\n}\nconst SCROLL_RESTORATION_STORAGE_KEY = \"react-router-scroll-positions\";\nlet savedScrollPositions = {};\n/**\n * When rendered inside a RouterProvider, will restore scroll positions on navigations\n */\nfunction useScrollRestoration(_temp4) {\n  let {\n    getKey,\n    storageKey\n  } = _temp4 === void 0 ? {} : _temp4;\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseScrollRestoration);\n  let {\n    restoreScrollPosition,\n    preventScrollReset\n  } = useDataRouterState(DataRouterStateHook.UseScrollRestoration);\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  let location = useLocation();\n  let matches = useMatches();\n  let navigation = useNavigation();\n  // Trigger manual scroll restoration while we're active\n  React.useEffect(() => {\n    window.history.scrollRestoration = \"manual\";\n    return () => {\n      window.history.scrollRestoration = \"auto\";\n    };\n  }, []);\n  // Save positions on pagehide\n  usePageHide(React.useCallback(() => {\n    if (navigation.state === \"idle\") {\n      let key = (getKey ? getKey(location, matches) : null) || location.key;\n      savedScrollPositions[key] = window.scrollY;\n    }\n    try {\n      sessionStorage.setItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY, JSON.stringify(savedScrollPositions));\n    } catch (error) {\n      process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"Failed to save scroll positions in sessionStorage, <ScrollRestoration /> will not work properly (\" + error + \").\") : void 0;\n    }\n    window.history.scrollRestoration = \"auto\";\n  }, [storageKey, getKey, navigation.state, location, matches]));\n  // Read in any saved scroll locations\n  if (typeof document !== \"undefined\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      try {\n        let sessionPositions = sessionStorage.getItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY);\n        if (sessionPositions) {\n          savedScrollPositions = JSON.parse(sessionPositions);\n        }\n      } catch (e) {\n        // no-op, use default empty object\n      }\n    }, [storageKey]);\n    // Enable scroll restoration in the router\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      let getKeyWithoutBasename = getKey && basename !== \"/\" ? (location, matches) => getKey( // Strip the basename to match useLocation()\n      _extends({}, location, {\n        pathname: stripBasename(location.pathname, basename) || location.pathname\n      }), matches) : getKey;\n      let disableScrollRestoration = router == null ? void 0 : router.enableScrollRestoration(savedScrollPositions, () => window.scrollY, getKeyWithoutBasename);\n      return () => disableScrollRestoration && disableScrollRestoration();\n    }, [router, basename, getKey]);\n    // Restore scrolling when state.restoreScrollPosition changes\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      // Explicit false means don't do anything (used for submissions)\n      if (restoreScrollPosition === false) {\n        return;\n      }\n      // been here before, scroll to it\n      if (typeof restoreScrollPosition === \"number\") {\n        window.scrollTo(0, restoreScrollPosition);\n        return;\n      }\n      // try to scroll to the hash\n      if (location.hash) {\n        let el = document.getElementById(decodeURIComponent(location.hash.slice(1)));\n        if (el) {\n          el.scrollIntoView();\n          return;\n        }\n      }\n      // Don't reset if this navigation opted out\n      if (preventScrollReset === true) {\n        return;\n      }\n      // otherwise go to the top on new locations\n      window.scrollTo(0, 0);\n    }, [location, restoreScrollPosition, preventScrollReset]);\n  }\n}\n/**\n * Setup a callback to be fired on the window's `beforeunload` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\nfunction useBeforeUnload(callback, options) {\n  let {\n    capture\n  } = options || {};\n  React.useEffect(() => {\n    let opts = capture != null ? {\n      capture\n    } : undefined;\n    window.addEventListener(\"beforeunload\", callback, opts);\n    return () => {\n      window.removeEventListener(\"beforeunload\", callback, opts);\n    };\n  }, [callback, capture]);\n}\n/**\n * Setup a callback to be fired on the window's `pagehide` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.  This event is better supported than beforeunload across browsers.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\nfunction usePageHide(callback, options) {\n  let {\n    capture\n  } = options || {};\n  React.useEffect(() => {\n    let opts = capture != null ? {\n      capture\n    } : undefined;\n    window.addEventListener(\"pagehide\", callback, opts);\n    return () => {\n      window.removeEventListener(\"pagehide\", callback, opts);\n    };\n  }, [callback, capture]);\n}\n/**\n * Wrapper around useBlocker to show a window.confirm prompt to users instead\n * of building a custom UI with useBlocker.\n *\n * Warning: This has *a lot of rough edges* and behaves very differently (and\n * very incorrectly in some cases) across browsers if user click addition\n * back/forward navigations while the confirm is open.  Use at your own risk.\n */\nfunction usePrompt(_ref12) {\n  let {\n    when,\n    message\n  } = _ref12;\n  let blocker = useBlocker(when);\n  React.useEffect(() => {\n    if (blocker.state === \"blocked\") {\n      let proceed = window.confirm(message);\n      if (proceed) {\n        // This timeout is needed to avoid a weird \"race\" on POP navigations\n        // between the `window.history` revert navigation and the result of\n        // `window.confirm`\n        setTimeout(blocker.proceed, 0);\n      } else {\n        blocker.reset();\n      }\n    }\n  }, [blocker, message]);\n  React.useEffect(() => {\n    if (blocker.state === \"blocked\" && !when) {\n      blocker.reset();\n    }\n  }, [blocker, when]);\n}\n/**\n * Return a boolean indicating if there is an active view transition to the\n * given href.  You can use this value to render CSS classes or viewTransitionName\n * styles onto your elements\n *\n * @param href The destination href\n * @param [opts.relative] Relative routing type (\"route\" | \"path\")\n */\nfunction useViewTransitionState(to, opts) {\n  if (opts === void 0) {\n    opts = {};\n  }\n  let vtContext = React.useContext(ViewTransitionContext);\n  !(vtContext != null) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"`unstable_useViewTransitionState` must be used within `react-router-dom`'s `RouterProvider`.  \" + \"Did you accidentally import `RouterProvider` from `react-router`?\") : UNSAFE_invariant(false) : void 0;\n  let {\n    basename\n  } = useDataRouterContext(DataRouterHook.useViewTransitionState);\n  let path = useResolvedPath(to, {\n    relative: opts.relative\n  });\n  if (!vtContext.isTransitioning) {\n    return false;\n  }\n  let currentPath = stripBasename(vtContext.currentLocation.pathname, basename) || vtContext.currentLocation.pathname;\n  let nextPath = stripBasename(vtContext.nextLocation.pathname, basename) || vtContext.nextLocation.pathname;\n  // Transition is active if we're going to or coming from the indicated\n  // destination.  This ensures that other PUSH navigations that reverse\n  // an indicated transition apply.  I.e., on the list view you have:\n  //\n  //   <NavLink to=\"/details/1\" unstable_viewTransition>\n  //\n  // If you click the breadcrumb back to the list view:\n  //\n  //   <NavLink to=\"/list\" unstable_viewTransition>\n  //\n  // We should apply the transition because it's indicated as active going\n  // from /list -> /details/1 and therefore should be active on the reverse\n  // (even though this isn't strictly a POP reverse)\n  return matchPath(path.pathname, nextPath) != null || matchPath(path.pathname, currentPath) != null;\n}\n//#endregion\n\nexport { BrowserRouter, Form, HashRouter, Link, NavLink, RouterProvider, ScrollRestoration, FetchersContext as UNSAFE_FetchersContext, ViewTransitionContext as UNSAFE_ViewTransitionContext, useScrollRestoration as UNSAFE_useScrollRestoration, createBrowserRouter, createHashRouter, createSearchParams, HistoryRouter as unstable_HistoryRouter, usePrompt as unstable_usePrompt, useViewTransitionState as unstable_useViewTransitionState, useBeforeUnload, useFetcher, useFetchers, useFormAction, useLinkClickHandler, useSearchParams, useSubmit };\n//# sourceMappingURL=index.js.map\n"],"names":["Action","_extends","Object","assign","bind","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","apply","this","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","every","compareIndexes","routesMeta","meta","childrenIndex","rankRouteBranches","matches","decoded","decodePath","matchRouteBranch","convertRouteMatchToUiMatch","match","loaderData","params","data","handle","parentsMeta","flattenRoute","relativePath","caseSensitive","joinPaths","concat","computeScore","forEach","_route$path","includes","exploded","explodeOptionalSegments","segments","split","first","rest","isOptional","endsWith","required","restExploded","result","subpath","paramRe","dynamicSegmentValue","indexRouteValue","emptySegmentValue","staticSegmentValue","splatPenalty","isSplat","s","initialScore","some","filter","reduce","segment","test","branch","matchedParams","matchedPathname","end","remainingPathname","matchPath","pathnameBase","normalizePathname","generatePath","originalPath","prefix","p","String","array","keyMatch","optional","param","pattern","matcher","compiledParams","regexpSource","_","paramName","RegExp","compilePath","captureGroups","memo","splatValue","v","decodeURIComponent","toLowerCase","startIndex","nextChar","resolvePath","fromPathname","toPathname","pop","resolvePathname","normalizeSearch","normalizeHash","getInvalidPathError","char","field","dest","getPathContributingMatches","getResolveToMatches","v7_relativeSplatPath","pathMatches","resolveTo","toArg","routePathnames","locationPathname","isPathRelative","from","isEmptyPath","routePathnameIndex","toSegments","shift","hasExplicitTrailingSlash","hasCurrentTrailingSlash","paths","json","init","responseInit","status","headers","Headers","has","set","Response","AbortedDeferredError","DeferredData","constructor","reject","pendingKeysSet","subscribers","deferredKeys","Array","isArray","abortPromise","Promise","r","controller","AbortController","onAbort","unlistenAbortSignal","signal","acc","_ref2","trackPromise","done","add","promise","race","then","onSettle","catch","defineProperty","get","aborted","delete","undefinedError","emit","settledKey","subscriber","subscribe","cancel","abort","k","resolveData","resolve","size","unwrappedData","_ref3","unwrapTrackedPromise","pendingKeys","_tracked","isTrackedPromise","_error","_data","defer","redirect","redirectDocument","response","ErrorResponseImpl","statusText","internal","isRouteErrorResponse","validMutationMethodsArr","validMutationMethods","validRequestMethodsArr","validRequestMethods","redirectStatusCodes","redirectPreserveMethodStatusCodes","IDLE_NAVIGATION","formMethod","formAction","formEncType","formData","text","IDLE_FETCHER","IDLE_BLOCKER","proceed","reset","ABSOLUTE_URL_REGEX","defaultMapRouteProperties","hasErrorBoundary","Boolean","TRANSITIONS_STORAGE_KEY","createRouter","routerWindow","isBrowser","createElement","isServer","detectErrorBoundary","inFlightDataRoutes","initialized","dataRoutes","future","v7_fetcherPersist","v7_normalizeFormMethod","v7_partialHydration","v7_prependBasename","unlistenHistory","savedScrollPositions","getScrollRestorationKey","getScrollPosition","initialScrollRestored","hydrationData","initialMatches","initialErrors","getInternalRouterError","getShortCircuitMatches","router","hasLazyRoutes","m","lazy","hasLoaders","loader","errors","isRouteInitialized","hydrate","findIndex","pendingNavigationController","historyAction","navigation","restoreScrollPosition","preventScrollReset","revalidation","actionData","fetchers","Map","blockers","pendingAction","pendingPreventScrollReset","pendingViewTransitionEnabled","appliedViewTransitions","removePageHideEventListener","isUninterruptedRevalidation","isRevalidationRequired","cancelledDeferredRoutes","cancelledFetcherLoads","fetchControllers","incrementingLoadId","pendingNavigationLoadId","fetchReloadIds","fetchRedirectIds","fetchLoadMatches","activeFetchers","deletedFetchers","activeDeferreds","blockerFunctions","ignoreNextHistoryUpdate","updateState","newState","opts","completedFetchers","deletedFetchersKeys","fetcher","unstable_viewTransitionOpts","viewTransitionOpts","unstable_flushSync","flushSync","deleteFetcher","completeNavigation","_temp","_location$state","_location$state2","isActionReload","isMutationMethod","_isRedirect","keys","mergeLoaderData","priorPaths","currentLocation","toPaths","getSavedScrollPosition","async","startNavigation","startUninterruptedRevalidation","getScrollKey","saveScrollPosition","enableViewTransition","routesToUse","loadingNavigation","overrideNavigation","notFoundMatches","cancelActiveDeferreds","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","initialHydration","activeSubmission","getSubmissionFromNavigation","matchesToLoad","revalidatingFetchers","getMatchesToLoad","updatedFetchers","markFetchRedirectsDone","rf","revalidatingFetcher","getLoadingFetcher","abortFetcher","abortPendingFetchRevalidations","f","results","loaderResults","fetcherResults","callLoadersAndMaybeResolveData","findRedirect","fetcherKey","processLoaderData","deferredData","didAbortFetchLoads","abortStaleFetchLoads","shouldUpdateFetchers","handleLoaders","_temp2","revalidate","redirectLocation","isDocumentReload","reloadDocument","redirectHistoryAction","currentMatches","fetchersToLoad","all","resolveDeferredResults","updateFetcherState","setFetcherError","getFetcher","markFetchersDone","doneFetcher","getDoneFetcher","doneKeys","landedId","yeetedKeys","deleteBlocker","updateBlocker","newBlocker","blocker","shouldBlockNavigation","_ref4","blockerKey","blockerFunction","predicate","cancelledRouteIds","dfd","y","initialize","_window","transitions","sessionPositions","sessionStorage","getItem","parse","restoreAppliedTransitions","_saveAppliedTransitions","setItem","persistAppliedTransitions","enableScrollRestoration","positions","getPosition","getKey","navigate","normalizedPath","normalizeTo","fromRouteId","relative","normalizeNavigateOptions","userReplace","unstable_viewTransition","fetch","requestMatches","existingFetcher","getSubmittingFetcher","abortController","fetchRequest","originatingLoadId","actionResult","revalidationRequest","loadId","loadFetcher","staleKey","handleFetcherAction","resolveDeferredData","handleFetcherLoader","count","dispose","clear","getBlocker","_internalFetchControllers","_internalActiveDeferreds","_internalSetRoutes","newRoutes","prependBasename","contextualMatches","activeRouteMatch","hasNakedIndexQuery","normalizeFormMethod","isFetcher","body","isSubmissionNavigation","searchParams","getInvalidBodyError","rawFormMethod","toUpperCase","stripHashFromPath","FormData","URLSearchParams","_ref5","convertFormDataToSearchParams","convertSearchParamsToFormData","append","isInitialLoad","values","currentUrl","nextUrl","boundaryId","navigationMatches","boundaryMatches","getLoaderMatchesUntilBoundary","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","handlerError","isStaticRequest","protocol","isSameBasename","isRouteRequest","contentType","statusCode","_result$init","_result$init2","deferred","isDeferredData","foundError","loaderHeaders","processRouteLoaderData","newLoaderData","mergedLoaderData","reverse","find","_temp5","errorMessage","signals","isRevalidatingLoader","unwrap","getAll","Symbol","DataRouterContext","DataRouterStateContext","AwaitContext","NavigationContext","LocationContext","RouteContext","outlet","isDataRoute","RouteErrorContext","useHref","useInRouterContext","navigator","useResolvedPath","joinedPathname","useLocation","useNavigationType","navigationType","useMatch","useIsomorphicLayoutEffect","cb","static","useNavigate","useDataRouterContext","DataRouterHook","UseNavigateStable","useCurrentRouteId","DataRouterStateHook","activeRef","useNavigateStable","dataRouterContext","routePathnamesJson","useNavigateUnstable","OutletContext","useOutletContext","useOutlet","Provider","useParams","routeMatch","useRoutes","useRoutesImpl","dataRouterState","parentMatches","parentParams","parentPathnameBase","locationFromContext","_parsedLocationArg$pa","parsedLocationArg","parentSegments","renderedMatches","_renderMatches","DefaultErrorComponent","useRouteError","stack","preStyles","padding","backgroundColor","style","fontStyle","defaultErrorElement","RenderErrorBoundary","props","super","getDerivedStateFromError","getDerivedStateFromProps","componentDidCatch","errorInfo","render","routeContext","component","RenderedRoute","staticContext","errorElement","ErrorBoundary","_deepestRenderedBoundaryId","_dataRouterState2","_dataRouterState","errorIndex","renderFallback","fallbackIndex","HydrateFallback","hydrateFallbackElement","needsToRunLoader","reduceRight","shouldRenderHydrateFallback","alreadyWarned","getChildren","Component","element","hookName","ctx","useDataRouterState","useRouteContext","thisRoute","useRouteId","UseRouteId","useNavigation","UseNavigation","useRevalidator","UseRevalidator","useMatches","UseMatches","useLoaderData","UseLoaderData","useRouteLoaderData","UseRouteLoaderData","useActionData","UseActionData","_state$errors","UseRouteError","useAsyncValue","useAsyncError","blockerId","useBlocker","shouldBlock","UseBlocker","setBlockerKey","startTransitionImpl","MemoryRouter","historyRef","setStateImpl","v7_startTransition","setState","Router","Navigate","isStatic","jsonPath","Outlet","Route","_props","basenameProp","locationProp","staticProp","navigationContext","locationContext","trailingPathname","Routes","_ref6","createRoutesFromChildren","Await","_ref7","AwaitErrorBoundary","ResolveAwait","AwaitRenderStatus","neverSettledPromise","pending","renderError","success","_ref8","toRender","renderMatches","updates","createMemoryRouter","_objectWithoutPropertiesLoose","excluded","sourceKeys","defaultMethod","defaultEncType","isHtmlElement","object","tagName","createSearchParams","_formDataSupportsSubmitter","supportedFormEncTypes","getFormEncType","encType","_excluded","_excluded2","_excluded3","__reactRouterVersion","createBrowserRouter","parseHydrationData","createHashRouter","__staticRouterHydrationData","deserializeErrors","serialized","val","__type","__subType","ErrorConstructor","ViewTransitionContext","isTransitioning","FetchersContext","flushSyncImpl","useIdImpl","flushSyncSafe","Deferred","reason","fallbackElement","pendingState","setPendingState","vtContext","setVtContext","renderDfd","setRenderDfd","transition","setTransition","interruption","setInterruption","fetcherData","optInStartTransition","startTransitionSafe","isViewTransitionUnavailable","startViewTransition","skipTransition","t","finished","finally","renderPromise","BrowserRouter","HashRouter","HistoryRouter","Link","ref","absoluteHref","onClick","isExternal","targetUrl","internalOnClick","useLinkClickHandler","event","defaultPrevented","NavLink","ariaCurrentProp","className","classNameProp","styleProp","routerState","useViewTransitionState","nextLocationPathname","endSlashPosition","isActive","isPending","renderProps","ariaCurrent","Form","_ref9","forwardedRef","onSubmit","submit","useSubmit","useFormAction","preventDefault","submitter","nativeEvent","submitMethod","currentTarget","ScrollRestoration","_ref10","storageKey","useScrollRestoration","replaceProp","button","metaKey","altKey","ctrlKey","shiftKey","isModifiedEvent","shouldProcessLinkClick","useSearchParams","defaultInit","defaultSearchParamsRef","hasSetSearchParamsRef","locationSearch","defaultSearchParams","getSearchParamsForLocation","setSearchParams","nextInit","navigateOptions","newSearchParams","fetcherId","getUniqueFetcherId","UseSubmit","currentRouteId","validateClientSideSubmission","attr","isButtonElement","isInputElement","form","isFormDataSubmitterSupported","getFormSubmissionInfo","useFetcher","_temp3","_route$matches","UseFetcher","defaultKey","setFetcherKey","load","submitImpl","FetcherForm","useFetchers","UseFetchers","_ref11","SCROLL_RESTORATION_STORAGE_KEY","_temp4","UseScrollRestoration","scrollRestoration","callback","capture","usePageHide","scrollY","getKeyWithoutBasename","disableScrollRestoration","el","getElementById","scrollIntoView","scrollTo","useBeforeUnload","usePrompt","_ref12","when","confirm","setTimeout","nextPath"],"sourceRoot":""}