{"version":3,"file":"js/250-4ca886d844d2988ba791.js","mappings":"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","sources":["webpack://app/./node_modules/@remix-run/router/dist/router.js","webpack://app/./node_modules/react-router/dist/index.js","webpack://app/./node_modules/react/cjs/react.production.min.js","webpack://app/./node_modules/react/index.js"],"sourcesContent":["/**\n * @remix-run/router v1.0.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\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Actions represent the type of change to a location value.\n */\nvar Action;\n\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\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\n  Action[\"Replace\"] = \"REPLACE\";\n})(Action || (Action = {}));\n\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 */\n\nfunction createMemoryHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  let {\n    initialEntries = [\"/\"],\n    initialIndex,\n    v5Compat = false\n  } = options;\n  let entries; // Declare so we can access from createMemoryLocation\n\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\n  function clampIndex(n) {\n    return Math.min(Math.max(n, 0), entries.length - 1);\n  }\n\n  function getCurrentLocation() {\n    return entries[index];\n  }\n\n  function createMemoryLocation(to, state, key) {\n    if (state === void 0) {\n      state = null;\n    }\n\n    let location = createLocation(entries ? getCurrentLocation().pathname : \"/\", to, state, key);\n    warning$1(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in memory history: \" + JSON.stringify(to));\n    return location;\n  }\n\n  let history = {\n    get index() {\n      return index;\n    },\n\n    get action() {\n      return action;\n    },\n\n    get location() {\n      return getCurrentLocation();\n    },\n\n    createHref(to) {\n      return typeof to === \"string\" ? to : createPath(to);\n    },\n\n    encodeLocation(location) {\n      return location;\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\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation\n        });\n      }\n    },\n\n    replace(to, state) {\n      action = Action.Replace;\n      let nextLocation = createMemoryLocation(to, state);\n      entries[index] = nextLocation;\n\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation\n        });\n      }\n    },\n\n    go(delta) {\n      action = Action.Pop;\n      index = clampIndex(index + delta);\n\n      if (listener) {\n        listener({\n          action,\n          location: getCurrentLocation()\n        });\n      }\n    },\n\n    listen(fn) {\n      listener = fn;\n      return () => {\n        listener = null;\n      };\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 */\n\nfunction createBrowserHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\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    }, // state defaults to `null` because `window.history.state` does\n    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n  }\n\n  function createBrowserHref(window, to) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\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 */\n\nfunction createHashHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  function createHashLocation(window, globalHistory) {\n    let {\n      pathname = \"/\",\n      search = \"\",\n      hash = \"\"\n    } = parsePath(window.location.hash.substr(1));\n    return createLocation(\"\", {\n      pathname,\n      search,\n      hash\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\n  function createHashHref(window, to) {\n    let base = window.document.querySelector(\"base\");\n    let href = \"\";\n\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\n    return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n  }\n\n  function validateHashLocation(location, to) {\n    warning$1(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in hash history.push(\" + JSON.stringify(to) + \")\");\n  }\n\n  return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);\n} //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region UTILS\n////////////////////////////////////////////////////////////////////////////////\n\nfunction warning$1(cond, message) {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== \"undefined\") console.warn(message);\n\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); // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\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 */\n\n\nfunction getHistoryState(location) {\n  return {\n    usr: location.state,\n    key: location.key\n  };\n}\n/**\n * Creates a Location object with a unique key from the given Path\n */\n\n\nfunction createLocation(current, to, state, key) {\n  if (state === void 0) {\n    state = null;\n  }\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\n  return location;\n}\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\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 */\n\nfunction parsePath(path) {\n  let parsedPath = {};\n\n  if (path) {\n    let hashIndex = path.indexOf(\"#\");\n\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n\n    let searchIndex = path.indexOf(\"?\");\n\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n\n  return parsedPath;\n}\nfunction createURL(location) {\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 = typeof window !== \"undefined\" && typeof window.location !== \"undefined\" && window.location.origin !== \"null\" ? window.location.origin : \"unknown://unknown\";\n  let href = typeof location === \"string\" ? location : createPath(location);\n  return new URL(href, base);\n}\n\nfunction getUrlBasedHistory(getLocation, createHref, validateLocation, options) {\n  if (options === void 0) {\n    options = {};\n  }\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\n  function handlePop() {\n    action = Action.Pop;\n\n    if (listener) {\n      listener({\n        action,\n        location: history.location\n      });\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    let historyState = getHistoryState(location);\n    let url = history.createHref(location); // try...catch because iOS limits us to 100 pushState calls :/\n\n    try {\n      globalHistory.pushState(historyState, \"\", url);\n    } catch (error) {\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\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location\n      });\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    let historyState = getHistoryState(location);\n    let url = history.createHref(location);\n    globalHistory.replaceState(historyState, \"\", url);\n\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location\n      });\n    }\n  }\n\n  let history = {\n    get action() {\n      return action;\n    },\n\n    get location() {\n      return getLocation(window, globalHistory);\n    },\n\n    listen(fn) {\n      if (listener) {\n        throw new Error(\"A history only accepts one active listener\");\n      }\n\n      window.addEventListener(PopStateEventType, handlePop);\n      listener = fn;\n      return () => {\n        window.removeEventListener(PopStateEventType, handlePop);\n        listener = null;\n      };\n    },\n\n    createHref(to) {\n      return createHref(window, to);\n    },\n\n    encodeLocation(location) {\n      // Encode a Location the same way window.location would\n      let url = createURL(createPath(location));\n      return _extends({}, location, {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash\n      });\n    },\n\n    push,\n    replace,\n\n    go(n) {\n      return globalHistory.go(n);\n    }\n\n  };\n  return history;\n} //#endregion\n\nvar ResultType;\n\n(function (ResultType) {\n  ResultType[\"data\"] = \"data\";\n  ResultType[\"deferred\"] = \"deferred\";\n  ResultType[\"redirect\"] = \"redirect\";\n  ResultType[\"error\"] = \"error\";\n})(ResultType || (ResultType = {}));\n\nfunction isIndexRoute(route) {\n  return route.index === true;\n} // Walk the route tree generating unique IDs where necessary so we are working\n// solely with AgnosticDataRouteObject's within the Router\n\n\nfunction convertRoutesToDataRoutes(routes, parentPath, allIds) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\n\n  if (allIds === void 0) {\n    allIds = new Set();\n  }\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(!allIds.has(id), \"Found a route id collision on id \\\"\" + id + \"\\\".  Route \" + \"id's must be globally unique within Data Router usages\");\n    allIds.add(id);\n\n    if (isIndexRoute(route)) {\n      let indexRoute = _extends({}, route, {\n        id\n      });\n\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute = _extends({}, route, {\n        id,\n        children: route.children ? convertRoutesToDataRoutes(route.children, treePath, allIds) : undefined\n      });\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/docs/en/v6/utils/match-routes\n */\n\nfunction matchRoutes(routes, locationArg, basename) {\n  if (basename === void 0) {\n    basename = \"/\";\n  }\n\n  let location = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n  let pathname = stripBasename(location.pathname || \"/\", basename);\n\n  if (pathname == null) {\n    return null;\n  }\n\n  let branches = flattenRoutes(routes);\n  rankRouteBranches(branches);\n  let matches = null;\n\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    matches = matchRouteBranch(branches[i], // Incoming pathnames are generally encoded from either window.location\n    // or from router.navigate, but we want to match against the unencoded\n    // paths in the route definitions.  Memory router locations won't be\n    // encoded here but there also shouldn't be anything to decode so this\n    // should be a safe operation.  This avoids needing matchRoutes to be\n    // history-aware.\n    safelyDecodeURI(pathname));\n  }\n\n  return matches;\n}\n\nfunction flattenRoutes(routes, branches, parentsMeta, parentPath) {\n  if (branches === void 0) {\n    branches = [];\n  }\n\n  if (parentsMeta === void 0) {\n    parentsMeta = [];\n  }\n\n  if (parentPath === void 0) {\n    parentPath = \"\";\n  }\n\n  routes.forEach((route, index) => {\n    let meta = {\n      relativePath: route.path || \"\",\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route\n    };\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\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta); // 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\n    if (route.children && route.children.length > 0) {\n      invariant( // 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    } // 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\n\n    if (route.path == null && !route.index) {\n      return;\n    }\n\n    branches.push({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta\n    });\n  });\n  return branches;\n}\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}\n\nconst paramRe = /^:\\w+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\n\nconst isSplat = s => s === \"*\";\n\nfunction computeScore(path, index) {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n\n  return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === \"\" ? emptySegmentValue : staticSegmentValue), initialScore);\n}\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 ? // 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] : // Otherwise, it doesn't really make sense to rank non-siblings by index,\n  // so they sort equally.\n  0;\n}\n\nfunction matchRouteBranch(branch, pathname) {\n  let {\n    routesMeta\n  } = branch;\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches = [];\n\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\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n\n  return matches;\n}\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/docs/en/v6/utils/generate-path\n */\n\n\nfunction generatePath(path, params) {\n  if (params === void 0) {\n    params = {};\n  }\n\n  return path.replace(/:(\\w+)/g, (_, key) => {\n    invariant(params[key] != null, \"Missing \\\":\" + key + \"\\\" param\");\n    return params[key];\n  }).replace(/(\\/?)\\*/, (_, prefix, __, str) => {\n    const star = \"*\";\n\n    if (params[star] == null) {\n      // If no splat was provided, trim the trailing slash _unless_ it's\n      // the entire path\n      return str === \"/*\" ? \"/\" : \"\";\n    } // Apply the splat\n\n\n    return \"\" + prefix + params[star];\n  });\n}\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/docs/en/v6/utils/match-path\n */\n\nfunction matchPath(pattern, pathname) {\n  if (typeof pattern === \"string\") {\n    pattern = {\n      path: pattern,\n      caseSensitive: false,\n      end: true\n    };\n  }\n\n  let [matcher, paramNames] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);\n  let match = pathname.match(matcher);\n  if (!match) return null;\n  let matchedPathname = match[0];\n  let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n  let captureGroups = match.slice(1);\n  let params = paramNames.reduce((memo, paramName, index) => {\n    // We need to compute the pathnameBase here using the raw splat value\n    // instead of using params[\"*\"] later because it will be decoded then\n    if (paramName === \"*\") {\n      let splatValue = captureGroups[index] || \"\";\n      pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\\/+$/, \"$1\");\n    }\n\n    memo[paramName] = safelyDecodeURIComponent(captureGroups[index] || \"\", paramName);\n    return memo;\n  }, {});\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern\n  };\n}\n\nfunction compilePath(path, caseSensitive, end) {\n  if (caseSensitive === void 0) {\n    caseSensitive = false;\n  }\n\n  if (end === void 0) {\n    end = true;\n  }\n\n  warning(path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"), \"Route path \\\"\" + path + \"\\\" will be treated as if it were \" + (\"\\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\" because the `*` character must \") + \"always follow a `/` in the pattern. To get rid of this warning, \" + (\"please change the route path to \\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\".\"));\n  let paramNames = [];\n  let regexpSource = \"^\" + path.replace(/\\/*\\*?$/, \"\") // Ignore trailing / and /*, we'll handle it below\n  .replace(/^\\/*/, \"/\") // Make sure it has a leading /\n  .replace(/[\\\\.*+^$?{}|()[\\]]/g, \"\\\\$&\") // Escape special regex chars\n  .replace(/:(\\w+)/g, (_, paramName) => {\n    paramNames.push(paramName);\n    return \"([^\\\\/]+)\";\n  });\n\n  if (path.endsWith(\"*\")) {\n    paramNames.push(\"*\");\n    regexpSource += path === \"*\" || path === \"/*\" ? \"(.*)$\" // Already matched the initial /, just match the rest\n    : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else if (end) {\n    // When matching to the end, ignore trailing slashes\n    regexpSource += \"\\\\/*$\";\n  } else if (path !== \"\" && path !== \"/\") {\n    // If our path is non-empty and contains anything beyond an initial slash,\n    // then we have _some_ form of path in our regex so we should expect to\n    // match only if we find the end of this path segment.  Look for an optional\n    // non-captured trailing slash (to match a portion of the URL) or the end\n    // of the path (if we've matched to the end).  We used to do this with a\n    // word boundary but that gives false positives on routes like\n    // /user-preferences since `-` counts as a word boundary.\n    regexpSource += \"(?:(?=\\\\/|$))\";\n  } else ;\n\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n  return [matcher, paramNames];\n}\n\nfunction safelyDecodeURI(value) {\n  try {\n    return decodeURI(value);\n  } catch (error) {\n    warning(false, \"The URL path \\\"\" + value + \"\\\" could not be decoded because it is is a \" + \"malformed URL segment. This is probably due to a bad percent \" + (\"encoding (\" + error + \").\"));\n    return value;\n  }\n}\n\nfunction safelyDecodeURIComponent(value, paramName) {\n  try {\n    return decodeURIComponent(value);\n  } catch (error) {\n    warning(false, \"The value for the URL param \\\"\" + paramName + \"\\\" will not be decoded because\" + (\" the string \\\"\" + value + \"\\\" is a malformed URL segment. This is probably\") + (\" due to a bad percent encoding (\" + error + \").\"));\n    return value;\n  }\n}\n/**\n * @private\n */\n\n\nfunction stripBasename(pathname, basename) {\n  if (basename === \"/\") return pathname;\n\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\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\n\n  let startIndex = basename.endsWith(\"/\") ? basename.length - 1 : basename.length;\n  let nextChar = pathname.charAt(startIndex);\n\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n\n  return pathname.slice(startIndex) || \"/\";\n}\nfunction invariant(value, message) {\n  if (value === false || value === null || typeof value === \"undefined\") {\n    throw new Error(message);\n  }\n}\n/**\n * @private\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\n    try {\n      // Welcome to debugging React Router!\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); // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/docs/en/v6/utils/resolve-path\n */\n\nfunction resolvePath(to, fromPathname) {\n  if (fromPathname === void 0) {\n    fromPathname = \"/\";\n  }\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}\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}\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 */\n\n\nfunction getPathContributingMatches(matches) {\n  return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);\n}\n/**\n * @private\n */\n\nfunction resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {\n  if (isPathRelative === void 0) {\n    isPathRelative = false;\n  }\n\n  let to;\n\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\n  let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n  let toPathname = isEmptyPath ? \"/\" : to.pathname;\n  let from; // 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\n  if (isPathRelative || toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n\n    if (toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\"); // Each leading .. segment means \"go up one route\" instead of \"go up one\n      // URL segment\".  This is a key difference from how <a href> works and a\n      // major reason we call this a \"to\" value instead of a \"href\".\n\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n\n      to.pathname = toSegments.join(\"/\");\n    } // If there are more \"..\" segments than parent routes, resolve relative to\n    // the root / URL.\n\n\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n\n  let path = resolvePath(to, from); // Ensure the pathname has a trailing slash if the original \"to\" had one\n\n  let hasExplicitTrailingSlash = toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\"); // Or if this was a link to the current path which has a trailing slash\n\n  let hasCurrentTrailingSlash = (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n\n  if (!path.pathname.endsWith(\"/\") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {\n    path.pathname += \"/\";\n  }\n\n  return path;\n}\n/**\n * @private\n */\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 */\n\nconst joinPaths = paths => paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n/**\n * @private\n */\n\nconst normalizePathname = pathname => pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n/**\n * @private\n */\n\nconst normalizeSearch = search => !search || search === \"?\" ? \"\" : search.startsWith(\"?\") ? search : \"?\" + search;\n/**\n * @private\n */\n\nconst normalizeHash = hash => !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n */\n\nconst json = function json(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  let headers = new Headers(responseInit.headers);\n\n  if (!headers.has(\"Content-Type\")) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n  }\n\n  return new Response(JSON.stringify(data), _extends({}, responseInit, {\n    headers\n  }));\n};\nclass AbortedDeferredError extends Error {}\nclass DeferredData {\n  constructor(data) {\n    this.pendingKeys = new Set();\n    this.subscriber = undefined;\n    invariant(data && typeof data === \"object\" && !Array.isArray(data), \"defer() only accepts plain objects\"); // Set up an AbortController + Promise we can race against to exit early\n    // cancellation\n\n    let reject;\n    this.abortPromise = new Promise((_, r) => reject = r);\n    this.controller = new AbortController();\n\n    let onAbort = () => reject(new AbortedDeferredError(\"Deferred data aborted\"));\n\n    this.unlistenAbortSignal = () => this.controller.signal.removeEventListener(\"abort\", onAbort);\n\n    this.controller.signal.addEventListener(\"abort\", onAbort);\n    this.data = Object.entries(data).reduce((acc, _ref) => {\n      let [key, value] = _ref;\n      return Object.assign(acc, {\n        [key]: this.trackPromise(key, value)\n      });\n    }, {});\n  }\n\n  trackPromise(key, value) {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n\n    this.pendingKeys.add(key); // We store a little wrapper promise that will be extended with\n    // _data/_error props upon resolve/reject\n\n    let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, null, data), error => this.onSettle(promise, key, error)); // Register rejection listeners to avoid uncaught promise rejections on\n    // errors or aborted deferred values\n\n    promise.catch(() => {});\n    Object.defineProperty(promise, \"_tracked\", {\n      get: () => true\n    });\n    return promise;\n  }\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\n    this.pendingKeys.delete(key);\n\n    if (this.done) {\n      // Nothing left to abort!\n      this.unlistenAbortSignal();\n    }\n\n    const subscriber = this.subscriber;\n\n    if (error) {\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      subscriber && subscriber(false);\n      return Promise.reject(error);\n    }\n\n    Object.defineProperty(promise, \"_data\", {\n      get: () => data\n    });\n    subscriber && subscriber(false);\n    return data;\n  }\n\n  subscribe(fn) {\n    this.subscriber = fn;\n  }\n\n  cancel() {\n    this.controller.abort();\n    this.pendingKeys.forEach((v, k) => this.pendingKeys.delete(k));\n    let subscriber = this.subscriber;\n    subscriber && subscriber(true);\n  }\n\n  async resolveData(signal) {\n    let aborted = false;\n\n    if (!this.done) {\n      let onAbort = () => this.cancel();\n\n      signal.addEventListener(\"abort\", onAbort);\n      aborted = await new Promise(resolve => {\n        this.subscribe(aborted => {\n          signal.removeEventListener(\"abort\", onAbort);\n\n          if (aborted || this.done) {\n            resolve(aborted);\n          }\n        });\n      });\n    }\n\n    return aborted;\n  }\n\n  get done() {\n    return this.pendingKeys.size === 0;\n  }\n\n  get unwrappedData() {\n    invariant(this.data !== null && this.done, \"Can only unwrap data on initialized and settled deferreds\");\n    return Object.entries(this.data).reduce((acc, _ref2) => {\n      let [key, value] = _ref2;\n      return Object.assign(acc, {\n        [key]: unwrapTrackedPromise(value)\n      });\n    }, {});\n  }\n\n}\n\nfunction isTrackedPromise(value) {\n  return value instanceof Promise && value._tracked === true;\n}\n\nfunction unwrapTrackedPromise(value) {\n  if (!isTrackedPromise(value)) {\n    return value;\n  }\n\n  if (value._error) {\n    throw value._error;\n  }\n\n  return value._data;\n}\n\nfunction defer(data) {\n  return new DeferredData(data);\n}\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\n\nconst redirect = function redirect(url, init) {\n  if (init === void 0) {\n    init = 302;\n  }\n\n  let responseInit = init;\n\n  if (typeof responseInit === \"number\") {\n    responseInit = {\n      status: responseInit\n    };\n  } else if (typeof responseInit.status === \"undefined\") {\n    responseInit.status = 302;\n  }\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 * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n */\n\nclass ErrorResponse {\n  constructor(status, statusText, data) {\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.data = data;\n  }\n\n}\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response throw from an action/loader\n */\n\nfunction isRouteErrorResponse(e) {\n  return e instanceof ErrorResponse;\n}\n\nconst IDLE_NAVIGATION = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined\n};\nconst IDLE_FETCHER = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined\n};\nconst isBrowser = typeof window !== \"undefined\" && typeof window.document !== \"undefined\" && typeof window.document.createElement !== \"undefined\";\nconst isServer = !isBrowser; //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Create a router and listen to history POP navigations\n */\n\nfunction createRouter(init) {\n  invariant(init.routes.length > 0, \"You must provide a non-empty routes array to createRouter\");\n  let dataRoutes = convertRoutesToDataRoutes(init.routes); // Cleanup function for history\n\n  let unlistenHistory = null; // Externally-provided functions to call on all state changes\n\n  let subscribers = new Set(); // Externally-provided object to hold scroll restoration locations during routing\n\n  let savedScrollPositions = null; // Externally-provided function to get scroll restoration keys\n\n  let getScrollRestorationKey = null; // Externally-provided function to get current scroll position\n\n  let getScrollPosition = null; // 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\n  let initialScrollRestored = false;\n  let initialMatches = matchRoutes(dataRoutes, init.history.location, init.basename);\n  let initialErrors = null;\n\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 {\n      matches,\n      route,\n      error\n    } = getNotFoundMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = {\n      [route.id]: error\n    };\n  }\n\n  let initialized = !initialMatches.some(m => m.route.loader) || init.hydrationData != null;\n  let router;\n  let state = {\n    historyAction: init.history.action,\n    location: init.history.location,\n    matches: initialMatches,\n    initialized,\n    navigation: IDLE_NAVIGATION,\n    restoreScrollPosition: 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  }; // -- Stateful internal variables to manage navigations --\n  // Current navigation in progress (to be committed in completeNavigation)\n\n  let pendingAction = Action.Pop; // Should the current navigation prevent the scroll reset if scroll cannot\n  // be restored?\n\n  let pendingPreventScrollReset = false; // AbortController for the active navigation\n\n  let pendingNavigationController; // We use this to avoid touching history in completeNavigation if a\n  // revalidation is entirely uninterrupted\n\n  let isUninterruptedRevalidation = false; // Use this internal flag to force revalidation of all loaders:\n  //  - submissions (completed or interrupted)\n  //  - useRevalidate()\n  //  - X-Remix-Revalidate (from redirect)\n\n  let isRevalidationRequired = false; // Use this internal array to capture routes that require revalidation due\n  // to a cancelled deferred on action submission\n\n  let cancelledDeferredRoutes = []; // Use this internal array to capture fetcher loads that were cancelled by an\n  // action navigation and require revalidation\n\n  let cancelledFetcherLoads = []; // AbortControllers for any in-flight fetchers\n\n  let fetchControllers = new Map(); // Track loads based on the order in which they started\n\n  let incrementingLoadId = 0; // 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\n  let pendingNavigationLoadId = -1; // Fetchers that triggered data reloads as a result of their actions\n\n  let fetchReloadIds = new Map(); // Fetchers that triggered redirect navigations from their actions\n\n  let fetchRedirectIds = new Set(); // Most recent href/match for fetcher.load calls for fetchers\n\n  let fetchLoadMatches = new Map(); // 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\n  let activeDeferreds = new Map(); // 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\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      } = _ref;\n      return startNavigation(historyAction, location);\n    }); // Kick off initial data load if needed.  Use Pop to avoid modifying history\n\n    if (!state.initialized) {\n      startNavigation(Action.Pop, state.location);\n    }\n\n    return router;\n  } // Clean up a router and it's side effects\n\n\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\n    }\n\n    subscribers.clear();\n    pendingNavigationController && pendingNavigationController.abort();\n    state.fetchers.forEach((_, key) => deleteFetcher(key));\n  } // Subscribe to state updates for the router\n\n\n  function subscribe(fn) {\n    subscribers.add(fn);\n    return () => subscribers.delete(fn);\n  } // Update our state and notify the calling context of the change\n\n\n  function updateState(newState) {\n    state = _extends({}, state, newState);\n    subscribers.forEach(subscriber => subscriber(state));\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\n\n  function completeNavigation(location, newState) {\n    var _state$navigation$for;\n\n    // Deduce if we're in a loading/actionReload state:\n    // - We have committed actionData in the store\n    // - The current navigation was a submission\n    // - We're past the submitting state and into the loading state\n    // - The location we've finished loading is different from the submission\n    //   location, indicating we redirected from the action (avoids false\n    //   positives for loading/submissionRedirect when actionData returned\n    //   on a prior submission)\n    let isActionReload = state.actionData != null && state.navigation.formMethod != null && state.navigation.state === \"loading\" && ((_state$navigation$for = state.navigation.formAction) == null ? void 0 : _state$navigation$for.split(\"?\")[0]) === location.pathname; // Always preserve any existing loaderData from re-used routes\n\n    let newLoaderData = newState.loaderData ? {\n      loaderData: mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [])\n    } : {};\n    updateState(_extends({}, isActionReload ? {} : {\n      actionData: null\n    }, newState, newLoaderData, {\n      historyAction: pendingAction,\n      location,\n      initialized: true,\n      navigation: IDLE_NAVIGATION,\n      revalidation: \"idle\",\n      // Don't restore on submission navigations\n      restoreScrollPosition: state.navigation.formData ? false : getSavedScrollPosition(location, newState.matches || state.matches),\n      preventScrollReset: pendingPreventScrollReset\n    }));\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    } // Reset stateful navigation vars\n\n\n    pendingAction = Action.Pop;\n    pendingPreventScrollReset = false;\n    isUninterruptedRevalidation = false;\n    isRevalidationRequired = false;\n    cancelledDeferredRoutes = [];\n    cancelledFetcherLoads = [];\n  } // Trigger a navigation event, which can either be a numerical POP or a PUSH\n  // replace with an optional submission\n\n\n  async function navigate(to, opts) {\n    if (typeof to === \"number\") {\n      init.history.go(to);\n      return;\n    }\n\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(to, opts);\n    let location = createLocation(state.location, path, opts && opts.state); // 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\n    location = init.history.encodeLocation(location);\n    let historyAction = (opts && opts.replace) === true || submission != null ? Action.Replace : Action.Push;\n    let preventScrollReset = opts && \"preventScrollReset\" in opts ? opts.preventScrollReset === true : undefined;\n    return await startNavigation(historyAction, location, {\n      submission,\n      // Send through the formData serialization error if we have one so we can\n      // render at the right error boundary after we match routes\n      pendingError: error,\n      preventScrollReset,\n      replace: opts && opts.replace\n    });\n  } // 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\n\n  function revalidate() {\n    interruptActiveLoads();\n    updateState({\n      revalidation: \"loading\"\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\n    if (state.navigation.state === \"submitting\") {\n      return;\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\n\n    if (state.navigation.state === \"idle\") {\n      startNavigation(state.historyAction, state.location, {\n        startUninterruptedRevalidation: true\n      });\n      return;\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\n\n    startNavigation(pendingAction || state.historyAction, state.navigation.location, {\n      overrideNavigation: state.navigation\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\n\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; // Save the current scroll position every time we start a new navigation,\n    // and track whether we should reset scroll on completion\n\n    saveScrollPosition(state.location, state.matches);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches = matchRoutes(dataRoutes, location, init.basename); // Short circuit with a 404 on the root error boundary if we match nothing\n\n    if (!matches) {\n      let {\n        matches: notFoundMatches,\n        route,\n        error\n      } = getNotFoundMatches(dataRoutes); // Cancel all pending deferred on 404s since we don't keep any routes\n\n      cancelActiveDeferreds();\n      completeNavigation(location, {\n        matches: notFoundMatches,\n        loaderData: {},\n        errors: {\n          [route.id]: error\n        }\n      });\n      return;\n    } // Short circuit if it's only a hash change\n\n\n    if (isHashChangeOnly(state.location, location)) {\n      completeNavigation(location, {\n        matches\n      });\n      return;\n    } // Create a controller/Request for this navigation\n\n\n    pendingNavigationController = new AbortController();\n    let request = createRequest(location, pendingNavigationController.signal, opts && opts.submission);\n    let pendingActionData;\n    let pendingError;\n\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) {\n      // Call action if we received an action submission\n      let actionOutput = await handleAction(request, location, opts.submission, matches, {\n        replace: opts.replace\n      });\n\n      if (actionOutput.shortCircuited) {\n        return;\n      }\n\n      pendingActionData = actionOutput.pendingActionData;\n      pendingError = actionOutput.pendingActionError;\n\n      let navigation = _extends({\n        state: \"loading\",\n        location\n      }, opts.submission);\n\n      loadingNavigation = navigation;\n    } // Call loaders\n\n\n    let {\n      shortCircuited,\n      loaderData,\n      errors\n    } = await handleLoaders(request, location, matches, loadingNavigation, opts && opts.submission, opts && opts.replace, pendingActionData, pendingError);\n\n    if (shortCircuited) {\n      return;\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\n\n    pendingNavigationController = null;\n    completeNavigation(location, {\n      matches,\n      loaderData,\n      errors\n    });\n  } // Call the action matched by the leaf route for this navigation and handle\n  // redirects/errors\n\n\n  async function handleAction(request, location, submission, matches, opts) {\n    interruptActiveLoads(); // Put us in a submitting state\n\n    let navigation = _extends({\n      state: \"submitting\",\n      location\n    }, submission);\n\n    updateState({\n      navigation\n    }); // Call our action and get the result\n\n    let result;\n    let actionMatch = getTargetMatch(matches, location);\n\n    if (!actionMatch.route.action) {\n      result = getMethodNotAllowedResult(location);\n    } else {\n      result = await callLoaderOrAction(\"action\", request, actionMatch, matches, router.basename);\n\n      if (request.signal.aborted) {\n        return {\n          shortCircuited: true\n        };\n      }\n    }\n\n    if (isRedirectResult(result)) {\n      let redirectNavigation = _extends({\n        state: \"loading\",\n        location: createLocation(state.location, result.location)\n      }, submission);\n\n      await startRedirectNavigation(result, redirectNavigation, opts && opts.replace);\n      return {\n        shortCircuited: true\n      };\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); // 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\n      if ((opts && opts.replace) !== true) {\n        pendingAction = Action.Push;\n      }\n\n      return {\n        pendingActionError: {\n          [boundaryMatch.route.id]: result.error\n        }\n      };\n    }\n\n    if (isDeferredResult(result)) {\n      throw new Error(\"defer() is not supported in actions\");\n    }\n\n    return {\n      pendingActionData: {\n        [actionMatch.route.id]: result.data\n      }\n    };\n  } // Call all applicable loaders for the given matches, handling redirects,\n  // errors, etc.\n\n\n  async function handleLoaders(request, location, matches, overrideNavigation, submission, replace, pendingActionData, pendingError) {\n    // Figure out the right navigation we want to use for data loading\n    let loadingNavigation = overrideNavigation;\n\n    if (!loadingNavigation) {\n      let navigation = {\n        state: \"loading\",\n        location,\n        formMethod: undefined,\n        formAction: undefined,\n        formEncType: undefined,\n        formData: undefined\n      };\n      loadingNavigation = navigation;\n    }\n\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(state, matches, submission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, pendingActionData, pendingError, fetchLoadMatches); // 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\n    cancelActiveDeferreds(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId)); // Short circuit if we have no loaders to run\n\n    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n      completeNavigation(location, {\n        matches,\n        loaderData: mergeLoaderData(state.loaderData, {}, matches),\n        // Commit pending error if we're short circuiting\n        errors: pendingError || null,\n        actionData: pendingActionData || null\n      });\n      return {\n        shortCircuited: true\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\n\n    if (!isUninterruptedRevalidation) {\n      revalidatingFetchers.forEach(_ref2 => {\n        let [key] = _ref2;\n        let fetcher = state.fetchers.get(key);\n        let revalidatingFetcher = {\n          state: \"loading\",\n          data: fetcher && fetcher.data,\n          formMethod: undefined,\n          formAction: undefined,\n          formEncType: undefined,\n          formData: undefined\n        };\n        state.fetchers.set(key, revalidatingFetcher);\n      });\n      updateState(_extends({\n        navigation: loadingNavigation,\n        actionData: pendingActionData || state.actionData || null\n      }, revalidatingFetchers.length > 0 ? {\n        fetchers: new Map(state.fetchers)\n      } : {}));\n    }\n\n    pendingNavigationLoadId = ++incrementingLoadId;\n    revalidatingFetchers.forEach(_ref3 => {\n      let [key] = _ref3;\n      return fetchControllers.set(key, pendingNavigationController);\n    });\n    let {\n      results,\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, request);\n\n    if (request.signal.aborted) {\n      return {\n        shortCircuited: true\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\n\n    revalidatingFetchers.forEach(_ref4 => {\n      let [key] = _ref4;\n      return fetchControllers.delete(key);\n    }); // If any loaders returned a redirect Response, start a new REPLACE navigation\n\n    let redirect = findRedirect(results);\n\n    if (redirect) {\n      let redirectNavigation = getLoaderRedirect(state, redirect);\n      await startRedirectNavigation(redirect, redirectNavigation, replace);\n      return {\n        shortCircuited: true\n      };\n    } // Process and commit output from loaders\n\n\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, matches, matchesToLoad, loaderResults, pendingError, revalidatingFetchers, fetcherResults, activeDeferreds); // Wire up subscribers to update loaderData as promises settle\n\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    markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    return _extends({\n      loaderData,\n      errors\n    }, didAbortFetchLoads || revalidatingFetchers.length > 0 ? {\n      fetchers: new Map(state.fetchers)\n    } : {});\n  }\n\n  function getFetcher(key) {\n    return state.fetchers.get(key) || IDLE_FETCHER;\n  } // Trigger a fetcher load/submit for the given fetcher key\n\n\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\n    if (fetchControllers.has(key)) abortFetcher(key);\n    let matches = matchRoutes(dataRoutes, href, init.basename);\n\n    if (!matches) {\n      setFetcherError(key, routeId, new ErrorResponse(404, \"Not Found\", null));\n      return;\n    }\n\n    let {\n      path,\n      submission\n    } = normalizeNavigateOptions(href, opts, true);\n    let match = getTargetMatch(matches, path);\n\n    if (submission) {\n      handleFetcherAction(key, routeId, path, match, matches, submission);\n      return;\n    } // Store off the match so we can call it's shouldRevalidate on subsequent\n    // revalidations\n\n\n    fetchLoadMatches.set(key, [path, match, matches]);\n    handleFetcherLoader(key, routeId, path, match, matches);\n  } // Call the action for the matched fetcher.submit(), and then handle redirects,\n  // errors, and revalidation\n\n\n  async function handleFetcherAction(key, routeId, path, match, requestMatches, submission) {\n    interruptActiveLoads();\n    fetchLoadMatches.delete(key);\n\n    if (!match.route.action) {\n      let {\n        error\n      } = getMethodNotAllowedResult(path);\n      setFetcherError(key, routeId, error);\n      return;\n    } // Put this fetcher into it's submitting state\n\n\n    let existingFetcher = state.fetchers.get(key);\n\n    let fetcher = _extends({\n      state: \"submitting\"\n    }, submission, {\n      data: existingFetcher && existingFetcher.data\n    });\n\n    state.fetchers.set(key, fetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    }); // Call the action for the fetcher\n\n    let abortController = new AbortController();\n    let fetchRequest = createRequest(path, abortController.signal, submission);\n    fetchControllers.set(key, abortController);\n    let actionResult = await callLoaderOrAction(\"action\", fetchRequest, match, requestMatches, router.basename);\n\n    if (fetchRequest.signal.aborted) {\n      // We can delete this so long as we weren't aborted by ou our own fetcher\n      // re-submit which would have put _new_ controller is in fetchControllers\n      if (fetchControllers.get(key) === abortController) {\n        fetchControllers.delete(key);\n      }\n\n      return;\n    }\n\n    if (isRedirectResult(actionResult)) {\n      fetchControllers.delete(key);\n      fetchRedirectIds.add(key);\n\n      let loadingFetcher = _extends({\n        state: \"loading\"\n      }, submission, {\n        data: undefined\n      });\n\n      state.fetchers.set(key, loadingFetcher);\n      updateState({\n        fetchers: new Map(state.fetchers)\n      });\n\n      let redirectNavigation = _extends({\n        state: \"loading\",\n        location: createLocation(state.location, actionResult.location)\n      }, submission);\n\n      await startRedirectNavigation(actionResult, redirectNavigation);\n      return;\n    } // Process any non-redirect errors thrown\n\n\n    if (isErrorResult(actionResult)) {\n      setFetcherError(key, routeId, actionResult.error);\n      return;\n    }\n\n    if (isDeferredResult(actionResult)) {\n      invariant(false, \"defer() is not supported in actions\");\n    } // Start the data load for current matches, or the next location if we're\n    // in the middle of a navigation\n\n\n    let nextLocation = state.navigation.location || state.location;\n    let revalidationRequest = createRequest(nextLocation, abortController.signal);\n    let matches = state.navigation.state !== \"idle\" ? matchRoutes(dataRoutes, state.navigation.location, init.basename) : state.matches;\n    invariant(matches, \"Didn't find any matches after fetcher action\");\n    let loadId = ++incrementingLoadId;\n    fetchReloadIds.set(key, loadId);\n\n    let loadFetcher = _extends({\n      state: \"loading\",\n      data: actionResult.data\n    }, submission);\n\n    state.fetchers.set(key, loadFetcher);\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(state, matches, submission, nextLocation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, {\n      [match.route.id]: actionResult.data\n    }, undefined, // No need to send through errors since we short circuit above\n    fetchLoadMatches); // 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\n    revalidatingFetchers.filter(_ref5 => {\n      let [staleKey] = _ref5;\n      return staleKey !== key;\n    }).forEach(_ref6 => {\n      let [staleKey] = _ref6;\n      let existingFetcher = state.fetchers.get(staleKey);\n      let revalidatingFetcher = {\n        state: \"loading\",\n        data: existingFetcher && existingFetcher.data,\n        formMethod: undefined,\n        formAction: undefined,\n        formEncType: undefined,\n        formData: undefined\n      };\n      state.fetchers.set(staleKey, revalidatingFetcher);\n      fetchControllers.set(staleKey, abortController);\n    });\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n    let {\n      results,\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);\n\n    if (abortController.signal.aborted) {\n      return;\n    }\n\n    fetchReloadIds.delete(key);\n    fetchControllers.delete(key);\n    revalidatingFetchers.forEach(_ref7 => {\n      let [staleKey] = _ref7;\n      return fetchControllers.delete(staleKey);\n    });\n    let redirect = findRedirect(results);\n\n    if (redirect) {\n      let redirectNavigation = getLoaderRedirect(state, redirect);\n      await startRedirectNavigation(redirect, redirectNavigation);\n      return;\n    } // Process and commit output from loaders\n\n\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, state.matches, matchesToLoad, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);\n    let doneFetcher = {\n      state: \"idle\",\n      data: actionResult.data,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined\n    };\n    state.fetchers.set(key, doneFetcher);\n    let didAbortFetchLoads = abortStaleFetchLoads(loadId); // 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\n    if (state.navigation.state === \"loading\" && loadId > pendingNavigationLoadId) {\n      invariant(pendingAction, \"Expected pending action\");\n      pendingNavigationController && pendingNavigationController.abort();\n      completeNavigation(state.navigation.location, {\n        matches,\n        loaderData,\n        errors,\n        fetchers: new Map(state.fetchers)\n      });\n    } else {\n      // otherwise just update with the fetcher data, preserving any existing\n      // loaderData for loaders that did not need to reload.  We have to\n      // manually merge here since we aren't going through completeNavigation\n      updateState(_extends({\n        errors,\n        loaderData: mergeLoaderData(state.loaderData, loaderData, matches)\n      }, didAbortFetchLoads ? {\n        fetchers: new Map(state.fetchers)\n      } : {}));\n      isRevalidationRequired = false;\n    }\n  } // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n\n\n  async function handleFetcherLoader(key, routeId, path, match, matches) {\n    let existingFetcher = state.fetchers.get(key); // Put this fetcher into it's loading state\n\n    let loadingFetcher = {\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      data: existingFetcher && existingFetcher.data\n    };\n    state.fetchers.set(key, loadingFetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    }); // Call the loader for this fetcher route match\n\n    let abortController = new AbortController();\n    let fetchRequest = createRequest(path, abortController.signal);\n    fetchControllers.set(key, abortController);\n    let result = await callLoaderOrAction(\"loader\", fetchRequest, match, matches, router.basename); // Deferred isn't supported or 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\n    if (isDeferredResult(result)) {\n      result = (await resolveDeferredData(result, fetchRequest.signal, true)) || result;\n    } // We can delete this so long as we weren't aborted by ou our own fetcher\n    // re-load which would have put _new_ controller is in fetchControllers\n\n\n    if (fetchControllers.get(key) === abortController) {\n      fetchControllers.delete(key);\n    }\n\n    if (fetchRequest.signal.aborted) {\n      return;\n    } // If the loader threw a redirect Response, start a new REPLACE navigation\n\n\n    if (isRedirectResult(result)) {\n      let redirectNavigation = getLoaderRedirect(state, result);\n      await startRedirectNavigation(result, redirectNavigation);\n      return;\n    } // Process any non-redirect errors thrown\n\n\n    if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, routeId);\n      state.fetchers.delete(key); // TODO: In remix, this would reset to IDLE_NAVIGATION if it was a catch -\n      // do we need to behave any differently with our non-redirect errors?\n      // What if it was a non-redirect Response?\n\n      updateState({\n        fetchers: new Map(state.fetchers),\n        errors: {\n          [boundaryMatch.route.id]: result.error\n        }\n      });\n      return;\n    }\n\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\"); // Put the fetcher back into an idle state\n\n    let doneFetcher = {\n      state: \"idle\",\n      data: result.data,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined\n    };\n    state.fetchers.set(key, doneFetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n  }\n  /**\n   * Utility function to handle redirects returned from an action or loader.\n   * Normally, a redirect \"replaces\" the navigation that triggered it.  So, for\n   * example:\n   *\n   *  - user is on /a\n   *  - user clicks a link to /b\n   *  - loader for /b redirects to /c\n   *\n   * In a non-JS app the browser would track the in-flight navigation to /b and\n   * then replace it with /c when it encountered the redirect response.  In\n   * the end it would only ever update the URL bar with /c.\n   *\n   * In client-side routing using pushState/replaceState, we aim to emulate\n   * this behavior and we also do not update history until the end of the\n   * navigation (including processed redirects).  This means that we never\n   * actually touch history until we've processed redirects, so we just use\n   * the history action from the original navigation (PUSH or REPLACE).\n   */\n\n\n  async function startRedirectNavigation(redirect, navigation, replace) {\n    if (redirect.revalidate) {\n      isRevalidationRequired = true;\n    }\n\n    invariant(navigation.location, \"Expected a location on the redirect navigation\"); // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n\n    pendingNavigationController = null;\n    let redirectHistoryAction = replace === true ? Action.Replace : Action.Push;\n    await startNavigation(redirectHistoryAction, navigation.location, {\n      overrideNavigation: navigation\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, router.basename)), ...fetchersToLoad.map(_ref8 => {\n      let [, href, match, fetchMatches] = _ref8;\n      return callLoaderOrAction(\"loader\", createRequest(href, request.signal), match, fetchMatches, router.basename);\n    })]);\n    let loaderResults = results.slice(0, matchesToLoad.length);\n    let fetcherResults = results.slice(matchesToLoad.length);\n    await Promise.all([resolveDeferredResults(currentMatches, matchesToLoad, loaderResults, request.signal, false, state.loaderData), resolveDeferredResults(currentMatches, fetchersToLoad.map(_ref9 => {\n      let [,, match] = _ref9;\n      return match;\n    }), fetcherResults, request.signal, true)]);\n    return {\n      results,\n      loaderResults,\n      fetcherResults\n    };\n  }\n\n  function interruptActiveLoads() {\n    // Every interruption triggers a revalidation\n    isRevalidationRequired = true; // Cancel pending route-level deferreds and mark cancelled routes for\n    // revalidation\n\n    cancelledDeferredRoutes.push(...cancelActiveDeferreds()); // Abort in-flight fetcher loads\n\n    fetchLoadMatches.forEach((_, key) => {\n      if (fetchControllers.has(key)) {\n        cancelledFetcherLoads.push(key);\n        abortFetcher(key);\n      }\n    });\n  }\n\n  function setFetcherError(key, routeId, error) {\n    let boundaryMatch = findNearestBoundary(state.matches, routeId);\n    deleteFetcher(key);\n    updateState({\n      errors: {\n        [boundaryMatch.route.id]: error\n      },\n      fetchers: new Map(state.fetchers)\n    });\n  }\n\n  function deleteFetcher(key) {\n    if (fetchControllers.has(key)) abortFetcher(key);\n    fetchLoadMatches.delete(key);\n    fetchReloadIds.delete(key);\n    fetchRedirectIds.delete(key);\n    state.fetchers.delete(key);\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\n  function markFetchersDone(keys) {\n    for (let key of keys) {\n      let fetcher = getFetcher(key);\n      let doneFetcher = {\n        state: \"idle\",\n        data: fetcher.data,\n        formMethod: undefined,\n        formAction: undefined,\n        formEncType: undefined,\n        formData: undefined\n      };\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n\n  function markFetchRedirectsDone() {\n    let doneKeys = [];\n\n    for (let key of fetchRedirectIds) {\n      let fetcher = state.fetchers.get(key);\n      invariant(fetcher, \"Expected fetcher: \" + key);\n\n      if (fetcher.state === \"loading\") {\n        fetchRedirectIds.delete(key);\n        doneKeys.push(key);\n      }\n    }\n\n    markFetchersDone(doneKeys);\n  }\n\n  function abortStaleFetchLoads(landedId) {\n    let yeetedKeys = [];\n\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\n        if (fetcher.state === \"loading\") {\n          abortFetcher(key);\n          fetchReloadIds.delete(key);\n          yeetedKeys.push(key);\n        }\n      }\n    }\n\n    markFetchersDone(yeetedKeys);\n    return yeetedKeys.length > 0;\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  } // Opt in to capturing and reporting scroll positions during navigations,\n  // used by the <ScrollRestoration> component\n\n\n  function enableScrollRestoration(positions, getPosition, getKey) {\n    savedScrollPositions = positions;\n    getScrollPosition = getPosition;\n\n    getScrollRestorationKey = getKey || (location => location.key); // 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\n\n    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n      initialScrollRestored = true;\n      let y = getSavedScrollPosition(state.location, state.matches);\n\n      if (y != null) {\n        updateState({\n          restoreScrollPosition: y\n        });\n      }\n    }\n\n    return () => {\n      savedScrollPositions = null;\n      getScrollPosition = null;\n      getScrollRestorationKey = null;\n    };\n  }\n\n  function saveScrollPosition(location, matches) {\n    if (savedScrollPositions && getScrollRestorationKey && getScrollPosition) {\n      let userMatches = matches.map(m => createUseMatchesMatch(m, state.loaderData));\n      let key = getScrollRestorationKey(location, userMatches) || location.key;\n      savedScrollPositions[key] = getScrollPosition();\n    }\n  }\n\n  function getSavedScrollPosition(location, matches) {\n    if (savedScrollPositions && getScrollRestorationKey && getScrollPosition) {\n      let userMatches = matches.map(m => createUseMatchesMatch(m, state.loaderData));\n      let key = getScrollRestorationKey(location, userMatches) || location.key;\n      let y = savedScrollPositions[key];\n\n      if (typeof y === \"number\") {\n        return y;\n      }\n    }\n\n    return null;\n  }\n\n  router = {\n    get basename() {\n      return init.basename;\n    },\n\n    get state() {\n      return state;\n    },\n\n    get routes() {\n      return dataRoutes;\n    },\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    getFetcher,\n    deleteFetcher,\n    dispose,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds\n  };\n  return router;\n} //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\n\nconst validActionMethods = new Set([\"POST\", \"PUT\", \"PATCH\", \"DELETE\"]);\nconst validRequestMethods = new Set([\"GET\", \"HEAD\", ...validActionMethods]);\nfunction unstable_createStaticHandler(routes) {\n  invariant(routes.length > 0, \"You must provide a non-empty routes array to unstable_createStaticHandler\");\n  let dataRoutes = convertRoutesToDataRoutes(routes);\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\n  async function query(request) {\n    let url = new URL(request.url);\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location);\n\n    if (!validRequestMethods.has(request.method)) {\n      let {\n        matches: methodNotAllowedMatches,\n        route,\n        error\n      } = getMethodNotAllowedMatches(dataRoutes);\n      return {\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      };\n    } else if (!matches) {\n      let {\n        matches: notFoundMatches,\n        route,\n        error\n      } = getNotFoundMatches(dataRoutes);\n      return {\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      };\n    }\n\n    let result = await queryImpl(request, location, matches);\n\n    if (result instanceof Response) {\n      return result;\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\n\n    return _extends({\n      location\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 thrown Response (such as a\n   * 404 or 405) will have a custom X-Remix-Router-Error: \"yes\" header on it\n   * in order to differentiate from responses thrown from user actions/loaders.\n   */\n\n\n  async function queryRoute(request, routeId) {\n    let url = new URL(request.url);\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location);\n\n    if (!validRequestMethods.has(request.method)) {\n      throw createRouterErrorResponse(null, {\n        status: 405,\n        statusText: \"Method Not Allowed\"\n      });\n    } else if (!matches) {\n      throw createRouterErrorResponse(null, {\n        status: 404,\n        statusText: \"Not Found\"\n      });\n    }\n\n    let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);\n\n    if (!match) {\n      throw createRouterErrorResponse(null, {\n        status: 404,\n        statusText: \"Not Found\"\n      });\n    }\n\n    let result = await queryImpl(request, location, matches, match);\n\n    if (result instanceof Response) {\n      return result;\n    }\n\n    let error = result.errors ? Object.values(result.errors)[0] : undefined;\n\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    } // Pick off the right state value to return\n\n\n    let routeData = [result.actionData, result.loaderData].find(v => v);\n    return Object.values(routeData || {})[0];\n  }\n\n  async function queryImpl(request, location, matches, routeMatch) {\n    invariant(request.signal, \"query()/queryRoute() requests must contain an AbortController signal\");\n\n    try {\n      if (validActionMethods.has(request.method)) {\n        let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), routeMatch != null);\n        return result;\n      }\n\n      let result = await loadRouteData(request, matches, routeMatch);\n      return result instanceof Response ? 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 && !isRedirectResponse(e.response)) {\n          throw e.response;\n        }\n\n        return e.response;\n      } // Redirects are always returned since they don't propagate to catch\n      // boundaries\n\n\n      if (isRedirectResponse(e)) {\n        return e;\n      }\n\n      throw e;\n    }\n  }\n\n  async function submit(request, matches, actionMatch, isRouteRequest) {\n    let result;\n\n    if (!actionMatch.route.action) {\n      if (isRouteRequest) {\n        throw createRouterErrorResponse(null, {\n          status: 405,\n          statusText: \"Method Not Allowed\"\n        });\n      }\n\n      result = getMethodNotAllowedResult(request.url);\n    } else {\n      result = await callLoaderOrAction(\"action\", request, actionMatch, matches, undefined, // Basename not currently supported in static handlers\n      true, isRouteRequest);\n\n      if (request.signal.aborted) {\n        let method = isRouteRequest ? \"queryRoute\" : \"query\";\n        throw new Error(method + \"() call aborted\");\n      }\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\n    if (isDeferredResult(result)) {\n      throw new Error(\"defer() is not supported in actions\");\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        let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n        return {\n          matches: [actionMatch],\n          loaderData: {},\n          actionData: null,\n          errors: {\n            [boundaryMatch.route.id]: result.error\n          },\n          // Note: statusCode + headers are unused here since queryRoute will\n          // return the raw Response or value\n          statusCode: 500,\n          loaderHeaders: {},\n          actionHeaders: {}\n        };\n      }\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      };\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, undefined, {\n        [boundaryMatch.route.id]: result.error\n      }); // action status codes take precedence over loader status codes\n\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\n    let context = await loadRouteData(request, matches);\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\n  async function loadRouteData(request, matches, routeMatch, pendingActionError) {\n    let isRouteRequest = routeMatch != null;\n    let requestMatches = routeMatch ? [routeMatch] : getLoaderMatchesUntilBoundary(matches, Object.keys(pendingActionError || {})[0]);\n    let matchesToLoad = requestMatches.filter(m => m.route.loader); // Short circuit if we have no loaders to run\n\n    if (matchesToLoad.length === 0) {\n      return {\n        matches,\n        loaderData: {},\n        errors: pendingActionError || null,\n        statusCode: 200,\n        loaderHeaders: {}\n      };\n    }\n\n    let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction(\"loader\", request, match, matches, undefined, // Basename not currently supported in static handlers\n    true, isRouteRequest))]);\n\n    if (request.signal.aborted) {\n      let method = isRouteRequest ? \"queryRoute\" : \"query\";\n      throw new Error(method + \"() call aborted\");\n    } // Can't do anything with these without the Remix side of things, so just\n    // cancel them for now\n\n\n    results.forEach(result => {\n      if (isDeferredResult(result)) {\n        result.deferredData.cancel();\n      }\n    }); // Process and commit output from loaders\n\n    let context = processRouteLoaderData(matches, matchesToLoad, results, pendingActionError);\n    return _extends({}, context, {\n      matches\n    });\n  }\n\n  function createRouterErrorResponse(body, init) {\n    return new Response(body, _extends({}, init, {\n      headers: _extends({}, init.headers, {\n        \"X-Remix-Router-Error\": \"yes\"\n      })\n    }));\n  }\n\n  return {\n    dataRoutes,\n    query,\n    queryRoute\n  };\n} //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Helpers\n////////////////////////////////////////////////////////////////////////////////\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 */\n\nfunction getStaticContextFromError(routes, context, error) {\n  let newContext = _extends({}, context, {\n    statusCode: 500,\n    errors: {\n      [context._deepestRenderedBoundaryId || routes[0].id]: error\n    }\n  });\n\n  return newContext;\n} // Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\n\nfunction normalizeNavigateOptions(to, opts, isFetcher) {\n  if (isFetcher === void 0) {\n    isFetcher = false;\n  }\n\n  let path = typeof to === \"string\" ? to : createPath(to); // Return location verbatim on non-submission navigations\n\n  if (!opts || !(\"formMethod\" in opts) && !(\"formData\" in opts)) {\n    return {\n      path\n    };\n  } // Create a Submission on non-GET navigations\n\n\n  if (opts.formMethod != null && opts.formMethod !== \"get\") {\n    return {\n      path,\n      submission: {\n        formMethod: opts.formMethod,\n        formAction: stripHashFromPath(path),\n        formEncType: opts && opts.formEncType || \"application/x-www-form-urlencoded\",\n        formData: opts.formData\n      }\n    };\n  } // No formData to flatten for GET submission\n\n\n  if (!opts.formData) {\n    return {\n      path\n    };\n  } // Flatten submission onto URLSearchParams for GET submissions\n\n\n  let parsedPath = parsePath(path);\n\n  try {\n    let searchParams = convertFormDataToSearchParams(opts.formData); // Since fetcher GET submissions only run a single loader (as opposed to\n    // navigation GET submissions which run all loaders), we need to preserve\n    // any incoming ?index params\n\n    if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n      searchParams.append(\"index\", \"\");\n    }\n\n    parsedPath.search = \"?\" + searchParams;\n  } catch (e) {\n    return {\n      path,\n      error: new ErrorResponse(400, \"Bad Request\", \"Cannot submit binary form data using GET\")\n    };\n  }\n\n  return {\n    path: createPath(parsedPath)\n  };\n}\n\nfunction getLoaderRedirect(state, redirect) {\n  let {\n    formMethod,\n    formAction,\n    formEncType,\n    formData\n  } = state.navigation;\n  let navigation = {\n    state: \"loading\",\n    location: createLocation(state.location, redirect.location),\n    formMethod: formMethod || undefined,\n    formAction: formAction || undefined,\n    formEncType: formEncType || undefined,\n    formData: formData || undefined\n  };\n  return navigation;\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\n\n\nfunction getLoaderMatchesUntilBoundary(matches, boundaryId) {\n  let boundaryMatches = matches;\n\n  if (boundaryId) {\n    let index = matches.findIndex(m => m.route.id === boundaryId);\n\n    if (index >= 0) {\n      boundaryMatches = matches.slice(0, index);\n    }\n  }\n\n  return boundaryMatches;\n}\n\nfunction getMatchesToLoad(state, matches, submission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, pendingActionData, pendingError, fetchLoadMatches) {\n  let actionResult = pendingError ? Object.values(pendingError)[0] : pendingActionData ? Object.values(pendingActionData)[0] : null; // Pick navigation matches that are net-new or qualify for revalidation\n\n  let boundaryId = pendingError ? Object.keys(pendingError)[0] : undefined;\n  let boundaryMatches = getLoaderMatchesUntilBoundary(matches, boundaryId);\n  let navigationMatches = boundaryMatches.filter((match, index) => match.route.loader != null && (isNewLoader(state.loaderData, state.matches[index], match) || // If this route had a pending deferred cancelled it must be revalidated\n  cancelledDeferredRoutes.some(id => id === match.route.id) || shouldRevalidateLoader(state.location, state.matches[index], submission, location, match, isRevalidationRequired, actionResult))); // Pick fetcher.loads that need to be revalidated\n\n  let revalidatingFetchers = [];\n  fetchLoadMatches && fetchLoadMatches.forEach((_ref10, key) => {\n    let [href, match, fetchMatches] = _ref10;\n\n    // This fetcher was cancelled from a prior action submission - force reload\n    if (cancelledFetcherLoads.includes(key)) {\n      revalidatingFetchers.push([key, href, match, fetchMatches]);\n    } else if (isRevalidationRequired) {\n      let shouldRevalidate = shouldRevalidateLoader(href, match, submission, href, match, isRevalidationRequired, actionResult);\n\n      if (shouldRevalidate) {\n        revalidatingFetchers.push([key, href, match, fetchMatches]);\n      }\n    }\n  });\n  return [navigationMatches, revalidatingFetchers];\n}\n\nfunction isNewLoader(currentLoaderData, currentMatch, match) {\n  let isNew = // [a] -> [a, b]\n  !currentMatch || // [a, b] -> [a, c]\n  match.route.id !== currentMatch.route.id; // 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\n  let isMissingData = currentLoaderData[match.route.id] === undefined; // Always load if this is a net-new route or we don't yet have data\n\n  return isNew || isMissingData;\n}\n\nfunction isNewRouteInstance(currentMatch, match) {\n  let currentPath = currentMatch.route.path;\n  return (// param change for this match, /users/123 -> /users/456\n    currentMatch.pathname !== match.pathname || // splat param changed, which is not present in match.path\n    // e.g. /files/images/avatar.jpg -> files/finances.xls\n    currentPath && currentPath.endsWith(\"*\") && currentMatch.params[\"*\"] !== match.params[\"*\"]\n  );\n}\n\nfunction shouldRevalidateLoader(currentLocation, currentMatch, submission, location, match, isRevalidationRequired, actionResult) {\n  let currentUrl = createURL(currentLocation);\n  let currentParams = currentMatch.params;\n  let nextUrl = createURL(location);\n  let nextParams = match.params; // This is the default implementation as to 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  // Note that fetchers always provide the same current/next locations so the\n  // URL-based checks here don't apply to fetcher shouldRevalidate calls\n\n  let defaultShouldRevalidate = isNewRouteInstance(currentMatch, match) || // Clicked the same link, resubmitted a GET form\n  currentUrl.toString() === nextUrl.toString() || // Search params affect all loaders\n  currentUrl.search !== nextUrl.search || // Forced revalidation due to submission, useRevalidate, or X-Remix-Revalidate\n  isRevalidationRequired;\n\n  if (match.route.shouldRevalidate) {\n    let routeChoice = match.route.shouldRevalidate(_extends({\n      currentUrl,\n      currentParams,\n      nextUrl,\n      nextParams\n    }, submission, {\n      actionResult,\n      defaultShouldRevalidate\n    }));\n\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n\n  return defaultShouldRevalidate;\n}\n\nasync function callLoaderOrAction(type, request, match, matches, basename, isStaticRequest, isRouteRequest) {\n  if (isStaticRequest === void 0) {\n    isStaticRequest = false;\n  }\n\n  if (isRouteRequest === void 0) {\n    isRouteRequest = false;\n  }\n\n  let resultType;\n  let result; // Setup a promise we can race against so that abort signals short circuit\n\n  let reject;\n  let abortPromise = new Promise((_, r) => reject = r);\n\n  let onReject = () => reject();\n\n  request.signal.addEventListener(\"abort\", onReject);\n\n  try {\n    let handler = match.route[type];\n    invariant(handler, \"Could not find the \" + type + \" to run on the \\\"\" + match.route.id + \"\\\" route\");\n    result = await Promise.race([handler({\n      request,\n      params: match.params\n    }), abortPromise]);\n  } catch (e) {\n    resultType = ResultType.error;\n    result = e;\n  } finally {\n    request.signal.removeEventListener(\"abort\", onReject);\n  }\n\n  if (result instanceof Response) {\n    let status = result.status; // Process redirects\n\n    if (status >= 300 && status <= 399) {\n      let location = result.headers.get(\"Location\");\n      invariant(location, \"Redirects returned/thrown from loaders/actions must have a Location header\"); // Support relative routing in redirects\n\n      let activeMatches = matches.slice(0, matches.indexOf(match) + 1);\n      let routePathnames = getPathContributingMatches(activeMatches).map(match => match.pathnameBase);\n      let requestPath = createURL(request.url).pathname;\n      let resolvedLocation = resolveTo(location, routePathnames, requestPath);\n      invariant(createPath(resolvedLocation), \"Unable to resolve redirect location: \" + result.headers.get(\"Location\")); // Prepend the basename to the redirect location if we have one\n\n      if (basename) {\n        let path = resolvedLocation.pathname;\n        resolvedLocation.pathname = path === \"/\" ? basename : joinPaths([basename, path]);\n      }\n\n      location = createPath(resolvedLocation); // 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\n      if (isStaticRequest) {\n        result.headers.set(\"Location\", location);\n        throw result;\n      }\n\n      return {\n        type: ResultType.redirect,\n        status,\n        location,\n        revalidate: result.headers.get(\"X-Remix-Revalidate\") !== null\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\n\n    if (isRouteRequest) {\n      // eslint-disable-next-line no-throw-literal\n      throw {\n        type: resultType || ResultType.data,\n        response: result\n      };\n    }\n\n    let data;\n    let contentType = result.headers.get(\"Content-Type\");\n\n    if (contentType && contentType.startsWith(\"application/json\")) {\n      data = await result.json();\n    } else {\n      data = await result.text();\n    }\n\n    if (resultType === ResultType.error) {\n      return {\n        type: resultType,\n        error: new ErrorResponse(status, result.statusText, data),\n        headers: result.headers\n      };\n    }\n\n    return {\n      type: ResultType.data,\n      data,\n      statusCode: result.status,\n      headers: result.headers\n    };\n  }\n\n  if (resultType === ResultType.error) {\n    return {\n      type: resultType,\n      error: result\n    };\n  }\n\n  if (result instanceof DeferredData) {\n    return {\n      type: ResultType.deferred,\n      deferredData: result\n    };\n  }\n\n  return {\n    type: ResultType.data,\n    data: result\n  };\n}\n\nfunction createRequest(location, signal, submission) {\n  let url = createURL(stripHashFromPath(location)).toString();\n  let init = {\n    signal\n  };\n\n  if (submission) {\n    let {\n      formMethod,\n      formEncType,\n      formData\n    } = submission;\n    init.method = formMethod.toUpperCase();\n    init.body = formEncType === \"application/x-www-form-urlencoded\" ? convertFormDataToSearchParams(formData) : formData;\n  } // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n\n\n  return new Request(url, init);\n}\n\nfunction convertFormDataToSearchParams(formData) {\n  let searchParams = new URLSearchParams();\n\n  for (let [key, value] of formData.entries()) {\n    invariant(typeof value === \"string\", 'File inputs are not supported with encType \"application/x-www-form-urlencoded\", ' + 'please use \"multipart/form-data\" instead.');\n    searchParams.append(key, value);\n  }\n\n  return searchParams;\n}\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 = {}; // Process loader results into state.loaderData/state.errors\n\n  results.forEach((result, index) => {\n    let id = matchesToLoad[index].route.id;\n    invariant(!isRedirectResult(result), \"Cannot handle redirect results in processLoaderData\");\n\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; // 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\n      if (pendingError) {\n        error = Object.values(pendingError)[0];\n        pendingError = undefined;\n      }\n\n      errors = Object.assign(errors || {}, {\n        [boundaryMatch.route.id]: error\n      }); // Once we find our first (highest) error, we set the status code and\n      // prevent deeper status codes from overriding\n\n      if (!foundError) {\n        foundError = true;\n        statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;\n      }\n\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    } else if (isDeferredResult(result)) {\n      activeDeferreds && activeDeferreds.set(id, result.deferredData);\n      loaderData[id] = result.deferredData.data; // TODO: Add statusCode/headers once we wire up streaming in Remix\n    } else {\n      loaderData[id] = result.data; // Error status codes always override success status codes, but if all\n      // loaders are successful we take the deepest status code.\n\n      if (result.statusCode != null && result.statusCode !== 200 && !foundError) {\n        statusCode = result.statusCode;\n      }\n\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    }\n  }); // If we didn't consume the pending action error (i.e., all loaders\n  // resolved), then consume it here\n\n  if (pendingError) {\n    errors = pendingError;\n  }\n\n  return {\n    loaderData,\n    errors,\n    statusCode: statusCode || 200,\n    loaderHeaders\n  };\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); // Process results from our revalidating fetchers\n\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let [key,, match] = revalidatingFetchers[index];\n    invariant(fetcherResults !== undefined && fetcherResults[index] !== undefined, \"Did not find corresponding fetcher result\");\n    let result = fetcherResults[index]; // Process fetcher non-redirect errors\n\n    if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, match.route.id);\n\n      if (!(errors && errors[boundaryMatch.route.id])) {\n        errors = _extends({}, errors, {\n          [boundaryMatch.route.id]: result.error\n        });\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      throw new Error(\"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      throw new Error(\"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = {\n        state: \"idle\",\n        data: result.data,\n        formMethod: undefined,\n        formAction: undefined,\n        formEncType: undefined,\n        formData: undefined\n      };\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n\n  return {\n    loaderData,\n    errors\n  };\n}\n\nfunction mergeLoaderData(loaderData, newLoaderData, matches) {\n  let mergedLoaderData = _extends({}, newLoaderData);\n\n  matches.forEach(match => {\n    let id = match.route.id;\n\n    if (newLoaderData[id] === undefined && loaderData[id] !== undefined) {\n      mergedLoaderData[id] = loaderData[id];\n    }\n  });\n  return mergedLoaderData;\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\n\n\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}\n\nfunction getShortCircuitMatches(routes, status, statusText) {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route = routes.find(r => r.index || !r.path || r.path === \"/\") || {\n    id: \"__shim-\" + status + \"-route__\"\n  };\n  return {\n    matches: [{\n      params: {},\n      pathname: \"\",\n      pathnameBase: \"\",\n      route\n    }],\n    route,\n    error: new ErrorResponse(status, statusText, null)\n  };\n}\n\nfunction getNotFoundMatches(routes) {\n  return getShortCircuitMatches(routes, 404, \"Not Found\");\n}\n\nfunction getMethodNotAllowedMatches(routes) {\n  return getShortCircuitMatches(routes, 405, \"Method Not Allowed\");\n}\n\nfunction getMethodNotAllowedResult(path) {\n  let href = typeof path === \"string\" ? path : createPath(path);\n  console.warn(\"You're trying to submit to a route that does not have an action.  To \" + \"fix this, please add an `action` function to the route for \" + (\"[\" + href + \"]\"));\n  return {\n    type: ResultType.error,\n    error: new ErrorResponse(405, \"Method Not Allowed\", \"\")\n  };\n} // Find any returned redirect errors, starting from the lowest match\n\n\nfunction findRedirect(results) {\n  for (let i = results.length - 1; i >= 0; i--) {\n    let result = results[i];\n\n    if (isRedirectResult(result)) {\n      return result;\n    }\n  }\n}\n\nfunction stripHashFromPath(path) {\n  let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n  return createPath(_extends({}, parsedPath, {\n    hash: \"\"\n  }));\n}\n\nfunction isHashChangeOnly(a, b) {\n  return a.pathname === b.pathname && a.search === b.search && a.hash !== b.hash;\n}\n\nfunction isDeferredResult(result) {\n  return result.type === ResultType.deferred;\n}\n\nfunction isErrorResult(result) {\n  return result.type === ResultType.error;\n}\n\nfunction isRedirectResult(result) {\n  return (result && result.type) === ResultType.redirect;\n}\n\nfunction isRedirectResponse(result) {\n  if (!(result instanceof Response)) {\n    return false;\n  }\n\n  let status = result.status;\n  let location = result.headers.get(\"Location\");\n  return status >= 300 && status <= 399 && location != null;\n}\n\nfunction isQueryRouteResponse(obj) {\n  return obj && obj.response instanceof Response && (obj.type === ResultType.data || ResultType.error);\n}\n\nasync function resolveDeferredResults(currentMatches, matchesToLoad, results, signal, isFetcher, currentLoaderData) {\n  for (let index = 0; index < results.length; index++) {\n    let result = results[index];\n    let match = matchesToLoad[index];\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\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      await resolveDeferredData(result, signal, isFetcher).then(result => {\n        if (result) {\n          results[index] = result || results[index];\n        }\n      });\n    }\n  }\n}\n\nasync function resolveDeferredData(result, signal, unwrap) {\n  if (unwrap === void 0) {\n    unwrap = false;\n  }\n\n  let aborted = await result.deferredData.resolveData(signal);\n\n  if (aborted) {\n    return;\n  }\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\n  return {\n    type: ResultType.data,\n    data: result.deferredData.data\n  };\n}\n\nfunction hasNakedIndexQuery(search) {\n  return new URLSearchParams(search).getAll(\"index\").some(v => v === \"\");\n} // Note: This should match the format exported by useMatches, so if you change\n// this please also change that :)  Eventually we'll DRY this up\n\n\nfunction createUseMatchesMatch(match, loaderData) {\n  let {\n    route,\n    pathname,\n    params\n  } = match;\n  return {\n    id: route.id,\n    pathname,\n    params,\n    data: loaderData[route.id],\n    handle: route.handle\n  };\n}\n\nfunction getTargetMatch(matches, location) {\n  let search = typeof location === \"string\" ? parsePath(location).search : location.search;\n\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  } // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n  // pathless layout routes)\n\n\n  let pathMatches = getPathContributingMatches(matches);\n  return pathMatches[pathMatches.length - 1];\n} //#endregion\n\nexport { AbortedDeferredError, Action, ErrorResponse, IDLE_FETCHER, IDLE_NAVIGATION, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, getPathContributingMatches as UNSAFE_getPathContributingMatches, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, createRouter, defer, generatePath, getStaticContextFromError, getToPathname, invariant, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, parsePath, redirect, resolvePath, resolveTo, stripBasename, unstable_createStaticHandler, warning };\n//# sourceMappingURL=router.js.map\n","/**\n * React Router v6.4.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 { invariant, joinPaths, matchPath, UNSAFE_getPathContributingMatches, warning, resolveTo, parsePath, matchRoutes, Action, isRouteErrorResponse, createMemoryHistory, stripBasename, AbortedDeferredError, createRouter } from '@remix-run/router';\nexport { AbortedDeferredError, Action as NavigationType, createPath, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, resolvePath } from '@remix-run/router';\nimport * as React from 'react';\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\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n/**\n * inlined Object.is polyfill to avoid requiring consumers ship their own\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n */\n\nfunction isPolyfill(x, y) {\n  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare\n  ;\n}\n\nconst is = typeof Object.is === \"function\" ? Object.is : isPolyfill; // Intentionally not using named imports because Rollup uses dynamic\n// dispatch for CommonJS interop named imports.\n\nconst {\n  useState,\n  useEffect,\n  useLayoutEffect,\n  useDebugValue\n} = React;\nlet didWarnOld18Alpha = false;\nlet didWarnUncachedGetSnapshot = false; // Disclaimer: This shim breaks many of the rules of React, and only works\n// because of a very particular set of implementation details and assumptions\n// -- change any one of them and it will break. The most important assumption\n// is that updates are always synchronous, because concurrent rendering is\n// only available in versions of React that also have a built-in\n// useSyncExternalStore API. And we only use this shim when the built-in API\n// does not exist.\n//\n// Do not assume that the clever hacks used by this hook also work in general.\n// The point of this shim is to replace the need for hacks by other libraries.\n\nfunction useSyncExternalStore$2(subscribe, getSnapshot, // Note: The shim does not use getServerSnapshot, because pre-18 versions of\n// React do not expose a way to check if we're hydrating. So users of the shim\n// will need to track that themselves and return the correct value\n// from `getSnapshot`.\ngetServerSnapshot) {\n  if (process.env.NODE_ENV !== \"production\") {\n    if (!didWarnOld18Alpha) {\n      if (\"startTransition\" in React) {\n        didWarnOld18Alpha = true;\n        console.error(\"You are using an outdated, pre-release alpha of React 18 that \" + \"does not support useSyncExternalStore. The \" + \"use-sync-external-store shim will not work correctly. Upgrade \" + \"to a newer pre-release.\");\n      }\n    }\n  } // Read the current snapshot from the store on every render. Again, this\n  // breaks the rules of React, and only works here because of specific\n  // implementation details, most importantly that updates are\n  // always synchronous.\n\n\n  const value = getSnapshot();\n\n  if (process.env.NODE_ENV !== \"production\") {\n    if (!didWarnUncachedGetSnapshot) {\n      const cachedValue = getSnapshot();\n\n      if (!is(value, cachedValue)) {\n        console.error(\"The result of getSnapshot should be cached to avoid an infinite loop\");\n        didWarnUncachedGetSnapshot = true;\n      }\n    }\n  } // Because updates are synchronous, we don't queue them. Instead we force a\n  // re-render whenever the subscribed state changes by updating an some\n  // arbitrary useState hook. Then, during render, we call getSnapshot to read\n  // the current value.\n  //\n  // Because we don't actually use the state returned by the useState hook, we\n  // can save a bit of memory by storing other stuff in that slot.\n  //\n  // To implement the early bailout, we need to track some things on a mutable\n  // object. Usually, we would put that in a useRef hook, but we can stash it in\n  // our useState hook instead.\n  //\n  // To force a re-render, we call forceUpdate({inst}). That works because the\n  // new object always fails an equality check.\n\n\n  const [{\n    inst\n  }, forceUpdate] = useState({\n    inst: {\n      value,\n      getSnapshot\n    }\n  }); // Track the latest getSnapshot function with a ref. This needs to be updated\n  // in the layout phase so we can access it during the tearing check that\n  // happens on subscribe.\n\n  useLayoutEffect(() => {\n    inst.value = value;\n    inst.getSnapshot = getSnapshot; // Whenever getSnapshot or subscribe changes, we need to check in the\n    // commit phase if there was an interleaved mutation. In concurrent mode\n    // this can happen all the time, but even in synchronous mode, an earlier\n    // effect may have mutated the store.\n\n    if (checkIfSnapshotChanged(inst)) {\n      // Force a re-render.\n      forceUpdate({\n        inst\n      });\n    } // eslint-disable-next-line react-hooks/exhaustive-deps\n\n  }, [subscribe, value, getSnapshot]);\n  useEffect(() => {\n    // Check for changes right before subscribing. Subsequent changes will be\n    // detected in the subscription handler.\n    if (checkIfSnapshotChanged(inst)) {\n      // Force a re-render.\n      forceUpdate({\n        inst\n      });\n    }\n\n    const handleStoreChange = () => {\n      // TODO: Because there is no cross-renderer API for batching updates, it's\n      // up to the consumer of this library to wrap their subscription event\n      // with unstable_batchedUpdates. Should we try to detect when this isn't\n      // the case and print a warning in development?\n      // The store changed. Check if the snapshot changed since the last time we\n      // read from the store.\n      if (checkIfSnapshotChanged(inst)) {\n        // Force a re-render.\n        forceUpdate({\n          inst\n        });\n      }\n    }; // Subscribe to the store and return a clean-up function.\n\n\n    return subscribe(handleStoreChange); // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [subscribe]);\n  useDebugValue(value);\n  return value;\n}\n\nfunction checkIfSnapshotChanged(inst) {\n  const latestGetSnapshot = inst.getSnapshot;\n  const prevValue = inst.value;\n\n  try {\n    const nextValue = latestGetSnapshot();\n    return !is(prevValue, nextValue);\n  } catch (error) {\n    return true;\n  }\n}\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n */\nfunction useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {\n  // Note: The shim does not use getServerSnapshot, because pre-18 versions of\n  // React do not expose a way to check if we're hydrating. So users of the shim\n  // will need to track that themselves and return the correct value\n  // from `getSnapshot`.\n  return getSnapshot();\n}\n\n/**\n * Inlined into the react-router repo since use-sync-external-store does not\n * provide a UMD-compatible package, so we need this to be able to distribute\n * UMD react-router bundles\n */\nconst canUseDOM = !!(typeof window !== \"undefined\" && typeof window.document !== \"undefined\" && typeof window.document.createElement !== \"undefined\");\nconst isServerEnvironment = !canUseDOM;\nconst shim = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore$2;\nconst useSyncExternalStore = \"useSyncExternalStore\" in React ? (module => module.useSyncExternalStore)(React) : shim;\n\n// Contexts for data routers\nconst DataStaticRouterContext = /*#__PURE__*/React.createContext(null);\n\nif (process.env.NODE_ENV !== \"production\") {\n  DataStaticRouterContext.displayName = \"DataStaticRouterContext\";\n}\n\nconst DataRouterContext = /*#__PURE__*/React.createContext(null);\n\nif (process.env.NODE_ENV !== \"production\") {\n  DataRouterContext.displayName = \"DataRouter\";\n}\n\nconst DataRouterStateContext = /*#__PURE__*/React.createContext(null);\n\nif (process.env.NODE_ENV !== \"production\") {\n  DataRouterStateContext.displayName = \"DataRouterState\";\n}\n\nconst AwaitContext = /*#__PURE__*/React.createContext(null);\n\nif (process.env.NODE_ENV !== \"production\") {\n  AwaitContext.displayName = \"Await\";\n}\n\nconst NavigationContext = /*#__PURE__*/React.createContext(null);\n\nif (process.env.NODE_ENV !== \"production\") {\n  NavigationContext.displayName = \"Navigation\";\n}\n\nconst LocationContext = /*#__PURE__*/React.createContext(null);\n\nif (process.env.NODE_ENV !== \"production\") {\n  LocationContext.displayName = \"Location\";\n}\n\nconst RouteContext = /*#__PURE__*/React.createContext({\n  outlet: null,\n  matches: []\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  RouteContext.displayName = \"Route\";\n}\n\nconst RouteErrorContext = /*#__PURE__*/React.createContext(null);\n\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/docs/en/v6/hooks/use-href\n */\n\nfunction useHref(to, _temp) {\n  let {\n    relative\n  } = _temp === void 0 ? {} : _temp;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : 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; // 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\n  if (basename !== \"/\") {\n    joinedPathname = pathname === \"/\" ? basename : joinPaths([basename, pathname]);\n  }\n\n  return navigator.createHref({\n    pathname: joinedPathname,\n    search,\n    hash\n  });\n}\n/**\n * Returns true if this component is a descendant of a <Router>.\n *\n * @see https://reactrouter.com/docs/en/v6/hooks/use-in-router-context\n */\n\nfunction useInRouterContext() {\n  return React.useContext(LocationContext) != null;\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/docs/en/v6/hooks/use-location\n */\n\nfunction useLocation() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : invariant(false) : void 0;\n  return React.useContext(LocationContext).location;\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/docs/en/v6/hooks/use-navigation-type\n */\n\nfunction useNavigationType() {\n  return React.useContext(LocationContext).navigationType;\n}\n/**\n * Returns true if the URL for the given \"to\" value 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/docs/en/v6/hooks/use-match\n */\n\nfunction useMatch(pattern) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : invariant(false) : void 0;\n  let {\n    pathname\n  } = useLocation();\n  return React.useMemo(() => matchPath(pattern, pathname), [pathname, pattern]);\n}\n/**\n * The interface for the navigate() function returned from useNavigate().\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/docs/en/v6/hooks/use-navigate\n */\nfunction useNavigate() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : invariant(false) : void 0;\n  let {\n    basename,\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_getPathContributingMatches(matches).map(match => match.pathnameBase));\n  let activeRef = React.useRef(false);\n  React.useEffect(() => {\n    activeRef.current = true;\n  });\n  let navigate = React.useCallback(function (to, options) {\n    if (options === void 0) {\n      options = {};\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(activeRef.current, \"You should call navigate() in a React.useEffect(), not when \" + \"your component is first rendered.\") : void 0;\n    if (!activeRef.current) return;\n\n    if (typeof to === \"number\") {\n      navigator.go(to);\n      return;\n    }\n\n    let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, options.relative === \"path\"); // If we're operating within a basename, prepend it to the pathname prior\n    // to handing off to history.  If this is a root navigation, then we\n    // navigate to the raw basename which allows the basename to have full\n    // control over the presence of a trailing slash on root links\n\n    if (basename !== \"/\") {\n      path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n    }\n\n    (!!options.replace ? navigator.replace : navigator.push)(path, options.state, options);\n  }, [basename, navigator, routePathnamesJson, locationPathname]);\n  return navigate;\n}\nconst OutletContext = /*#__PURE__*/React.createContext(null);\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/docs/en/v6/hooks/use-outlet-context\n */\n\nfunction useOutletContext() {\n  return React.useContext(OutletContext);\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/docs/en/v6/hooks/use-outlet\n */\n\nfunction useOutlet(context) {\n  let outlet = React.useContext(RouteContext).outlet;\n\n  if (outlet) {\n    return /*#__PURE__*/React.createElement(OutletContext.Provider, {\n      value: context\n    }, outlet);\n  }\n\n  return outlet;\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/docs/en/v6/hooks/use-params\n */\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 * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/docs/en/v6/hooks/use-resolved-path\n */\n\nfunction useResolvedPath(to, _temp2) {\n  let {\n    relative\n  } = _temp2 === void 0 ? {} : _temp2;\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let routePathnamesJson = JSON.stringify(UNSAFE_getPathContributingMatches(matches).map(match => match.pathnameBase));\n  return React.useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, relative === \"path\"), [to, routePathnamesJson, locationPathname, relative]);\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/docs/en/v6/hooks/use-routes\n */\n\nfunction useRoutes(routes, locationArg) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : invariant(false) : void 0;\n  let dataRouterStateContext = React.useContext(DataRouterStateContext);\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\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\n  let locationFromContext = useLocation();\n  let location;\n\n  if (locationArg) {\n    var _parsedLocationArg$pa;\n\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\" ? 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.\")) : invariant(false) : void 0;\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\n\n  let pathname = location.pathname || \"/\";\n  let remainingPathname = parentPathnameBase === \"/\" ? pathname : pathname.slice(parentPathnameBase.length) || \"/\";\n  let matches = matchRoutes(routes, {\n    pathname: remainingPathname\n  });\n\n  if (process.env.NODE_ENV !== \"production\") {\n    process.env.NODE_ENV !== \"production\" ? warning(parentRoute || matches != null, \"No routes matched location \\\"\" + location.pathname + location.search + location.hash + \"\\\" \") : void 0;\n    process.env.NODE_ENV !== \"production\" ? warning(matches == null || matches[matches.length - 1].route.element !== undefined, \"Matched leaf route at location \\\"\" + location.pathname + location.search + location.hash + \"\\\" does not have an element. \" + \"This means it will render an <Outlet /> with a null value by default resulting in an \\\"empty\\\" page.\") : void 0;\n  }\n\n  let renderedMatches = _renderMatches(matches && matches.map(match => Object.assign({}, match, {\n    params: Object.assign({}, parentParams, match.params),\n    pathname: joinPaths([parentPathnameBase, match.pathname]),\n    pathnameBase: match.pathnameBase === \"/\" ? parentPathnameBase : joinPaths([parentPathnameBase, match.pathnameBase])\n  })), parentMatches, dataRouterStateContext || undefined); // 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\n\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\n  return renderedMatches;\n}\n\nfunction DefaultErrorElement() {\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  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"h2\", null, \"Unhandled Thrown Error!\"), /*#__PURE__*/React.createElement(\"h3\", {\n    style: {\n      fontStyle: \"italic\"\n    }\n  }, message), stack ? /*#__PURE__*/React.createElement(\"pre\", {\n    style: preStyles\n  }, stack) : 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\\xA0\", /*#__PURE__*/React.createElement(\"code\", {\n    style: codeStyles\n  }, \"errorElement\"), \" props on\\xA0\", /*#__PURE__*/React.createElement(\"code\", {\n    style: codeStyles\n  }, \"<Route>\")));\n}\n\nclass RenderErrorBoundary extends React.Component {\n  constructor(props) {\n    super(props);\n    this.state = {\n      location: props.location,\n      error: props.error\n    };\n  }\n\n  static getDerivedStateFromError(error) {\n    return {\n      error: error\n    };\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) {\n      return {\n        error: props.error,\n        location: props.location\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\n\n    return {\n      error: props.error || state.error,\n      location: state.location\n    };\n  }\n\n  componentDidCatch(error, errorInfo) {\n    console.error(\"React Router caught the following error during render\", error, errorInfo);\n  }\n\n  render() {\n    return this.state.error ? /*#__PURE__*/React.createElement(RouteErrorContext.Provider, {\n      value: this.state.error,\n      children: this.props.component\n    }) : this.props.children;\n  }\n\n}\n\nfunction RenderedRoute(_ref) {\n  let {\n    routeContext,\n    match,\n    children\n  } = _ref;\n  let dataStaticRouterContext = React.useContext(DataStaticRouterContext); // Track how deep we got in our render pass to emulate SSR componentDidCatch\n  // in a DataStaticRouter\n\n  if (dataStaticRouterContext && match.route.errorElement) {\n    dataStaticRouterContext._deepestRenderedBoundaryId = match.route.id;\n  }\n\n  return /*#__PURE__*/React.createElement(RouteContext.Provider, {\n    value: routeContext\n  }, children);\n}\n\nfunction _renderMatches(matches, parentMatches, dataRouterState) {\n  if (parentMatches === void 0) {\n    parentMatches = [];\n  }\n\n  if (matches == null) {\n    if (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\n  let renderedMatches = matches; // If we have data errors, trim matches to the highest error boundary\n\n  let errors = dataRouterState == null ? void 0 : dataRouterState.errors;\n\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\" ? invariant(false, \"Could not find a matching route for the current errors: \" + errors) : invariant(false) : void 0;\n    renderedMatches = renderedMatches.slice(0, Math.min(renderedMatches.length, errorIndex + 1));\n  }\n\n  return renderedMatches.reduceRight((outlet, match, index) => {\n    let error = match.route.id ? errors == null ? void 0 : errors[match.route.id] : null; // Only data routers handle errors\n\n    let errorElement = dataRouterState ? match.route.errorElement || /*#__PURE__*/React.createElement(DefaultErrorElement, null) : null;\n\n    let getChildren = () => /*#__PURE__*/React.createElement(RenderedRoute, {\n      match: match,\n      routeContext: {\n        outlet,\n        matches: parentMatches.concat(renderedMatches.slice(0, index + 1))\n      }\n    }, error ? errorElement : match.route.element !== undefined ? match.route.element : outlet); // Only wrap in an error boundary within data router usages when we have an\n    // errorElement on this route.  Otherwise let it bubble up to an ancestor\n    // errorElement\n\n\n    return dataRouterState && (match.route.errorElement || index === 0) ? /*#__PURE__*/React.createElement(RenderErrorBoundary, {\n      location: dataRouterState.location,\n      component: errorElement,\n      error: error,\n      children: getChildren()\n    }) : getChildren();\n  }, null);\n}\nvar DataRouterHook;\n\n(function (DataRouterHook) {\n  DataRouterHook[\"UseRevalidator\"] = \"useRevalidator\";\n})(DataRouterHook || (DataRouterHook = {}));\n\nvar DataRouterStateHook;\n\n(function (DataRouterStateHook) {\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 || (DataRouterStateHook = {}));\n\nfunction getDataRouterConsoleError(hookName) {\n  return hookName + \" must be used within a data router.  See https://reactrouter.com/en/main/routers/picking-a-router.\";\n}\n\nfunction useDataRouterContext(hookName) {\n  let ctx = React.useContext(DataRouterContext);\n  !ctx ? process.env.NODE_ENV !== \"production\" ? invariant(false, getDataRouterConsoleError(hookName)) : invariant(false) : void 0;\n  return ctx;\n}\n\nfunction useDataRouterState(hookName) {\n  let state = React.useContext(DataRouterStateContext);\n  !state ? process.env.NODE_ENV !== \"production\" ? invariant(false, getDataRouterConsoleError(hookName)) : invariant(false) : void 0;\n  return state;\n}\n/**\n * Returns the current navigation, defaulting to an \"idle\" navigation when\n * no navigation is in progress\n */\n\n\nfunction useNavigation() {\n  let state = useDataRouterState(DataRouterStateHook.UseNavigation);\n  return state.navigation;\n}\n/**\n * Returns a revalidate function for manually triggering revalidation, as well\n * as the current state of any manual revalidations\n */\n\nfunction useRevalidator() {\n  let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);\n  let state = useDataRouterState(DataRouterStateHook.UseRevalidator);\n  return {\n    revalidate: dataRouterContext.router.revalidate,\n    state: 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 */\n\nfunction useMatches() {\n  let {\n    matches,\n    loaderData\n  } = useDataRouterState(DataRouterStateHook.UseMatches);\n  return React.useMemo(() => matches.map(match => {\n    let {\n      pathname,\n      params\n    } = match; // Note: This structure matches that created by createUseMatchesMatch\n    // in the @remix-run/router , so if you change this please also change\n    // that :)  Eventually we'll DRY this up\n\n    return {\n      id: match.route.id,\n      pathname,\n      params,\n      data: loaderData[match.route.id],\n      handle: match.route.handle\n    };\n  }), [matches, loaderData]);\n}\n/**\n * Returns the loader data for the nearest ancestor Route loader\n */\n\nfunction useLoaderData() {\n  let state = useDataRouterState(DataRouterStateHook.UseLoaderData);\n  let route = React.useContext(RouteContext);\n  !route ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"useLoaderData must be used inside a RouteContext\") : invariant(false) : void 0;\n  let thisRoute = route.matches[route.matches.length - 1];\n  !thisRoute.route.id ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"useLoaderData can only be used on routes that contain a unique \\\"id\\\"\") : invariant(false) : void 0;\n  return state.loaderData[thisRoute.route.id];\n}\n/**\n * Returns the loaderData for the given routeId\n */\n\nfunction useRouteLoaderData(routeId) {\n  let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);\n  return state.loaderData[routeId];\n}\n/**\n * Returns the action data for the nearest ancestor Route action\n */\n\nfunction useActionData() {\n  let state = useDataRouterState(DataRouterStateHook.UseActionData);\n  let route = React.useContext(RouteContext);\n  !route ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"useActionData must be used inside a RouteContext\") : invariant(false) : void 0;\n  return Object.values((state == null ? void 0 : state.actionData) || {})[0];\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 * errorElement to display a proper error message.\n */\n\nfunction useRouteError() {\n  var _state$errors;\n\n  let error = React.useContext(RouteErrorContext);\n  let state = useDataRouterState(DataRouterStateHook.UseRouteError);\n  let route = React.useContext(RouteContext);\n  let thisRoute = route.matches[route.matches.length - 1]; // If this was a render error, we put it in a RouteError context inside\n  // of RenderErrorBoundary\n\n  if (error) {\n    return error;\n  }\n\n  !route ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"useRouteError must be used inside a RouteContext\") : invariant(false) : void 0;\n  !thisRoute.route.id ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"useRouteError can only be used on routes that contain a unique \\\"id\\\"\") : invariant(false) : void 0; // Otherwise look for errors from our data router state\n\n  return (_state$errors = state.errors) == null ? void 0 : _state$errors[thisRoute.route.id];\n}\n/**\n * Returns the happy-path data from the nearest ancestor <Await /> value\n */\n\nfunction useAsyncValue() {\n  let value = React.useContext(AwaitContext);\n  return value == null ? void 0 : value._data;\n}\n/**\n * Returns the error from the nearest ancestor <Await /> value\n */\n\nfunction useAsyncError() {\n  let value = React.useContext(AwaitContext);\n  return value == null ? void 0 : value._error;\n}\nconst alreadyWarned = {};\n\nfunction warningOnce(key, cond, message) {\n  if (!cond && !alreadyWarned[key]) {\n    alreadyWarned[key] = true;\n    process.env.NODE_ENV !== \"production\" ? warning(false, message) : void 0;\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  } = _ref;\n  // Sync router state to our component state to force re-renders\n  let state = useSyncExternalStore(router.subscribe, () => router.state, // We have to provide this so React@18 doesn't complain during hydration,\n  // but we pass our serialized hydration data into the router so state here\n  // is already synced with what the server saw\n  () => router.state);\n  let navigator = React.useMemo(() => {\n    return {\n      createHref: router.createHref,\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  return /*#__PURE__*/React.createElement(DataRouterContext.Provider, {\n    value: {\n      router,\n      navigator,\n      static: false,\n      // Do we need this?\n      basename\n    }\n  }, /*#__PURE__*/React.createElement(DataRouterStateContext.Provider, {\n    value: state\n  }, /*#__PURE__*/React.createElement(Router, {\n    basename: router.basename,\n    location: router.state.location,\n    navigationType: router.state.historyAction,\n    navigator: navigator\n  }, router.state.initialized ? /*#__PURE__*/React.createElement(Routes, null) : fallbackElement)));\n}\n\n/**\n * A <Router> that stores all entries in memory.\n *\n * @see https://reactrouter.com/docs/en/v6/routers/memory-router\n */\nfunction MemoryRouter(_ref2) {\n  let {\n    basename,\n    children,\n    initialEntries,\n    initialIndex\n  } = _ref2;\n  let historyRef = React.useRef();\n\n  if (historyRef.current == null) {\n    historyRef.current = createMemoryHistory({\n      initialEntries,\n      initialIndex,\n      v5Compat: true\n    });\n  }\n\n  let history = historyRef.current;\n  let [state, setState] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  React.useLayoutEffect(() => history.listen(setState), [history]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history\n  });\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/docs/en/v6/components/navigate\n */\nfunction Navigate(_ref3) {\n  let {\n    to,\n    replace,\n    state,\n    relative\n  } = _ref3;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : invariant(false) : void 0;\n  process.env.NODE_ENV !== \"production\" ? warning(!React.useContext(NavigationContext).static, \"<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 dataRouterState = React.useContext(DataRouterStateContext);\n  let navigate = useNavigate();\n  React.useEffect(() => {\n    // Avoid kicking off multiple navigations if we're in the middle of a\n    // data-router navigation, since components get re-rendered when we enter\n    // a submitting/loading state\n    if (dataRouterState && dataRouterState.navigation.state !== \"idle\") {\n      return;\n    }\n\n    navigate(to, {\n      replace,\n      state,\n      relative\n    });\n  });\n  return null;\n}\n\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/docs/en/v6/components/outlet\n */\nfunction Outlet(props) {\n  return useOutlet(props.context);\n}\n\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/docs/en/v6/components/route\n */\nfunction Route(_props) {\n  process.env.NODE_ENV !== \"production\" ? 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>.\") : invariant(false) ;\n}\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/docs/en/v6/routers/router\n */\nfunction Router(_ref4) {\n  let {\n    basename: basenameProp = \"/\",\n    children = null,\n    location: locationProp,\n    navigationType = Action.Pop,\n    navigator,\n    static: staticProp = false\n  } = _ref4;\n  !!useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You cannot render a <Router> inside another <Router>.\" + \" You should never have more than one in your app.\") : invariant(false) : void 0; // Preserve trailing slashes on basename, so we can let the user control\n  // the enforcement of trailing slashes throughout the app\n\n  let basename = basenameProp.replace(/^\\/*/, \"/\");\n  let navigationContext = React.useMemo(() => ({\n    basename,\n    navigator,\n    static: staticProp\n  }), [basename, navigator, staticProp]);\n\n  if (typeof locationProp === \"string\") {\n    locationProp = parsePath(locationProp);\n  }\n\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\",\n    state = null,\n    key = \"default\"\n  } = locationProp;\n  let location = React.useMemo(() => {\n    let trailingPathname = stripBasename(pathname, basename);\n\n    if (trailingPathname == null) {\n      return null;\n    }\n\n    return {\n      pathname: trailingPathname,\n      search,\n      hash,\n      state,\n      key\n    };\n  }, [basename, pathname, search, hash, state, key]);\n  process.env.NODE_ENV !== \"production\" ? warning(location != 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\n  if (location == null) {\n    return null;\n  }\n\n  return /*#__PURE__*/React.createElement(NavigationContext.Provider, {\n    value: navigationContext\n  }, /*#__PURE__*/React.createElement(LocationContext.Provider, {\n    children: children,\n    value: {\n      location,\n      navigationType\n    }\n  }));\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/docs/en/v6/components/routes\n */\nfunction Routes(_ref5) {\n  let {\n    children,\n    location\n  } = _ref5;\n  let dataRouterContext = React.useContext(DataRouterContext); // When in a DataRouterContext _without_ children, we use the router routes\n  // directly.  If we have children, then we're in a descendant tree and we\n  // need to use child routes.\n\n  let routes = dataRouterContext && !children ? dataRouterContext.router.routes : createRoutesFromChildren(children);\n  return useRoutes(routes, location);\n}\n\n/**\n * Component to use for rendering lazily loaded data from returning defer()\n * in a loader function\n */\nfunction Await(_ref6) {\n  let {\n    children,\n    errorElement,\n    resolve\n  } = _ref6;\n  return /*#__PURE__*/React.createElement(AwaitErrorBoundary, {\n    resolve: resolve,\n    errorElement: errorElement\n  }, /*#__PURE__*/React.createElement(ResolveAwait, null, children));\n}\nvar AwaitRenderStatus;\n\n(function (AwaitRenderStatus) {\n  AwaitRenderStatus[AwaitRenderStatus[\"pending\"] = 0] = \"pending\";\n  AwaitRenderStatus[AwaitRenderStatus[\"success\"] = 1] = \"success\";\n  AwaitRenderStatus[AwaitRenderStatus[\"error\"] = 2] = \"error\";\n})(AwaitRenderStatus || (AwaitRenderStatus = {}));\n\nconst neverSettledPromise = new Promise(() => {});\n\nclass AwaitErrorBoundary extends React.Component {\n  constructor(props) {\n    super(props);\n    this.state = {\n      error: null\n    };\n  }\n\n  static getDerivedStateFromError(error) {\n    return {\n      error\n    };\n  }\n\n  componentDidCatch(error, errorInfo) {\n    console.error(\"<Await> caught the following error during render\", error, errorInfo);\n  }\n\n  render() {\n    let {\n      children,\n      errorElement,\n      resolve\n    } = this.props;\n    let promise = null;\n    let status = AwaitRenderStatus.pending;\n\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\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\n    if (status === AwaitRenderStatus.error && promise._error instanceof AbortedDeferredError) {\n      // Freeze the UI by throwing a never resolved promise\n      throw neverSettledPromise;\n    }\n\n    if (status === AwaitRenderStatus.error && !errorElement) {\n      // No errorElement, throw to the nearest route-level error boundary\n      throw promise._error;\n    }\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\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    } // Throw to the suspense boundary\n\n\n    throw promise;\n  }\n\n}\n/**\n * @private\n * Indirection to leverage useAsyncValue for a render-prop API on <Await>\n */\n\n\nfunction ResolveAwait(_ref7) {\n  let {\n    children\n  } = _ref7;\n  let data = useAsyncValue();\n\n  if (typeof children === \"function\") {\n    return children(data);\n  }\n\n  return /*#__PURE__*/React.createElement(React.Fragment, null, children);\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/docs/en/v6/utils/create-routes-from-children\n */\n\n\nfunction createRoutesFromChildren(children, parentPath) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\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\n    if (element.type === React.Fragment) {\n      // Transparently support React.Fragment and its children.\n      routes.push.apply(routes, createRoutesFromChildren(element.props.children, parentPath));\n      return;\n    }\n\n    !(element.type === Route) ? process.env.NODE_ENV !== \"production\" ? 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>\") : invariant(false) : void 0;\n    !(!element.props.index || !element.props.children) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"An index route cannot have child routes.\") : invariant(false) : void 0;\n    let treePath = [...parentPath, index];\n    let route = {\n      id: element.props.id || treePath.join(\"-\"),\n      caseSensitive: element.props.caseSensitive,\n      element: element.props.element,\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      hasErrorBoundary: element.props.errorElement != null,\n      shouldRevalidate: element.props.shouldRevalidate,\n      handle: element.props.handle\n    };\n\n    if (element.props.children) {\n      route.children = createRoutesFromChildren(element.props.children, treePath);\n    }\n\n    routes.push(route);\n  });\n  return routes;\n}\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\n\nfunction renderMatches(matches) {\n  return _renderMatches(matches);\n}\n/**\n * @private\n * Walk the route tree and add hasErrorBoundary if it's not provided, so that\n * users providing manual route arrays can just specify errorElement\n */\n\nfunction enhanceManualRouteObjects(routes) {\n  return routes.map(route => {\n    let routeClone = _extends({}, route);\n\n    if (routeClone.hasErrorBoundary == null) {\n      routeClone.hasErrorBoundary = routeClone.errorElement != null;\n    }\n\n    if (routeClone.children) {\n      routeClone.children = enhanceManualRouteObjects(routeClone.children);\n    }\n\n    return routeClone;\n  });\n}\n\nfunction createMemoryRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\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: enhanceManualRouteObjects(routes)\n  }).initialize();\n} ///////////////////////////////////////////////////////////////////////////////\n\nexport { Await, MemoryRouter, Navigate, Outlet, Route, Router, RouterProvider, Routes, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, DataStaticRouterContext as UNSAFE_DataStaticRouterContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RouteContext as UNSAFE_RouteContext, enhanceManualRouteObjects as UNSAFE_enhanceManualRouteObjects, createMemoryRouter, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, renderMatches, useActionData, useAsyncError, useAsyncValue, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };\n//# sourceMappingURL=index.js.map\n","/**\n * @license React\n * react.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var l=Symbol.for(\"react.element\"),n=Symbol.for(\"react.portal\"),p=Symbol.for(\"react.fragment\"),q=Symbol.for(\"react.strict_mode\"),r=Symbol.for(\"react.profiler\"),t=Symbol.for(\"react.provider\"),u=Symbol.for(\"react.context\"),v=Symbol.for(\"react.forward_ref\"),w=Symbol.for(\"react.suspense\"),x=Symbol.for(\"react.memo\"),y=Symbol.for(\"react.lazy\"),z=Symbol.iterator;function A(a){if(null===a||\"object\"!==typeof a)return null;a=z&&a[z]||a[\"@@iterator\"];return\"function\"===typeof a?a:null}\nvar B={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},C=Object.assign,D={};function E(a,b,e){this.props=a;this.context=b;this.refs=D;this.updater=e||B}E.prototype.isReactComponent={};\nE.prototype.setState=function(a,b){if(\"object\"!==typeof a&&\"function\"!==typeof a&&null!=a)throw Error(\"setState(...): takes an object of state variables to update or a function which returns an object of state variables.\");this.updater.enqueueSetState(this,a,b,\"setState\")};E.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,\"forceUpdate\")};function F(){}F.prototype=E.prototype;function G(a,b,e){this.props=a;this.context=b;this.refs=D;this.updater=e||B}var H=G.prototype=new F;\nH.constructor=G;C(H,E.prototype);H.isPureReactComponent=!0;var I=Array.isArray,J=Object.prototype.hasOwnProperty,K={current:null},L={key:!0,ref:!0,__self:!0,__source:!0};\nfunction M(a,b,e){var d,c={},k=null,h=null;if(null!=b)for(d in void 0!==b.ref&&(h=b.ref),void 0!==b.key&&(k=\"\"+b.key),b)J.call(b,d)&&!L.hasOwnProperty(d)&&(c[d]=b[d]);var g=arguments.length-2;if(1===g)c.children=e;else if(1<g){for(var f=Array(g),m=0;m<g;m++)f[m]=arguments[m+2];c.children=f}if(a&&a.defaultProps)for(d in g=a.defaultProps,g)void 0===c[d]&&(c[d]=g[d]);return{$$typeof:l,type:a,key:k,ref:h,props:c,_owner:K.current}}\nfunction N(a,b){return{$$typeof:l,type:a.type,key:b,ref:a.ref,props:a.props,_owner:a._owner}}function O(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===l}function escape(a){var b={\"=\":\"=0\",\":\":\"=2\"};return\"$\"+a.replace(/[=:]/g,function(a){return b[a]})}var P=/\\/+/g;function Q(a,b){return\"object\"===typeof a&&null!==a&&null!=a.key?escape(\"\"+a.key):b.toString(36)}\nfunction R(a,b,e,d,c){var k=typeof a;if(\"undefined\"===k||\"boolean\"===k)a=null;var h=!1;if(null===a)h=!0;else switch(k){case \"string\":case \"number\":h=!0;break;case \"object\":switch(a.$$typeof){case l:case n:h=!0}}if(h)return h=a,c=c(h),a=\"\"===d?\".\"+Q(h,0):d,I(c)?(e=\"\",null!=a&&(e=a.replace(P,\"$&/\")+\"/\"),R(c,b,e,\"\",function(a){return a})):null!=c&&(O(c)&&(c=N(c,e+(!c.key||h&&h.key===c.key?\"\":(\"\"+c.key).replace(P,\"$&/\")+\"/\")+a)),b.push(c)),1;h=0;d=\"\"===d?\".\":d+\":\";if(I(a))for(var g=0;g<a.length;g++){k=\na[g];var f=d+Q(k,g);h+=R(k,b,e,f,c)}else if(f=A(a),\"function\"===typeof f)for(a=f.call(a),g=0;!(k=a.next()).done;)k=k.value,f=d+Q(k,g++),h+=R(k,b,e,f,c);else if(\"object\"===k)throw b=String(a),Error(\"Objects are not valid as a React child (found: \"+(\"[object Object]\"===b?\"object with keys {\"+Object.keys(a).join(\", \")+\"}\":b)+\"). If you meant to render a collection of children, use an array instead.\");return h}\nfunction S(a,b,e){if(null==a)return a;var d=[],c=0;R(a,d,\"\",\"\",function(a){return b.call(e,a,c++)});return d}function T(a){if(-1===a._status){var b=a._result;b=b();b.then(function(b){if(0===a._status||-1===a._status)a._status=1,a._result=b},function(b){if(0===a._status||-1===a._status)a._status=2,a._result=b});-1===a._status&&(a._status=0,a._result=b)}if(1===a._status)return a._result.default;throw a._result;}\nvar U={current:null},V={transition:null},W={ReactCurrentDispatcher:U,ReactCurrentBatchConfig:V,ReactCurrentOwner:K};exports.Children={map:S,forEach:function(a,b,e){S(a,function(){b.apply(this,arguments)},e)},count:function(a){var b=0;S(a,function(){b++});return b},toArray:function(a){return S(a,function(a){return a})||[]},only:function(a){if(!O(a))throw Error(\"React.Children.only expected to receive a single React element child.\");return a}};exports.Component=E;exports.Fragment=p;\nexports.Profiler=r;exports.PureComponent=G;exports.StrictMode=q;exports.Suspense=w;exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=W;\nexports.cloneElement=function(a,b,e){if(null===a||void 0===a)throw Error(\"React.cloneElement(...): The argument must be a React element, but you passed \"+a+\".\");var d=C({},a.props),c=a.key,k=a.ref,h=a._owner;if(null!=b){void 0!==b.ref&&(k=b.ref,h=K.current);void 0!==b.key&&(c=\"\"+b.key);if(a.type&&a.type.defaultProps)var g=a.type.defaultProps;for(f in b)J.call(b,f)&&!L.hasOwnProperty(f)&&(d[f]=void 0===b[f]&&void 0!==g?g[f]:b[f])}var f=arguments.length-2;if(1===f)d.children=e;else if(1<f){g=Array(f);\nfor(var m=0;m<f;m++)g[m]=arguments[m+2];d.children=g}return{$$typeof:l,type:a.type,key:c,ref:k,props:d,_owner:h}};exports.createContext=function(a){a={$$typeof:u,_currentValue:a,_currentValue2:a,_threadCount:0,Provider:null,Consumer:null,_defaultValue:null,_globalName:null};a.Provider={$$typeof:t,_context:a};return a.Consumer=a};exports.createElement=M;exports.createFactory=function(a){var b=M.bind(null,a);b.type=a;return b};exports.createRef=function(){return{current:null}};\nexports.forwardRef=function(a){return{$$typeof:v,render:a}};exports.isValidElement=O;exports.lazy=function(a){return{$$typeof:y,_payload:{_status:-1,_result:a},_init:T}};exports.memo=function(a,b){return{$$typeof:x,type:a,compare:void 0===b?null:b}};exports.startTransition=function(a){var b=V.transition;V.transition={};try{a()}finally{V.transition=b}};exports.unstable_act=function(){throw Error(\"act(...) is not supported in production builds of React.\");};\nexports.useCallback=function(a,b){return U.current.useCallback(a,b)};exports.useContext=function(a){return U.current.useContext(a)};exports.useDebugValue=function(){};exports.useDeferredValue=function(a){return U.current.useDeferredValue(a)};exports.useEffect=function(a,b){return U.current.useEffect(a,b)};exports.useId=function(){return U.current.useId()};exports.useImperativeHandle=function(a,b,e){return U.current.useImperativeHandle(a,b,e)};\nexports.useInsertionEffect=function(a,b){return U.current.useInsertionEffect(a,b)};exports.useLayoutEffect=function(a,b){return U.current.useLayoutEffect(a,b)};exports.useMemo=function(a,b){return U.current.useMemo(a,b)};exports.useReducer=function(a,b,e){return U.current.useReducer(a,b,e)};exports.useRef=function(a){return U.current.useRef(a)};exports.useState=function(a){return U.current.useState(a)};exports.useSyncExternalStore=function(a,b,e){return U.current.useSyncExternalStore(a,b,e)};\nexports.useTransition=function(){return U.current.useTransition()};exports.version=\"18.2.0\";\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react.production.min.js');\n} else {\n  module.exports = require('./cjs/react.development.js');\n}\n"],"names":["_extends","Object","assign","bind","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","apply","this","Action","PopStateEventType","createBrowserHistory","options","getUrlBasedHistory","window","globalHistory","pathname","search","hash","location","createLocation","state","usr","to","createPath","getHistoryState","current","parsePath","Math","random","toString","substr","_ref","charAt","path","parsedPath","hashIndex","indexOf","searchIndex","createURL","base","origin","href","URL","getLocation","createHref","validateLocation","document","defaultView","v5Compat","history","action","Pop","listener","handlePop","listen","fn","Error","addEventListener","removeEventListener","encodeLocation","url","push","Push","historyState","pushState","error","replace","Replace","replaceState","go","n","ResultType","matchRoutes","routes","locationArg","basename","stripBasename","branches","flattenRoutes","sort","a","b","score","slice","every","compareIndexes","routesMeta","map","meta","childrenIndex","rankRouteBranches","matches","matchRouteBranch","safelyDecodeURI","parentsMeta","parentPath","forEach","route","index","relativePath","caseSensitive","startsWith","invariant","joinPaths","concat","children","computeScore","paramRe","isSplat","s","segments","split","initialScore","some","filter","reduce","segment","test","branch","matchedParams","matchedPathname","end","remainingPathname","match","matchPath","params","pathnameBase","normalizePathname","pattern","matcher","paramNames","warning","endsWith","regexpSource","_","paramName","RegExp","undefined","compilePath","captureGroups","memo","splatValue","value","decodeURIComponent","safelyDecodeURIComponent","decodeURI","toLowerCase","startIndex","nextChar","message","cond","console","warn","e","getInvalidPathError","char","field","dest","JSON","stringify","getPathContributingMatches","resolveTo","toArg","routePathnames","locationPathname","isPathRelative","includes","from","isEmptyPath","toPathname","routePathnameIndex","toSegments","shift","join","fromPathname","pop","resolvePathname","normalizeSearch","normalizeHash","resolvePath","hasExplicitTrailingSlash","hasCurrentTrailingSlash","paths","AbortedDeferredError","ErrorResponse","constructor","status","statusText","data","isRouteErrorResponse","createElement","validActionMethods","Set","is","x","y","useState","useEffect","useLayoutEffect","useDebugValue","checkIfSnapshotChanged","inst","latestGetSnapshot","getSnapshot","prevValue","nextValue","useSyncExternalStore","DataStaticRouterContext","DataRouterContext","DataRouterStateContext","NavigationContext","LocationContext","RouteContext","outlet","RouteErrorContext","useHref","_temp","relative","useInRouterContext","navigator","useResolvedPath","joinedPathname","useLocation","useNavigate","routePathnamesJson","activeRef","parse","OutletContext","_temp2","DefaultErrorElement","_state$errors","useDataRouterState","DataRouterStateHook","UseRouteError","thisRoute","id","errors","useRouteError","stack","lightgrey","preStyles","padding","backgroundColor","codeStyles","style","fontStyle","RenderErrorBoundary","props","super","static","componentDidCatch","errorInfo","render","Provider","component","RenderedRoute","routeContext","dataStaticRouterContext","errorElement","_deepestRenderedBoundaryId","_renderMatches","parentMatches","dataRouterState","renderedMatches","errorIndex","findIndex","m","min","reduceRight","getChildren","element","DataRouterHook","hookName","Navigate","_ref3","navigate","navigation","Outlet","context","useOutlet","Route","_props","Router","_ref4","basenameProp","locationProp","navigationType","staticProp","navigationContext","trailingPathname","Routes","_ref5","dataRouterContext","dataRouterStateContext","routeMatch","parentParams","parentPathnameBase","locationFromContext","_parsedLocationArg$pa","parsedLocationArg","useRoutes","router","createRoutesFromChildren","AwaitRenderStatus","Promise","AwaitErrorBoundary","resolve","promise","pending","renderError","reject","catch","defineProperty","get","_tracked","_error","_data","success","then","neverSettledPromise","React","AwaitContext","type","treePath","loader","hasErrorBoundary","shouldRevalidate","handle","l","Symbol","for","p","q","r","t","u","v","w","z","iterator","B","isMounted","enqueueForceUpdate","enqueueReplaceState","enqueueSetState","C","D","E","refs","updater","F","G","isReactComponent","setState","forceUpdate","H","isPureReactComponent","I","Array","isArray","J","K","L","ref","__self","__source","M","d","c","k","h","g","f","defaultProps","$$typeof","_owner","O","P","Q","escape","R","N","A","next","done","String","keys","S","T","_status","_result","default","U","V","transition","W","ReactCurrentDispatcher","ReactCurrentBatchConfig","ReactCurrentOwner","exports","Children","count","toArray","only","Component","Fragment","Profiler","PureComponent","StrictMode","Suspense","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","cloneElement","createContext","_currentValue","_currentValue2","_threadCount","Consumer","_defaultValue","_globalName","_context","createFactory","createRef","forwardRef","isValidElement","lazy","_payload","_init","compare","startTransition","unstable_act","useCallback","useContext","useDeferredValue","useId","useImperativeHandle","useInsertionEffect","useMemo","useReducer","useRef","useTransition","version","module"],"sourceRoot":""}