{"version":3,"file":"static/818.4bd1713c31a7f6661d68.js","mappings":"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","sources":["webpack://react-buy-vs-build-calculator/./node_modules/@remix-run/router/dist/router.js","webpack://react-buy-vs-build-calculator/./node_modules/react-router/dist/index.js","webpack://react-buy-vs-build-calculator/./node_modules/react-router-dom/dist/index.js"],"sourcesContent":["/**\n * @remix-run/router v1.4.0\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\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(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in memory history: \" + JSON.stringify(to));\n    return location;\n  }\n\n  function createHref(to) {\n    return typeof to === \"string\" ? to : createPath(to);\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,\n\n    createURL(to) {\n      return new URL(createHref(to), \"http://localhost\");\n    },\n\n    encodeLocation(to) {\n      let path = typeof to === \"string\" ? parsePath(to) : to;\n      return {\n        pathname: path.pathname || \"\",\n        search: path.search || \"\",\n        hash: path.hash || \"\"\n      };\n    },\n\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          delta: 1\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          delta: 0\n        });\n      }\n    },\n\n    go(delta) {\n      action = Action.Pop;\n      let nextIndex = clampIndex(index + delta);\n      let nextLocation = entries[nextIndex];\n      index = nextIndex;\n\n      if (listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta\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(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}\nfunction invariant(value, message) {\n  if (value === false || value === null || typeof value === \"undefined\") {\n    throw new Error(message);\n  }\n}\nfunction warning(cond, message) {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== \"undefined\") console.warn(message);\n\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, index) {\n  return {\n    usr: location.state,\n    key: location.key,\n    idx: index\n  };\n}\n/**\n * Creates a Location object with a unique key from the given Path\n */\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}\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  let index = getIndex(); // Index should only be null when we initialize. If not, it's because the\n  // user called history.pushState or history.replaceState directly, in which\n  // case we should log a warning as it will result in bugs.\n\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState(_extends({}, globalHistory.state, {\n      idx: index\n    }), \"\");\n  }\n\n  function getIndex() {\n    let state = globalHistory.state || {\n      idx: null\n    };\n    return state.idx;\n  }\n\n  function handlePop() {\n    action = Action.Pop;\n    let nextIndex = getIndex();\n    let delta = nextIndex == null ? null : nextIndex - index;\n    index = nextIndex;\n\n    if (listener) {\n      listener({\n        action,\n        location: history.location,\n        delta\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    index = getIndex() + 1;\n    let historyState = getHistoryState(location, index);\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        delta: 1\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    index = getIndex();\n    let historyState = getHistoryState(location, index);\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        delta: 0\n      });\n    }\n  }\n\n  function createURL(to) {\n    // window.location.origin is \"null\" (the literal string value) in Firefox\n    // under certain conditions, notably when serving from a local HTML file\n    // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n    let base = window.location.origin !== \"null\" ? window.location.origin : window.location.href;\n    let href = typeof to === \"string\" ? to : createPath(to);\n    invariant(base, \"No window.location.(origin|href) available to create URL for href: \" + href);\n    return new URL(href, base);\n  }\n\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    createURL,\n\n    encodeLocation(to) {\n      // Encode a Location the same way window.location would\n      let url = createURL(to);\n      return {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash\n      };\n    },\n\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\nconst immutableRouteKeys = new Set([\"lazy\", \"caseSensitive\", \"path\", \"id\", \"index\", \"children\"]);\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, detectErrorBoundary, parentPath, manifest) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\n\n  if (manifest === void 0) {\n    manifest = {};\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(!manifest[id], \"Found a route id collision on id \\\"\" + id + \"\\\".  Route \" + \"id's must be globally unique within Data Router usages\");\n\n    if (isIndexRoute(route)) {\n      let indexRoute = _extends({}, route, {\n        hasErrorBoundary: detectErrorBoundary(route),\n        id\n      });\n\n      manifest[id] = indexRoute;\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute = _extends({}, route, {\n        id,\n        hasErrorBoundary: detectErrorBoundary(route),\n        children: undefined\n      });\n\n      manifest[id] = pathOrLayoutRoute;\n\n      if (route.children) {\n        pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, detectErrorBoundary, treePath, manifest);\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/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  let flattenRoute = (route, index, relativePath) => {\n    let meta = {\n      relativePath: relativePath === undefined ? route.path || \"\" : relativePath,\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route\n    };\n\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\n  routes.forEach((route, index) => {\n    var _route$path;\n\n    // coarse-grain check for optional params\n    if (route.path === \"\" || !((_route$path = route.path) != null && _route$path.includes(\"?\"))) {\n      flattenRoute(route, index);\n    } else {\n      for (let exploded of explodeOptionalSegments(route.path)) {\n        flattenRoute(route, index, exploded);\n      }\n    }\n  });\n  return branches;\n}\n/**\n * Computes all combinations of optional path segments for a given path,\n * excluding combinations that are ambiguous and of lower priority.\n *\n * For example, `/one/:two?/three/:four?/:five?` explodes to:\n * - `/one/three`\n * - `/one/:two/three`\n * - `/one/three/:four`\n * - `/one/three/:five`\n * - `/one/:two/three/:four`\n * - `/one/:two/three/:five`\n * - `/one/three/:four/:five`\n * - `/one/:two/three/:four/:five`\n */\n\n\nfunction explodeOptionalSegments(path) {\n  let segments = path.split(\"/\");\n  if (segments.length === 0) return [];\n  let [first, ...rest] = segments; // Optional path segments are denoted by a trailing `?`\n\n  let isOptional = first.endsWith(\"?\"); // Compute the corresponding required segment: `foo?` -> `foo`\n\n  let required = first.replace(/\\?$/, \"\");\n\n  if (rest.length === 0) {\n    // Intepret empty string as omitting an optional segment\n    // `[\"one\", \"\", \"three\"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`\n    return isOptional ? [required, \"\"] : [required];\n  }\n\n  let restExploded = explodeOptionalSegments(rest.join(\"/\"));\n  let result = []; // All child paths with the prefix.  Do this for all children before the\n  // optional version for all children so we get consistent ordering where the\n  // parent optional aspect is preferred as required.  Otherwise, we can get\n  // child sections interspersed where deeper optional segments are higher than\n  // parent optional segments, where for example, /:two would explodes _earlier_\n  // then /:one.  By always including the parent as required _for all children_\n  // first, we avoid this issue\n\n  result.push(...restExploded.map(subpath => subpath === \"\" ? required : [required, subpath].join(\"/\"))); // Then if this is an optional value, add all child versions without\n\n  if (isOptional) {\n    result.push(...restExploded);\n  } // for absolute paths, ensure `/` instead of empty segment\n\n\n  return result.map(exploded => path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded);\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/utils/generate-path\n */\n\n\nfunction generatePath(originalPath, params) {\n  if (params === void 0) {\n    params = {};\n  }\n\n  let path = originalPath;\n\n  if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n    warning(false, \"Route path \\\"\" + path + \"\\\" will be treated as if it were \" + (\"\\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\" because the `*` character must \") + \"always follow a `/` in the pattern. To get rid of this warning, \" + (\"please change the route path to \\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\".\"));\n    path = path.replace(/\\*$/, \"/*\");\n  } // ensure `/` is added at the beginning if the path is absolute\n\n\n  const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n  const segments = path.split(/\\/+/).map((segment, index, array) => {\n    const isLastSegment = index === array.length - 1; // only apply the splat if it's the last segment\n\n    if (isLastSegment && segment === \"*\") {\n      const star = \"*\";\n      const starParam = params[star]; // Apply the splat\n\n      return starParam;\n    }\n\n    const keyMatch = segment.match(/^:(\\w+)(\\??)$/);\n\n    if (keyMatch) {\n      const [, key, optional] = keyMatch;\n      let param = params[key];\n\n      if (optional === \"?\") {\n        return param == null ? \"\" : param;\n      }\n\n      if (param == null) {\n        invariant(false, \"Missing \\\":\" + key + \"\\\" param\");\n      }\n\n      return param;\n    } // Remove any optional markers from optional static segments\n\n\n    return segment.replace(/\\?$/g, \"\");\n  }) // Remove empty segments\n  .filter(segment => !!segment);\n  return prefix + segments.join(\"/\");\n}\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/utils/match-path\n */\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}\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/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, responseInit) {\n    this.pendingKeysSet = new Set();\n    this.subscribers = new Set();\n    this.deferredKeys = [];\n    invariant(data && typeof data === \"object\" && !Array.isArray(data), \"defer() only accepts plain objects\"); // 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    if (this.done) {\n      // All incoming values were resolved\n      this.unlistenAbortSignal();\n    }\n\n    this.init = responseInit;\n  }\n\n  trackPromise(key, value) {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n\n    this.deferredKeys.push(key);\n    this.pendingKeysSet.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.pendingKeysSet.delete(key);\n\n    if (this.done) {\n      // Nothing left to abort!\n      this.unlistenAbortSignal();\n    }\n\n    if (error) {\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      this.emit(false, key);\n      return Promise.reject(error);\n    }\n\n    Object.defineProperty(promise, \"_data\", {\n      get: () => data\n    });\n    this.emit(false, key);\n    return data;\n  }\n\n  emit(aborted, settledKey) {\n    this.subscribers.forEach(subscriber => subscriber(aborted, settledKey));\n  }\n\n  subscribe(fn) {\n    this.subscribers.add(fn);\n    return () => this.subscribers.delete(fn);\n  }\n\n  cancel() {\n    this.controller.abort();\n    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));\n    this.emit(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.pendingKeysSet.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  get pendingKeys() {\n    return Array.from(this.pendingKeysSet);\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\nconst defer = function defer(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  return new DeferredData(data, responseInit);\n};\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\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, internal) {\n    if (internal === void 0) {\n      internal = false;\n    }\n\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.internal = internal;\n\n    if (data instanceof Error) {\n      this.data = data.toString();\n      this.error = data;\n    } else {\n      this.data = data;\n    }\n  }\n\n}\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\n\nfunction isRouteErrorResponse(error) {\n  return error != null && typeof error.status === \"number\" && typeof error.statusText === \"string\" && typeof error.internal === \"boolean\" && \"data\" in error;\n}\n\nconst validMutationMethodsArr = [\"post\", \"put\", \"patch\", \"delete\"];\nconst validMutationMethods = new Set(validMutationMethodsArr);\nconst validRequestMethodsArr = [\"get\", ...validMutationMethodsArr];\nconst validRequestMethods = new Set(validRequestMethodsArr);\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\nconst IDLE_NAVIGATION = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined\n};\nconst IDLE_FETCHER = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined\n};\nconst IDLE_BLOCKER = {\n  state: \"unblocked\",\n  proceed: undefined,\n  reset: undefined,\n  location: undefined\n};\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\nconst isBrowser = typeof window !== \"undefined\" && typeof window.document !== \"undefined\" && typeof window.document.createElement !== \"undefined\";\nconst isServer = !isBrowser;\n\nconst defaultDetectErrorBoundary = route => Boolean(route.hasErrorBoundary); //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Create a router and listen to history POP navigations\n */\n\n\nfunction createRouter(init) {\n  invariant(init.routes.length > 0, \"You must provide a non-empty routes array to createRouter\");\n  let detectErrorBoundary = init.detectErrorBoundary || defaultDetectErrorBoundary; // Routes keyed by ID\n\n  let manifest = {}; // Routes in tree format for matching\n\n  let dataRoutes = convertRoutesToDataRoutes(init.routes, detectErrorBoundary, undefined, manifest);\n  let inFlightDataRoutes; // 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  // Set to true if we have `hydrationData` since we assume we were SSR'd and that\n  // SSR did the initial scroll restoration.\n\n  let initialScrollRestored = init.hydrationData != null;\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 error = getInternalRouterError(404, {\n      pathname: init.history.location.pathname\n    });\n    let {\n      matches,\n      route\n    } = getShortCircuitMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = {\n      [route.id]: error\n    };\n  }\n\n  let initialized = // All initialMatches need to be loaded before we're ready.  If we have lazy\n  // functions around still then we'll need to run them in initialize()\n  !initialMatches.some(m => m.route.lazy) && ( // And we have to either have no loaders or have been provided hydrationData\n  !initialMatches.some(m => m.route.loader) || init.hydrationData != null);\n  let router;\n  let state = {\n    historyAction: init.history.action,\n    location: init.history.location,\n    matches: initialMatches,\n    initialized,\n    navigation: IDLE_NAVIGATION,\n    // Don't restore on initial updateState() if we were SSR'd\n    restoreScrollPosition: init.hydrationData != null ? false : null,\n    preventScrollReset: false,\n    revalidation: \"idle\",\n    loaderData: init.hydrationData && init.hydrationData.loaderData || {},\n    actionData: init.hydrationData && init.hydrationData.actionData || null,\n    errors: init.hydrationData && init.hydrationData.errors || initialErrors,\n    fetchers: new Map(),\n    blockers: new Map()\n  }; // -- 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(); // Store blocker functions in a separate Map outside of router state since\n  // we don't need to update UI state if they change\n\n  let blockerFunctions = new Map(); // Flag to ignore the next history update, so we can revert the URL change on\n  // a POP navigation that was blocked by the user without touching router state\n\n  let ignoreNextHistoryUpdate = false; // 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        delta\n      } = _ref;\n\n      // Ignore this event if it was just us resetting the URL from a\n      // blocked POP navigation\n      if (ignoreNextHistoryUpdate) {\n        ignoreNextHistoryUpdate = false;\n        return;\n      }\n\n      warning(blockerFunctions.size === 0 || delta != null, \"You are trying to use a blocker on a POP navigation to a location \" + \"that was not created by @remix-run/router. This will fail silently in \" + \"production. This can happen if you are navigating outside the router \" + \"via `window.history.pushState`/`window.location.hash` instead of using \" + \"router navigation APIs.  This can also happen if you are using \" + \"createHashRouter and the user manually changes the URL.\");\n      let blockerKey = shouldBlockNavigation({\n        currentLocation: state.location,\n        nextLocation: location,\n        historyAction\n      });\n\n      if (blockerKey && delta != null) {\n        // Restore the URL to match the current UI, but don't update router state\n        ignoreNextHistoryUpdate = true;\n        init.history.go(delta * -1); // Put the blocker into a blocked state\n\n        updateBlocker(blockerKey, {\n          state: \"blocked\",\n          location,\n\n          proceed() {\n            updateBlocker(blockerKey, {\n              state: \"proceeding\",\n              proceed: undefined,\n              reset: undefined,\n              location\n            }); // Re-do the same POP navigation we just blocked\n\n            init.history.go(delta);\n          },\n\n          reset() {\n            deleteBlocker(blockerKey);\n            updateState({\n              blockers: new Map(router.state.blockers)\n            });\n          }\n\n        });\n        return;\n      }\n\n      return startNavigation(historyAction, location);\n    });\n\n    if (state.initialized) {\n      return router;\n    }\n\n    let lazyMatches = state.matches.filter(m => m.route.lazy);\n\n    if (lazyMatches.length === 0) {\n      // Kick off initial data load if needed.  Use Pop to avoid modifying history\n      startNavigation(Action.Pop, state.location);\n      return router;\n    } // Load lazy modules, then kick off initial data load if needed\n\n\n    let lazyPromises = lazyMatches.map(m => loadLazyRouteModule(m.route, detectErrorBoundary, manifest));\n    Promise.all(lazyPromises).then(() => {\n      let initialized = !state.matches.some(m => m.route.loader) || init.hydrationData != null;\n\n      if (initialized) {\n        // We already have required loaderData so we can just set initialized\n        updateState({\n          initialized: true\n        });\n      } else {\n        // We still need to kick off initial data loads\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    state.blockers.forEach((_, key) => deleteBlocker(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 _location$state, _location$state2;\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 mutation submission\n    // - We're past the submitting state and into the loading state\n    // - The location being loaded is not the result of a redirect\n    let isActionReload = state.actionData != null && state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && state.navigation.state === \"loading\" && ((_location$state = location.state) == null ? void 0 : _location$state._isRedirect) !== true;\n    let actionData;\n\n    if (newState.actionData) {\n      if (Object.keys(newState.actionData).length > 0) {\n        actionData = newState.actionData;\n      } else {\n        // Empty actionData -> clear prior actionData due to an action error\n        actionData = null;\n      }\n    } else if (isActionReload) {\n      // Keep the current data if we're wrapping up the action reload\n      actionData = state.actionData;\n    } else {\n      // Clear actionData on any other completed navigations\n      actionData = null;\n    } // Always preserve any existing loaderData from re-used routes\n\n\n    let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData; // On a successful navigation we can assume we got through all blockers\n    // so we can start fresh\n\n    for (let [key] of blockerFunctions) {\n      deleteBlocker(key);\n    } // Always respect the user flag.  Otherwise don't reset on mutation\n    // submission navigations unless they redirect\n\n\n    let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;\n\n    if (inFlightDataRoutes) {\n      dataRoutes = inFlightDataRoutes;\n      inFlightDataRoutes = undefined;\n    }\n\n    updateState(_extends({}, newState, {\n      actionData,\n      loaderData,\n      historyAction: pendingAction,\n      location,\n      initialized: true,\n      navigation: IDLE_NAVIGATION,\n      revalidation: \"idle\",\n      restoreScrollPosition: getSavedScrollPosition(location, newState.matches || state.matches),\n      preventScrollReset,\n      blockers: new Map(state.blockers)\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 currentLocation = state.location;\n    let nextLocation = 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    nextLocation = _extends({}, nextLocation, init.history.encodeLocation(nextLocation));\n    let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n    let historyAction = Action.Push;\n\n    if (userReplace === true) {\n      historyAction = Action.Replace;\n    } else if (userReplace === false) ; else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) {\n      // By default on submissions to the current location we REPLACE so that\n      // users don't have to double-click the back button to get to the prior\n      // location.  If the user redirects to a different location from the\n      // action/loader this will be ignored and the redirect will be a PUSH\n      historyAction = Action.Replace;\n    }\n\n    let preventScrollReset = opts && \"preventScrollReset\" in opts ? opts.preventScrollReset === true : undefined;\n    let blockerKey = shouldBlockNavigation({\n      currentLocation,\n      nextLocation,\n      historyAction\n    });\n\n    if (blockerKey) {\n      // Put the blocker into a blocked state\n      updateBlocker(blockerKey, {\n        state: \"blocked\",\n        location: nextLocation,\n\n        proceed() {\n          updateBlocker(blockerKey, {\n            state: \"proceeding\",\n            proceed: undefined,\n            reset: undefined,\n            location: nextLocation\n          }); // Send the same navigation through\n\n          navigate(to, opts);\n        },\n\n        reset() {\n          deleteBlocker(blockerKey);\n          updateState({\n            blockers: new Map(state.blockers)\n          });\n        }\n\n      });\n      return;\n    }\n\n    return await startNavigation(historyAction, nextLocation, {\n      submission,\n      // Send through the formData serialization error if we have one so we can\n      // render at the right error boundary after we match routes\n      pendingError: error,\n      preventScrollReset,\n      replace: opts && opts.replace\n    });\n  } // 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 routesToUse = inFlightDataRoutes || dataRoutes;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches = matchRoutes(routesToUse, location, init.basename); // Short circuit with a 404 on the root error boundary if we match nothing\n\n    if (!matches) {\n      let error = getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n      let {\n        matches: notFoundMatches,\n        route\n      } = getShortCircuitMatches(routesToUse); // 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 and not a mutation submission\n    // For example, on /page#hash and submit a <Form method=\"post\"> which will\n    // default to a navigation to /page\n\n\n    if (isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {\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 = createClientSideRequest(init.history, 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 && isMutationMethod(opts.submission.formMethod)) {\n      // Call action if we received an action submission\n      let actionOutput = await handleAction(request, location, opts.submission, matches, {\n        replace: opts.replace\n      });\n\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; // Create a GET request for the loaders\n\n      request = new Request(request.url, {\n        signal: request.signal\n      });\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, _extends({\n      matches\n    }, pendingActionData ? {\n      actionData: pendingActionData\n    } : {}, {\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 && !actionMatch.route.lazy) {\n      result = {\n        type: ResultType.error,\n        error: getInternalRouterError(405, {\n          method: request.method,\n          pathname: location.pathname,\n          routeId: actionMatch.route.id\n        })\n      };\n    } else {\n      result = await callLoaderOrAction(\"action\", request, actionMatch, matches, manifest, detectErrorBoundary, router.basename);\n\n      if (request.signal.aborted) {\n        return {\n          shortCircuited: true\n        };\n      }\n    }\n\n    if (isRedirectResult(result)) {\n      let replace;\n\n      if (opts && opts.replace != null) {\n        replace = opts.replace;\n      } else {\n        // If the user didn't explicity indicate replace behavior, replace if\n        // we redirected to the exact same location we're currently at to avoid\n        // double back-buttons\n        replace = result.location === state.location.pathname + state.location.search;\n      }\n\n      await startRedirectNavigation(state, result, {\n        submission,\n        replace\n      });\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        // Send back an empty object we can use to clear out any prior actionData\n        pendingActionData: {},\n        pendingActionError: {\n          [boundaryMatch.route.id]: result.error\n        }\n      };\n    }\n\n    if (isDeferredResult(result)) {\n      throw getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\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 = _extends({\n        state: \"loading\",\n        location,\n        formMethod: undefined,\n        formAction: undefined,\n        formEncType: undefined,\n        formData: undefined\n      }, submission);\n\n      loadingNavigation = navigation;\n    } // If this was a redirect from an action we don't have a \"submission\" but\n    // we have it on the loading navigation so use that if available\n\n\n    let activeSubmission = submission ? submission : loadingNavigation.formMethod && loadingNavigation.formAction && loadingNavigation.formData && loadingNavigation.formEncType ? {\n      formMethod: loadingNavigation.formMethod,\n      formAction: loadingNavigation.formAction,\n      formData: loadingNavigation.formData,\n      formEncType: loadingNavigation.formEncType\n    } : undefined;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, fetchLoadMatches, routesToUse, init.basename, pendingActionData, pendingError); // 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, _extends({\n        matches,\n        loaderData: {},\n        // Commit pending error if we're short circuiting\n        errors: pendingError || null\n      }, pendingActionData ? {\n        actionData: pendingActionData\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(rf => {\n        let fetcher = state.fetchers.get(rf.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          \" _hasFetcherDoneAnything \": true\n        };\n        state.fetchers.set(rf.key, revalidatingFetcher);\n      });\n      let actionData = pendingActionData || state.actionData;\n      updateState(_extends({\n        navigation: loadingNavigation\n      }, actionData ? Object.keys(actionData).length === 0 ? {\n        actionData: null\n      } : {\n        actionData\n      } : {}, revalidatingFetchers.length > 0 ? {\n        fetchers: new Map(state.fetchers)\n      } : {}));\n    }\n\n    pendingNavigationLoadId = ++incrementingLoadId;\n    revalidatingFetchers.forEach(rf => fetchControllers.set(rf.key, pendingNavigationController));\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(rf => fetchControllers.delete(rf.key)); // If any loaders returned a redirect Response, start a new REPLACE navigation\n\n    let redirect = findRedirect(results);\n\n    if (redirect) {\n      await startRedirectNavigation(state, redirect, {\n        replace\n      });\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 routesToUse = inFlightDataRoutes || dataRoutes;\n    let matches = matchRoutes(routesToUse, href, init.basename);\n\n    if (!matches) {\n      setFetcherError(key, routeId, getInternalRouterError(404, {\n        pathname: href\n      }));\n      return;\n    }\n\n    let {\n      path,\n      submission\n    } = normalizeNavigateOptions(href, opts, true);\n    let match = getTargetMatch(matches, path);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n\n    if (submission && isMutationMethod(submission.formMethod)) {\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, {\n      routeId,\n      path\n    });\n    handleFetcherLoader(key, routeId, path, match, matches, submission);\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 && !match.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: submission.formMethod,\n        pathname: path,\n        routeId: routeId\n      });\n      setFetcherError(key, routeId, error);\n      return;\n    } // 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      \" _hasFetcherDoneAnything \": true\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 = createClientSideRequest(init.history, path, abortController.signal, submission);\n    fetchControllers.set(key, abortController);\n    let actionResult = await callLoaderOrAction(\"action\", fetchRequest, match, requestMatches, manifest, detectErrorBoundary, 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        \" _hasFetcherDoneAnything \": true\n      });\n\n      state.fetchers.set(key, loadingFetcher);\n      updateState({\n        fetchers: new Map(state.fetchers)\n      });\n      return startRedirectNavigation(state, actionResult, {\n        isFetchActionRedirect: true\n      });\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      throw getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\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 = createClientSideRequest(init.history, nextLocation, abortController.signal);\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let matches = state.navigation.state !== \"idle\" ? matchRoutes(routesToUse, 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      \" _hasFetcherDoneAnything \": true\n    });\n\n    state.fetchers.set(key, loadFetcher);\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, fetchLoadMatches, routesToUse, init.basename, {\n      [match.route.id]: actionResult.data\n    }, undefined // No need to send through errors since we short circuit above\n    ); // Put all revalidating fetchers into the loading state, except for the\n    // current fetcher which we want to keep in it's current loading state which\n    // contains it's action submission info + action data\n\n    revalidatingFetchers.filter(rf => rf.key !== key).forEach(rf => {\n      let staleKey = rf.key;\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        \" _hasFetcherDoneAnything \": true\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(r => fetchControllers.delete(r.key));\n    let redirect = findRedirect(results);\n\n    if (redirect) {\n      return startRedirectNavigation(state, redirect);\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      \" _hasFetcherDoneAnything \": true\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, errors)\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, submission) {\n    let existingFetcher = state.fetchers.get(key); // Put this fetcher into it's loading state\n\n    let loadingFetcher = _extends({\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined\n    }, submission, {\n      data: existingFetcher && existingFetcher.data,\n      \" _hasFetcherDoneAnything \": true\n    });\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 = createClientSideRequest(init.history, path, abortController.signal);\n    fetchControllers.set(key, abortController);\n    let result = await callLoaderOrAction(\"loader\", fetchRequest, match, matches, manifest, detectErrorBoundary, router.basename); // Deferred isn't supported for fetcher loads, await everything and treat it\n    // as a normal load.  resolveDeferredData will return undefined if this\n    // fetcher gets aborted, so we just leave result untouched and short circuit\n    // below if that happens\n\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      await startRedirectNavigation(state, result);\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      \" _hasFetcherDoneAnything \": true\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(state, redirect, _temp) {\n    var _window;\n\n    let {\n      submission,\n      replace,\n      isFetchActionRedirect\n    } = _temp === void 0 ? {} : _temp;\n\n    if (redirect.revalidate) {\n      isRevalidationRequired = true;\n    }\n\n    let redirectLocation = createLocation(state.location, redirect.location, // TODO: This can be removed once we get rid of useTransition in Remix v2\n    _extends({\n      _isRedirect: true\n    }, isFetchActionRedirect ? {\n      _isFetchActionRedirect: true\n    } : {}));\n    invariant(redirectLocation, \"Expected a location on the redirect navigation\"); // Check if this an absolute external redirect that goes to a new origin\n\n    if (ABSOLUTE_URL_REGEX.test(redirect.location) && isBrowser && typeof ((_window = window) == null ? void 0 : _window.location) !== \"undefined\") {\n      let url = init.history.createURL(redirect.location);\n      let isDifferentBasename = stripBasename(url.pathname, init.basename || \"/\") == null;\n\n      if (window.location.origin !== url.origin || isDifferentBasename) {\n        if (replace) {\n          window.location.replace(redirect.location);\n        } else {\n          window.location.assign(redirect.location);\n        }\n\n        return;\n      }\n    } // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n\n\n    pendingNavigationController = null;\n    let redirectHistoryAction = replace === true ? Action.Replace : Action.Push; // Use the incoming submission if provided, fallback on the active one in\n    // state.navigation\n\n    let {\n      formMethod,\n      formAction,\n      formEncType,\n      formData\n    } = state.navigation;\n\n    if (!submission && formMethod && formAction && formData && formEncType) {\n      submission = {\n        formMethod,\n        formAction,\n        formEncType,\n        formData\n      };\n    } // If this was a 307/308 submission we want to preserve the HTTP method and\n    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the\n    // redirected location\n\n\n    if (redirectPreserveMethodStatusCodes.has(redirect.status) && submission && isMutationMethod(submission.formMethod)) {\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        submission: _extends({}, submission, {\n          formAction: redirect.location\n        }),\n        // Preserve this flag across redirects\n        preventScrollReset: pendingPreventScrollReset\n      });\n    } else {\n      // Otherwise, we kick off a new loading navigation, preserving the\n      // submission info for the duration of this navigation\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        overrideNavigation: {\n          state: \"loading\",\n          location: redirectLocation,\n          formMethod: submission ? submission.formMethod : undefined,\n          formAction: submission ? submission.formAction : undefined,\n          formEncType: submission ? submission.formEncType : undefined,\n          formData: submission ? submission.formData : undefined\n        },\n        // Preserve this flag across redirects\n        preventScrollReset: pendingPreventScrollReset\n      });\n    }\n  }\n\n  async function callLoadersAndMaybeResolveData(currentMatches, matches, matchesToLoad, fetchersToLoad, request) {\n    // Call all navigation loaders and revalidating fetcher loaders in parallel,\n    // then slice off the results into separate arrays so we can handle them\n    // accordingly\n    let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction(\"loader\", request, match, matches, manifest, detectErrorBoundary, router.basename)), ...fetchersToLoad.map(f => {\n      if (f.matches && f.match) {\n        return callLoaderOrAction(\"loader\", createClientSideRequest(init.history, f.path, request.signal), f.match, f.matches, manifest, detectErrorBoundary, router.basename);\n      } else {\n        let error = {\n          type: ResultType.error,\n          error: getInternalRouterError(404, {\n            pathname: f.path\n          })\n        };\n        return error;\n      }\n    })]);\n    let loaderResults = results.slice(0, matchesToLoad.length);\n    let fetcherResults = results.slice(matchesToLoad.length);\n    await Promise.all([resolveDeferredResults(currentMatches, matchesToLoad, loaderResults, request.signal, false, state.loaderData), resolveDeferredResults(currentMatches, fetchersToLoad.map(f => f.match), 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        \" _hasFetcherDoneAnything \": true\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 getBlocker(key, fn) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n\n    if (blockerFunctions.get(key) !== fn) {\n      blockerFunctions.set(key, fn);\n    }\n\n    return blocker;\n  }\n\n  function deleteBlocker(key) {\n    state.blockers.delete(key);\n    blockerFunctions.delete(key);\n  } // Utility function to update blockers, ensuring valid state transitions\n\n\n  function updateBlocker(key, newBlocker) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER; // Poor mans state machine :)\n    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n\n    invariant(blocker.state === \"unblocked\" && newBlocker.state === \"blocked\" || blocker.state === \"blocked\" && newBlocker.state === \"blocked\" || blocker.state === \"blocked\" && newBlocker.state === \"proceeding\" || blocker.state === \"blocked\" && newBlocker.state === \"unblocked\" || blocker.state === \"proceeding\" && newBlocker.state === \"unblocked\", \"Invalid blocker state transition: \" + blocker.state + \" -> \" + newBlocker.state);\n    state.blockers.set(key, newBlocker);\n    updateState({\n      blockers: new Map(state.blockers)\n    });\n  }\n\n  function shouldBlockNavigation(_ref2) {\n    let {\n      currentLocation,\n      nextLocation,\n      historyAction\n    } = _ref2;\n\n    if (blockerFunctions.size === 0) {\n      return;\n    } // We ony support a single active blocker at the moment since we don't have\n    // any compelling use cases for multi-blocker yet\n\n\n    if (blockerFunctions.size > 1) {\n      warning(false, \"A router only supports one blocker at a time\");\n    }\n\n    let entries = Array.from(blockerFunctions.entries());\n    let [blockerKey, blockerFunction] = entries[entries.length - 1];\n    let blocker = state.blockers.get(blockerKey);\n\n    if (blocker && blocker.state === \"proceeding\") {\n      // If the blocker is currently proceeding, we don't need to re-check\n      // it and can let this navigation continue\n      return;\n    } // At this point, we know we're unblocked/blocked so we need to check the\n    // user-provided blocker function\n\n\n    if (blockerFunction({\n      currentLocation,\n      nextLocation,\n      historyAction\n    })) {\n      return blockerKey;\n    }\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  function _internalSetRoutes(newRoutes) {\n    inFlightDataRoutes = newRoutes;\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    encodeLocation: to => init.history.encodeLocation(to),\n    getFetcher,\n    deleteFetcher,\n    dispose,\n    getBlocker,\n    deleteBlocker,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds,\n    // TODO: Remove setRoutes, it's temporary to avoid dealing with\n    // updating the tree while validating the update algorithm.\n    _internalSetRoutes\n  };\n  return router;\n} //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\n\nconst UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\nfunction createStaticHandler(routes, opts) {\n  invariant(routes.length > 0, \"You must provide a non-empty routes array to createStaticHandler\");\n  let manifest = {};\n  let detectErrorBoundary = (opts == null ? void 0 : opts.detectErrorBoundary) || defaultDetectErrorBoundary;\n  let dataRoutes = convertRoutesToDataRoutes(routes, detectErrorBoundary, undefined, manifest);\n  let basename = (opts ? opts.basename : null) || \"/\";\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, _temp2) {\n    let {\n      requestContext\n    } = _temp2 === void 0 ? {} : _temp2;\n    let url = new URL(request.url);\n    let method = request.method.toLowerCase();\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename); // SSR supports HEAD requests while SPA doesn't\n\n    if (!isValidMethod(method) && method !== \"head\") {\n      let error = getInternalRouterError(405, {\n        method\n      });\n      let {\n        matches: methodNotAllowedMatches,\n        route\n      } = getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: methodNotAllowedMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    } else if (!matches) {\n      let error = getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n      let {\n        matches: notFoundMatches,\n        route\n      } = getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: notFoundMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    }\n\n    let result = await queryImpl(request, location, matches, requestContext);\n\n    if (isResponse(result)) {\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      basename\n    }, result);\n  }\n  /**\n   * The queryRoute() method is intended for targeted route requests, either\n   * for fetch ?_data requests or resource route requests.  In this case, we\n   * are only ever calling a single action or loader, and we are returning the\n   * returned value directly.  In most cases, this will be a Response returned\n   * from the action/loader, but it may be a primitive or other value as well -\n   * and in such cases the calling context should handle that accordingly.\n   *\n   * We do respect the throw/return differentiation, so if an action/loader\n   * throws, then this method will throw the value.  This is important so we\n   * can do proper boundary identification in Remix where a thrown Response\n   * must go to the Catch Boundary but a returned Response is happy-path.\n   *\n   * One thing to note is that any Router-initiated Errors that make sense\n   * to associate with a status code will be thrown as an ErrorResponse\n   * instance which include the raw Error, such that the calling context can\n   * serialize the error as they see fit while including the proper response\n   * code.  Examples here are 404 and 405 errors that occur prior to reaching\n   * any user-defined loaders.\n   */\n\n\n  async function queryRoute(request, _temp3) {\n    let {\n      routeId,\n      requestContext\n    } = _temp3 === void 0 ? {} : _temp3;\n    let url = new URL(request.url);\n    let method = request.method.toLowerCase();\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename); // SSR supports HEAD requests while SPA doesn't\n\n    if (!isValidMethod(method) && method !== \"head\" && method !== \"options\") {\n      throw getInternalRouterError(405, {\n        method\n      });\n    } else if (!matches) {\n      throw getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n    }\n\n    let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);\n\n    if (routeId && !match) {\n      throw getInternalRouterError(403, {\n        pathname: location.pathname,\n        routeId\n      });\n    } else if (!match) {\n      // This should never hit I don't think?\n      throw getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n    }\n\n    let result = await queryImpl(request, location, matches, requestContext, match);\n\n    if (isResponse(result)) {\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    if (result.actionData) {\n      return Object.values(result.actionData)[0];\n    }\n\n    if (result.loaderData) {\n      var _result$activeDeferre;\n\n      let data = Object.values(result.loaderData)[0];\n\n      if ((_result$activeDeferre = result.activeDeferreds) != null && _result$activeDeferre[match.route.id]) {\n        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];\n      }\n\n      return data;\n    }\n\n    return undefined;\n  }\n\n  async function queryImpl(request, location, matches, requestContext, routeMatch) {\n    invariant(request.signal, \"query()/queryRoute() requests must contain an AbortController signal\");\n\n    try {\n      if (isMutationMethod(request.method.toLowerCase())) {\n        let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, routeMatch != null);\n        return result;\n      }\n\n      let result = await loadRouteData(request, matches, requestContext, routeMatch);\n      return isResponse(result) ? result : _extends({}, result, {\n        actionData: null,\n        actionHeaders: {}\n      });\n    } catch (e) {\n      // If the user threw/returned a Response in callLoaderOrAction, we throw\n      // it to bail out and then return or throw here based on whether the user\n      // returned or threw\n      if (isQueryRouteResponse(e)) {\n        if (e.type === ResultType.error && !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, requestContext, isRouteRequest) {\n    let result;\n\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: actionMatch.route.id\n      });\n\n      if (isRouteRequest) {\n        throw error;\n      }\n\n      result = {\n        type: ResultType.error,\n        error\n      };\n    } else {\n      result = await callLoaderOrAction(\"action\", request, actionMatch, matches, manifest, detectErrorBoundary, basename, true, isRouteRequest, requestContext);\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      let error = getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n\n      if (isRouteRequest) {\n        throw error;\n      }\n\n      result = {\n        type: ResultType.error,\n        error\n      };\n    }\n\n    if (isRouteRequest) {\n      // Note: This should only be non-Response values if we get here, since\n      // isRouteRequest should throw any Response received in callLoaderOrAction\n      if (isErrorResult(result)) {\n        throw result.error;\n      }\n\n      return {\n        matches: [actionMatch],\n        loaderData: {},\n        actionData: {\n          [actionMatch.route.id]: result.data\n        },\n        errors: null,\n        // Note: statusCode + headers are unused here since queryRoute will\n        // return the raw Response or value\n        statusCode: 200,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    }\n\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n      let context = await loadRouteData(request, matches, requestContext, undefined, {\n        [boundaryMatch.route.id]: result.error\n      }); // 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    } // Create a GET request for the loaders\n\n\n    let loaderRequest = new Request(request.url, {\n      headers: request.headers,\n      redirect: request.redirect,\n      signal: request.signal\n    });\n    let context = await loadRouteData(loaderRequest, matches, requestContext);\n    return _extends({}, context, result.statusCode ? {\n      statusCode: result.statusCode\n    } : {}, {\n      actionData: {\n        [actionMatch.route.id]: result.data\n      },\n      actionHeaders: _extends({}, result.headers ? {\n        [actionMatch.route.id]: result.headers\n      } : {})\n    });\n  }\n\n  async function loadRouteData(request, matches, requestContext, routeMatch, pendingActionError) {\n    let isRouteRequest = routeMatch != null; // Short circuit if we have no loaders to run (queryRoute())\n\n    if (isRouteRequest && !(routeMatch != null && routeMatch.route.loader) && !(routeMatch != null && routeMatch.route.lazy)) {\n      throw getInternalRouterError(400, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: routeMatch == null ? void 0 : routeMatch.route.id\n      });\n    }\n\n    let requestMatches = routeMatch ? [routeMatch] : getLoaderMatchesUntilBoundary(matches, Object.keys(pendingActionError || {})[0]);\n    let matchesToLoad = requestMatches.filter(m => m.route.loader || m.route.lazy); // Short circuit if we have no loaders to run (query())\n\n    if (matchesToLoad.length === 0) {\n      return {\n        matches,\n        // Add a null for all matched routes for proper revalidation on the client\n        loaderData: matches.reduce((acc, m) => Object.assign(acc, {\n          [m.route.id]: null\n        }), {}),\n        errors: pendingActionError || null,\n        statusCode: 200,\n        loaderHeaders: {},\n        activeDeferreds: null\n      };\n    }\n\n    let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction(\"loader\", request, match, matches, manifest, detectErrorBoundary, basename, true, isRouteRequest, requestContext))]);\n\n    if (request.signal.aborted) {\n      let method = isRouteRequest ? \"queryRoute\" : \"query\";\n      throw new Error(method + \"() call aborted\");\n    } // Process and commit output from loaders\n\n\n    let activeDeferreds = new Map();\n    let context = processRouteLoaderData(matches, matchesToLoad, results, pendingActionError, activeDeferreds); // Add a null for any non-loader matches for proper revalidation on the client\n\n    let executedLoaders = new Set(matchesToLoad.map(match => match.route.id));\n    matches.forEach(match => {\n      if (!executedLoaders.has(match.route.id)) {\n        context.loaderData[match.route.id] = null;\n      }\n    });\n    return _extends({}, context, {\n      matches,\n      activeDeferreds: activeDeferreds.size > 0 ? Object.fromEntries(activeDeferreds.entries()) : null\n    });\n  }\n\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}\n\nfunction isSubmissionNavigation(opts) {\n  return opts != null && \"formData\" in opts;\n} // Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\n\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 || !isSubmissionNavigation(opts)) {\n    return {\n      path\n    };\n  }\n\n  if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n    return {\n      path,\n      error: getInternalRouterError(405, {\n        method: opts.formMethod\n      })\n    };\n  } // Create a Submission on non-GET navigations\n\n\n  let submission;\n\n  if (opts.formData) {\n    submission = {\n      formMethod: opts.formMethod || \"get\",\n      formAction: stripHashFromPath(path),\n      formEncType: opts && opts.formEncType || \"application/x-www-form-urlencoded\",\n      formData: opts.formData\n    };\n\n    if (isMutationMethod(submission.formMethod)) {\n      return {\n        path,\n        submission\n      };\n    }\n  } // Flatten submission onto URLSearchParams for GET submissions\n\n\n  let parsedPath = parsePath(path);\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  return {\n    path: createPath(parsedPath),\n    submission\n  };\n} // Filter out all routes below any caught error as they aren't going to\n// render so we don't need to load them\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(history, state, matches, submission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, fetchLoadMatches, routesToUse, basename, pendingActionData, pendingError) {\n  let actionResult = pendingError ? Object.values(pendingError)[0] : pendingActionData ? Object.values(pendingActionData)[0] : undefined;\n  let currentUrl = history.createURL(state.location);\n  let nextUrl = history.createURL(location);\n  let defaultShouldRevalidate = // Forced revalidation due to submission, useRevalidate, or X-Remix-Revalidate\n  isRevalidationRequired || // Clicked the same link, resubmitted a GET form\n  currentUrl.toString() === nextUrl.toString() || // Search params affect all loaders\n  currentUrl.search !== nextUrl.search; // 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) => {\n    if (match.route.lazy) {\n      // We haven't loaded this route yet so we don't know if it's got a loader!\n      return true;\n    }\n\n    if (match.route.loader == null) {\n      return false;\n    } // Always call the loader on new route instances and pending defer cancellations\n\n\n    if (isNewLoader(state.loaderData, state.matches[index], match) || cancelledDeferredRoutes.some(id => id === match.route.id)) {\n      return true;\n    } // This is the default implementation for when we revalidate.  If the route\n    // provides it's own implementation, then we give them full control but\n    // provide this value so they can leverage it if needed after they check\n    // their own specific use cases\n\n\n    let currentRouteMatch = state.matches[index];\n    let nextRouteMatch = match;\n    return shouldRevalidateLoader(match, _extends({\n      currentUrl,\n      currentParams: currentRouteMatch.params,\n      nextUrl,\n      nextParams: nextRouteMatch.params\n    }, submission, {\n      actionResult,\n      defaultShouldRevalidate: defaultShouldRevalidate || isNewRouteInstance(currentRouteMatch, nextRouteMatch)\n    }));\n  }); // Pick fetcher.loads that need to be revalidated\n\n  let revalidatingFetchers = [];\n  fetchLoadMatches.forEach((f, key) => {\n    // Don't revalidate if fetcher won't be present in the subsequent render\n    if (!matches.some(m => m.route.id === f.routeId)) {\n      return;\n    }\n\n    let fetcherMatches = matchRoutes(routesToUse, f.path, basename); // If the fetcher path no longer matches, push it in with null matches so\n    // we can trigger a 404 in callLoadersAndMaybeResolveData\n\n    if (!fetcherMatches) {\n      revalidatingFetchers.push(_extends({\n        key\n      }, f, {\n        matches: null,\n        match: null\n      }));\n      return;\n    }\n\n    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);\n\n    if (cancelledFetcherLoads.includes(key)) {\n      revalidatingFetchers.push(_extends({\n        key,\n        matches: fetcherMatches,\n        match: fetcherMatch\n      }, f));\n      return;\n    } // Revalidating fetchers are decoupled from the route matches since they\n    // hit a static href, so they _always_ check shouldRevalidate and the\n    // default is strictly if a revalidation is explicitly required (action\n    // submissions, useRevalidator, X-Remix-Revalidate).\n\n\n    let shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({\n      currentUrl,\n      currentParams: state.matches[state.matches.length - 1].params,\n      nextUrl,\n      nextParams: matches[matches.length - 1].params\n    }, submission, {\n      actionResult,\n      defaultShouldRevalidate\n    }));\n\n    if (shouldRevalidate) {\n      revalidatingFetchers.push(_extends({\n        key,\n        matches: fetcherMatches,\n        match: fetcherMatch\n      }, f));\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 != null && currentPath.endsWith(\"*\") && currentMatch.params[\"*\"] !== match.params[\"*\"]\n  );\n}\n\nfunction shouldRevalidateLoader(loaderMatch, arg) {\n  if (loaderMatch.route.shouldRevalidate) {\n    let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n\n  return arg.defaultShouldRevalidate;\n}\n/**\n * Execute route.lazy() methods to lazily load route modules (loader, action,\n * shouldRevalidate) and update the routeManifest in place which shares objects\n * with dataRoutes so those get updated as well.\n */\n\n\nasync function loadLazyRouteModule(route, detectErrorBoundary, manifest) {\n  if (!route.lazy) {\n    return;\n  }\n\n  let lazyRoute = await route.lazy(); // If the lazy route function was executed and removed by another parallel\n  // call then we can return - first lazy() to finish wins because the return\n  // value of lazy is expected to be static\n\n  if (!route.lazy) {\n    return;\n  }\n\n  let routeToUpdate = manifest[route.id];\n  invariant(routeToUpdate, \"No route found in manifest\"); // Update the route in place.  This should be safe because there's no way\n  // we could yet be sitting on this route as we can't get there without\n  // resolving lazy() first.\n  //\n  // This is different than the HMR \"update\" use-case where we may actively be\n  // on the route being updated.  The main concern boils down to \"does this\n  // mutation affect any ongoing navigations or any current state.matches\n  // values?\".  If not, it should be safe to update in place.\n\n  let routeUpdates = {};\n\n  for (let lazyRouteProperty in lazyRoute) {\n    let staticRouteValue = routeToUpdate[lazyRouteProperty];\n    let isPropertyStaticallyDefined = staticRouteValue !== undefined && // This property isn't static since it should always be updated based\n    // on the route updates\n    lazyRouteProperty !== \"hasErrorBoundary\";\n    warning(!isPropertyStaticallyDefined, \"Route \\\"\" + routeToUpdate.id + \"\\\" has a static property \\\"\" + lazyRouteProperty + \"\\\" \" + \"defined but its lazy function is also returning a value for this property. \" + (\"The lazy route property \\\"\" + lazyRouteProperty + \"\\\" will be ignored.\"));\n\n    if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {\n      routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];\n    }\n  } // Mutate the route with the provided updates.  Do this first so we pass\n  // the updated version to detectErrorBoundary\n\n\n  Object.assign(routeToUpdate, routeUpdates); // Mutate the `hasErrorBoundary` property on the route based on the route\n  // updates and remove the `lazy` function so we don't resolve the lazy\n  // route again.\n\n  Object.assign(routeToUpdate, {\n    // To keep things framework agnostic, we use the provided\n    // `detectErrorBoundary` function to set the `hasErrorBoundary` route\n    // property since the logic will differ between frameworks.\n    hasErrorBoundary: detectErrorBoundary(_extends({}, routeToUpdate)),\n    lazy: undefined\n  });\n}\n\nasync function callLoaderOrAction(type, request, match, matches, manifest, detectErrorBoundary, basename, isStaticRequest, isRouteRequest, requestContext) {\n  if (basename === void 0) {\n    basename = \"/\";\n  }\n\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;\n  let onReject;\n\n  let runHandler = handler => {\n    // Setup a promise we can race against so that abort signals short circuit\n    let reject;\n    let abortPromise = new Promise((_, r) => reject = r);\n\n    onReject = () => reject();\n\n    request.signal.addEventListener(\"abort\", onReject);\n    return Promise.race([handler({\n      request,\n      params: match.params,\n      context: requestContext\n    }), abortPromise]);\n  };\n\n  try {\n    let handler = match.route[type];\n\n    if (match.route.lazy) {\n      if (handler) {\n        // Run statically defined handler in parallel with lazy()\n        let values = await Promise.all([runHandler(handler), loadLazyRouteModule(match.route, detectErrorBoundary, manifest)]);\n        result = values[0];\n      } else {\n        // Load lazy route module, then run any returned handler\n        await loadLazyRouteModule(match.route, detectErrorBoundary, manifest);\n        handler = match.route[type];\n\n        if (handler) {\n          // Handler still run even if we got interrupted to maintain consistency\n          // with un-abortable behavior of handler execution on non-lazy or\n          // previously-lazy-loaded routes\n          result = await runHandler(handler);\n        } else if (type === \"action\") {\n          throw getInternalRouterError(405, {\n            method: request.method,\n            pathname: new URL(request.url).pathname,\n            routeId: match.route.id\n          });\n        } else {\n          // lazy() route has no loader to run.  Short circuit here so we don't\n          // hit the invariant below that errors on returning undefined.\n          return {\n            type: ResultType.data,\n            data: undefined\n          };\n        }\n      }\n    } else {\n      invariant(handler, \"Could not find the \" + type + \" to run on the \\\"\" + match.route.id + \"\\\" route\");\n      result = await runHandler(handler);\n    }\n\n    invariant(result !== undefined, \"You defined \" + (type === \"action\" ? \"an action\" : \"a loader\") + \" for route \" + (\"\\\"\" + match.route.id + \"\\\" but didn't return anything from your `\" + type + \"` \") + \"function. Please return a value or `null`.\");\n  } catch (e) {\n    resultType = ResultType.error;\n    result = e;\n  } finally {\n    if (onReject) {\n      request.signal.removeEventListener(\"abort\", onReject);\n    }\n  }\n\n  if (isResponse(result)) {\n    let status = result.status; // Process redirects\n\n    if (redirectStatusCodes.has(status)) {\n      let location = result.headers.get(\"Location\");\n      invariant(location, \"Redirects returned/thrown from loaders/actions must have a Location header\"); // Support relative routing in internal redirects\n\n      if (!ABSOLUTE_URL_REGEX.test(location)) {\n        let activeMatches = matches.slice(0, matches.indexOf(match) + 1);\n        let routePathnames = getPathContributingMatches(activeMatches).map(match => match.pathnameBase);\n        let resolvedLocation = resolveTo(location, routePathnames, new URL(request.url).pathname);\n        invariant(createPath(resolvedLocation), \"Unable to resolve redirect location: \" + 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);\n      } else if (!isStaticRequest) {\n        // Strip off the protocol+origin for same-origin + same-basename absolute\n        // redirects. If this is a static request, we can let it go back to the\n        // browser as-is\n        let currentUrl = new URL(request.url);\n        let url = location.startsWith(\"//\") ? new URL(currentUrl.protocol + location) : new URL(location);\n        let isSameBasename = stripBasename(url.pathname, basename) != null;\n\n        if (url.origin === currentUrl.origin && isSameBasename) {\n          location = url.pathname + url.search + url.hash;\n        }\n      } // Don't process redirects in the router during static requests requests.\n      // Instead, throw the Response and let the server handle it with an HTTP\n      // redirect.  We also update the Location header in place in this flow so\n      // basename and relative routing is taken into account\n\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\"); // Check between word boundaries instead of startsWith() due to the last\n    // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type\n\n    if (contentType && /\\bapplication\\/json\\b/.test(contentType)) {\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    var _result$init, _result$init2;\n\n    return {\n      type: ResultType.deferred,\n      deferredData: result,\n      statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status,\n      headers: ((_result$init2 = result.init) == null ? void 0 : _result$init2.headers) && new Headers(result.init.headers)\n    };\n  }\n\n  return {\n    type: ResultType.data,\n    data: result\n  };\n} // Utility method for creating the Request instances for loaders/actions during\n// client-side navigations and fetches.  During SSR we will always have a\n// Request instance from the static handler (query/queryRoute)\n\n\nfunction createClientSideRequest(history, location, signal, submission) {\n  let url = history.createURL(stripHashFromPath(location)).toString();\n  let init = {\n    signal\n  };\n\n  if (submission && isMutationMethod(submission.formMethod)) {\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    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs\n    searchParams.append(key, value instanceof File ? value.name : 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 = errors || {}; // Prefer higher error values if lower errors bubble to the same boundary\n\n      if (errors[boundaryMatch.route.id] == null) {\n        errors[boundaryMatch.route.id] = error;\n      } // Clear our any prior loaderData for the throwing route\n\n\n      loaderData[id] = undefined; // 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 {\n      if (isDeferredResult(result)) {\n        activeDeferreds.set(id, result.deferredData);\n        loaderData[id] = result.deferredData.data;\n      } else {\n        loaderData[id] = result.data;\n      } // Error status codes always override success status codes, but if all\n      // loaders are successful we take the deepest status code.\n\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.  Also clear out any loaderData for the\n  // throwing route\n\n  if (pendingError) {\n    errors = pendingError;\n    loaderData[Object.keys(pendingError)[0]] = undefined;\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 {\n      key,\n      match\n    } = 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 == null ? void 0 : 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      invariant(false, \"Unhandled fetcher revalidation redirect\");\n    } else if (isDeferredResult(result)) {\n      // Should never get here, deferred data should be awaited for fetchers\n      // in resolveDeferredResults\n      invariant(false, \"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = {\n        state: \"idle\",\n        data: result.data,\n        formMethod: undefined,\n        formAction: undefined,\n        formEncType: undefined,\n        formData: undefined,\n        \" _hasFetcherDoneAnything \": true\n      };\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n\n  return {\n    loaderData,\n    errors\n  };\n}\n\nfunction mergeLoaderData(loaderData, newLoaderData, matches, errors) {\n  let mergedLoaderData = _extends({}, newLoaderData);\n\n  for (let match of matches) {\n    let id = match.route.id;\n\n    if (newLoaderData.hasOwnProperty(id)) {\n      if (newLoaderData[id] !== undefined) {\n        mergedLoaderData[id] = newLoaderData[id];\n      }\n    } else if (loaderData[id] !== undefined && match.route.loader) {\n      // Preserve existing keys not included in newLoaderData and where a loader\n      // wasn't removed by HMR\n      mergedLoaderData[id] = loaderData[id];\n    }\n\n    if (errors && errors.hasOwnProperty(id)) {\n      // Don't keep any loader data below the boundary\n      break;\n    }\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) {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route = routes.find(r => r.index || !r.path || r.path === \"/\") || {\n    id: \"__shim-error-route__\"\n  };\n  return {\n    matches: [{\n      params: {},\n      pathname: \"\",\n      pathnameBase: \"\",\n      route\n    }],\n    route\n  };\n}\n\nfunction getInternalRouterError(status, _temp4) {\n  let {\n    pathname,\n    routeId,\n    method,\n    type\n  } = _temp4 === void 0 ? {} : _temp4;\n  let statusText = \"Unknown Server Error\";\n  let errorMessage = \"Unknown @remix-run/router error\";\n\n  if (status === 400) {\n    statusText = \"Bad Request\";\n\n    if (method && pathname && routeId) {\n      errorMessage = \"You made a \" + method + \" request to \\\"\" + pathname + \"\\\" but \" + (\"did not provide a `loader` for route \\\"\" + routeId + \"\\\", \") + \"so there is no way to handle the request.\";\n    } else if (type === \"defer-action\") {\n      errorMessage = \"defer() is not supported in actions\";\n    }\n  } else if (status === 403) {\n    statusText = \"Forbidden\";\n    errorMessage = \"Route \\\"\" + routeId + \"\\\" does not match URL \\\"\" + pathname + \"\\\"\";\n  } else if (status === 404) {\n    statusText = \"Not Found\";\n    errorMessage = \"No route matches URL \\\"\" + pathname + \"\\\"\";\n  } else if (status === 405) {\n    statusText = \"Method Not Allowed\";\n\n    if (method && pathname && routeId) {\n      errorMessage = \"You made a \" + method.toUpperCase() + \" request to \\\"\" + pathname + \"\\\" but \" + (\"did not provide an `action` for route \\\"\" + routeId + \"\\\", \") + \"so there is no way to handle the request.\";\n    } else if (method) {\n      errorMessage = \"Invalid request method \\\"\" + method.toUpperCase() + \"\\\"\";\n    }\n  }\n\n  return new ErrorResponse(status || 500, statusText, new Error(errorMessage), true);\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 isResponse(value) {\n  return value != null && typeof value.status === \"number\" && typeof value.statusText === \"string\" && typeof value.headers === \"object\" && typeof value.body !== \"undefined\";\n}\n\nfunction isRedirectResponse(result) {\n  if (!isResponse(result)) {\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 && isResponse(obj.response) && (obj.type === ResultType.data || ResultType.error);\n}\n\nfunction isValidMethod(method) {\n  return validRequestMethods.has(method);\n}\n\nfunction isMutationMethod(method) {\n  return validMutationMethods.has(method);\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]; // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n\n    if (!match) {\n      continue;\n    }\n\n    let currentMatch = currentMatches.find(m => m.route.id === match.route.id);\n    let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\n\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_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, UNSAFE_DEFERRED_SYMBOL, DeferredData as UNSAFE_DeferredData, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, getPathContributingMatches as UNSAFE_getPathContributingMatches, invariant as UNSAFE_invariant, warning as UNSAFE_warning, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, createRouter, createStaticHandler, defer, generatePath, getStaticContextFromError, getToPathname, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, parsePath, redirect, resolvePath, resolveTo, stripBasename };\n//# sourceMappingURL=router.js.map\n","/**\n * React Router v6.9.0\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nimport { UNSAFE_invariant, joinPaths, matchPath, UNSAFE_getPathContributingMatches, UNSAFE_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\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\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\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 * Returns the full href for the given \"to\" value. This is useful for building\n * custom links that are also accessible and preserve right-click behavior.\n *\n * @see https://reactrouter.com/hooks/use-href\n */\n\nfunction useHref(to, _temp) {\n  let {\n    relative\n  } = _temp === void 0 ? {} : _temp;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useHref() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    basename,\n    navigator\n  } = React.useContext(NavigationContext);\n  let {\n    hash,\n    pathname,\n    search\n  } = useResolvedPath(to, {\n    relative\n  });\n  let joinedPathname = pathname; // 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/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/hooks/use-location\n */\n\nfunction useLocation() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useLocation() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  return React.useContext(LocationContext).location;\n}\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/hooks/use-navigation-type\n */\n\nfunction useNavigationType() {\n  return React.useContext(LocationContext).navigationType;\n}\n/**\n * Returns a PathMatch object if the given pattern matches the current URL.\n * This is useful for components that need to know \"active\" state, e.g.\n * <NavLink>.\n *\n * @see https://reactrouter.com/hooks/use-match\n */\n\nfunction useMatch(pattern) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useMatch() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    pathname\n  } = useLocation();\n  return React.useMemo(() => matchPath(pattern, pathname), [pathname, pattern]);\n}\n/**\n * 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/hooks/use-navigate\n */\nfunction useNavigate() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useNavigate() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\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\" ? UNSAFE_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/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/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/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/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/hooks/use-routes\n */\n\nfunction useRoutes(routes, locationArg) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useRoutes() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    navigator\n  } = React.useContext(NavigationContext);\n  let 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\" ? UNSAFE_invariant(false, \"When overriding the location using `<Routes location>` or `useRoutes(routes, location)`, \" + \"the location pathname must begin with the portion of the URL pathname that was \" + (\"matched by all parent routes. The current pathname base is \\\"\" + parentPathnameBase + \"\\\" \") + (\"but pathname \\\"\" + parsedLocationArg.pathname + \"\\\" was given in the `location` prop.\")) : UNSAFE_invariant(false) : void 0;\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\n\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\" ? UNSAFE_warning(parentRoute || matches != null, \"No routes matched location \\\"\" + location.pathname + location.search + location.hash + \"\\\" \") : void 0;\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(matches == null || matches[matches.length - 1].route.element !== undefined || matches[matches.length - 1].route.Component !== undefined, \"Matched leaf route at location \\\"\" + location.pathname + location.search + location.hash + \"\\\" \" + \"does not have an element or Component. This means it will render an <Outlet /> with a \" + \"null value by default resulting in an \\\"empty\\\" page.\") : void 0;\n  }\n\n  let renderedMatches = _renderMatches(matches && matches.map(match => Object.assign({}, match, {\n    params: Object.assign({}, parentParams, match.params),\n    pathname: joinPaths([parentPathnameBase, // Re-encode pathnames that were decoded inside matchRoutes\n    navigator.encodeLocation ? navigator.encodeLocation(match.pathname).pathname : match.pathname]),\n    pathnameBase: match.pathnameBase === \"/\" ? parentPathnameBase : joinPaths([parentPathnameBase, // Re-encode pathnames that were decoded inside matchRoutes\n    navigator.encodeLocation ? navigator.encodeLocation(match.pathnameBase).pathname : 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 DefaultErrorComponent() {\n  let error = useRouteError();\n  let message = isRouteErrorResponse(error) ? error.status + \" \" + error.statusText : error instanceof Error ? error.message : JSON.stringify(error);\n  let stack = error instanceof Error ? error.stack : null;\n  let lightgrey = \"rgba(200,200,200, 0.5)\";\n  let preStyles = {\n    padding: \"0.5rem\",\n    backgroundColor: lightgrey\n  };\n  let codeStyles = {\n    padding: \"2px 4px\",\n    backgroundColor: lightgrey\n  };\n  let devInfo = null;\n\n  if (process.env.NODE_ENV !== \"production\") {\n    devInfo = /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"p\", null, \"\\uD83D\\uDCBF Hey developer \\uD83D\\uDC4B\"), /*#__PURE__*/React.createElement(\"p\", null, \"You can provide a way better UX than this when your app throws errors by providing your own\\xA0\", /*#__PURE__*/React.createElement(\"code\", {\n      style: codeStyles\n    }, \"ErrorBoundary\"), \" prop on\\xA0\", /*#__PURE__*/React.createElement(\"code\", {\n      style: codeStyles\n    }, \"<Route>\")));\n  }\n\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"h2\", null, \"Unexpected Application Error!\"), /*#__PURE__*/React.createElement(\"h3\", {\n    style: {\n      fontStyle: \"italic\"\n    }\n  }, message), stack ? /*#__PURE__*/React.createElement(\"pre\", {\n    style: preStyles\n  }, stack) : null, devInfo);\n}\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(RouteContext.Provider, {\n      value: this.props.routeContext\n    }, /*#__PURE__*/React.createElement(RouteErrorContext.Provider, {\n      value: this.state.error,\n      children: this.props.component\n    })) : this.props.children;\n  }\n\n}\n\nfunction RenderedRoute(_ref) {\n  let {\n    routeContext,\n    match,\n    children\n  } = _ref;\n  let dataRouterContext = React.useContext(DataRouterContext); // Track how deep we got in our render pass to emulate SSR componentDidCatch\n  // in a DataStaticRouter\n\n  if (dataRouterContext && dataRouterContext.static && dataRouterContext.staticContext && (match.route.errorElement || match.route.ErrorBoundary)) {\n    dataRouterContext.staticContext._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\" ? UNSAFE_invariant(false, \"Could not find a matching route for the current errors: \" + errors) : UNSAFE_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 = null;\n\n    if (dataRouterState) {\n      if (match.route.ErrorBoundary) {\n        errorElement = /*#__PURE__*/React.createElement(match.route.ErrorBoundary, null);\n      } else if (match.route.errorElement) {\n        errorElement = match.route.errorElement;\n      } else {\n        errorElement = /*#__PURE__*/React.createElement(DefaultErrorComponent, null);\n      }\n    }\n\n    let matches = parentMatches.concat(renderedMatches.slice(0, index + 1));\n\n    let getChildren = () => {\n      let children = outlet;\n\n      if (error) {\n        children = errorElement;\n      } else if (match.route.Component) {\n        children = /*#__PURE__*/React.createElement(match.route.Component, null);\n      } else if (match.route.element) {\n        children = match.route.element;\n      }\n\n      return /*#__PURE__*/React.createElement(RenderedRoute, {\n        match: match,\n        routeContext: {\n          outlet,\n          matches\n        },\n        children: children\n      });\n    }; // Only wrap in an error boundary within data router usages when we have an\n    // ErrorBoundary/errorElement on this route.  Otherwise let it bubble up to\n    // an ancestor ErrorBoundary/errorElement\n\n\n    return dataRouterState && (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? /*#__PURE__*/React.createElement(RenderErrorBoundary, {\n      location: dataRouterState.location,\n      component: errorElement,\n      error: error,\n      children: getChildren(),\n      routeContext: {\n        outlet: null,\n        matches\n      }\n    }) : getChildren();\n  }, null);\n}\nvar DataRouterHook;\n\n(function (DataRouterHook) {\n  DataRouterHook[\"UseBlocker\"] = \"useBlocker\";\n  DataRouterHook[\"UseRevalidator\"] = \"useRevalidator\";\n})(DataRouterHook || (DataRouterHook = {}));\n\nvar DataRouterStateHook;\n\n(function (DataRouterStateHook) {\n  DataRouterStateHook[\"UseBlocker\"] = \"useBlocker\";\n  DataRouterStateHook[\"UseLoaderData\"] = \"useLoaderData\";\n  DataRouterStateHook[\"UseActionData\"] = \"useActionData\";\n  DataRouterStateHook[\"UseRouteError\"] = \"useRouteError\";\n  DataRouterStateHook[\"UseNavigation\"] = \"useNavigation\";\n  DataRouterStateHook[\"UseRouteLoaderData\"] = \"useRouteLoaderData\";\n  DataRouterStateHook[\"UseMatches\"] = \"useMatches\";\n  DataRouterStateHook[\"UseRevalidator\"] = \"useRevalidator\";\n})(DataRouterStateHook || (DataRouterStateHook = {}));\n\nfunction getDataRouterConsoleError(hookName) {\n  return hookName + \" must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.\";\n}\n\nfunction useDataRouterContext(hookName) {\n  let ctx = React.useContext(DataRouterContext);\n  !ctx ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return ctx;\n}\n\nfunction useDataRouterState(hookName) {\n  let state = React.useContext(DataRouterStateContext);\n  !state ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return state;\n}\n\nfunction useRouteContext(hookName) {\n  let route = React.useContext(RouteContext);\n  !route ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return route;\n}\n\nfunction useCurrentRouteId(hookName) {\n  let route = useRouteContext(hookName);\n  let thisRoute = route.matches[route.matches.length - 1];\n  !thisRoute.route.id ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, hookName + \" can only be used on routes that contain a unique \\\"id\\\"\") : UNSAFE_invariant(false) : void 0;\n  return thisRoute.route.id;\n}\n/**\n * 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 routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n\n  if (state.errors && state.errors[routeId] != null) {\n    console.error(\"You cannot `useLoaderData` in an errorElement (routeId: \" + routeId + \")\");\n    return undefined;\n  }\n\n  return state.loaderData[routeId];\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\" ? UNSAFE_invariant(false, \"useActionData must be used inside a RouteContext\") : UNSAFE_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 * ErrorBoundary/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 routeId = useCurrentRouteId(DataRouterStateHook.UseRouteError); // 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  } // Otherwise look for errors from our data router state\n\n\n  return (_state$errors = state.errors) == null ? void 0 : _state$errors[routeId];\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}\nlet blockerId = 0;\n/**\n * Allow the application to block navigations within the SPA and present the\n * user a confirmation dialog to confirm the navigation.  Mostly used to avoid\n * using half-filled form data.  This does not handle hard-reloads or\n * cross-origin navigations.\n */\n\nfunction useBlocker(shouldBlock) {\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseBlocker);\n  let state = useDataRouterState(DataRouterStateHook.UseBlocker);\n  let [blockerKey] = React.useState(() => String(++blockerId));\n  let blockerFunction = React.useCallback(args => {\n    return typeof shouldBlock === \"function\" ? !!shouldBlock(args) : !!shouldBlock;\n  }, [shouldBlock]);\n  let blocker = router.getBlocker(blockerKey, blockerFunction); // Cleanup on unmount\n\n  React.useEffect(() => () => router.deleteBlocker(blockerKey), [router, blockerKey]); // Prefer the blocker from state since DataRouterContext is memoized so this\n  // ensures we update on blocker state updates\n\n  return state.blockers.get(blockerKey) || blocker;\n}\nconst alreadyWarned = {};\n\nfunction warningOnce(key, cond, message) {\n  if (!cond && !alreadyWarned[key]) {\n    alreadyWarned[key] = true;\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, message) : void 0;\n  }\n}\n\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nfunction RouterProvider(_ref) {\n  let {\n    fallbackElement,\n    router\n  } = _ref;\n  let getState = React.useCallback(() => router.state, [router]); // Sync router state to our component state to force re-renders\n\n  let state = useSyncExternalStore(router.subscribe, getState, // 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  getState);\n  let navigator = React.useMemo(() => {\n    return {\n      createHref: router.createHref,\n      encodeLocation: router.encodeLocation,\n      go: n => router.navigate(n),\n      push: (to, state, opts) => router.navigate(to, {\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      }),\n      replace: (to, state, opts) => router.navigate(to, {\n        replace: true,\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      })\n    };\n  }, [router]);\n  let basename = router.basename || \"/\";\n  let dataRouterContext = React.useMemo(() => ({\n    router,\n    navigator,\n    static: false,\n    basename\n  }), [router, navigator, basename]); // The fragment and {null} here are important!  We need them to keep React 18's\n  // useId happy when we are server-rendering since we may have a <script> here\n  // containing the hydrated server-side staticContext (from StaticRouterProvider).\n  // useId relies on the component tree structure to generate deterministic id's\n  // so we need to ensure it remains the same on the client even though\n  // we don't need the <script> tag\n\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(DataRouterContext.Provider, {\n    value: dataRouterContext\n  }, /*#__PURE__*/React.createElement(DataRouterStateContext.Provider, {\n    value: state\n  }, /*#__PURE__*/React.createElement(Router, {\n    basename: 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))), null);\n}\n\n/**\n * A <Router> that stores all entries in memory.\n *\n * @see https://reactrouter.com/router-components/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/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\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of\n  // the router loaded. We can help them understand how to avoid that.\n  \"<Navigate> may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_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/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/components/route\n */\nfunction Route(_props) {\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"A <Route> is only ever to be used as the child of <Routes> element, \" + \"never rendered directly. Please wrap your <Route> in a <Routes>.\") : UNSAFE_invariant(false) ;\n}\n\n/**\n * Provides location context for the rest of the app.\n *\n * Note: You usually won't render a <Router> directly. Instead, you'll render a\n * router that is more specific to your environment such as a <BrowserRouter>\n * in web browsers or a <StaticRouter> for server rendering.\n *\n * @see https://reactrouter.com/router-components/router\n */\nfunction Router(_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\" ? UNSAFE_invariant(false, \"You cannot render a <Router> inside another <Router>.\" + \" You should never have more than one in your app.\") : UNSAFE_invariant(false) : void 0; // 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 locationContext = React.useMemo(() => {\n    let trailingPathname = stripBasename(pathname, basename);\n\n    if (trailingPathname == null) {\n      return null;\n    }\n\n    return {\n      location: {\n        pathname: trailingPathname,\n        search,\n        hash,\n        state,\n        key\n      },\n      navigationType\n    };\n  }, [basename, pathname, search, hash, state, key, navigationType]);\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(locationContext != null, \"<Router basename=\\\"\" + basename + \"\\\"> is not able to match the URL \" + (\"\\\"\" + pathname + search + hash + \"\\\" because it does not start with the \") + \"basename, so the <Router> won't render anything.\") : void 0;\n\n  if (locationContext == 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: locationContext\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/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  let toRender = typeof children === \"function\" ? children(data) : children;\n  return /*#__PURE__*/React.createElement(React.Fragment, null, toRender);\n} ///////////////////////////////////////////////////////////////////////////////\n// UTILS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Creates a route config from a React \"children\" object, which is usually\n * either a `<Route>` element or an array of them. Used internally by\n * `<Routes>` to create a route config from its children.\n *\n * @see https://reactrouter.com/utils/create-routes-from-children\n */\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\" ? UNSAFE_invariant(false, \"[\" + (typeof element.type === \"string\" ? element.type : element.type.name) + \"] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>\") : UNSAFE_invariant(false) : void 0;\n    !(!element.props.index || !element.props.children) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"An index route cannot have child routes.\") : UNSAFE_invariant(false) : void 0;\n    let treePath = [...parentPath, index];\n    let route = {\n      id: element.props.id || treePath.join(\"-\"),\n      caseSensitive: element.props.caseSensitive,\n      element: element.props.element,\n      Component: element.props.Component,\n      index: element.props.index,\n      path: element.props.path,\n      loader: element.props.loader,\n      action: element.props.action,\n      errorElement: element.props.errorElement,\n      ErrorBoundary: element.props.ErrorBoundary,\n      hasErrorBoundary: element.props.ErrorBoundary != null || element.props.errorElement != null,\n      shouldRevalidate: element.props.shouldRevalidate,\n      handle: element.props.handle,\n      lazy: element.props.lazy\n    };\n\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\nfunction detectErrorBoundary(route) {\n  if (process.env.NODE_ENV !== \"production\") {\n    if (route.Component && route.element) {\n      process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `Component` and `element` on your route - \" + \"`element` will be ignored.\") : void 0;\n    }\n\n    if (route.ErrorBoundary && route.errorElement) {\n      process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `ErrorBoundary` and `errorElement` on your route - \" + \"`errorElement` will be ignored.\") : void 0;\n    }\n  } // Note: this check also occurs in createRoutesFromChildren so update\n  // there if you change this\n\n\n  return Boolean(route.ErrorBoundary) || Boolean(route.errorElement);\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,\n    detectErrorBoundary\n  }).initialize();\n} ///////////////////////////////////////////////////////////////////////////////\n\nexport { Await, MemoryRouter, Navigate, Outlet, Route, Router, RouterProvider, Routes, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RouteContext as UNSAFE_RouteContext, detectErrorBoundary as UNSAFE_detectErrorBoundary, createMemoryRouter, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, renderMatches, useBlocker as unstable_useBlocker, 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 * React Router DOM v6.9.0\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nimport * as React from 'react';\nimport { UNSAFE_detectErrorBoundary, Router, UNSAFE_NavigationContext, useHref, useResolvedPath, useLocation, UNSAFE_DataRouterStateContext, useNavigate, createPath, UNSAFE_RouteContext, useMatches, useNavigation, unstable_useBlocker, UNSAFE_DataRouterContext } from 'react-router';\nexport { AbortedDeferredError, Await, MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, RouterProvider, Routes, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RouteContext, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromElements, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, renderMatches, resolvePath, unstable_useBlocker, useActionData, useAsyncError, useAsyncValue, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes } from 'react-router';\nimport { createRouter, createBrowserHistory, createHashHistory, ErrorResponse, stripBasename, UNSAFE_warning, UNSAFE_invariant, joinPaths } from '@remix-run/router';\n\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\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\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nconst defaultMethod = \"get\";\nconst defaultEncType = \"application/x-www-form-urlencoded\";\nfunction isHtmlElement(object) {\n  return object != null && typeof object.tagName === \"string\";\n}\nfunction isButtonElement(object) {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"button\";\n}\nfunction isFormElement(object) {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"form\";\n}\nfunction isInputElement(object) {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"input\";\n}\n\nfunction isModifiedEvent(event) {\n  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\n\nfunction shouldProcessLinkClick(event, target) {\n  return event.button === 0 && ( // Ignore everything but left clicks\n  !target || target === \"_self\") && // Let browser handle \"target=_blank\" etc.\n  !isModifiedEvent(event) // Ignore clicks with modifier keys\n  ;\n}\n/**\n * Creates a URLSearchParams object using the given initializer.\n *\n * This is identical to `new URLSearchParams(init)` except it also\n * supports arrays as values in the object form of the initializer\n * instead of just strings. This is convenient when you need multiple\n * values for a given key, but don't want to use an array initializer.\n *\n * For example, instead of:\n *\n *   let searchParams = new URLSearchParams([\n *     ['sort', 'name'],\n *     ['sort', 'price']\n *   ]);\n *\n * you can do:\n *\n *   let searchParams = createSearchParams({\n *     sort: ['name', 'price']\n *   });\n */\n\nfunction createSearchParams(init) {\n  if (init === void 0) {\n    init = \"\";\n  }\n\n  return new URLSearchParams(typeof init === \"string\" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => {\n    let value = init[key];\n    return memo.concat(Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]);\n  }, []));\n}\nfunction getSearchParamsForLocation(locationSearch, defaultSearchParams) {\n  let searchParams = createSearchParams(locationSearch);\n\n  if (defaultSearchParams) {\n    for (let key of defaultSearchParams.keys()) {\n      if (!searchParams.has(key)) {\n        defaultSearchParams.getAll(key).forEach(value => {\n          searchParams.append(key, value);\n        });\n      }\n    }\n  }\n\n  return searchParams;\n}\nfunction getFormSubmissionInfo(target, defaultAction, options) {\n  let method;\n  let action;\n  let encType;\n  let formData;\n\n  if (isFormElement(target)) {\n    let submissionTrigger = options.submissionTrigger;\n    method = options.method || target.getAttribute(\"method\") || defaultMethod;\n    action = options.action || target.getAttribute(\"action\") || defaultAction;\n    encType = options.encType || target.getAttribute(\"enctype\") || defaultEncType;\n    formData = new FormData(target);\n\n    if (submissionTrigger && submissionTrigger.name) {\n      formData.append(submissionTrigger.name, submissionTrigger.value);\n    }\n  } else if (isButtonElement(target) || isInputElement(target) && (target.type === \"submit\" || target.type === \"image\")) {\n    let form = target.form;\n\n    if (form == null) {\n      throw new Error(\"Cannot submit a <button> or <input type=\\\"submit\\\"> without a <form>\");\n    } // <button>/<input type=\"submit\"> may override attributes of <form>\n\n\n    method = options.method || target.getAttribute(\"formmethod\") || form.getAttribute(\"method\") || defaultMethod;\n    action = options.action || target.getAttribute(\"formaction\") || form.getAttribute(\"action\") || defaultAction;\n    encType = options.encType || target.getAttribute(\"formenctype\") || form.getAttribute(\"enctype\") || defaultEncType;\n    formData = new FormData(form); // Include name + value from a <button>, appending in case the button name\n    // matches an existing input name\n\n    if (target.name) {\n      formData.append(target.name, target.value);\n    }\n  } else if (isHtmlElement(target)) {\n    throw new Error(\"Cannot submit element that is not <form>, <button>, or \" + \"<input type=\\\"submit|image\\\">\");\n  } else {\n    method = options.method || defaultMethod;\n    action = options.action || defaultAction;\n    encType = options.encType || defaultEncType;\n\n    if (target instanceof FormData) {\n      formData = target;\n    } else {\n      formData = new FormData();\n\n      if (target instanceof URLSearchParams) {\n        for (let [name, value] of target) {\n          formData.append(name, value);\n        }\n      } else if (target != null) {\n        for (let name of Object.keys(target)) {\n          formData.append(name, target[name]);\n        }\n      }\n    }\n  }\n\n  let {\n    protocol,\n    host\n  } = window.location;\n  let url = new URL(action, protocol + \"//\" + host);\n  return {\n    url,\n    method: method.toLowerCase(),\n    encType,\n    formData\n  };\n}\n\nconst _excluded = [\"onClick\", \"relative\", \"reloadDocument\", \"replace\", \"state\", \"target\", \"to\", \"preventScrollReset\"],\n      _excluded2 = [\"aria-current\", \"caseSensitive\", \"className\", \"end\", \"style\", \"to\", \"children\"],\n      _excluded3 = [\"reloadDocument\", \"replace\", \"method\", \"action\", \"onSubmit\", \"fetcherKey\", \"routeId\", \"relative\", \"preventScrollReset\"];\n//#region Routers\n////////////////////////////////////////////////////////////////////////////////\n\nfunction createBrowserRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    history: createBrowserHistory({\n      window: opts == null ? void 0 : opts.window\n    }),\n    hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(),\n    routes,\n    detectErrorBoundary: UNSAFE_detectErrorBoundary\n  }).initialize();\n}\nfunction createHashRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    history: createHashHistory({\n      window: opts == null ? void 0 : opts.window\n    }),\n    hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(),\n    routes,\n    detectErrorBoundary: UNSAFE_detectErrorBoundary\n  }).initialize();\n}\n\nfunction parseHydrationData() {\n  var _window;\n\n  let state = (_window = window) == null ? void 0 : _window.__staticRouterHydrationData;\n\n  if (state && state.errors) {\n    state = _extends({}, state, {\n      errors: deserializeErrors(state.errors)\n    });\n  }\n\n  return state;\n}\n\nfunction deserializeErrors(errors) {\n  if (!errors) return null;\n  let entries = Object.entries(errors);\n  let serialized = {};\n\n  for (let [key, val] of entries) {\n    // Hey you!  If you change this, please change the corresponding logic in\n    // serializeErrors in react-router-dom/server.tsx :)\n    if (val && val.__type === \"RouteErrorResponse\") {\n      serialized[key] = new ErrorResponse(val.status, val.statusText, val.data, val.internal === true);\n    } else if (val && val.__type === \"Error\") {\n      let error = new Error(val.message); // Wipe away the client-side stack trace.  Nothing to fill it in with\n      // because we don't serialize SSR stack traces for security reasons\n\n      error.stack = \"\";\n      serialized[key] = error;\n    } else {\n      serialized[key] = val;\n    }\n  }\n\n  return serialized;\n}\n/**\n * A `<Router>` for use in web browsers. Provides the cleanest URLs.\n */\n\n\nfunction BrowserRouter(_ref) {\n  let {\n    basename,\n    children,\n    window\n  } = _ref;\n  let historyRef = React.useRef();\n\n  if (historyRef.current == null) {\n    historyRef.current = createBrowserHistory({\n      window,\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 * A `<Router>` for use in web browsers. Stores the location in the hash\n * portion of the URL so it is not sent to the server.\n */\n\nfunction HashRouter(_ref2) {\n  let {\n    basename,\n    children,\n    window\n  } = _ref2;\n  let historyRef = React.useRef();\n\n  if (historyRef.current == null) {\n    historyRef.current = createHashHistory({\n      window,\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 * A `<Router>` that accepts a pre-instantiated history object. It's important\n * to note that using your own history object is highly discouraged and may add\n * two versions of the history library to your bundles unless you use the same\n * version of the history library that React Router uses internally.\n */\n\nfunction HistoryRouter(_ref3) {\n  let {\n    basename,\n    children,\n    history\n  } = _ref3;\n  const [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\nif (process.env.NODE_ENV !== \"production\") {\n  HistoryRouter.displayName = \"unstable_HistoryRouter\";\n}\nconst isBrowser = typeof window !== \"undefined\" && typeof window.document !== \"undefined\" && typeof window.document.createElement !== \"undefined\";\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n/**\n * The public API for rendering a history-aware <a>.\n */\n\nconst Link = /*#__PURE__*/React.forwardRef(function LinkWithRef(_ref4, ref) {\n  let {\n    onClick,\n    relative,\n    reloadDocument,\n    replace,\n    state,\n    target,\n    to,\n    preventScrollReset\n  } = _ref4,\n      rest = _objectWithoutPropertiesLoose(_ref4, _excluded);\n\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext); // Rendered into <a href> for absolute URLs\n\n  let absoluteHref;\n  let isExternal = false;\n\n  if (typeof to === \"string\" && ABSOLUTE_URL_REGEX.test(to)) {\n    // Render the absolute href server- and client-side\n    absoluteHref = to; // Only check for external origins client-side\n\n    if (isBrowser) {\n      let currentUrl = new URL(window.location.href);\n      let targetUrl = to.startsWith(\"//\") ? new URL(currentUrl.protocol + to) : new URL(to);\n      let path = stripBasename(targetUrl.pathname, basename);\n\n      if (targetUrl.origin === currentUrl.origin && path != null) {\n        // Strip the protocol/origin/basename for same-origin absolute URLs\n        to = path + targetUrl.search + targetUrl.hash;\n      } else {\n        isExternal = true;\n      }\n    }\n  } // Rendered into <a href> for relative URLs\n\n\n  let href = useHref(to, {\n    relative\n  });\n  let internalOnClick = useLinkClickHandler(to, {\n    replace,\n    state,\n    target,\n    preventScrollReset,\n    relative\n  });\n\n  function handleClick(event) {\n    if (onClick) onClick(event);\n\n    if (!event.defaultPrevented) {\n      internalOnClick(event);\n    }\n  }\n\n  return (\n    /*#__PURE__*/\n    // eslint-disable-next-line jsx-a11y/anchor-has-content\n    React.createElement(\"a\", _extends({}, rest, {\n      href: absoluteHref || href,\n      onClick: isExternal || reloadDocument ? onClick : handleClick,\n      ref: ref,\n      target: target\n    }))\n  );\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  Link.displayName = \"Link\";\n}\n/**\n * A <Link> wrapper that knows if it's \"active\" or not.\n */\n\n\nconst NavLink = /*#__PURE__*/React.forwardRef(function NavLinkWithRef(_ref5, ref) {\n  let {\n    \"aria-current\": ariaCurrentProp = \"page\",\n    caseSensitive = false,\n    className: classNameProp = \"\",\n    end = false,\n    style: styleProp,\n    to,\n    children\n  } = _ref5,\n      rest = _objectWithoutPropertiesLoose(_ref5, _excluded2);\n\n  let path = useResolvedPath(to, {\n    relative: rest.relative\n  });\n  let location = useLocation();\n  let routerState = React.useContext(UNSAFE_DataRouterStateContext);\n  let {\n    navigator\n  } = React.useContext(UNSAFE_NavigationContext);\n  let toPathname = navigator.encodeLocation ? navigator.encodeLocation(path).pathname : path.pathname;\n  let locationPathname = location.pathname;\n  let nextLocationPathname = routerState && routerState.navigation && routerState.navigation.location ? routerState.navigation.location.pathname : null;\n\n  if (!caseSensitive) {\n    locationPathname = locationPathname.toLowerCase();\n    nextLocationPathname = nextLocationPathname ? nextLocationPathname.toLowerCase() : null;\n    toPathname = toPathname.toLowerCase();\n  }\n\n  let isActive = locationPathname === toPathname || !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(toPathname.length) === \"/\";\n  let isPending = nextLocationPathname != null && (nextLocationPathname === toPathname || !end && nextLocationPathname.startsWith(toPathname) && nextLocationPathname.charAt(toPathname.length) === \"/\");\n  let ariaCurrent = isActive ? ariaCurrentProp : undefined;\n  let className;\n\n  if (typeof classNameProp === \"function\") {\n    className = classNameProp({\n      isActive,\n      isPending\n    });\n  } else {\n    // If the className prop is not a function, we use a default `active`\n    // class for <NavLink />s that are active. In v5 `active` was the default\n    // value for `activeClassName`, but we are removing that API and can still\n    // use the old default behavior for a cleaner upgrade path and keep the\n    // simple styling rules working as they currently do.\n    className = [classNameProp, isActive ? \"active\" : null, isPending ? \"pending\" : null].filter(Boolean).join(\" \");\n  }\n\n  let style = typeof styleProp === \"function\" ? styleProp({\n    isActive,\n    isPending\n  }) : styleProp;\n  return /*#__PURE__*/React.createElement(Link, _extends({}, rest, {\n    \"aria-current\": ariaCurrent,\n    className: className,\n    ref: ref,\n    style: style,\n    to: to\n  }), typeof children === \"function\" ? children({\n    isActive,\n    isPending\n  }) : children);\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  NavLink.displayName = \"NavLink\";\n}\n/**\n * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except\n * that the interaction with the server is with `fetch` instead of new document\n * requests, allowing components to add nicer UX to the page as the form is\n * submitted and returns with data.\n */\n\n\nconst Form = /*#__PURE__*/React.forwardRef((props, ref) => {\n  return /*#__PURE__*/React.createElement(FormImpl, _extends({}, props, {\n    ref: ref\n  }));\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  Form.displayName = \"Form\";\n}\n\nconst FormImpl = /*#__PURE__*/React.forwardRef((_ref6, forwardedRef) => {\n  let {\n    reloadDocument,\n    replace,\n    method = defaultMethod,\n    action,\n    onSubmit,\n    fetcherKey,\n    routeId,\n    relative,\n    preventScrollReset\n  } = _ref6,\n      props = _objectWithoutPropertiesLoose(_ref6, _excluded3);\n\n  let submit = useSubmitImpl(fetcherKey, routeId);\n  let formMethod = method.toLowerCase() === \"get\" ? \"get\" : \"post\";\n  let formAction = useFormAction(action, {\n    relative\n  });\n\n  let submitHandler = event => {\n    onSubmit && onSubmit(event);\n    if (event.defaultPrevented) return;\n    event.preventDefault();\n    let submitter = event.nativeEvent.submitter;\n    let submitMethod = (submitter == null ? void 0 : submitter.getAttribute(\"formmethod\")) || method;\n    submit(submitter || event.currentTarget, {\n      method: submitMethod,\n      replace,\n      relative,\n      preventScrollReset\n    });\n  };\n\n  return /*#__PURE__*/React.createElement(\"form\", _extends({\n    ref: forwardedRef,\n    method: formMethod,\n    action: formAction,\n    onSubmit: reloadDocument ? onSubmit : submitHandler\n  }, props));\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  FormImpl.displayName = \"FormImpl\";\n}\n/**\n * This component will emulate the browser's scroll restoration on location\n * changes.\n */\n\n\nfunction ScrollRestoration(_ref7) {\n  let {\n    getKey,\n    storageKey\n  } = _ref7;\n  useScrollRestoration({\n    getKey,\n    storageKey\n  });\n  return null;\n}\n\nif (process.env.NODE_ENV !== \"production\") {\n  ScrollRestoration.displayName = \"ScrollRestoration\";\n} //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Hooks\n////////////////////////////////////////////////////////////////////////////////\n\n\nvar DataRouterHook;\n\n(function (DataRouterHook) {\n  DataRouterHook[\"UseScrollRestoration\"] = \"useScrollRestoration\";\n  DataRouterHook[\"UseSubmitImpl\"] = \"useSubmitImpl\";\n  DataRouterHook[\"UseFetcher\"] = \"useFetcher\";\n})(DataRouterHook || (DataRouterHook = {}));\n\nvar DataRouterStateHook;\n\n(function (DataRouterStateHook) {\n  DataRouterStateHook[\"UseFetchers\"] = \"useFetchers\";\n  DataRouterStateHook[\"UseScrollRestoration\"] = \"useScrollRestoration\";\n})(DataRouterStateHook || (DataRouterStateHook = {}));\n\nfunction getDataRouterConsoleError(hookName) {\n  return hookName + \" must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.\";\n}\n\nfunction useDataRouterContext(hookName) {\n  let ctx = React.useContext(UNSAFE_DataRouterContext);\n  !ctx ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return ctx;\n}\n\nfunction useDataRouterState(hookName) {\n  let state = React.useContext(UNSAFE_DataRouterStateContext);\n  !state ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return state;\n}\n/**\n * Handles the click behavior for router `<Link>` components. This is useful if\n * you need to create custom `<Link>` components with the same click behavior we\n * use in our exported `<Link>`.\n */\n\n\nfunction useLinkClickHandler(to, _temp) {\n  let {\n    target,\n    replace: replaceProp,\n    state,\n    preventScrollReset,\n    relative\n  } = _temp === void 0 ? {} : _temp;\n  let navigate = useNavigate();\n  let location = useLocation();\n  let path = useResolvedPath(to, {\n    relative\n  });\n  return React.useCallback(event => {\n    if (shouldProcessLinkClick(event, target)) {\n      event.preventDefault(); // If the URL hasn't changed, a regular <a> will do a replace instead of\n      // a push, so do the same here unless the replace prop is explicitly set\n\n      let replace = replaceProp !== undefined ? replaceProp : createPath(location) === createPath(path);\n      navigate(to, {\n        replace,\n        state,\n        preventScrollReset,\n        relative\n      });\n    }\n  }, [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative]);\n}\n/**\n * A convenient wrapper for reading and writing search parameters via the\n * URLSearchParams interface.\n */\n\nfunction useSearchParams(defaultInit) {\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(typeof URLSearchParams !== \"undefined\", \"You cannot use the `useSearchParams` hook in a browser that does not \" + \"support the URLSearchParams API. If you need to support Internet \" + \"Explorer 11, we recommend you load a polyfill such as \" + \"https://github.com/ungap/url-search-params\\n\\n\" + \"If you're unsure how to load polyfills, we recommend you check out \" + \"https://polyfill.io/v3/ which provides some recommendations about how \" + \"to load polyfills only for users that need them, instead of for every \" + \"user.\") : void 0;\n  let defaultSearchParamsRef = React.useRef(createSearchParams(defaultInit));\n  let hasSetSearchParamsRef = React.useRef(false);\n  let location = useLocation();\n  let searchParams = React.useMemo(() => // Only merge in the defaults if we haven't yet called setSearchParams.\n  // Once we call that we want those to take precedence, otherwise you can't\n  // remove a param with setSearchParams({}) if it has an initial value\n  getSearchParamsForLocation(location.search, hasSetSearchParamsRef.current ? null : defaultSearchParamsRef.current), [location.search]);\n  let navigate = useNavigate();\n  let setSearchParams = React.useCallback((nextInit, navigateOptions) => {\n    const newSearchParams = createSearchParams(typeof nextInit === \"function\" ? nextInit(searchParams) : nextInit);\n    hasSetSearchParamsRef.current = true;\n    navigate(\"?\" + newSearchParams, navigateOptions);\n  }, [navigate, searchParams]);\n  return [searchParams, setSearchParams];\n}\n/**\n * Returns a function that may be used to programmatically submit a form (or\n * some arbitrary data) to the server.\n */\n\nfunction useSubmit() {\n  return useSubmitImpl();\n}\n\nfunction useSubmitImpl(fetcherKey, routeId) {\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseSubmitImpl);\n  let defaultAction = useFormAction();\n  return React.useCallback(function (target, options) {\n    if (options === void 0) {\n      options = {};\n    }\n\n    if (typeof document === \"undefined\") {\n      throw new Error(\"You are calling submit during the server render. \" + \"Try calling submit within a `useEffect` or callback instead.\");\n    }\n\n    let {\n      method,\n      encType,\n      formData,\n      url\n    } = getFormSubmissionInfo(target, defaultAction, options);\n    let href = url.pathname + url.search;\n    let opts = {\n      replace: options.replace,\n      preventScrollReset: options.preventScrollReset,\n      formData,\n      formMethod: method,\n      formEncType: encType\n    };\n\n    if (fetcherKey) {\n      !(routeId != null) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"No routeId available for useFetcher()\") : UNSAFE_invariant(false) : void 0;\n      router.fetch(fetcherKey, routeId, href, opts);\n    } else {\n      router.navigate(href, opts);\n    }\n  }, [defaultAction, router, fetcherKey, routeId]);\n}\n\nfunction useFormAction(action, _temp2) {\n  let {\n    relative\n  } = _temp2 === void 0 ? {} : _temp2;\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  let routeContext = React.useContext(UNSAFE_RouteContext);\n  !routeContext ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFormAction must be used inside a RouteContext\") : UNSAFE_invariant(false) : void 0;\n  let [match] = routeContext.matches.slice(-1); // Shallow clone path so we can modify it below, otherwise we modify the\n  // object referenced by useMemo inside useResolvedPath\n\n  let path = _extends({}, useResolvedPath(action ? action : \".\", {\n    relative\n  })); // Previously we set the default action to \".\". The problem with this is that\n  // `useResolvedPath(\".\")` excludes search params and the hash of the resolved\n  // URL. This is the intended behavior of when \".\" is specifically provided as\n  // the form action, but inconsistent w/ browsers when the action is omitted.\n  // https://github.com/remix-run/remix/issues/927\n\n\n  let location = useLocation();\n\n  if (action == null) {\n    // Safe to write to these directly here since if action was undefined, we\n    // would have called useResolvedPath(\".\") which will never include a search\n    // or hash\n    path.search = location.search;\n    path.hash = location.hash; // When grabbing search params from the URL, remove the automatically\n    // inserted ?index param so we match the useResolvedPath search behavior\n    // which would not include ?index\n\n    if (match.route.index) {\n      let params = new URLSearchParams(path.search);\n      params.delete(\"index\");\n      path.search = params.toString() ? \"?\" + params.toString() : \"\";\n    }\n  }\n\n  if ((!action || action === \".\") && match.route.index) {\n    path.search = path.search ? path.search.replace(/^\\?/, \"?index&\") : \"?index\";\n  } // If we're operating within a basename, prepend it to the pathname prior\n  // to creating the form action.  If this is a root navigation, then just use\n  // the raw basename which allows the basename to have full control over the\n  // presence of a trailing slash on root actions\n\n\n  if (basename !== \"/\") {\n    path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n\n  return createPath(path);\n}\n\nfunction createFetcherForm(fetcherKey, routeId) {\n  let FetcherForm = /*#__PURE__*/React.forwardRef((props, ref) => {\n    return /*#__PURE__*/React.createElement(FormImpl, _extends({}, props, {\n      ref: ref,\n      fetcherKey: fetcherKey,\n      routeId: routeId\n    }));\n  });\n\n  if (process.env.NODE_ENV !== \"production\") {\n    FetcherForm.displayName = \"fetcher.Form\";\n  }\n\n  return FetcherForm;\n}\n\nlet fetcherId = 0;\n/**\n * Interacts with route loaders and actions without causing a navigation. Great\n * for any interaction that stays on the same page.\n */\n\nfunction useFetcher() {\n  var _route$matches;\n\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseFetcher);\n  let route = React.useContext(UNSAFE_RouteContext);\n  !route ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher must be used inside a RouteContext\") : UNSAFE_invariant(false) : void 0;\n  let routeId = (_route$matches = route.matches[route.matches.length - 1]) == null ? void 0 : _route$matches.route.id;\n  !(routeId != null) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher can only be used on routes that contain a unique \\\"id\\\"\") : UNSAFE_invariant(false) : void 0;\n  let [fetcherKey] = React.useState(() => String(++fetcherId));\n  let [Form] = React.useState(() => {\n    !routeId ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"No routeId available for fetcher.Form()\") : UNSAFE_invariant(false) : void 0;\n    return createFetcherForm(fetcherKey, routeId);\n  });\n  let [load] = React.useState(() => href => {\n    !router ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"No router available for fetcher.load()\") : UNSAFE_invariant(false) : void 0;\n    !routeId ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"No routeId available for fetcher.load()\") : UNSAFE_invariant(false) : void 0;\n    router.fetch(fetcherKey, routeId, href);\n  });\n  let submit = useSubmitImpl(fetcherKey, routeId);\n  let fetcher = router.getFetcher(fetcherKey);\n  let fetcherWithComponents = React.useMemo(() => _extends({\n    Form,\n    submit,\n    load\n  }, fetcher), [fetcher, Form, submit, load]);\n  React.useEffect(() => {\n    // Is this busted when the React team gets real weird and calls effects\n    // twice on mount?  We really just need to garbage collect here when this\n    // fetcher is no longer around.\n    return () => {\n      if (!router) {\n        console.warn(\"No fetcher available to clean up from useFetcher()\");\n        return;\n      }\n\n      router.deleteFetcher(fetcherKey);\n    };\n  }, [router, fetcherKey]);\n  return fetcherWithComponents;\n}\n/**\n * Provides all fetchers currently on the page. Useful for layouts and parent\n * routes that need to provide pending/optimistic UI regarding the fetch.\n */\n\nfunction useFetchers() {\n  let state = useDataRouterState(DataRouterStateHook.UseFetchers);\n  return [...state.fetchers.values()];\n}\nconst SCROLL_RESTORATION_STORAGE_KEY = \"react-router-scroll-positions\";\nlet savedScrollPositions = {};\n/**\n * When rendered inside a RouterProvider, will restore scroll positions on navigations\n */\n\nfunction useScrollRestoration(_temp3) {\n  let {\n    getKey,\n    storageKey\n  } = _temp3 === void 0 ? {} : _temp3;\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseScrollRestoration);\n  let {\n    restoreScrollPosition,\n    preventScrollReset\n  } = useDataRouterState(DataRouterStateHook.UseScrollRestoration);\n  let location = useLocation();\n  let matches = useMatches();\n  let navigation = useNavigation(); // Trigger manual scroll restoration while we're active\n\n  React.useEffect(() => {\n    window.history.scrollRestoration = \"manual\";\n    return () => {\n      window.history.scrollRestoration = \"auto\";\n    };\n  }, []); // Save positions on pagehide\n\n  usePageHide(React.useCallback(() => {\n    if (navigation.state === \"idle\") {\n      let key = (getKey ? getKey(location, matches) : null) || location.key;\n      savedScrollPositions[key] = window.scrollY;\n    }\n\n    sessionStorage.setItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY, JSON.stringify(savedScrollPositions));\n    window.history.scrollRestoration = \"auto\";\n  }, [storageKey, getKey, navigation.state, location, matches])); // Read in any saved scroll locations\n\n  if (typeof document !== \"undefined\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      try {\n        let sessionPositions = sessionStorage.getItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY);\n\n        if (sessionPositions) {\n          savedScrollPositions = JSON.parse(sessionPositions);\n        }\n      } catch (e) {// no-op, use default empty object\n      }\n    }, [storageKey]); // Enable scroll restoration in the router\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n\n    React.useLayoutEffect(() => {\n      let disableScrollRestoration = router == null ? void 0 : router.enableScrollRestoration(savedScrollPositions, () => window.scrollY, getKey);\n      return () => disableScrollRestoration && disableScrollRestoration();\n    }, [router, getKey]); // Restore scrolling when state.restoreScrollPosition changes\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n\n    React.useLayoutEffect(() => {\n      // Explicit false means don't do anything (used for submissions)\n      if (restoreScrollPosition === false) {\n        return;\n      } // been here before, scroll to it\n\n\n      if (typeof restoreScrollPosition === \"number\") {\n        window.scrollTo(0, restoreScrollPosition);\n        return;\n      } // try to scroll to the hash\n\n\n      if (location.hash) {\n        let el = document.getElementById(location.hash.slice(1));\n\n        if (el) {\n          el.scrollIntoView();\n          return;\n        }\n      } // Don't reset if this navigation opted out\n\n\n      if (preventScrollReset === true) {\n        return;\n      } // otherwise go to the top on new locations\n\n\n      window.scrollTo(0, 0);\n    }, [location, restoreScrollPosition, preventScrollReset]);\n  }\n}\n/**\n * Setup a callback to be fired on the window's `beforeunload` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\n\nfunction useBeforeUnload(callback, options) {\n  let {\n    capture\n  } = options || {};\n  React.useEffect(() => {\n    let opts = capture != null ? {\n      capture\n    } : undefined;\n    window.addEventListener(\"beforeunload\", callback, opts);\n    return () => {\n      window.removeEventListener(\"beforeunload\", callback, opts);\n    };\n  }, [callback, capture]);\n}\n/**\n * Setup a callback to be fired on the window's `pagehide` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.  This event is better supported than beforeunload across browsers.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\n\nfunction usePageHide(callback, options) {\n  let {\n    capture\n  } = options || {};\n  React.useEffect(() => {\n    let opts = capture != null ? {\n      capture\n    } : undefined;\n    window.addEventListener(\"pagehide\", callback, opts);\n    return () => {\n      window.removeEventListener(\"pagehide\", callback, opts);\n    };\n  }, [callback, capture]);\n}\n/**\n * Wrapper around useBlocker to show a window.confirm prompt to users instead\n * of building a custom UI with useBlocker.\n *\n * Warning: This has *a lot of rough edges* and behaves very differently (and\n * very incorrectly in some cases) across browsers if user click addition\n * back/forward navigations while the confirm is open.  Use at your own risk.\n */\n\n\nfunction usePrompt(_ref8) {\n  let {\n    when,\n    message\n  } = _ref8;\n  let blocker = unstable_useBlocker(when);\n  React.useEffect(() => {\n    if (blocker.state === \"blocked\" && !when) {\n      blocker.reset();\n    }\n  }, [blocker, when]);\n  React.useEffect(() => {\n    if (blocker.state === \"blocked\") {\n      let proceed = window.confirm(message);\n\n      if (proceed) {\n        setTimeout(blocker.proceed, 0);\n      } else {\n        blocker.reset();\n      }\n    }\n  }, [blocker, message]);\n}\n //#endregion\n\nexport { BrowserRouter, Form, HashRouter, Link, NavLink, ScrollRestoration, useScrollRestoration as UNSAFE_useScrollRestoration, createBrowserRouter, createHashRouter, createSearchParams, HistoryRouter as unstable_HistoryRouter, usePrompt as unstable_usePrompt, useBeforeUnload, useFetcher, useFetchers, useFormAction, useLinkClickHandler, useSearchParams, useSubmit };\n//# sourceMappingURL=index.js.map\n"],"names":["Action","_extends","Object","assign","bind","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","apply","this","PopStateEventType","createMemoryHistory","options","entries","initialEntries","initialIndex","v5Compat","map","entry","index","createMemoryLocation","state","undefined","clampIndex","action","Pop","listener","n","Math","min","max","getCurrentLocation","to","location","createLocation","pathname","warning","charAt","JSON","stringify","createHref","createPath","createURL","URL","encodeLocation","path","parsePath","search","hash","push","Push","nextLocation","splice","delta","replace","Replace","go","nextIndex","listen","fn","createBrowserHistory","getUrlBasedHistory","window","globalHistory","usr","createHashHistory","substr","base","document","querySelector","href","getAttribute","url","hashIndex","indexOf","slice","invariant","value","message","Error","cond","console","warn","e","getHistoryState","idx","current","random","toString","_ref","parsedPath","searchIndex","getLocation","validateLocation","defaultView","history","getIndex","handlePop","origin","replaceState","addEventListener","removeEventListener","historyState","pushState","error","ResultType","immutableRouteKeys","Set","convertRoutesToDataRoutes","routes","detectErrorBoundary","parentPath","manifest","route","treePath","id","join","children","isIndexRoute","indexRoute","hasErrorBoundary","pathOrLayoutRoute","matchRoutes","locationArg","basename","stripBasename","branches","flattenRoutes","sort","a","b","score","every","compareIndexes","routesMeta","meta","childrenIndex","rankRouteBranches","matches","matchRouteBranch","safelyDecodeURI","parentsMeta","flattenRoute","relativePath","caseSensitive","startsWith","joinPaths","concat","computeScore","forEach","_route$path","includes","exploded","explodeOptionalSegments","segments","split","first","rest","isOptional","endsWith","required","restExploded","result","subpath","paramRe","dynamicSegmentValue","indexRouteValue","emptySegmentValue","staticSegmentValue","splatPenalty","isSplat","s","initialScore","some","filter","reduce","segment","test","branch","matchedParams","matchedPathname","end","remainingPathname","match","matchPath","params","pathnameBase","normalizePathname","generatePath","originalPath","array","keyMatch","optional","param","pattern","matcher","paramNames","regexpSource","_","paramName","RegExp","compilePath","captureGroups","memo","splatValue","decodeURIComponent","safelyDecodeURIComponent","decodeURI","toLowerCase","startIndex","nextChar","resolvePath","fromPathname","toPathname","pop","resolvePathname","normalizeSearch","normalizeHash","getInvalidPathError","char","field","dest","getPathContributingMatches","resolveTo","toArg","routePathnames","locationPathname","isPathRelative","from","isEmptyPath","routePathnameIndex","toSegments","shift","hasExplicitTrailingSlash","hasCurrentTrailingSlash","paths","json","data","init","responseInit","status","headers","Headers","has","set","Response","AbortedDeferredError","DeferredData","constructor","reject","pendingKeysSet","subscribers","deferredKeys","Array","isArray","abortPromise","Promise","r","controller","AbortController","onAbort","unlistenAbortSignal","signal","acc","trackPromise","done","add","promise","race","then","onSettle","catch","defineProperty","get","aborted","delete","emit","settledKey","subscriber","subscribe","cancel","abort","v","k","async","resolve","size","unwrappedData","_ref2","unwrapTrackedPromise","pendingKeys","_tracked","isTrackedPromise","_error","_data","defer","redirect","ErrorResponse","statusText","internal","isRouteErrorResponse","validMutationMethodsArr","validMutationMethods","validRequestMethodsArr","validRequestMethods","redirectStatusCodes","redirectPreserveMethodStatusCodes","IDLE_NAVIGATION","formMethod","formAction","formEncType","formData","IDLE_FETCHER","IDLE_BLOCKER","proceed","reset","ABSOLUTE_URL_REGEX","isBrowser","createElement","isServer","defaultDetectErrorBoundary","Boolean","createRouter","inFlightDataRoutes","dataRoutes","unlistenHistory","savedScrollPositions","getScrollRestorationKey","getScrollPosition","initialScrollRestored","hydrationData","initialMatches","initialErrors","getInternalRouterError","getShortCircuitMatches","router","pendingNavigationController","initialized","m","lazy","loader","historyAction","navigation","restoreScrollPosition","preventScrollReset","revalidation","loaderData","actionData","errors","fetchers","Map","blockers","pendingAction","pendingPreventScrollReset","isUninterruptedRevalidation","isRevalidationRequired","cancelledDeferredRoutes","cancelledFetcherLoads","fetchControllers","incrementingLoadId","pendingNavigationLoadId","fetchReloadIds","fetchRedirectIds","fetchLoadMatches","activeDeferreds","blockerFunctions","ignoreNextHistoryUpdate","updateState","newState","completeNavigation","_location$state","_location$state2","isActionReload","isMutationMethod","_isRedirect","keys","mergeLoaderData","deleteBlocker","getSavedScrollPosition","startNavigation","opts","startUninterruptedRevalidation","userMatches","createUseMatchesMatch","saveScrollPosition","routesToUse","loadingNavigation","overrideNavigation","notFoundMatches","cancelActiveDeferreds","submission","pendingActionData","pendingError","request","createClientSideRequest","findNearestBoundary","actionOutput","interruptActiveLoads","actionMatch","getTargetMatch","callLoaderOrAction","shortCircuited","type","method","routeId","isRedirectResult","startRedirectNavigation","isErrorResult","boundaryMatch","pendingActionError","isDeferredResult","handleAction","Request","activeSubmission","matchesToLoad","revalidatingFetchers","getMatchesToLoad","rf","fetcher","revalidatingFetcher","results","loaderResults","fetcherResults","callLoadersAndMaybeResolveData","findRedirect","processLoaderData","deferredData","doneKeys","markFetchersDone","markFetchRedirectsDone","abortStaleFetchLoads","handleLoaders","getFetcher","_temp","_window","isFetchActionRedirect","revalidate","redirectLocation","_isFetchActionRedirect","isDifferentBasename","redirectHistoryAction","currentMatches","fetchersToLoad","all","f","resolveDeferredResults","abortFetcher","setFetcherError","deleteFetcher","doneFetcher","landedId","yeetedKeys","updateBlocker","newBlocker","blocker","shouldBlockNavigation","currentLocation","blockerKey","blockerFunction","predicate","cancelledRouteIds","dfd","y","initialize","lazyMatches","lazyPromises","loadLazyRouteModule","enableScrollRestoration","positions","getPosition","getKey","navigate","normalizeNavigateOptions","userReplace","fetch","requestMatches","existingFetcher","abortController","fetchRequest","actionResult","loadingFetcher","revalidationRequest","loadId","loadFetcher","staleKey","didAbortFetchLoads","handleFetcherAction","resolveDeferredData","handleFetcherLoader","dispose","clear","getBlocker","_internalFetchControllers","_internalActiveDeferreds","_internalSetRoutes","newRoutes","isFetcher","isSubmissionNavigation","stripHashFromPath","searchParams","convertFormDataToSearchParams","hasNakedIndexQuery","append","values","currentUrl","nextUrl","defaultShouldRevalidate","boundaryId","navigationMatches","boundaryMatches","findIndex","getLoaderMatchesUntilBoundary","currentLoaderData","currentMatch","isNew","isMissingData","isNewLoader","currentRouteMatch","nextRouteMatch","shouldRevalidateLoader","currentParams","nextParams","isNewRouteInstance","fetcherMatches","fetcherMatch","currentPath","loaderMatch","arg","shouldRevalidate","routeChoice","lazyRoute","routeToUpdate","routeUpdates","lazyRouteProperty","isPropertyStaticallyDefined","isStaticRequest","isRouteRequest","requestContext","resultType","onReject","runHandler","handler","context","body","protocol","isSameBasename","resolvedLocation","response","contentType","text","statusCode","_result$init","_result$init2","deferred","toUpperCase","URLSearchParams","File","name","foundError","loaderHeaders","processRouteLoaderData","newLoaderData","mergedLoaderData","reverse","find","_temp4","errorMessage","isRevalidatingLoader","unwrap","resolveData","getAll","handle","pathMatches","Symbol","is","x","useState","useEffect","useLayoutEffect","useDebugValue","checkIfSnapshotChanged","inst","latestGetSnapshot","getSnapshot","prevValue","nextValue","shim","getServerSnapshot","forceUpdate","useSyncExternalStore","DataRouterContext","DataRouterStateContext","AwaitContext","NavigationContext","LocationContext","RouteContext","outlet","RouteErrorContext","useHref","relative","useInRouterContext","navigator","useResolvedPath","joinedPathname","useLocation","useNavigationType","navigationType","useMatch","useNavigate","routePathnamesJson","activeRef","parse","OutletContext","useOutletContext","useOutlet","Provider","useParams","routeMatch","_temp2","useRoutes","dataRouterStateContext","parentMatches","parentParams","parentPathnameBase","locationFromContext","_parsedLocationArg$pa","parsedLocationArg","renderedMatches","_renderMatches","DefaultErrorComponent","useRouteError","stack","preStyles","padding","backgroundColor","style","fontStyle","RenderErrorBoundary","props","super","static","componentDidCatch","errorInfo","render","routeContext","component","RenderedRoute","dataRouterContext","staticContext","errorElement","ErrorBoundary","_deepestRenderedBoundaryId","dataRouterState","errorIndex","reduceRight","getChildren","Component","element","DataRouterHook","DataRouterStateHook","useDataRouterContext","hookName","ctx","useDataRouterState","useCurrentRouteId","useRouteContext","thisRoute","useNavigation","UseNavigation","useRevalidator","UseRevalidator","useMatches","UseMatches","useLoaderData","UseLoaderData","useRouteLoaderData","UseRouteLoaderData","useActionData","UseActionData","_state$errors","UseRouteError","useAsyncValue","useAsyncError","blockerId","useBlocker","shouldBlock","UseBlocker","String","args","RouterProvider","fallbackElement","getState","Router","Routes","MemoryRouter","historyRef","setState","Navigate","_ref3","Outlet","Route","_props","_ref4","basenameProp","locationProp","staticProp","navigationContext","locationContext","trailingPathname","_ref5","createRoutesFromChildren","Await","_ref6","AwaitErrorBoundary","ResolveAwait","AwaitRenderStatus","neverSettledPromise","pending","renderError","success","_ref7","toRender","renderMatches","createMemoryRouter","_objectWithoutPropertiesLoose","excluded","sourceKeys","defaultMethod","defaultEncType","isHtmlElement","object","tagName","createSearchParams","_excluded","_excluded2","_excluded3","createBrowserRouter","parseHydrationData","createHashRouter","__staticRouterHydrationData","deserializeErrors","serialized","val","__type","BrowserRouter","HashRouter","HistoryRouter","Link","ref","absoluteHref","onClick","reloadDocument","isExternal","targetUrl","internalOnClick","useLinkClickHandler","event","defaultPrevented","NavLink","ariaCurrentProp","className","classNameProp","styleProp","routerState","nextLocationPathname","isActive","isPending","ariaCurrent","Form","FormImpl","forwardedRef","onSubmit","fetcherKey","submit","useSubmitImpl","useFormAction","preventDefault","submitter","nativeEvent","submitMethod","currentTarget","ScrollRestoration","storageKey","useScrollRestoration","replaceProp","button","metaKey","altKey","ctrlKey","shiftKey","isModifiedEvent","shouldProcessLinkClick","useSearchParams","defaultInit","defaultSearchParamsRef","hasSetSearchParamsRef","locationSearch","defaultSearchParams","getSearchParamsForLocation","setSearchParams","nextInit","navigateOptions","newSearchParams","useSubmit","UseSubmitImpl","defaultAction","encType","submissionTrigger","FormData","isButtonElement","isInputElement","form","host","getFormSubmissionInfo","fetcherId","useFetcher","_route$matches","UseFetcher","createFetcherForm","load","fetcherWithComponents","useFetchers","UseFetchers","SCROLL_RESTORATION_STORAGE_KEY","_temp3","UseScrollRestoration","scrollRestoration","callback","capture","usePageHide","scrollY","sessionStorage","setItem","sessionPositions","getItem","disableScrollRestoration","el","getElementById","scrollIntoView","scrollTo","useBeforeUnload","usePrompt","_ref8","when","confirm","setTimeout"],"sourceRoot":""}