{"version":3,"file":"static/js/chunk-mix3.968c1ed5.chunk.js","mappings":"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","sources":["../node_modules/.pnpm/@remix-run+router@1.16.0/node_modules/@remix-run/router/history.ts","../node_modules/.pnpm/@remix-run+router@1.16.0/node_modules/@remix-run/router/utils.ts","../node_modules/.pnpm/@remix-run+router@1.16.0/node_modules/@remix-run/router/router.ts","../node_modules/.pnpm/@restart+hooks@0.4.15_react@18.2.0/node_modules/@restart/hooks/esm/useMediaQuery.js","../node_modules/.pnpm/@restart+hooks@0.4.15_react@18.2.0/node_modules/@restart/hooks/esm/useBreakpoint.js","../node_modules/.pnpm/@restart+hooks@0.4.15_react@18.2.0/node_modules/@restart/hooks/esm/useCallbackRef.js","../node_modules/.pnpm/@restart+hooks@0.4.15_react@18.2.0/node_modules/@restart/hooks/esm/useCommittedRef.js","../node_modules/.pnpm/@restart+hooks@0.4.15_react@18.2.0/node_modules/@restart/hooks/esm/useEventCallback.js","../node_modules/.pnpm/@restart+hooks@0.4.15_react@18.2.0/node_modules/@restart/hooks/esm/useEventListener.js","../node_modules/.pnpm/@restart+hooks@0.4.15_react@18.2.0/node_modules/@restart/hooks/esm/useForceUpdate.js","../node_modules/.pnpm/@restart+hooks@0.4.15_react@18.2.0/node_modules/@restart/hooks/esm/useIsomorphicEffect.js","../node_modules/.pnpm/@restart+hooks@0.4.15_react@18.2.0/node_modules/@restart/hooks/esm/useMergedRefs.js","../node_modules/.pnpm/@restart+hooks@0.4.15_react@18.2.0/node_modules/@restart/hooks/esm/useMounted.js","../node_modules/.pnpm/@restart+hooks@0.4.15_react@18.2.0/node_modules/@restart/hooks/esm/usePrevious.js","../node_modules/.pnpm/@restart+hooks@0.4.15_react@18.2.0/node_modules/@restart/hooks/esm/useTimeout.js","../node_modules/.pnpm/@restart+hooks@0.4.15_react@18.2.0/node_modules/@restart/hooks/esm/useWillUnmount.js","../node_modules/.pnpm/@restart+hooks@0.4.15_react@18.2.0/node_modules/@restart/hooks/esm/useUpdatedRef.js","../node_modules/.pnpm/@restart+hooks@0.4.15_react@18.2.0/node_modules/@restart/hooks/esm/useResizeObserver.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/Anchor.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/Button.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/DataKey.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/Dropdown.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/DropdownContext.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/DropdownItem.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/DropdownMenu.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/DropdownToggle.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/ImperativeTransition.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/Modal.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/ModalManager.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/getScrollbarWidth.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/Nav.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/NavContext.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/NavItem.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/NoopTransition.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/useRootClose.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/Overlay.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/SelectableContext.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/TabContext.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/TabPanel.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/Tabs.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/mergeOptionsWithPopperConfig.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/useClickOutside.js","../node_modules/.pnpm/@restart+hooks@0.4.15_react@18.2.0/node_modules/@restart/hooks/esm/useSafeState.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/popper.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/usePopper.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/useWaitForDOMRef.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/useWindow.js","../node_modules/.pnpm/@restart+ui@1.6.6_react-dom@18.2.0_react@18.2.0/node_modules/@restart/ui/esm/utils.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/index.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/adapters/xhr.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/axios.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/cancel/CancelToken.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/cancel/CanceledError.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/cancel/isCancel.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/core/Axios.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/core/AxiosError.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/core/InterceptorManager.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/core/buildFullPath.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/core/dispatchRequest.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/core/mergeConfig.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/core/settle.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/core/transformData.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/defaults/index.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/defaults/transitional.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/env/classes/FormData.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/env/data.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/helpers/AxiosURLSearchParams.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/helpers/bind.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/helpers/buildURL.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/helpers/combineURLs.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/helpers/cookies.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/helpers/formDataToJSON.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/helpers/isAbsoluteURL.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/helpers/isAxiosError.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/helpers/isURLSameOrigin.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/helpers/normalizeHeaderName.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/helpers/parseHeaders.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/helpers/parseProtocol.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/helpers/spread.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/helpers/toFormData.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/helpers/toURLEncodedForm.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/helpers/validator.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/platform/browser/classes/FormData.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/platform/browser/classes/URLSearchParams.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/platform/browser/index.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/platform/index.js","../node_modules/.pnpm/axios@0.28.1/node_modules/axios/lib/utils.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/convert/dmp.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/convert/xml.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/diff/array.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/diff/base.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/diff/character.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/diff/css.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/diff/json.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/diff/line.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/diff/sentence.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/diff/word.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/index.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/patch/apply.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/patch/create.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/patch/merge.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/patch/parse.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/util/array.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/util/distance-iterator.js","../node_modules/.pnpm/diff@5.1.0/node_modules/diff/src/util/params.js"],"sourcesContent":["////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Actions represent the type of change to a location value.\n */\nexport enum 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  Pop = \"POP\",\n\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  Push = \"PUSH\",\n\n  /**\n   * A REPLACE indicates the entry at the current index in the history stack\n   * being replaced by a new one.\n   */\n  Replace = \"REPLACE\",\n}\n\n/**\n * The pathname, search, and hash values of a URL.\n */\nexport interface Path {\n  /**\n   * A URL pathname, beginning with a /.\n   */\n  pathname: string;\n\n  /**\n   * A URL search string, beginning with a ?.\n   */\n  search: string;\n\n  /**\n   * A URL fragment identifier, beginning with a #.\n   */\n  hash: string;\n}\n\n// TODO: (v7) Change the Location generic default from `any` to `unknown` and\n// remove Remix `useLocation` wrapper.\n\n/**\n * An entry in a history stack. A location contains information about the\n * URL path, as well as possibly some arbitrary state and a key.\n */\nexport interface Location<State = any> extends Path {\n  /**\n   * A value of arbitrary data associated with this location.\n   */\n  state: State;\n\n  /**\n   * A unique string associated with this location. May be used to safely store\n   * and retrieve data in some other storage API, like `localStorage`.\n   *\n   * Note: This value is always \"default\" on the initial location.\n   */\n  key: string;\n}\n\n/**\n * A change to the current location.\n */\nexport interface Update {\n  /**\n   * The action that triggered the change.\n   */\n  action: Action;\n\n  /**\n   * The new location.\n   */\n  location: Location;\n\n  /**\n   * The delta between this location and the former location in the history stack\n   */\n  delta: number | null;\n}\n\n/**\n * A function that receives notifications about location changes.\n */\nexport interface Listener {\n  (update: Update): void;\n}\n\n/**\n * Describes a location that is the destination of some navigation, either via\n * `history.push` or `history.replace`. This may be either a URL or the pieces\n * of a URL path.\n */\nexport type To = string | Partial<Path>;\n\n/**\n * A history is an interface to the navigation stack. The history serves as the\n * source of truth for the current location, as well as provides a set of\n * methods that may be used to change it.\n *\n * It is similar to the DOM's `window.history` object, but with a smaller, more\n * focused API.\n */\nexport interface History {\n  /**\n   * The last action that modified the current location. This will always be\n   * Action.Pop when a history instance is first created. This value is mutable.\n   */\n  readonly action: Action;\n\n  /**\n   * The current location. This value is mutable.\n   */\n  readonly location: Location;\n\n  /**\n   * Returns a valid href for the given `to` value that may be used as\n   * the value of an <a href> attribute.\n   *\n   * @param to - The destination URL\n   */\n  createHref(to: To): string;\n\n  /**\n   * Returns a URL for the given `to` value\n   *\n   * @param to - The destination URL\n   */\n  createURL(to: To): URL;\n\n  /**\n   * Encode a location the same way window.history would do (no-op for memory\n   * history) so we ensure our PUSH/REPLACE navigations for data routers\n   * behave the same as POP\n   *\n   * @param to Unencoded path\n   */\n  encodeLocation(to: To): Path;\n\n  /**\n   * Pushes a new location onto the history stack, increasing its length by one.\n   * If there were any entries in the stack after the current one, they are\n   * lost.\n   *\n   * @param to - The new URL\n   * @param state - Data to associate with the new location\n   */\n  push(to: To, state?: any): void;\n\n  /**\n   * Replaces the current location in the history stack with a new one.  The\n   * location that was replaced will no longer be available.\n   *\n   * @param to - The new URL\n   * @param state - Data to associate with the new location\n   */\n  replace(to: To, state?: any): void;\n\n  /**\n   * Navigates `n` entries backward/forward in the history stack relative to the\n   * current index. For example, a \"back\" navigation would use go(-1).\n   *\n   * @param delta - The delta in the stack index\n   */\n  go(delta: number): void;\n\n  /**\n   * Sets up a listener that will be called whenever the current location\n   * changes.\n   *\n   * @param listener - A function that will be called when the location changes\n   * @returns unlisten - A function that may be used to stop listening\n   */\n  listen(listener: Listener): () => void;\n}\n\ntype HistoryState = {\n  usr: any;\n  key?: string;\n  idx: number;\n};\n\nconst PopStateEventType = \"popstate\";\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Memory History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A user-supplied object that describes a location. Used when providing\n * entries to `createMemoryHistory` via its `initialEntries` option.\n */\nexport type InitialEntry = string | Partial<Location>;\n\nexport type MemoryHistoryOptions = {\n  initialEntries?: InitialEntry[];\n  initialIndex?: number;\n  v5Compat?: boolean;\n};\n\n/**\n * A memory history stores locations in memory. This is useful in stateful\n * environments where there is no web browser, such as node tests or React\n * Native.\n */\nexport interface MemoryHistory extends History {\n  /**\n   * The current index in the history stack.\n   */\n  readonly index: number;\n}\n\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 */\nexport function createMemoryHistory(\n  options: MemoryHistoryOptions = {}\n): MemoryHistory {\n  let { initialEntries = [\"/\"], initialIndex, v5Compat = false } = options;\n  let entries: Location[]; // Declare so we can access from createMemoryLocation\n  entries = initialEntries.map((entry, index) =>\n    createMemoryLocation(\n      entry,\n      typeof entry === \"string\" ? null : entry.state,\n      index === 0 ? \"default\" : undefined\n    )\n  );\n  let index = clampIndex(\n    initialIndex == null ? entries.length - 1 : initialIndex\n  );\n  let action = Action.Pop;\n  let listener: Listener | null = null;\n\n  function clampIndex(n: number): number {\n    return Math.min(Math.max(n, 0), entries.length - 1);\n  }\n  function getCurrentLocation(): Location {\n    return entries[index];\n  }\n  function createMemoryLocation(\n    to: To,\n    state: any = null,\n    key?: string\n  ): Location {\n    let location = createLocation(\n      entries ? getCurrentLocation().pathname : \"/\",\n      to,\n      state,\n      key\n    );\n    warning(\n      location.pathname.charAt(0) === \"/\",\n      `relative pathnames are not supported in memory history: ${JSON.stringify(\n        to\n      )}`\n    );\n    return location;\n  }\n\n  function createHref(to: To) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n\n  let history: MemoryHistory = {\n    get index() {\n      return index;\n    },\n    get action() {\n      return action;\n    },\n    get location() {\n      return getCurrentLocation();\n    },\n    createHref,\n    createURL(to) {\n      return new URL(createHref(to), \"http://localhost\");\n    },\n    encodeLocation(to: To) {\n      let path = typeof to === \"string\" ? parsePath(to) : to;\n      return {\n        pathname: path.pathname || \"\",\n        search: path.search || \"\",\n        hash: path.hash || \"\",\n      };\n    },\n    push(to, state) {\n      action = Action.Push;\n      let nextLocation = createMemoryLocation(to, state);\n      index += 1;\n      entries.splice(index, entries.length, nextLocation);\n      if (v5Compat && listener) {\n        listener({ action, location: nextLocation, delta: 1 });\n      }\n    },\n    replace(to, state) {\n      action = Action.Replace;\n      let nextLocation = createMemoryLocation(to, state);\n      entries[index] = nextLocation;\n      if (v5Compat && listener) {\n        listener({ action, location: nextLocation, delta: 0 });\n      }\n    },\n    go(delta) {\n      action = Action.Pop;\n      let nextIndex = clampIndex(index + delta);\n      let nextLocation = entries[nextIndex];\n      index = nextIndex;\n      if (listener) {\n        listener({ action, location: nextLocation, delta });\n      }\n    },\n    listen(fn: Listener) {\n      listener = fn;\n      return () => {\n        listener = null;\n      };\n    },\n  };\n\n  return history;\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Browser History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A browser history stores the current location in regular URLs in a web\n * browser environment. This is the standard for most web apps and provides the\n * cleanest URLs the browser's address bar.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory\n */\nexport interface BrowserHistory extends UrlHistory {}\n\nexport type BrowserHistoryOptions = UrlHistoryOptions;\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 */\nexport function createBrowserHistory(\n  options: BrowserHistoryOptions = {}\n): BrowserHistory {\n  function createBrowserLocation(\n    window: Window,\n    globalHistory: Window[\"history\"]\n  ) {\n    let { pathname, search, hash } = window.location;\n    return createLocation(\n      \"\",\n      { pathname, search, hash },\n      // state defaults to `null` because `window.history.state` does\n      (globalHistory.state && globalHistory.state.usr) || null,\n      (globalHistory.state && globalHistory.state.key) || \"default\"\n    );\n  }\n\n  function createBrowserHref(window: Window, to: To) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n\n  return getUrlBasedHistory(\n    createBrowserLocation,\n    createBrowserHref,\n    null,\n    options\n  );\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Hash History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A hash history stores the current location in the fragment identifier portion\n * of the URL in a web browser environment.\n *\n * This is ideal for apps that do not control the server for some reason\n * (because the fragment identifier is never sent to the server), including some\n * shared hosting environments that do not provide fine-grained controls over\n * which pages are served at which URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory\n */\nexport interface HashHistory extends UrlHistory {}\n\nexport type HashHistoryOptions = UrlHistoryOptions;\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 */\nexport function createHashHistory(\n  options: HashHistoryOptions = {}\n): HashHistory {\n  function createHashLocation(\n    window: Window,\n    globalHistory: Window[\"history\"]\n  ) {\n    let {\n      pathname = \"/\",\n      search = \"\",\n      hash = \"\",\n    } = parsePath(window.location.hash.substr(1));\n\n    // Hash URL should always have a leading / just like window.location.pathname\n    // does, so if an app ends up at a route like /#something then we add a\n    // leading slash so all of our path-matching behaves the same as if it would\n    // in a browser router.  This is particularly important when there exists a\n    // root splat route (<Route path=\"*\">) since that matches internally against\n    // \"/*\" and we'd expect /#something to 404 in a hash router app.\n    if (!pathname.startsWith(\"/\") && !pathname.startsWith(\".\")) {\n      pathname = \"/\" + pathname;\n    }\n\n    return createLocation(\n      \"\",\n      { pathname, search, hash },\n      // state defaults to `null` because `window.history.state` does\n      (globalHistory.state && globalHistory.state.usr) || null,\n      (globalHistory.state && globalHistory.state.key) || \"default\"\n    );\n  }\n\n  function createHashHref(window: Window, to: 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: Location, to: To) {\n    warning(\n      location.pathname.charAt(0) === \"/\",\n      `relative pathnames are not supported in hash history.push(${JSON.stringify(\n        to\n      )})`\n    );\n  }\n\n  return getUrlBasedHistory(\n    createHashLocation,\n    createHashHref,\n    validateHashLocation,\n    options\n  );\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region UTILS\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * @private\n */\nexport function invariant(value: boolean, message?: string): asserts value;\nexport function invariant<T>(\n  value: T | null | undefined,\n  message?: string\n): asserts value is T;\nexport function invariant(value: any, message?: string) {\n  if (value === false || value === null || typeof value === \"undefined\") {\n    throw new Error(message);\n  }\n}\n\nexport function warning(cond: any, message: string) {\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);\n      // 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/**\n * For browser-based histories, we combine the state and key into an object\n */\nfunction getHistoryState(location: Location, index: number): HistoryState {\n  return {\n    usr: location.state,\n    key: location.key,\n    idx: index,\n  };\n}\n\n/**\n * Creates a Location object with a unique key from the given Path\n */\nexport function createLocation(\n  current: string | Location,\n  to: To,\n  state: any = null,\n  key?: string\n): Readonly<Location> {\n  let location: Readonly<Location> = {\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 as Location).key) || key || createKey(),\n  };\n  return location;\n}\n\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\nexport function createPath({\n  pathname = \"/\",\n  search = \"\",\n  hash = \"\",\n}: Partial<Path>) {\n  if (search && search !== \"?\")\n    pathname += search.charAt(0) === \"?\" ? search : \"?\" + search;\n  if (hash && hash !== \"#\")\n    pathname += hash.charAt(0) === \"#\" ? hash : \"#\" + hash;\n  return pathname;\n}\n\n/**\n * Parses a string URL path into its separate pathname, search, and hash components.\n */\nexport function parsePath(path: string): Partial<Path> {\n  let parsedPath: Partial<Path> = {};\n\n  if (path) {\n    let hashIndex = path.indexOf(\"#\");\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n\n    let searchIndex = path.indexOf(\"?\");\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\nexport interface UrlHistory extends History {}\n\nexport type UrlHistoryOptions = {\n  window?: Window;\n  v5Compat?: boolean;\n};\n\nfunction getUrlBasedHistory(\n  getLocation: (window: Window, globalHistory: Window[\"history\"]) => Location,\n  createHref: (window: Window, to: To) => string,\n  validateLocation: ((location: Location, to: To) => void) | null,\n  options: UrlHistoryOptions = {}\n): UrlHistory {\n  let { window = document.defaultView!, v5Compat = false } = options;\n  let globalHistory = window.history;\n  let action = Action.Pop;\n  let listener: Listener | null = null;\n\n  let index = getIndex()!;\n  // Index should only be null when we initialize. If not, it's because the\n  // user called history.pushState or history.replaceState directly, in which\n  // case we should log a warning as it will result in bugs.\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState({ ...globalHistory.state, idx: index }, \"\");\n  }\n\n  function getIndex(): number {\n    let state = globalHistory.state || { idx: null };\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    if (listener) {\n      listener({ action, location: history.location, delta });\n    }\n  }\n\n  function push(to: To, state?: any) {\n    action = Action.Push;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n\n    index = getIndex() + 1;\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n\n    // try...catch because iOS limits us to 100 pushState calls :/\n    try {\n      globalHistory.pushState(historyState, \"\", url);\n    } catch (error) {\n      // If the exception is because `state` can't be serialized, let that throw\n      // outwards just like a replace call would so the dev knows the cause\n      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps\n      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal\n      if (error instanceof DOMException && error.name === \"DataCloneError\") {\n        throw error;\n      }\n      // They are going to lose state here, but there is no real\n      // way to warn them about it since the page will refresh...\n      window.location.assign(url);\n    }\n\n    if (v5Compat && listener) {\n      listener({ action, location: history.location, delta: 1 });\n    }\n  }\n\n  function replace(to: To, state?: any) {\n    action = Action.Replace;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n\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({ action, location: history.location, delta: 0 });\n    }\n  }\n\n  function createURL(to: To): URL {\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 =\n      window.location.origin !== \"null\"\n        ? window.location.origin\n        : window.location.href;\n\n    let href = typeof to === \"string\" ? to : createPath(to);\n    // Treating this as a full URL will strip any trailing spaces so we need to\n    // pre-encode them since they might be part of a matching splat param from\n    // an ancestor route\n    href = href.replace(/ $/, \"%20\");\n    invariant(\n      base,\n      `No window.location.(origin|href) available to create URL for href: ${href}`\n    );\n    return new URL(href, base);\n  }\n\n  let history: History = {\n    get action() {\n      return action;\n    },\n    get location() {\n      return getLocation(window, globalHistory);\n    },\n    listen(fn: Listener) {\n      if (listener) {\n        throw new Error(\"A history only accepts one active listener\");\n      }\n      window.addEventListener(PopStateEventType, handlePop);\n      listener = fn;\n\n      return () => {\n        window.removeEventListener(PopStateEventType, handlePop);\n        listener = null;\n      };\n    },\n    createHref(to) {\n      return createHref(window, to);\n    },\n    createURL,\n    encodeLocation(to) {\n      // Encode a Location the same way window.location would\n      let url = createURL(to);\n      return {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash,\n      };\n    },\n    push,\n    replace,\n    go(n) {\n      return globalHistory.go(n);\n    },\n  };\n\n  return history;\n}\n\n//#endregion\n","import type { Location, Path, To } from \"./history\";\nimport { invariant, parsePath, warning } from \"./history\";\n\n/**\n * Map of routeId -> data returned from a loader/action/error\n */\nexport interface RouteData {\n  [routeId: string]: any;\n}\n\nexport enum ResultType {\n  data = \"data\",\n  deferred = \"deferred\",\n  redirect = \"redirect\",\n  error = \"error\",\n}\n\n/**\n * Successful result from a loader or action\n */\nexport interface SuccessResult {\n  type: ResultType.data;\n  data: unknown;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Successful defer() result from a loader or action\n */\nexport interface DeferredResult {\n  type: ResultType.deferred;\n  deferredData: DeferredData;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Redirect result from a loader or action\n */\nexport interface RedirectResult {\n  type: ResultType.redirect;\n  // We keep the raw Response for redirects so we can return it verbatim\n  response: Response;\n}\n\n/**\n * Unsuccessful result from a loader or action\n */\nexport interface ErrorResult {\n  type: ResultType.error;\n  error: unknown;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Result from a loader or action - potentially successful or unsuccessful\n */\nexport type DataResult =\n  | SuccessResult\n  | DeferredResult\n  | RedirectResult\n  | ErrorResult;\n\n/**\n * Result from a loader or action called via dataStrategy\n */\nexport interface HandlerResult {\n  type: \"data\" | \"error\";\n  result: unknown; // data, Error, Response, DeferredData\n  status?: number;\n}\n\ntype LowerCaseFormMethod = \"get\" | \"post\" | \"put\" | \"patch\" | \"delete\";\ntype UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;\n\n/**\n * Users can specify either lowercase or uppercase form methods on `<Form>`,\n * useSubmit(), `<fetcher.Form>`, etc.\n */\nexport type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;\n\n/**\n * Active navigation/fetcher form methods are exposed in lowercase on the\n * RouterState\n */\nexport type FormMethod = LowerCaseFormMethod;\nexport type MutationFormMethod = Exclude<FormMethod, \"get\">;\n\n/**\n * In v7, active navigation/fetcher form methods are exposed in uppercase on the\n * RouterState.  This is to align with the normalization done via fetch().\n */\nexport type V7_FormMethod = UpperCaseFormMethod;\nexport type V7_MutationFormMethod = Exclude<V7_FormMethod, \"GET\">;\n\nexport type FormEncType =\n  | \"application/x-www-form-urlencoded\"\n  | \"multipart/form-data\"\n  | \"application/json\"\n  | \"text/plain\";\n\n// Thanks https://github.com/sindresorhus/type-fest!\ntype JsonObject = { [Key in string]: JsonValue } & {\n  [Key in string]?: JsonValue | undefined;\n};\ntype JsonArray = JsonValue[] | readonly JsonValue[];\ntype JsonPrimitive = string | number | boolean | null;\ntype JsonValue = JsonPrimitive | JsonObject | JsonArray;\n\n/**\n * @private\n * Internal interface to pass around for action submissions, not intended for\n * external consumption\n */\nexport type Submission =\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: FormData;\n      json: undefined;\n      text: undefined;\n    }\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: undefined;\n      json: JsonValue;\n      text: undefined;\n    }\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: undefined;\n      json: undefined;\n      text: string;\n    };\n\n/**\n * @private\n * Arguments passed to route loader/action functions.  Same for now but we keep\n * this as a private implementation detail in case they diverge in the future.\n */\ninterface DataFunctionArgs<Context> {\n  request: Request;\n  params: Params;\n  context?: Context;\n}\n\n// TODO: (v7) Change the defaults from any to unknown in and remove Remix wrappers:\n//   ActionFunction, ActionFunctionArgs, LoaderFunction, LoaderFunctionArgs\n//   Also, make them a type alias instead of an interface\n\n/**\n * Arguments passed to loader functions\n */\nexport interface LoaderFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {}\n\n/**\n * Arguments passed to action functions\n */\nexport interface ActionFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {}\n\n/**\n * Loaders and actions can return anything except `undefined` (`null` is a\n * valid return value if there is no data to return).  Responses are preferred\n * and will ease any future migration to Remix\n */\ntype DataFunctionValue = Response | NonNullable<unknown> | null;\n\ntype DataFunctionReturnValue = Promise<DataFunctionValue> | DataFunctionValue;\n\n/**\n * Route loader function signature\n */\nexport type LoaderFunction<Context = any> = {\n  (\n    args: LoaderFunctionArgs<Context>,\n    handlerCtx?: unknown\n  ): DataFunctionReturnValue;\n} & { hydrate?: boolean };\n\n/**\n * Route action function signature\n */\nexport interface ActionFunction<Context = any> {\n  (\n    args: ActionFunctionArgs<Context>,\n    handlerCtx?: unknown\n  ): DataFunctionReturnValue;\n}\n\n/**\n * Arguments passed to shouldRevalidate function\n */\nexport interface ShouldRevalidateFunctionArgs {\n  currentUrl: URL;\n  currentParams: AgnosticDataRouteMatch[\"params\"];\n  nextUrl: URL;\n  nextParams: AgnosticDataRouteMatch[\"params\"];\n  formMethod?: Submission[\"formMethod\"];\n  formAction?: Submission[\"formAction\"];\n  formEncType?: Submission[\"formEncType\"];\n  text?: Submission[\"text\"];\n  formData?: Submission[\"formData\"];\n  json?: Submission[\"json\"];\n  unstable_actionStatus?: number;\n  actionResult?: any;\n  defaultShouldRevalidate: boolean;\n}\n\n/**\n * Route shouldRevalidate function signature.  This runs after any submission\n * (navigation or fetcher), so we flatten the navigation/fetcher submission\n * onto the arguments.  It shouldn't matter whether it came from a navigation\n * or a fetcher, what really matters is the URLs and the formData since loaders\n * have to re-run based on the data models that were potentially mutated.\n */\nexport interface ShouldRevalidateFunction {\n  (args: ShouldRevalidateFunctionArgs): boolean;\n}\n\n/**\n * Function provided by the framework-aware layers to set `hasErrorBoundary`\n * from the framework-aware `errorElement` prop\n *\n * @deprecated Use `mapRouteProperties` instead\n */\nexport interface DetectErrorBoundaryFunction {\n  (route: AgnosticRouteObject): boolean;\n}\n\nexport interface DataStrategyMatch\n  extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {\n  shouldLoad: boolean;\n  resolve: (\n    handlerOverride?: (\n      handler: (ctx?: unknown) => DataFunctionReturnValue\n    ) => Promise<HandlerResult>\n  ) => Promise<HandlerResult>;\n}\n\nexport interface DataStrategyFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {\n  matches: DataStrategyMatch[];\n}\n\nexport interface DataStrategyFunction {\n  (args: DataStrategyFunctionArgs): Promise<HandlerResult[]>;\n}\n\n/**\n * Function provided by the framework-aware layers to set any framework-specific\n * properties from framework-agnostic properties\n */\nexport interface MapRoutePropertiesFunction {\n  (route: AgnosticRouteObject): {\n    hasErrorBoundary: boolean;\n  } & Record<string, any>;\n}\n\n/**\n * Keys we cannot change from within a lazy() function. We spread all other keys\n * onto the route. Either they're meaningful to the router, or they'll get\n * ignored.\n */\nexport type ImmutableRouteKey =\n  | \"lazy\"\n  | \"caseSensitive\"\n  | \"path\"\n  | \"id\"\n  | \"index\"\n  | \"children\";\n\nexport const immutableRouteKeys = new Set<ImmutableRouteKey>([\n  \"lazy\",\n  \"caseSensitive\",\n  \"path\",\n  \"id\",\n  \"index\",\n  \"children\",\n]);\n\ntype RequireOne<T, Key = keyof T> = Exclude<\n  {\n    [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;\n  }[keyof T],\n  undefined\n>;\n\n/**\n * lazy() function to load a route definition, which can add non-matching\n * related properties to a route\n */\nexport interface LazyRouteFunction<R extends AgnosticRouteObject> {\n  (): Promise<RequireOne<Omit<R, ImmutableRouteKey>>>;\n}\n\n/**\n * Base RouteObject with common props shared by all types of routes\n */\ntype AgnosticBaseRouteObject = {\n  caseSensitive?: boolean;\n  path?: string;\n  id?: string;\n  loader?: LoaderFunction | boolean;\n  action?: ActionFunction | boolean;\n  hasErrorBoundary?: boolean;\n  shouldRevalidate?: ShouldRevalidateFunction;\n  handle?: any;\n  lazy?: LazyRouteFunction<AgnosticBaseRouteObject>;\n};\n\n/**\n * Index routes must not have children\n */\nexport type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {\n  children?: undefined;\n  index: true;\n};\n\n/**\n * Non-index routes may have children, but cannot have index\n */\nexport type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {\n  children?: AgnosticRouteObject[];\n  index?: false;\n};\n\n/**\n * A route object represents a logical route, with (optionally) its child\n * routes organized in a tree-like structure.\n */\nexport type AgnosticRouteObject =\n  | AgnosticIndexRouteObject\n  | AgnosticNonIndexRouteObject;\n\nexport type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {\n  id: string;\n};\n\nexport type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {\n  children?: AgnosticDataRouteObject[];\n  id: string;\n};\n\n/**\n * A data route object, which is just a RouteObject with a required unique ID\n */\nexport type AgnosticDataRouteObject =\n  | AgnosticDataIndexRouteObject\n  | AgnosticDataNonIndexRouteObject;\n\nexport type RouteManifest = Record<string, AgnosticDataRouteObject | undefined>;\n\n// Recursive helper for finding path parameters in the absence of wildcards\ntype _PathParam<Path extends string> =\n  // split path into individual path segments\n  Path extends `${infer L}/${infer R}`\n    ? _PathParam<L> | _PathParam<R>\n    : // find params after `:`\n    Path extends `:${infer Param}`\n    ? Param extends `${infer Optional}?`\n      ? Optional\n      : Param\n    : // otherwise, there aren't any params present\n      never;\n\n/**\n * Examples:\n * \"/a/b/*\" -> \"*\"\n * \":a\" -> \"a\"\n * \"/a/:b\" -> \"b\"\n * \"/a/blahblahblah:b\" -> \"b\"\n * \"/:a/:b\" -> \"a\" | \"b\"\n * \"/:a/b/:c/*\" -> \"a\" | \"c\" | \"*\"\n */\nexport type PathParam<Path extends string> =\n  // check if path is just a wildcard\n  Path extends \"*\" | \"/*\"\n    ? \"*\"\n    : // look for wildcard at the end of the path\n    Path extends `${infer Rest}/*`\n    ? \"*\" | _PathParam<Rest>\n    : // look for params in the absence of wildcards\n      _PathParam<Path>;\n\n// Attempt to parse the given string segment. If it fails, then just return the\n// plain string type as a default fallback. Otherwise, return the union of the\n// parsed string literals that were referenced as dynamic segments in the route.\nexport type ParamParseKey<Segment extends string> =\n  // if you could not find path params, fallback to `string`\n  [PathParam<Segment>] extends [never] ? string : PathParam<Segment>;\n\n/**\n * The parameters that were parsed from the URL path.\n */\nexport type Params<Key extends string = string> = {\n  readonly [key in Key]: string | undefined;\n};\n\n/**\n * A RouteMatch contains info about how a route matched a URL.\n */\nexport interface AgnosticRouteMatch<\n  ParamKey extends string = string,\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n  /**\n   * The names and values of dynamic parameters in the URL.\n   */\n  params: Params<ParamKey>;\n  /**\n   * The portion of the URL pathname that was matched.\n   */\n  pathname: string;\n  /**\n   * The portion of the URL pathname that was matched before child routes.\n   */\n  pathnameBase: string;\n  /**\n   * The route object that was used to match.\n   */\n  route: RouteObjectType;\n}\n\nexport interface AgnosticDataRouteMatch\n  extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {}\n\nfunction isIndexRoute(\n  route: AgnosticRouteObject\n): route is AgnosticIndexRouteObject {\n  return route.index === true;\n}\n\n// Walk the route tree generating unique IDs where necessary, so we are working\n// solely with AgnosticDataRouteObject's within the Router\nexport function convertRoutesToDataRoutes(\n  routes: AgnosticRouteObject[],\n  mapRouteProperties: MapRoutePropertiesFunction,\n  parentPath: number[] = [],\n  manifest: RouteManifest = {}\n): AgnosticDataRouteObject[] {\n  return routes.map((route, index) => {\n    let treePath = [...parentPath, index];\n    let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n    invariant(\n      route.index !== true || !route.children,\n      `Cannot specify children on an index route`\n    );\n    invariant(\n      !manifest[id],\n      `Found a route id collision on id \"${id}\".  Route ` +\n        \"id's must be globally unique within Data Router usages\"\n    );\n\n    if (isIndexRoute(route)) {\n      let indexRoute: AgnosticDataIndexRouteObject = {\n        ...route,\n        ...mapRouteProperties(route),\n        id,\n      };\n      manifest[id] = indexRoute;\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute: AgnosticDataNonIndexRouteObject = {\n        ...route,\n        ...mapRouteProperties(route),\n        id,\n        children: undefined,\n      };\n      manifest[id] = pathOrLayoutRoute;\n\n      if (route.children) {\n        pathOrLayoutRoute.children = convertRoutesToDataRoutes(\n          route.children,\n          mapRouteProperties,\n          treePath,\n          manifest\n        );\n      }\n\n      return pathOrLayoutRoute;\n    }\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 */\nexport function matchRoutes<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  locationArg: Partial<Location> | string,\n  basename = \"/\"\n): AgnosticRouteMatch<string, RouteObjectType>[] | null {\n  let location =\n    typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\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\n  let matches = null;\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    // Incoming pathnames are generally encoded from either window.location\n    // or from router.navigate, but we want to match against the unencoded\n    // paths in the route definitions.  Memory router locations won't be\n    // encoded here but there also shouldn't be anything to decode so this\n    // should be a safe operation.  This avoids needing matchRoutes to be\n    // history-aware.\n    let decoded = decodePath(pathname);\n    matches = matchRouteBranch<string, RouteObjectType>(branches[i], decoded);\n  }\n\n  return matches;\n}\n\nexport interface UIMatch<Data = unknown, Handle = unknown> {\n  id: string;\n  pathname: string;\n  params: AgnosticRouteMatch[\"params\"];\n  data: Data;\n  handle: Handle;\n}\n\nexport function convertRouteMatchToUiMatch(\n  match: AgnosticDataRouteMatch,\n  loaderData: RouteData\n): UIMatch {\n  let { route, pathname, params } = match;\n  return {\n    id: route.id,\n    pathname,\n    params,\n    data: loaderData[route.id],\n    handle: route.handle,\n  };\n}\n\ninterface RouteMeta<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n  relativePath: string;\n  caseSensitive: boolean;\n  childrenIndex: number;\n  route: RouteObjectType;\n}\n\ninterface RouteBranch<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n  path: string;\n  score: number;\n  routesMeta: RouteMeta<RouteObjectType>[];\n}\n\nfunction flattenRoutes<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  branches: RouteBranch<RouteObjectType>[] = [],\n  parentsMeta: RouteMeta<RouteObjectType>[] = [],\n  parentPath = \"\"\n): RouteBranch<RouteObjectType>[] {\n  let flattenRoute = (\n    route: RouteObjectType,\n    index: number,\n    relativePath?: string\n  ) => {\n    let meta: RouteMeta<RouteObjectType> = {\n      relativePath:\n        relativePath === undefined ? route.path || \"\" : relativePath,\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route,\n    };\n\n    if (meta.relativePath.startsWith(\"/\")) {\n      invariant(\n        meta.relativePath.startsWith(parentPath),\n        `Absolute route path \"${meta.relativePath}\" nested under path ` +\n          `\"${parentPath}\" is not valid. An absolute child route path ` +\n          `must start with the combined path of all its parent routes.`\n      );\n\n      meta.relativePath = meta.relativePath.slice(parentPath.length);\n    }\n\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta);\n\n    // Add the children before adding this route to the array, so we traverse the\n    // route tree depth-first and child routes appear before their parents in\n    // the \"flattened\" version.\n    if (route.children && route.children.length > 0) {\n      invariant(\n        // Our types know better, but runtime JS may not!\n        // @ts-expect-error\n        route.index !== true,\n        `Index routes must not have child routes. Please remove ` +\n          `all child routes from route path \"${path}\".`\n      );\n\n      flattenRoutes(route.children, branches, routesMeta, path);\n    }\n\n    // Routes without a path shouldn't ever match by themselves unless they are\n    // index routes, so don't add them to the list of possible branches.\n    if (route.path == null && !route.index) {\n      return;\n    }\n\n    branches.push({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta,\n    });\n  };\n  routes.forEach((route, index) => {\n    // coarse-grain check for optional params\n    if (route.path === \"\" || !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\n  return branches;\n}\n\n/**\n * Computes all combinations of optional path segments for a given path,\n * excluding combinations that are ambiguous and of lower priority.\n *\n * For example, `/one/:two?/three/:four?/:five?` explodes to:\n * - `/one/three`\n * - `/one/:two/three`\n * - `/one/three/:four`\n * - `/one/three/:five`\n * - `/one/:two/three/:four`\n * - `/one/:two/three/:five`\n * - `/one/three/:four/:five`\n * - `/one/:two/three/:four/:five`\n */\nfunction explodeOptionalSegments(path: string): string[] {\n  let segments = path.split(\"/\");\n  if (segments.length === 0) return [];\n\n  let [first, ...rest] = segments;\n\n  // Optional path segments are denoted by a trailing `?`\n  let isOptional = first.endsWith(\"?\");\n  // Compute the corresponding required segment: `foo?` -> `foo`\n  let required = first.replace(/\\?$/, \"\");\n\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\n  let result: string[] = [];\n\n  // All child paths with the prefix.  Do this for all children before the\n  // optional version for all children, so we get consistent ordering where the\n  // parent optional aspect is preferred as required.  Otherwise, we can get\n  // child sections interspersed where deeper optional segments are higher than\n  // parent optional segments, where for example, /:two would explode _earlier_\n  // then /:one.  By always including the parent as required _for all children_\n  // first, we avoid this issue\n  result.push(\n    ...restExploded.map((subpath) =>\n      subpath === \"\" ? required : [required, subpath].join(\"/\")\n    )\n  );\n\n  // Then, if this is an optional value, add all child versions without\n  if (isOptional) {\n    result.push(...restExploded);\n  }\n\n  // for absolute paths, ensure `/` instead of empty segment\n  return result.map((exploded) =>\n    path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded\n  );\n}\n\nfunction rankRouteBranches(branches: RouteBranch[]): void {\n  branches.sort((a, b) =>\n    a.score !== b.score\n      ? b.score - a.score // Higher score first\n      : compareIndexes(\n          a.routesMeta.map((meta) => meta.childrenIndex),\n          b.routesMeta.map((meta) => meta.childrenIndex)\n        )\n  );\n}\n\nconst paramRe = /^:[\\w-]+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = (s: string) => s === \"*\";\n\nfunction computeScore(path: string, index: boolean | undefined): number {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n\n  return segments\n    .filter((s) => !isSplat(s))\n    .reduce(\n      (score, segment) =>\n        score +\n        (paramRe.test(segment)\n          ? dynamicSegmentValue\n          : segment === \"\"\n          ? emptySegmentValue\n          : staticSegmentValue),\n      initialScore\n    );\n}\n\nfunction compareIndexes(a: number[], b: number[]): number {\n  let siblings =\n    a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n\n  return siblings\n    ? // If two routes are siblings, we should try to match the earlier sibling\n      // first. This allows people to have fine-grained control over the matching\n      // behavior by simply putting routes with identical paths in the order they\n      // want them tried.\n      a[a.length - 1] - b[b.length - 1]\n    : // Otherwise, it doesn't really make sense to rank non-siblings by index,\n      // so they sort equally.\n      0;\n}\n\nfunction matchRouteBranch<\n  ParamKey extends string = string,\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  branch: RouteBranch<RouteObjectType>,\n  pathname: string\n): AgnosticRouteMatch<ParamKey, RouteObjectType>[] | null {\n  let { routesMeta } = branch;\n\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches: AgnosticRouteMatch<ParamKey, RouteObjectType>[] = [];\n  for (let i = 0; i < routesMeta.length; ++i) {\n    let meta = routesMeta[i];\n    let end = i === routesMeta.length - 1;\n    let remainingPathname =\n      matchedPathname === \"/\"\n        ? pathname\n        : pathname.slice(matchedPathname.length) || \"/\";\n    let match = matchPath(\n      { path: meta.relativePath, caseSensitive: meta.caseSensitive, end },\n      remainingPathname\n    );\n\n    if (!match) return null;\n\n    Object.assign(matchedParams, match.params);\n\n    let route = meta.route;\n\n    matches.push({\n      // TODO: Can this as be avoided?\n      params: matchedParams as Params<ParamKey>,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(\n        joinPaths([matchedPathname, match.pathnameBase])\n      ),\n      route,\n    });\n\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n\n  return matches;\n}\n\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/utils/generate-path\n */\nexport function generatePath<Path extends string>(\n  originalPath: Path,\n  params: {\n    [key in PathParam<Path>]: string | null;\n  } = {} as any\n): string {\n  let path: string = originalPath;\n  if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n    warning(\n      false,\n      `Route path \"${path}\" will be treated as if it were ` +\n        `\"${path.replace(/\\*$/, \"/*\")}\" because the \\`*\\` character must ` +\n        `always follow a \\`/\\` in the pattern. To get rid of this warning, ` +\n        `please change the route path to \"${path.replace(/\\*$/, \"/*\")}\".`\n    );\n    path = path.replace(/\\*$/, \"/*\") as Path;\n  }\n\n  // ensure `/` is added at the beginning if the path is absolute\n  const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n\n  const stringify = (p: any) =>\n    p == null ? \"\" : typeof p === \"string\" ? p : String(p);\n\n  const segments = path\n    .split(/\\/+/)\n    .map((segment, index, array) => {\n      const isLastSegment = index === array.length - 1;\n\n      // only apply the splat if it's the last segment\n      if (isLastSegment && segment === \"*\") {\n        const star = \"*\" as PathParam<Path>;\n        // Apply the splat\n        return stringify(params[star]);\n      }\n\n      const keyMatch = segment.match(/^:([\\w-]+)(\\??)$/);\n      if (keyMatch) {\n        const [, key, optional] = keyMatch;\n        let param = params[key as PathParam<Path>];\n        invariant(optional === \"?\" || param != null, `Missing \":${key}\" param`);\n        return stringify(param);\n      }\n\n      // Remove any optional markers from optional static segments\n      return segment.replace(/\\?$/g, \"\");\n    })\n    // Remove empty segments\n    .filter((segment) => !!segment);\n\n  return prefix + segments.join(\"/\");\n}\n\n/**\n * A PathPattern is used to match on some portion of a URL pathname.\n */\nexport interface PathPattern<Path extends string = string> {\n  /**\n   * A string to match against a URL pathname. May contain `:id`-style segments\n   * to indicate placeholders for dynamic parameters. May also end with `/*` to\n   * indicate matching the rest of the URL pathname.\n   */\n  path: Path;\n  /**\n   * Should be `true` if the static portions of the `path` should be matched in\n   * the same case.\n   */\n  caseSensitive?: boolean;\n  /**\n   * Should be `true` if this pattern should match the entire URL pathname.\n   */\n  end?: boolean;\n}\n\n/**\n * A PathMatch contains info about how a PathPattern matched on a URL pathname.\n */\nexport interface PathMatch<ParamKey extends string = string> {\n  /**\n   * The names and values of dynamic parameters in the URL.\n   */\n  params: Params<ParamKey>;\n  /**\n   * The portion of the URL pathname that was matched.\n   */\n  pathname: string;\n  /**\n   * The portion of the URL pathname that was matched before child routes.\n   */\n  pathnameBase: string;\n  /**\n   * The pattern that was used to match.\n   */\n  pattern: PathPattern;\n}\n\ntype Mutable<T> = {\n  -readonly [P in keyof T]: T[P];\n};\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 */\nexport function matchPath<\n  ParamKey extends ParamParseKey<Path>,\n  Path extends string\n>(\n  pattern: PathPattern<Path> | Path,\n  pathname: string\n): PathMatch<ParamKey> | null {\n  if (typeof pattern === \"string\") {\n    pattern = { path: pattern, caseSensitive: false, end: true };\n  }\n\n  let [matcher, compiledParams] = compilePath(\n    pattern.path,\n    pattern.caseSensitive,\n    pattern.end\n  );\n\n  let match = pathname.match(matcher);\n  if (!match) return null;\n\n  let matchedPathname = match[0];\n  let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n  let captureGroups = match.slice(1);\n  let params: Params = compiledParams.reduce<Mutable<Params>>(\n    (memo, { paramName, isOptional }, 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\n          .slice(0, matchedPathname.length - splatValue.length)\n          .replace(/(.)\\/+$/, \"$1\");\n      }\n\n      const value = captureGroups[index];\n      if (isOptional && !value) {\n        memo[paramName] = undefined;\n      } else {\n        memo[paramName] = (value || \"\").replace(/%2F/g, \"/\");\n      }\n      return memo;\n    },\n    {}\n  );\n\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern,\n  };\n}\n\ntype CompiledPathParam = { paramName: string; isOptional?: boolean };\n\nfunction compilePath(\n  path: string,\n  caseSensitive = false,\n  end = true\n): [RegExp, CompiledPathParam[]] {\n  warning(\n    path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"),\n    `Route path \"${path}\" will be treated as if it were ` +\n      `\"${path.replace(/\\*$/, \"/*\")}\" because the \\`*\\` character must ` +\n      `always follow a \\`/\\` in the pattern. To get rid of this warning, ` +\n      `please change the route path to \"${path.replace(/\\*$/, \"/*\")}\".`\n  );\n\n  let params: CompiledPathParam[] = [];\n  let regexpSource =\n    \"^\" +\n    path\n      .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(\n        /\\/:([\\w-]+)(\\?)?/g,\n        (_: string, paramName: string, isOptional) => {\n          params.push({ paramName, isOptional: isOptional != null });\n          return isOptional ? \"/?([^\\\\/]+)?\" : \"/([^\\\\/]+)\";\n        }\n      );\n\n  if (path.endsWith(\"*\")) {\n    params.push({ paramName: \"*\" });\n    regexpSource +=\n      path === \"*\" || path === \"/*\"\n        ? \"(.*)$\" // 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    // Nothing to match for \"\" or \"/\"\n  }\n\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n\n  return [matcher, params];\n}\n\nfunction decodePath(value: string) {\n  try {\n    return value\n      .split(\"/\")\n      .map((v) => decodeURIComponent(v).replace(/\\//g, \"%2F\"))\n      .join(\"/\");\n  } catch (error) {\n    warning(\n      false,\n      `The URL path \"${value}\" could not be decoded because it is is a ` +\n        `malformed URL segment. This is probably due to a bad percent ` +\n        `encoding (${error}).`\n    );\n\n    return value;\n  }\n}\n\n/**\n * @private\n */\nexport function stripBasename(\n  pathname: string,\n  basename: string\n): string | null {\n  if (basename === \"/\") return pathname;\n\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n\n  // We want to leave trailing slash behavior in the user's control, so if they\n  // specify a basename with a trailing slash, we should support it\n  let startIndex = basename.endsWith(\"/\")\n    ? basename.length - 1\n    : basename.length;\n  let nextChar = pathname.charAt(startIndex);\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n\n  return pathname.slice(startIndex) || \"/\";\n}\n\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/utils/resolve-path\n */\nexport function resolvePath(to: To, fromPathname = \"/\"): Path {\n  let {\n    pathname: toPathname,\n    search = \"\",\n    hash = \"\",\n  } = typeof to === \"string\" ? parsePath(to) : to;\n\n  let pathname = toPathname\n    ? toPathname.startsWith(\"/\")\n      ? toPathname\n      : resolvePathname(toPathname, fromPathname)\n    : fromPathname;\n\n  return {\n    pathname,\n    search: normalizeSearch(search),\n    hash: normalizeHash(hash),\n  };\n}\n\nfunction resolvePathname(relativePath: string, fromPathname: string): string {\n  let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n  let relativeSegments = relativePath.split(\"/\");\n\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\n  return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\n\nfunction getInvalidPathError(\n  char: string,\n  field: string,\n  dest: string,\n  path: Partial<Path>\n) {\n  return (\n    `Cannot include a '${char}' character in a manually specified ` +\n    `\\`to.${field}\\` field [${JSON.stringify(\n      path\n    )}].  Please separate it out to the ` +\n    `\\`to.${dest}\\` field. Alternatively you may provide the full path as ` +\n    `a string in <Link to=\"...\"> and the router will parse it for you.`\n  );\n}\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 */\nexport function getPathContributingMatches<\n  T extends AgnosticRouteMatch = AgnosticRouteMatch\n>(matches: T[]) {\n  return matches.filter(\n    (match, index) =>\n      index === 0 || (match.route.path && match.route.path.length > 0)\n  );\n}\n\n// Return the array of pathnames for the current route matches - used to\n// generate the routePathnames input for resolveTo()\nexport function getResolveToMatches<\n  T extends AgnosticRouteMatch = AgnosticRouteMatch\n>(matches: T[], v7_relativeSplatPath: boolean) {\n  let pathMatches = getPathContributingMatches(matches);\n\n  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf\n  // match so we include splat values for \".\" links.  See:\n  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329\n  if (v7_relativeSplatPath) {\n    return pathMatches.map((match, idx) =>\n      idx === matches.length - 1 ? match.pathname : match.pathnameBase\n    );\n  }\n\n  return pathMatches.map((match) => match.pathnameBase);\n}\n\n/**\n * @private\n */\nexport function resolveTo(\n  toArg: To,\n  routePathnames: string[],\n  locationPathname: string,\n  isPathRelative = false\n): Path {\n  let to: Partial<Path>;\n  if (typeof toArg === \"string\") {\n    to = parsePath(toArg);\n  } else {\n    to = { ...toArg };\n\n    invariant(\n      !to.pathname || !to.pathname.includes(\"?\"),\n      getInvalidPathError(\"?\", \"pathname\", \"search\", to)\n    );\n    invariant(\n      !to.pathname || !to.pathname.includes(\"#\"),\n      getInvalidPathError(\"#\", \"pathname\", \"hash\", to)\n    );\n    invariant(\n      !to.search || !to.search.includes(\"#\"),\n      getInvalidPathError(\"#\", \"search\", \"hash\", to)\n    );\n  }\n\n  let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n  let toPathname = isEmptyPath ? \"/\" : to.pathname;\n\n  let from: string;\n\n  // Routing is relative to the current pathname if explicitly requested.\n  //\n  // If a pathname is explicitly provided in `to`, it should be relative to the\n  // route context. This is explained in `Note on `<Link to>` values` in our\n  // migration guide from v5 as a means of disambiguation between `to` values\n  // that begin with `/` and those that do not. However, this is problematic for\n  // `to` values that do not provide a pathname. `to` can simply be a search or\n  // hash string, in which case we should assume that the navigation is relative\n  // to the current location's pathname and *not* the route pathname.\n  if (toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n\n    // With relative=\"route\" (the default), each leading .. segment means\n    // \"go up one route\" instead of \"go up one URL segment\".  This is a key\n    // difference from how <a href> works and a major reason we call this a\n    // \"to\" value instead of a \"href\".\n    if (!isPathRelative && toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\n\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n\n      to.pathname = toSegments.join(\"/\");\n    }\n\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n\n  let path = resolvePath(to, from);\n\n  // Ensure the pathname has a trailing slash if the original \"to\" had one\n  let hasExplicitTrailingSlash =\n    toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\");\n  // Or if this was a link to the current path which has a trailing slash\n  let hasCurrentTrailingSlash =\n    (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n  if (\n    !path.pathname.endsWith(\"/\") &&\n    (hasExplicitTrailingSlash || hasCurrentTrailingSlash)\n  ) {\n    path.pathname += \"/\";\n  }\n\n  return path;\n}\n\n/**\n * @private\n */\nexport function getToPathname(to: To): string | undefined {\n  // Empty strings should be treated the same as / paths\n  return to === \"\" || (to as Path).pathname === \"\"\n    ? \"/\"\n    : typeof to === \"string\"\n    ? parsePath(to).pathname\n    : to.pathname;\n}\n\n/**\n * @private\n */\nexport const joinPaths = (paths: string[]): string =>\n  paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n\n/**\n * @private\n */\nexport const normalizePathname = (pathname: string): string =>\n  pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n\n/**\n * @private\n */\nexport const normalizeSearch = (search: string): string =>\n  !search || search === \"?\"\n    ? \"\"\n    : search.startsWith(\"?\")\n    ? search\n    : \"?\" + search;\n\n/**\n * @private\n */\nexport const normalizeHash = (hash: string): string =>\n  !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n\nexport type JsonFunction = <Data>(\n  data: Data,\n  init?: number | ResponseInit\n) => Response;\n\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n */\nexport const json: JsonFunction = (data, init = {}) => {\n  let responseInit = typeof init === \"number\" ? { status: init } : init;\n\n  let headers = new Headers(responseInit.headers);\n  if (!headers.has(\"Content-Type\")) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n  }\n\n  return new Response(JSON.stringify(data), {\n    ...responseInit,\n    headers,\n  });\n};\n\nexport interface TrackedPromise extends Promise<any> {\n  _tracked?: boolean;\n  _data?: any;\n  _error?: any;\n}\n\nexport class AbortedDeferredError extends Error {}\n\nexport class DeferredData {\n  private pendingKeysSet: Set<string> = new Set<string>();\n  private controller: AbortController;\n  private abortPromise: Promise<void>;\n  private unlistenAbortSignal: () => void;\n  private subscribers: Set<(aborted: boolean, settledKey?: string) => void> =\n    new Set();\n  data: Record<string, unknown>;\n  init?: ResponseInit;\n  deferredKeys: string[] = [];\n\n  constructor(data: Record<string, unknown>, responseInit?: ResponseInit) {\n    invariant(\n      data && typeof data === \"object\" && !Array.isArray(data),\n      \"defer() only accepts plain objects\"\n    );\n\n    // Set up an AbortController + Promise we can race against to exit early\n    // cancellation\n    let reject: (e: AbortedDeferredError) => void;\n    this.abortPromise = new Promise((_, r) => (reject = r));\n    this.controller = new AbortController();\n    let onAbort = () =>\n      reject(new AbortedDeferredError(\"Deferred data aborted\"));\n    this.unlistenAbortSignal = () =>\n      this.controller.signal.removeEventListener(\"abort\", onAbort);\n    this.controller.signal.addEventListener(\"abort\", onAbort);\n\n    this.data = Object.entries(data).reduce(\n      (acc, [key, value]) =>\n        Object.assign(acc, {\n          [key]: this.trackPromise(key, value),\n        }),\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  private trackPromise(\n    key: string,\n    value: Promise<unknown> | unknown\n  ): TrackedPromise | unknown {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n\n    this.deferredKeys.push(key);\n    this.pendingKeysSet.add(key);\n\n    // We store a little wrapper promise that will be extended with\n    // _data/_error props upon resolve/reject\n    let promise: TrackedPromise = Promise.race([value, this.abortPromise]).then(\n      (data) => this.onSettle(promise, key, undefined, data as unknown),\n      (error) => this.onSettle(promise, key, error as unknown)\n    );\n\n    // Register rejection listeners to avoid uncaught promise rejections on\n    // errors or aborted deferred values\n    promise.catch(() => {});\n\n    Object.defineProperty(promise, \"_tracked\", { get: () => true });\n    return promise;\n  }\n\n  private onSettle(\n    promise: TrackedPromise,\n    key: string,\n    error: unknown,\n    data?: unknown\n  ): unknown {\n    if (\n      this.controller.signal.aborted &&\n      error instanceof AbortedDeferredError\n    ) {\n      this.unlistenAbortSignal();\n      Object.defineProperty(promise, \"_error\", { get: () => error });\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 the promise was resolved/rejected with undefined, we'll throw an error as you\n    // should always resolve with a value or null\n    if (error === undefined && data === undefined) {\n      let undefinedError = new Error(\n        `Deferred data for key \"${key}\" resolved/rejected with \\`undefined\\`, ` +\n          `you must resolve/reject with a value or \\`null\\`.`\n      );\n      Object.defineProperty(promise, \"_error\", { get: () => undefinedError });\n      this.emit(false, key);\n      return Promise.reject(undefinedError);\n    }\n\n    if (data === undefined) {\n      Object.defineProperty(promise, \"_error\", { get: () => error });\n      this.emit(false, key);\n      return Promise.reject(error);\n    }\n\n    Object.defineProperty(promise, \"_data\", { get: () => data });\n    this.emit(false, key);\n    return data;\n  }\n\n  private emit(aborted: boolean, settledKey?: string) {\n    this.subscribers.forEach((subscriber) => subscriber(aborted, settledKey));\n  }\n\n  subscribe(fn: (aborted: boolean, settledKey?: string) => void) {\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: AbortSignal) {\n    let aborted = false;\n    if (!this.done) {\n      let onAbort = () => this.cancel();\n      signal.addEventListener(\"abort\", onAbort);\n      aborted = await new Promise((resolve) => {\n        this.subscribe((aborted) => {\n          signal.removeEventListener(\"abort\", onAbort);\n          if (aborted || this.done) {\n            resolve(aborted);\n          }\n        });\n      });\n    }\n    return aborted;\n  }\n\n  get done() {\n    return this.pendingKeysSet.size === 0;\n  }\n\n  get unwrappedData() {\n    invariant(\n      this.data !== null && this.done,\n      \"Can only unwrap data on initialized and settled deferreds\"\n    );\n\n    return Object.entries(this.data).reduce(\n      (acc, [key, value]) =>\n        Object.assign(acc, {\n          [key]: unwrapTrackedPromise(value),\n        }),\n      {}\n    );\n  }\n\n  get pendingKeys() {\n    return Array.from(this.pendingKeysSet);\n  }\n}\n\nfunction isTrackedPromise(value: any): value is TrackedPromise {\n  return (\n    value instanceof Promise && (value as TrackedPromise)._tracked === true\n  );\n}\n\nfunction unwrapTrackedPromise(value: any) {\n  if (!isTrackedPromise(value)) {\n    return value;\n  }\n\n  if (value._error) {\n    throw value._error;\n  }\n  return value._data;\n}\n\nexport type DeferFunction = (\n  data: Record<string, unknown>,\n  init?: number | ResponseInit\n) => DeferredData;\n\nexport const defer: DeferFunction = (data, init = {}) => {\n  let responseInit = typeof init === \"number\" ? { status: init } : init;\n\n  return new DeferredData(data, responseInit);\n};\n\nexport type RedirectFunction = (\n  url: string,\n  init?: number | ResponseInit\n) => Response;\n\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const redirect: RedirectFunction = (url, init = 302) => {\n  let responseInit = init;\n  if (typeof responseInit === \"number\") {\n    responseInit = { status: responseInit };\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\n  return new Response(null, {\n    ...responseInit,\n    headers,\n  });\n};\n\n/**\n * A redirect response that will force a document reload to the new location.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const redirectDocument: RedirectFunction = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Reload-Document\", \"true\");\n  return response;\n};\n\nexport type ErrorResponse = {\n  status: number;\n  statusText: string;\n  data: any;\n};\n\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n *\n * We don't export the class for public use since it's an implementation\n * detail, but we export the interface above so folks can build their own\n * abstractions around instances via isRouteErrorResponse()\n */\nexport class ErrorResponseImpl implements ErrorResponse {\n  status: number;\n  statusText: string;\n  data: any;\n  private error?: Error;\n  private internal: boolean;\n\n  constructor(\n    status: number,\n    statusText: string | undefined,\n    data: any,\n    internal = false\n  ) {\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.internal = internal;\n    if (data instanceof Error) {\n      this.data = data.toString();\n      this.error = data;\n    } else {\n      this.data = data;\n    }\n  }\n}\n\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\nexport function isRouteErrorResponse(error: any): error is ErrorResponse {\n  return (\n    error != null &&\n    typeof error.status === \"number\" &&\n    typeof error.statusText === \"string\" &&\n    typeof error.internal === \"boolean\" &&\n    \"data\" in error\n  );\n}\n","import type { History, Location, Path, To } from \"./history\";\nimport {\n  Action as HistoryAction,\n  createLocation,\n  createPath,\n  invariant,\n  parsePath,\n  warning,\n} from \"./history\";\nimport type {\n  AgnosticDataRouteMatch,\n  AgnosticDataRouteObject,\n  DataStrategyMatch,\n  AgnosticRouteObject,\n  DataResult,\n  DataStrategyFunction,\n  DataStrategyFunctionArgs,\n  DeferredData,\n  DeferredResult,\n  DetectErrorBoundaryFunction,\n  ErrorResult,\n  FormEncType,\n  FormMethod,\n  HTMLFormMethod,\n  HandlerResult,\n  ImmutableRouteKey,\n  MapRoutePropertiesFunction,\n  MutationFormMethod,\n  RedirectResult,\n  RouteData,\n  RouteManifest,\n  ShouldRevalidateFunctionArgs,\n  Submission,\n  SuccessResult,\n  UIMatch,\n  V7_FormMethod,\n  V7_MutationFormMethod,\n} from \"./utils\";\nimport {\n  ErrorResponseImpl,\n  ResultType,\n  convertRouteMatchToUiMatch,\n  convertRoutesToDataRoutes,\n  getPathContributingMatches,\n  getResolveToMatches,\n  immutableRouteKeys,\n  isRouteErrorResponse,\n  joinPaths,\n  matchRoutes,\n  resolveTo,\n  stripBasename,\n} from \"./utils\";\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A Router instance manages all navigation and data loading/mutations\n */\nexport interface Router {\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the basename for the router\n   */\n  get basename(): RouterInit[\"basename\"];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the future config for the router\n   */\n  get future(): FutureConfig;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the current state of the router\n   */\n  get state(): RouterState;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the routes for this router instance\n   */\n  get routes(): AgnosticDataRouteObject[];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the window associated with the router\n   */\n  get window(): RouterInit[\"window\"];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Initialize the router, including adding history listeners and kicking off\n   * initial data fetches.  Returns a function to cleanup listeners and abort\n   * any in-progress loads\n   */\n  initialize(): Router;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Subscribe to router.state updates\n   *\n   * @param fn function to call with the new state\n   */\n  subscribe(fn: RouterSubscriber): () => void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Enable scroll restoration behavior in the router\n   *\n   * @param savedScrollPositions Object that will manage positions, in case\n   *                             it's being restored from sessionStorage\n   * @param getScrollPosition    Function to get the active Y scroll position\n   * @param getKey               Function to get the key to use for restoration\n   */\n  enableScrollRestoration(\n    savedScrollPositions: Record<string, number>,\n    getScrollPosition: GetScrollPositionFunction,\n    getKey?: GetScrollRestorationKeyFunction\n  ): () => void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Navigate forward/backward in the history stack\n   * @param to Delta to move in the history stack\n   */\n  navigate(to: number): Promise<void>;\n\n  /**\n   * Navigate to the given path\n   * @param to Path to navigate to\n   * @param opts Navigation options (method, submission, etc.)\n   */\n  navigate(to: To | null, opts?: RouterNavigateOptions): Promise<void>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Trigger a fetcher load/submission\n   *\n   * @param key     Fetcher key\n   * @param routeId Route that owns the fetcher\n   * @param href    href to fetch\n   * @param opts    Fetcher options, (method, submission, etc.)\n   */\n  fetch(\n    key: string,\n    routeId: string,\n    href: string | null,\n    opts?: RouterFetchOptions\n  ): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Trigger a revalidation of all current route loaders and fetcher loads\n   */\n  revalidate(): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Utility function to create an href for the given location\n   * @param location\n   */\n  createHref(location: Location | URL): string;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Utility function to URL encode a destination path according to the internal\n   * history implementation\n   * @param to\n   */\n  encodeLocation(to: To): Path;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Get/create a fetcher for the given key\n   * @param key\n   */\n  getFetcher<TData = any>(key: string): Fetcher<TData>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Delete the fetcher for a given key\n   * @param key\n   */\n  deleteFetcher(key: string): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Cleanup listeners and abort any in-progress loads\n   */\n  dispose(): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Get a navigation blocker\n   * @param key The identifier for the blocker\n   * @param fn The blocker function implementation\n   */\n  getBlocker(key: string, fn: BlockerFunction): Blocker;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Delete a navigation blocker\n   * @param key The identifier for the blocker\n   */\n  deleteBlocker(key: string): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * HMR needs to pass in-flight route updates to React Router\n   * TODO: Replace this with granular route update APIs (addRoute, updateRoute, deleteRoute)\n   */\n  _internalSetRoutes(routes: AgnosticRouteObject[]): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Internal fetch AbortControllers accessed by unit tests\n   */\n  _internalFetchControllers: Map<string, AbortController>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Internal pending DeferredData instances accessed by unit tests\n   */\n  _internalActiveDeferreds: Map<string, DeferredData>;\n}\n\n/**\n * State maintained internally by the router.  During a navigation, all states\n * reflect the the \"old\" location unless otherwise noted.\n */\nexport interface RouterState {\n  /**\n   * The action of the most recent navigation\n   */\n  historyAction: HistoryAction;\n\n  /**\n   * The current location reflected by the router\n   */\n  location: Location;\n\n  /**\n   * The current set of route matches\n   */\n  matches: AgnosticDataRouteMatch[];\n\n  /**\n   * Tracks whether we've completed our initial data load\n   */\n  initialized: boolean;\n\n  /**\n   * Current scroll position we should start at for a new view\n   *  - number -> scroll position to restore to\n   *  - false -> do not restore scroll at all (used during submissions)\n   *  - null -> don't have a saved position, scroll to hash or top of page\n   */\n  restoreScrollPosition: number | false | null;\n\n  /**\n   * Indicate whether this navigation should skip resetting the scroll position\n   * if we are unable to restore the scroll position\n   */\n  preventScrollReset: boolean;\n\n  /**\n   * Tracks the state of the current navigation\n   */\n  navigation: Navigation;\n\n  /**\n   * Tracks any in-progress revalidations\n   */\n  revalidation: RevalidationState;\n\n  /**\n   * Data from the loaders for the current matches\n   */\n  loaderData: RouteData;\n\n  /**\n   * Data from the action for the current matches\n   */\n  actionData: RouteData | null;\n\n  /**\n   * Errors caught from loaders for the current matches\n   */\n  errors: RouteData | null;\n\n  /**\n   * Map of current fetchers\n   */\n  fetchers: Map<string, Fetcher>;\n\n  /**\n   * Map of current blockers\n   */\n  blockers: Map<string, Blocker>;\n}\n\n/**\n * Data that can be passed into hydrate a Router from SSR\n */\nexport type HydrationState = Partial<\n  Pick<RouterState, \"loaderData\" | \"actionData\" | \"errors\">\n>;\n\n/**\n * Future flags to toggle new feature behavior\n */\nexport interface FutureConfig {\n  v7_fetcherPersist: boolean;\n  v7_normalizeFormMethod: boolean;\n  v7_partialHydration: boolean;\n  v7_prependBasename: boolean;\n  v7_relativeSplatPath: boolean;\n  unstable_skipActionErrorRevalidation: boolean;\n}\n\n/**\n * Initialization options for createRouter\n */\nexport interface RouterInit {\n  routes: AgnosticRouteObject[];\n  history: History;\n  basename?: string;\n  /**\n   * @deprecated Use `mapRouteProperties` instead\n   */\n  detectErrorBoundary?: DetectErrorBoundaryFunction;\n  mapRouteProperties?: MapRoutePropertiesFunction;\n  future?: Partial<FutureConfig>;\n  hydrationData?: HydrationState;\n  window?: Window;\n  unstable_dataStrategy?: DataStrategyFunction;\n}\n\n/**\n * State returned from a server-side query() call\n */\nexport interface StaticHandlerContext {\n  basename: Router[\"basename\"];\n  location: RouterState[\"location\"];\n  matches: RouterState[\"matches\"];\n  loaderData: RouterState[\"loaderData\"];\n  actionData: RouterState[\"actionData\"];\n  errors: RouterState[\"errors\"];\n  statusCode: number;\n  loaderHeaders: Record<string, Headers>;\n  actionHeaders: Record<string, Headers>;\n  activeDeferreds: Record<string, DeferredData> | null;\n  _deepestRenderedBoundaryId?: string | null;\n}\n\n/**\n * A StaticHandler instance manages a singular SSR navigation/fetch event\n */\nexport interface StaticHandler {\n  dataRoutes: AgnosticDataRouteObject[];\n  query(\n    request: Request,\n    opts?: {\n      requestContext?: unknown;\n      skipLoaderErrorBubbling?: boolean;\n      unstable_dataStrategy?: DataStrategyFunction;\n    }\n  ): Promise<StaticHandlerContext | Response>;\n  queryRoute(\n    request: Request,\n    opts?: { routeId?: string; requestContext?: unknown }\n  ): Promise<any>;\n}\n\ntype ViewTransitionOpts = {\n  currentLocation: Location;\n  nextLocation: Location;\n};\n\n/**\n * Subscriber function signature for changes to router state\n */\nexport interface RouterSubscriber {\n  (\n    state: RouterState,\n    opts: {\n      deletedFetchers: string[];\n      unstable_viewTransitionOpts?: ViewTransitionOpts;\n      unstable_flushSync: boolean;\n    }\n  ): void;\n}\n\n/**\n * Function signature for determining the key to be used in scroll restoration\n * for a given location\n */\nexport interface GetScrollRestorationKeyFunction {\n  (location: Location, matches: UIMatch[]): string | null;\n}\n\n/**\n * Function signature for determining the current scroll position\n */\nexport interface GetScrollPositionFunction {\n  (): number;\n}\n\nexport type RelativeRoutingType = \"route\" | \"path\";\n\n// Allowed for any navigation or fetch\ntype BaseNavigateOrFetchOptions = {\n  preventScrollReset?: boolean;\n  relative?: RelativeRoutingType;\n  unstable_flushSync?: boolean;\n};\n\n// Only allowed for navigations\ntype BaseNavigateOptions = BaseNavigateOrFetchOptions & {\n  replace?: boolean;\n  state?: any;\n  fromRouteId?: string;\n  unstable_viewTransition?: boolean;\n};\n\n// Only allowed for submission navigations\ntype BaseSubmissionOptions = {\n  formMethod?: HTMLFormMethod;\n  formEncType?: FormEncType;\n} & (\n  | { formData: FormData; body?: undefined }\n  | { formData?: undefined; body: any }\n);\n\n/**\n * Options for a navigate() call for a normal (non-submission) navigation\n */\ntype LinkNavigateOptions = BaseNavigateOptions;\n\n/**\n * Options for a navigate() call for a submission navigation\n */\ntype SubmissionNavigateOptions = BaseNavigateOptions & BaseSubmissionOptions;\n\n/**\n * Options to pass to navigate() for a navigation\n */\nexport type RouterNavigateOptions =\n  | LinkNavigateOptions\n  | SubmissionNavigateOptions;\n\n/**\n * Options for a fetch() load\n */\ntype LoadFetchOptions = BaseNavigateOrFetchOptions;\n\n/**\n * Options for a fetch() submission\n */\ntype SubmitFetchOptions = BaseNavigateOrFetchOptions & BaseSubmissionOptions;\n\n/**\n * Options to pass to fetch()\n */\nexport type RouterFetchOptions = LoadFetchOptions | SubmitFetchOptions;\n\n/**\n * Potential states for state.navigation\n */\nexport type NavigationStates = {\n  Idle: {\n    state: \"idle\";\n    location: undefined;\n    formMethod: undefined;\n    formAction: undefined;\n    formEncType: undefined;\n    formData: undefined;\n    json: undefined;\n    text: undefined;\n  };\n  Loading: {\n    state: \"loading\";\n    location: Location;\n    formMethod: Submission[\"formMethod\"] | undefined;\n    formAction: Submission[\"formAction\"] | undefined;\n    formEncType: Submission[\"formEncType\"] | undefined;\n    formData: Submission[\"formData\"] | undefined;\n    json: Submission[\"json\"] | undefined;\n    text: Submission[\"text\"] | undefined;\n  };\n  Submitting: {\n    state: \"submitting\";\n    location: Location;\n    formMethod: Submission[\"formMethod\"];\n    formAction: Submission[\"formAction\"];\n    formEncType: Submission[\"formEncType\"];\n    formData: Submission[\"formData\"];\n    json: Submission[\"json\"];\n    text: Submission[\"text\"];\n  };\n};\n\nexport type Navigation = NavigationStates[keyof NavigationStates];\n\nexport type RevalidationState = \"idle\" | \"loading\";\n\n/**\n * Potential states for fetchers\n */\ntype FetcherStates<TData = any> = {\n  Idle: {\n    state: \"idle\";\n    formMethod: undefined;\n    formAction: undefined;\n    formEncType: undefined;\n    text: undefined;\n    formData: undefined;\n    json: undefined;\n    data: TData | undefined;\n  };\n  Loading: {\n    state: \"loading\";\n    formMethod: Submission[\"formMethod\"] | undefined;\n    formAction: Submission[\"formAction\"] | undefined;\n    formEncType: Submission[\"formEncType\"] | undefined;\n    text: Submission[\"text\"] | undefined;\n    formData: Submission[\"formData\"] | undefined;\n    json: Submission[\"json\"] | undefined;\n    data: TData | undefined;\n  };\n  Submitting: {\n    state: \"submitting\";\n    formMethod: Submission[\"formMethod\"];\n    formAction: Submission[\"formAction\"];\n    formEncType: Submission[\"formEncType\"];\n    text: Submission[\"text\"];\n    formData: Submission[\"formData\"];\n    json: Submission[\"json\"];\n    data: TData | undefined;\n  };\n};\n\nexport type Fetcher<TData = any> =\n  FetcherStates<TData>[keyof FetcherStates<TData>];\n\ninterface BlockerBlocked {\n  state: \"blocked\";\n  reset(): void;\n  proceed(): void;\n  location: Location;\n}\n\ninterface BlockerUnblocked {\n  state: \"unblocked\";\n  reset: undefined;\n  proceed: undefined;\n  location: undefined;\n}\n\ninterface BlockerProceeding {\n  state: \"proceeding\";\n  reset: undefined;\n  proceed: undefined;\n  location: Location;\n}\n\nexport type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;\n\nexport type BlockerFunction = (args: {\n  currentLocation: Location;\n  nextLocation: Location;\n  historyAction: HistoryAction;\n}) => boolean;\n\ninterface ShortCircuitable {\n  /**\n   * startNavigation does not need to complete the navigation because we\n   * redirected or got interrupted\n   */\n  shortCircuited?: boolean;\n}\n\ntype PendingActionResult = [string, SuccessResult | ErrorResult];\n\ninterface HandleActionResult extends ShortCircuitable {\n  /**\n   * Tuple for the returned or thrown value from the current action.  The routeId\n   * is the action route for success and the bubbled boundary route for errors.\n   */\n  pendingActionResult?: PendingActionResult;\n}\n\ninterface HandleLoadersResult extends ShortCircuitable {\n  /**\n   * loaderData returned from the current set of loaders\n   */\n  loaderData?: RouterState[\"loaderData\"];\n  /**\n   * errors thrown from the current set of loaders\n   */\n  errors?: RouterState[\"errors\"];\n}\n\n/**\n * Cached info for active fetcher.load() instances so they can participate\n * in revalidation\n */\ninterface FetchLoadMatch {\n  routeId: string;\n  path: string;\n}\n\n/**\n * Identified fetcher.load() calls that need to be revalidated\n */\ninterface RevalidatingFetcher extends FetchLoadMatch {\n  key: string;\n  match: AgnosticDataRouteMatch | null;\n  matches: AgnosticDataRouteMatch[] | null;\n  controller: AbortController | null;\n}\n\nconst validMutationMethodsArr: MutationFormMethod[] = [\n  \"post\",\n  \"put\",\n  \"patch\",\n  \"delete\",\n];\nconst validMutationMethods = new Set<MutationFormMethod>(\n  validMutationMethodsArr\n);\n\nconst validRequestMethodsArr: FormMethod[] = [\n  \"get\",\n  ...validMutationMethodsArr,\n];\nconst validRequestMethods = new Set<FormMethod>(validRequestMethodsArr);\n\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\n\nexport const IDLE_NAVIGATION: NavigationStates[\"Idle\"] = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined,\n};\n\nexport const IDLE_FETCHER: FetcherStates[\"Idle\"] = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined,\n};\n\nexport const IDLE_BLOCKER: BlockerUnblocked = {\n  state: \"unblocked\",\n  proceed: undefined,\n  reset: undefined,\n  location: undefined,\n};\n\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n\nconst defaultMapRouteProperties: MapRoutePropertiesFunction = (route) => ({\n  hasErrorBoundary: Boolean(route.hasErrorBoundary),\n});\n\nconst TRANSITIONS_STORAGE_KEY = \"remix-router-transitions\";\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Create a router and listen to history POP navigations\n */\nexport function createRouter(init: RouterInit): Router {\n  const routerWindow = init.window\n    ? init.window\n    : typeof window !== \"undefined\"\n    ? window\n    : undefined;\n  const isBrowser =\n    typeof routerWindow !== \"undefined\" &&\n    typeof routerWindow.document !== \"undefined\" &&\n    typeof routerWindow.document.createElement !== \"undefined\";\n  const isServer = !isBrowser;\n\n  invariant(\n    init.routes.length > 0,\n    \"You must provide a non-empty routes array to createRouter\"\n  );\n\n  let mapRouteProperties: MapRoutePropertiesFunction;\n  if (init.mapRouteProperties) {\n    mapRouteProperties = init.mapRouteProperties;\n  } else if (init.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = init.detectErrorBoundary;\n    mapRouteProperties = (route) => ({\n      hasErrorBoundary: detectErrorBoundary(route),\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n\n  // Routes keyed by ID\n  let manifest: RouteManifest = {};\n  // Routes in tree format for matching\n  let dataRoutes = convertRoutesToDataRoutes(\n    init.routes,\n    mapRouteProperties,\n    undefined,\n    manifest\n  );\n  let inFlightDataRoutes: AgnosticDataRouteObject[] | undefined;\n  let basename = init.basename || \"/\";\n  let dataStrategyImpl = init.unstable_dataStrategy || defaultDataStrategy;\n  // Config driven behavior flags\n  let future: FutureConfig = {\n    v7_fetcherPersist: false,\n    v7_normalizeFormMethod: false,\n    v7_partialHydration: false,\n    v7_prependBasename: false,\n    v7_relativeSplatPath: false,\n    unstable_skipActionErrorRevalidation: false,\n    ...init.future,\n  };\n  // Cleanup function for history\n  let unlistenHistory: (() => void) | null = null;\n  // Externally-provided functions to call on all state changes\n  let subscribers = new Set<RouterSubscriber>();\n  // Externally-provided object to hold scroll restoration locations during routing\n  let savedScrollPositions: Record<string, number> | null = null;\n  // Externally-provided function to get scroll restoration keys\n  let getScrollRestorationKey: GetScrollRestorationKeyFunction | null = null;\n  // Externally-provided function to get current scroll position\n  let getScrollPosition: GetScrollPositionFunction | null = null;\n  // One-time flag to control the initial hydration scroll restoration.  Because\n  // we don't get the saved positions from <ScrollRestoration /> until _after_\n  // the initial render, we need to manually trigger a separate updateState to\n  // send along the restoreScrollPosition\n  // Set to true if we have `hydrationData` since we assume we were SSR'd and that\n  // SSR did the initial scroll restoration.\n  let initialScrollRestored = init.hydrationData != null;\n\n  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);\n  let initialErrors: RouteData | null = 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 { matches, route } = getShortCircuitMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = { [route.id]: error };\n  }\n\n  let initialized: boolean;\n  let hasLazyRoutes = initialMatches.some((m) => m.route.lazy);\n  let hasLoaders = initialMatches.some((m) => m.route.loader);\n  if (hasLazyRoutes) {\n    // All initialMatches need to be loaded before we're ready.  If we have lazy\n    // functions around still then we'll need to run them in initialize()\n    initialized = false;\n  } else if (!hasLoaders) {\n    // If we've got no loaders to run, then we're good to go\n    initialized = true;\n  } else if (future.v7_partialHydration) {\n    // If partial hydration is enabled, we're initialized so long as we were\n    // provided with hydrationData for every route with a loader, and no loaders\n    // were marked for explicit hydration\n    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;\n    let errors = init.hydrationData ? init.hydrationData.errors : null;\n    let isRouteInitialized = (m: AgnosticDataRouteMatch) => {\n      // No loader, nothing to initialize\n      if (!m.route.loader) {\n        return true;\n      }\n      // Explicitly opting-in to running on hydration\n      if (\n        typeof m.route.loader === \"function\" &&\n        m.route.loader.hydrate === true\n      ) {\n        return false;\n      }\n      // Otherwise, initialized if hydrated with data or an error\n      return (\n        (loaderData && loaderData[m.route.id] !== undefined) ||\n        (errors && errors[m.route.id] !== undefined)\n      );\n    };\n\n    // If errors exist, don't consider routes below the boundary\n    if (errors) {\n      let idx = initialMatches.findIndex(\n        (m) => errors![m.route.id] !== undefined\n      );\n      initialized = initialMatches.slice(0, idx + 1).every(isRouteInitialized);\n    } else {\n      initialized = initialMatches.every(isRouteInitialized);\n    }\n  } else {\n    // Without partial hydration - we're initialized if we were provided any\n    // hydrationData - which is expected to be complete\n    initialized = init.hydrationData != null;\n  }\n\n  let router: Router;\n  let state: RouterState = {\n    historyAction: init.history.action,\n    location: init.history.location,\n    matches: initialMatches,\n    initialized,\n    navigation: IDLE_NAVIGATION,\n    // Don't restore on initial updateState() if we were SSR'd\n    restoreScrollPosition: init.hydrationData != null ? false : null,\n    preventScrollReset: false,\n    revalidation: \"idle\",\n    loaderData: (init.hydrationData && init.hydrationData.loaderData) || {},\n    actionData: (init.hydrationData && init.hydrationData.actionData) || null,\n    errors: (init.hydrationData && init.hydrationData.errors) || initialErrors,\n    fetchers: new Map(),\n    blockers: new Map(),\n  };\n\n  // -- Stateful internal variables to manage navigations --\n  // Current navigation in progress (to be committed in completeNavigation)\n  let pendingAction: HistoryAction = HistoryAction.Pop;\n\n  // Should the current navigation prevent the scroll reset if scroll cannot\n  // be restored?\n  let pendingPreventScrollReset = false;\n\n  // AbortController for the active navigation\n  let pendingNavigationController: AbortController | null;\n\n  // Should the current navigation enable document.startViewTransition?\n  let pendingViewTransitionEnabled = false;\n\n  // Store applied view transitions so we can apply them on POP\n  let appliedViewTransitions: Map<string, Set<string>> = new Map<\n    string,\n    Set<string>\n  >();\n\n  // Cleanup function for persisting applied transitions to sessionStorage\n  let removePageHideEventListener: (() => void) | null = null;\n\n  // We use this to avoid touching history in completeNavigation if a\n  // revalidation is entirely uninterrupted\n  let isUninterruptedRevalidation = false;\n\n  // Use this internal flag to force revalidation of all loaders:\n  //  - submissions (completed or interrupted)\n  //  - useRevalidator()\n  //  - X-Remix-Revalidate (from redirect)\n  let isRevalidationRequired = false;\n\n  // Use this internal array to capture routes that require revalidation due\n  // to a cancelled deferred on action submission\n  let cancelledDeferredRoutes: string[] = [];\n\n  // Use this internal array to capture fetcher loads that were cancelled by an\n  // action navigation and require revalidation\n  let cancelledFetcherLoads: string[] = [];\n\n  // AbortControllers for any in-flight fetchers\n  let fetchControllers = new Map<string, AbortController>();\n\n  // Track loads based on the order in which they started\n  let incrementingLoadId = 0;\n\n  // Track the outstanding pending navigation data load to be compared against\n  // the globally incrementing load when a fetcher load lands after a completed\n  // navigation\n  let pendingNavigationLoadId = -1;\n\n  // Fetchers that triggered data reloads as a result of their actions\n  let fetchReloadIds = new Map<string, number>();\n\n  // Fetchers that triggered redirect navigations\n  let fetchRedirectIds = new Set<string>();\n\n  // Most recent href/match for fetcher.load calls for fetchers\n  let fetchLoadMatches = new Map<string, FetchLoadMatch>();\n\n  // Ref-count mounted fetchers so we know when it's ok to clean them up\n  let activeFetchers = new Map<string, number>();\n\n  // Fetchers that have requested a delete when using v7_fetcherPersist,\n  // they'll be officially removed after they return to idle\n  let deletedFetchers = new Set<string>();\n\n  // Store DeferredData instances for active route matches.  When a\n  // route loader returns defer() we stick one in here.  Then, when a nested\n  // promise resolves we update loaderData.  If a new navigation starts we\n  // cancel active deferreds for eliminated routes.\n  let activeDeferreds = new Map<string, DeferredData>();\n\n  // Store blocker functions in a separate Map outside of router state since\n  // we don't need to update UI state if they change\n  let blockerFunctions = new Map<string, BlockerFunction>();\n\n  // Flag to ignore the next history update, so we can revert the URL change on\n  // a POP navigation that was blocked by the user without touching router state\n  let ignoreNextHistoryUpdate = false;\n\n  // Initialize the router, all side effects should be kicked off from here.\n  // Implemented as a Fluent API for ease of:\n  //   let router = createRouter(init).initialize();\n  function initialize() {\n    // If history informs us of a POP navigation, start the navigation but do not update\n    // state.  We'll update our own state once the navigation completes\n    unlistenHistory = init.history.listen(\n      ({ action: historyAction, location, delta }) => {\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(\n          blockerFunctions.size === 0 || delta != null,\n          \"You are trying to use a blocker on a POP navigation to a location \" +\n            \"that was not created by @remix-run/router. This will fail silently in \" +\n            \"production. This can happen if you are navigating outside the router \" +\n            \"via `window.history.pushState`/`window.location.hash` instead of using \" +\n            \"router navigation APIs.  This can also happen if you are using \" +\n            \"createHashRouter and the user manually changes the URL.\"\n        );\n\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);\n\n          // Put the blocker into a blocked state\n          updateBlocker(blockerKey, {\n            state: \"blocked\",\n            location,\n            proceed() {\n              updateBlocker(blockerKey!, {\n                state: \"proceeding\",\n                proceed: undefined,\n                reset: undefined,\n                location,\n              });\n              // Re-do the same POP navigation we just blocked\n              init.history.go(delta);\n            },\n            reset() {\n              let blockers = new Map(state.blockers);\n              blockers.set(blockerKey!, IDLE_BLOCKER);\n              updateState({ blockers });\n            },\n          });\n          return;\n        }\n\n        return startNavigation(historyAction, location);\n      }\n    );\n\n    if (isBrowser) {\n      // FIXME: This feels gross.  How can we cleanup the lines between\n      // scrollRestoration/appliedTransitions persistance?\n      restoreAppliedTransitions(routerWindow, appliedViewTransitions);\n      let _saveAppliedTransitions = () =>\n        persistAppliedTransitions(routerWindow, appliedViewTransitions);\n      routerWindow.addEventListener(\"pagehide\", _saveAppliedTransitions);\n      removePageHideEventListener = () =>\n        routerWindow.removeEventListener(\"pagehide\", _saveAppliedTransitions);\n    }\n\n    // Kick off initial data load if needed.  Use Pop to avoid modifying history\n    // Note we don't do any handling of lazy here.  For SPA's it'll get handled\n    // in the normal navigation flow.  For SSR it's expected that lazy modules are\n    // resolved prior to router creation since we can't go into a fallbackElement\n    // UI for SSR'd apps\n    if (!state.initialized) {\n      startNavigation(HistoryAction.Pop, state.location, {\n        initialHydration: true,\n      });\n    }\n\n    return router;\n  }\n\n  // Clean up a router and it's side effects\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\n    }\n    if (removePageHideEventListener) {\n      removePageHideEventListener();\n    }\n    subscribers.clear();\n    pendingNavigationController && pendingNavigationController.abort();\n    state.fetchers.forEach((_, key) => deleteFetcher(key));\n    state.blockers.forEach((_, key) => deleteBlocker(key));\n  }\n\n  // Subscribe to state updates for the router\n  function subscribe(fn: RouterSubscriber) {\n    subscribers.add(fn);\n    return () => subscribers.delete(fn);\n  }\n\n  // Update our state and notify the calling context of the change\n  function updateState(\n    newState: Partial<RouterState>,\n    opts: {\n      flushSync?: boolean;\n      viewTransitionOpts?: ViewTransitionOpts;\n    } = {}\n  ): void {\n    state = {\n      ...state,\n      ...newState,\n    };\n\n    // Prep fetcher cleanup so we can tell the UI which fetcher data entries\n    // can be removed\n    let completedFetchers: string[] = [];\n    let deletedFetchersKeys: string[] = [];\n\n    if (future.v7_fetcherPersist) {\n      state.fetchers.forEach((fetcher, key) => {\n        if (fetcher.state === \"idle\") {\n          if (deletedFetchers.has(key)) {\n            // Unmounted from the UI and can be totally removed\n            deletedFetchersKeys.push(key);\n          } else {\n            // Returned to idle but still mounted in the UI, so semi-remains for\n            // revalidations and such\n            completedFetchers.push(key);\n          }\n        }\n      });\n    }\n\n    // Iterate over a local copy so that if flushSync is used and we end up\n    // removing and adding a new subscriber due to the useCallback dependencies,\n    // we don't get ourselves into a loop calling the new subscriber immediately\n    [...subscribers].forEach((subscriber) =>\n      subscriber(state, {\n        deletedFetchers: deletedFetchersKeys,\n        unstable_viewTransitionOpts: opts.viewTransitionOpts,\n        unstable_flushSync: opts.flushSync === true,\n      })\n    );\n\n    // Remove idle fetchers from state since we only care about in-flight fetchers.\n    if (future.v7_fetcherPersist) {\n      completedFetchers.forEach((key) => state.fetchers.delete(key));\n      deletedFetchersKeys.forEach((key) => deleteFetcher(key));\n    }\n  }\n\n  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION\n  // and setting state.[historyAction/location/matches] to the new route.\n  // - Location is a required param\n  // - Navigation will always be set to IDLE_NAVIGATION\n  // - Can pass any other state in newState\n  function completeNavigation(\n    location: Location,\n    newState: Partial<Omit<RouterState, \"action\" | \"location\" | \"navigation\">>,\n    { flushSync }: { flushSync?: boolean } = {}\n  ): void {\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 =\n      state.actionData != null &&\n      state.navigation.formMethod != null &&\n      isMutationMethod(state.navigation.formMethod) &&\n      state.navigation.state === \"loading\" &&\n      location.state?._isRedirect !== true;\n\n    let actionData: RouteData | null;\n    if (newState.actionData) {\n      if (Object.keys(newState.actionData).length > 0) {\n        actionData = newState.actionData;\n      } else {\n        // Empty actionData -> clear prior actionData due to an action error\n        actionData = null;\n      }\n    } else if (isActionReload) {\n      // Keep the current data if we're wrapping up the action reload\n      actionData = state.actionData;\n    } else {\n      // Clear actionData on any other completed navigations\n      actionData = null;\n    }\n\n    // Always preserve any existing loaderData from re-used routes\n    let loaderData = newState.loaderData\n      ? mergeLoaderData(\n          state.loaderData,\n          newState.loaderData,\n          newState.matches || [],\n          newState.errors\n        )\n      : state.loaderData;\n\n    // On a successful navigation we can assume we got through all blockers\n    // so we can start fresh\n    let blockers = state.blockers;\n    if (blockers.size > 0) {\n      blockers = new Map(blockers);\n      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));\n    }\n\n    // Always respect the user flag.  Otherwise don't reset on mutation\n    // submission navigations unless they redirect\n    let preventScrollReset =\n      pendingPreventScrollReset === true ||\n      (state.navigation.formMethod != null &&\n        isMutationMethod(state.navigation.formMethod) &&\n        location.state?._isRedirect !== true);\n\n    if (inFlightDataRoutes) {\n      dataRoutes = inFlightDataRoutes;\n      inFlightDataRoutes = undefined;\n    }\n\n    if (isUninterruptedRevalidation) {\n      // If this was an uninterrupted revalidation then do not touch history\n    } else if (pendingAction === HistoryAction.Pop) {\n      // Do nothing for POP - URL has already been updated\n    } else if (pendingAction === HistoryAction.Push) {\n      init.history.push(location, location.state);\n    } else if (pendingAction === HistoryAction.Replace) {\n      init.history.replace(location, location.state);\n    }\n\n    let viewTransitionOpts: ViewTransitionOpts | undefined;\n\n    // On POP, enable transitions if they were enabled on the original navigation\n    if (pendingAction === HistoryAction.Pop) {\n      // Forward takes precedence so they behave like the original navigation\n      let priorPaths = appliedViewTransitions.get(state.location.pathname);\n      if (priorPaths && priorPaths.has(location.pathname)) {\n        viewTransitionOpts = {\n          currentLocation: state.location,\n          nextLocation: location,\n        };\n      } else if (appliedViewTransitions.has(location.pathname)) {\n        // If we don't have a previous forward nav, assume we're popping back to\n        // the new location and enable if that location previously enabled\n        viewTransitionOpts = {\n          currentLocation: location,\n          nextLocation: state.location,\n        };\n      }\n    } else if (pendingViewTransitionEnabled) {\n      // Store the applied transition on PUSH/REPLACE\n      let toPaths = appliedViewTransitions.get(state.location.pathname);\n      if (toPaths) {\n        toPaths.add(location.pathname);\n      } else {\n        toPaths = new Set<string>([location.pathname]);\n        appliedViewTransitions.set(state.location.pathname, toPaths);\n      }\n      viewTransitionOpts = {\n        currentLocation: state.location,\n        nextLocation: location,\n      };\n    }\n\n    updateState(\n      {\n        ...newState, // matches, errors, fetchers go through as-is\n        actionData,\n        loaderData,\n        historyAction: pendingAction,\n        location,\n        initialized: true,\n        navigation: IDLE_NAVIGATION,\n        revalidation: \"idle\",\n        restoreScrollPosition: getSavedScrollPosition(\n          location,\n          newState.matches || state.matches\n        ),\n        preventScrollReset,\n        blockers,\n      },\n      {\n        viewTransitionOpts,\n        flushSync: flushSync === true,\n      }\n    );\n\n    // Reset stateful navigation vars\n    pendingAction = HistoryAction.Pop;\n    pendingPreventScrollReset = false;\n    pendingViewTransitionEnabled = false;\n    isUninterruptedRevalidation = false;\n    isRevalidationRequired = false;\n    cancelledDeferredRoutes = [];\n    cancelledFetcherLoads = [];\n  }\n\n  // Trigger a navigation event, which can either be a numerical POP or a PUSH\n  // replace with an optional submission\n  async function navigate(\n    to: number | To | null,\n    opts?: RouterNavigateOptions\n  ): Promise<void> {\n    if (typeof to === \"number\") {\n      init.history.go(to);\n      return;\n    }\n\n    let normalizedPath = normalizeTo(\n      state.location,\n      state.matches,\n      basename,\n      future.v7_prependBasename,\n      to,\n      future.v7_relativeSplatPath,\n      opts?.fromRouteId,\n      opts?.relative\n    );\n    let { path, submission, error } = normalizeNavigateOptions(\n      future.v7_normalizeFormMethod,\n      false,\n      normalizedPath,\n      opts\n    );\n\n    let currentLocation = state.location;\n    let nextLocation = createLocation(state.location, path, opts && opts.state);\n\n    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded\n    // URL from window.location, so we need to encode it here so the behavior\n    // remains the same as POP and non-data-router usages.  new URL() does all\n    // the same encoding we'd get from a history.pushState/window.location read\n    // without having to touch history\n    nextLocation = {\n      ...nextLocation,\n      ...init.history.encodeLocation(nextLocation),\n    };\n\n    let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n\n    let historyAction = HistoryAction.Push;\n\n    if (userReplace === true) {\n      historyAction = HistoryAction.Replace;\n    } else if (userReplace === false) {\n      // no-op\n    } else if (\n      submission != null &&\n      isMutationMethod(submission.formMethod) &&\n      submission.formAction === state.location.pathname + state.location.search\n    ) {\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 = HistoryAction.Replace;\n    }\n\n    let preventScrollReset =\n      opts && \"preventScrollReset\" in opts\n        ? opts.preventScrollReset === true\n        : undefined;\n\n    let flushSync = (opts && opts.unstable_flushSync) === true;\n\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        proceed() {\n          updateBlocker(blockerKey!, {\n            state: \"proceeding\",\n            proceed: undefined,\n            reset: undefined,\n            location: nextLocation,\n          });\n          // Send the same navigation through\n          navigate(to, opts);\n        },\n        reset() {\n          let blockers = new Map(state.blockers);\n          blockers.set(blockerKey!, IDLE_BLOCKER);\n          updateState({ blockers });\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      enableViewTransition: opts && opts.unstable_viewTransition,\n      flushSync,\n    });\n  }\n\n  // Revalidate all current loaders.  If a navigation is in progress or if this\n  // is interrupted by a navigation, allow this to \"succeed\" by calling all\n  // loaders during the next loader round\n  function revalidate() {\n    interruptActiveLoads();\n    updateState({ revalidation: \"loading\" });\n\n    // If we're currently submitting an action, we don't need to start a new\n    // navigation, we'll just let the follow up loader execution call all loaders\n    if (state.navigation.state === \"submitting\") {\n      return;\n    }\n\n    // If we're currently in an idle state, start a new navigation for the current\n    // action/location and mark it as uninterrupted, which will skip the history\n    // update in completeNavigation\n    if (state.navigation.state === \"idle\") {\n      startNavigation(state.historyAction, state.location, {\n        startUninterruptedRevalidation: true,\n      });\n      return;\n    }\n\n    // Otherwise, if we're currently in a loading state, just start a new\n    // navigation to the navigation.location but do not trigger an uninterrupted\n    // revalidation so that history correctly updates once the navigation completes\n    startNavigation(\n      pendingAction || state.historyAction,\n      state.navigation.location,\n      { overrideNavigation: state.navigation }\n    );\n  }\n\n  // Start a navigation to the given action/location.  Can optionally provide a\n  // overrideNavigation which will override the normalLoad in the case of a redirect\n  // navigation\n  async function startNavigation(\n    historyAction: HistoryAction,\n    location: Location,\n    opts?: {\n      initialHydration?: boolean;\n      submission?: Submission;\n      fetcherSubmission?: Submission;\n      overrideNavigation?: Navigation;\n      pendingError?: ErrorResponseImpl;\n      startUninterruptedRevalidation?: boolean;\n      preventScrollReset?: boolean;\n      replace?: boolean;\n      enableViewTransition?: boolean;\n      flushSync?: boolean;\n    }\n  ): Promise<void> {\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 =\n      (opts && opts.startUninterruptedRevalidation) === true;\n\n    // Save the current scroll position every time we start a new navigation,\n    // and track whether we should reset scroll on completion\n    saveScrollPosition(state.location, state.matches);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n\n    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches = matchRoutes(routesToUse, location, basename);\n    let flushSync = (opts && opts.flushSync) === true;\n\n    // Short circuit with a 404 on the root error boundary if we match nothing\n    if (!matches) {\n      let error = getInternalRouterError(404, { pathname: location.pathname });\n      let { matches: notFoundMatches, route } =\n        getShortCircuitMatches(routesToUse);\n      // Cancel all pending deferred on 404s since we don't keep any routes\n      cancelActiveDeferreds();\n      completeNavigation(\n        location,\n        {\n          matches: notFoundMatches,\n          loaderData: {},\n          errors: {\n            [route.id]: error,\n          },\n        },\n        { flushSync }\n      );\n      return;\n    }\n\n    // Short circuit if it's only a hash change and not a revalidation or\n    // mutation submission.\n    //\n    // Ignore on initial page loads because since the initial load will always\n    // be \"same hash\".  For example, on /page#hash and submit a <Form method=\"post\">\n    // which will default to a navigation to /page\n    if (\n      state.initialized &&\n      !isRevalidationRequired &&\n      isHashChangeOnly(state.location, location) &&\n      !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))\n    ) {\n      completeNavigation(location, { matches }, { flushSync });\n      return;\n    }\n\n    // Create a controller/Request for this navigation\n    pendingNavigationController = new AbortController();\n    let request = createClientSideRequest(\n      init.history,\n      location,\n      pendingNavigationController.signal,\n      opts && opts.submission\n    );\n    let pendingActionResult: PendingActionResult | undefined;\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      pendingActionResult = [\n        findNearestBoundary(matches).route.id,\n        { type: ResultType.error, error: opts.pendingError },\n      ];\n    } else if (\n      opts &&\n      opts.submission &&\n      isMutationMethod(opts.submission.formMethod)\n    ) {\n      // Call action if we received an action submission\n      let actionResult = await handleAction(\n        request,\n        location,\n        opts.submission,\n        matches,\n        { replace: opts.replace, flushSync }\n      );\n\n      if (actionResult.shortCircuited) {\n        return;\n      }\n\n      pendingActionResult = actionResult.pendingActionResult;\n      loadingNavigation = getLoadingNavigation(location, opts.submission);\n      flushSync = false;\n\n      // Create a GET request for the loaders\n      request = createClientSideRequest(\n        init.history,\n        request.url,\n        request.signal\n      );\n    }\n\n    // Call loaders\n    let { shortCircuited, loaderData, errors } = await handleLoaders(\n      request,\n      location,\n      matches,\n      loadingNavigation,\n      opts && opts.submission,\n      opts && opts.fetcherSubmission,\n      opts && opts.replace,\n      opts && opts.initialHydration === true,\n      flushSync,\n      pendingActionResult\n    );\n\n    if (shortCircuited) {\n      return;\n    }\n\n    // Clean up now that the action/loaders have completed.  Don't clean up if\n    // we short circuited because pendingNavigationController will have already\n    // been assigned to a new controller for the next navigation\n    pendingNavigationController = null;\n\n    completeNavigation(location, {\n      matches,\n      ...getActionDataForCommit(pendingActionResult),\n      loaderData,\n      errors,\n    });\n  }\n\n  // Call the action matched by the leaf route for this navigation and handle\n  // redirects/errors\n  async function handleAction(\n    request: Request,\n    location: Location,\n    submission: Submission,\n    matches: AgnosticDataRouteMatch[],\n    opts: { replace?: boolean; flushSync?: boolean } = {}\n  ): Promise<HandleActionResult> {\n    interruptActiveLoads();\n\n    // Put us in a submitting state\n    let navigation = getSubmittingNavigation(location, submission);\n    updateState({ navigation }, { flushSync: opts.flushSync === true });\n\n    // Call our action and get the result\n    let result: DataResult;\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      let results = await callDataStrategy(\n        \"action\",\n        request,\n        [actionMatch],\n        matches\n      );\n      result = results[0];\n\n      if (request.signal.aborted) {\n        return { shortCircuited: true };\n      }\n    }\n\n    if (isRedirectResult(result)) {\n      let replace: boolean;\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        let location = normalizeRedirectLocation(\n          result.response.headers.get(\"Location\")!,\n          new URL(request.url),\n          basename\n        );\n        replace = location === state.location.pathname + state.location.search;\n      }\n      await startRedirectNavigation(request, result, {\n        submission,\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    if (isDeferredResult(result)) {\n      throw getInternalRouterError(400, { type: \"defer-action\" });\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\n      // By default, all submissions are REPLACE navigations, but if the\n      // action threw an error that'll be rendered in an errorElement, we fall\n      // back to PUSH so that the user can use the back button to get back to\n      // the pre-submission form location to try again\n      if ((opts && opts.replace) !== true) {\n        pendingAction = HistoryAction.Push;\n      }\n\n      return {\n        pendingActionResult: [boundaryMatch.route.id, result],\n      };\n    }\n\n    return {\n      pendingActionResult: [actionMatch.route.id, result],\n    };\n  }\n\n  // Call all applicable loaders for the given matches, handling redirects,\n  // errors, etc.\n  async function handleLoaders(\n    request: Request,\n    location: Location,\n    matches: AgnosticDataRouteMatch[],\n    overrideNavigation?: Navigation,\n    submission?: Submission,\n    fetcherSubmission?: Submission,\n    replace?: boolean,\n    initialHydration?: boolean,\n    flushSync?: boolean,\n    pendingActionResult?: PendingActionResult\n  ): Promise<HandleLoadersResult> {\n    // Figure out the right navigation we want to use for data loading\n    let loadingNavigation =\n      overrideNavigation || getLoadingNavigation(location, submission);\n\n    // If this was a redirect from an action we don't have a \"submission\" but\n    // we have it on the loading navigation so use that if available\n    let activeSubmission =\n      submission ||\n      fetcherSubmission ||\n      getSubmissionFromNavigation(loadingNavigation);\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(\n      init.history,\n      state,\n      matches,\n      activeSubmission,\n      location,\n      future.v7_partialHydration && initialHydration === true,\n      future.unstable_skipActionErrorRevalidation,\n      isRevalidationRequired,\n      cancelledDeferredRoutes,\n      cancelledFetcherLoads,\n      deletedFetchers,\n      fetchLoadMatches,\n      fetchRedirectIds,\n      routesToUse,\n      basename,\n      pendingActionResult\n    );\n\n    // Cancel pending deferreds for no-longer-matched routes or routes we're\n    // about to reload.  Note that if this is an action reload we would have\n    // already cancelled all pending deferreds so this would be a no-op\n    cancelActiveDeferreds(\n      (routeId) =>\n        !(matches && matches.some((m) => m.route.id === routeId)) ||\n        (matchesToLoad && matchesToLoad.some((m) => m.route.id === routeId))\n    );\n\n    pendingNavigationLoadId = ++incrementingLoadId;\n\n    // Short circuit if we have no loaders to run\n    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n      let updatedFetchers = markFetchRedirectsDone();\n      completeNavigation(\n        location,\n        {\n          matches,\n          loaderData: {},\n          // Commit pending error if we're short circuiting\n          errors:\n            pendingActionResult && isErrorResult(pendingActionResult[1])\n              ? { [pendingActionResult[0]]: pendingActionResult[1].error }\n              : null,\n          ...getActionDataForCommit(pendingActionResult),\n          ...(updatedFetchers ? { fetchers: new Map(state.fetchers) } : {}),\n        },\n        { flushSync }\n      );\n      return { shortCircuited: true };\n    }\n\n    // If this is an uninterrupted revalidation, we remain in our current idle\n    // state.  If not, we need to switch to our loading state and load data,\n    // preserving any new action data or existing action data (in the case of\n    // a revalidation interrupting an actionReload)\n    // If we have partialHydration enabled, then don't update the state for the\n    // initial data load since it's not a \"navigation\"\n    if (\n      !isUninterruptedRevalidation &&\n      (!future.v7_partialHydration || !initialHydration)\n    ) {\n      revalidatingFetchers.forEach((rf) => {\n        let fetcher = state.fetchers.get(rf.key);\n        let revalidatingFetcher = getLoadingFetcher(\n          undefined,\n          fetcher ? fetcher.data : undefined\n        );\n        state.fetchers.set(rf.key, revalidatingFetcher);\n      });\n\n      let actionData: Record<string, RouteData> | null | undefined;\n      if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {\n        // This is cast to `any` currently because `RouteData`uses any and it\n        // would be a breaking change to use any.\n        // TODO: v7 - change `RouteData` to use `unknown` instead of `any`\n        actionData = {\n          [pendingActionResult[0]]: pendingActionResult[1].data as any,\n        };\n      } else if (state.actionData) {\n        if (Object.keys(state.actionData).length === 0) {\n          actionData = null;\n        } else {\n          actionData = state.actionData;\n        }\n      }\n\n      updateState(\n        {\n          navigation: loadingNavigation,\n          ...(actionData !== undefined ? { actionData } : {}),\n          ...(revalidatingFetchers.length > 0\n            ? { fetchers: new Map(state.fetchers) }\n            : {}),\n        },\n        {\n          flushSync,\n        }\n      );\n    }\n\n    revalidatingFetchers.forEach((rf) => {\n      if (fetchControllers.has(rf.key)) {\n        abortFetcher(rf.key);\n      }\n      if (rf.controller) {\n        // Fetchers use an independent AbortController so that aborting a fetcher\n        // (via deleteFetcher) does not abort the triggering navigation that\n        // triggered the revalidation\n        fetchControllers.set(rf.key, rf.controller);\n      }\n    });\n\n    // Proxy navigation abort through to revalidation fetchers\n    let abortPendingFetchRevalidations = () =>\n      revalidatingFetchers.forEach((f) => abortFetcher(f.key));\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.addEventListener(\n        \"abort\",\n        abortPendingFetchRevalidations\n      );\n    }\n\n    let { loaderResults, fetcherResults } =\n      await callLoadersAndMaybeResolveData(\n        state.matches,\n        matches,\n        matchesToLoad,\n        revalidatingFetchers,\n        request\n      );\n\n    if (request.signal.aborted) {\n      return { shortCircuited: true };\n    }\n\n    // Clean up _after_ loaders have completed.  Don't clean up if we short\n    // circuited because fetchControllers would have been aborted and\n    // reassigned to new controllers for the next navigation\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.removeEventListener(\n        \"abort\",\n        abortPendingFetchRevalidations\n      );\n    }\n    revalidatingFetchers.forEach((rf) => fetchControllers.delete(rf.key));\n\n    // If any loaders returned a redirect Response, start a new REPLACE navigation\n    let redirect = findRedirect([...loaderResults, ...fetcherResults]);\n    if (redirect) {\n      if (redirect.idx >= matchesToLoad.length) {\n        // If this redirect came from a fetcher make sure we mark it in\n        // fetchRedirectIds so it doesn't get revalidated on the next set of\n        // loader executions\n        let fetcherKey =\n          revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n        fetchRedirectIds.add(fetcherKey);\n      }\n      await startRedirectNavigation(request, redirect.result, {\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    // Process and commit output from loaders\n    let { loaderData, errors } = processLoaderData(\n      state,\n      matches,\n      matchesToLoad,\n      loaderResults,\n      pendingActionResult,\n      revalidatingFetchers,\n      fetcherResults,\n      activeDeferreds\n    );\n\n    // Wire up subscribers to update loaderData as promises settle\n    activeDeferreds.forEach((deferredData, routeId) => {\n      deferredData.subscribe((aborted) => {\n        // Note: No need to updateState here since the TrackedPromise on\n        // loaderData is stable across resolve/reject\n        // Remove this instance if we were aborted or if promises have settled\n        if (aborted || deferredData.done) {\n          activeDeferreds.delete(routeId);\n        }\n      });\n    });\n\n    // During partial hydration, preserve SSR errors for routes that don't re-run\n    if (future.v7_partialHydration && initialHydration && state.errors) {\n      Object.entries(state.errors)\n        .filter(([id]) => !matchesToLoad.some((m) => m.route.id === id))\n        .forEach(([routeId, error]) => {\n          errors = Object.assign(errors || {}, { [routeId]: error });\n        });\n    }\n\n    let updatedFetchers = markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    let shouldUpdateFetchers =\n      updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n\n    return {\n      loaderData,\n      errors,\n      ...(shouldUpdateFetchers ? { fetchers: new Map(state.fetchers) } : {}),\n    };\n  }\n\n  // Trigger a fetcher load/submit for the given fetcher key\n  function fetch(\n    key: string,\n    routeId: string,\n    href: string | null,\n    opts?: RouterFetchOptions\n  ) {\n    if (isServer) {\n      throw new Error(\n        \"router.fetch() was called during the server render, but it shouldn't be. \" +\n          \"You are likely calling a useFetcher() method in the body of your component. \" +\n          \"Try moving it to a useEffect or a callback.\"\n      );\n    }\n\n    if (fetchControllers.has(key)) abortFetcher(key);\n    let flushSync = (opts && opts.unstable_flushSync) === true;\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let normalizedPath = normalizeTo(\n      state.location,\n      state.matches,\n      basename,\n      future.v7_prependBasename,\n      href,\n      future.v7_relativeSplatPath,\n      routeId,\n      opts?.relative\n    );\n    let matches = matchRoutes(routesToUse, normalizedPath, basename);\n\n    if (!matches) {\n      setFetcherError(\n        key,\n        routeId,\n        getInternalRouterError(404, { pathname: normalizedPath }),\n        { flushSync }\n      );\n      return;\n    }\n\n    let { path, submission, error } = normalizeNavigateOptions(\n      future.v7_normalizeFormMethod,\n      true,\n      normalizedPath,\n      opts\n    );\n\n    if (error) {\n      setFetcherError(key, routeId, error, { flushSync });\n      return;\n    }\n\n    let match = getTargetMatch(matches, path);\n\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n\n    if (submission && isMutationMethod(submission.formMethod)) {\n      handleFetcherAction(\n        key,\n        routeId,\n        path,\n        match,\n        matches,\n        flushSync,\n        submission\n      );\n      return;\n    }\n\n    // Store off the match so we can call it's shouldRevalidate on subsequent\n    // revalidations\n    fetchLoadMatches.set(key, { routeId, path });\n    handleFetcherLoader(\n      key,\n      routeId,\n      path,\n      match,\n      matches,\n      flushSync,\n      submission\n    );\n  }\n\n  // Call the action for the matched fetcher.submit(), and then handle redirects,\n  // errors, and revalidation\n  async function handleFetcherAction(\n    key: string,\n    routeId: string,\n    path: string,\n    match: AgnosticDataRouteMatch,\n    requestMatches: AgnosticDataRouteMatch[],\n    flushSync: boolean,\n    submission: Submission\n  ) {\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, { flushSync });\n      return;\n    }\n\n    // Put this fetcher into it's submitting state\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {\n      flushSync,\n    });\n\n    // Call the action for the fetcher\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(\n      init.history,\n      path,\n      abortController.signal,\n      submission\n    );\n    fetchControllers.set(key, abortController);\n\n    let originatingLoadId = incrementingLoadId;\n    let actionResults = await callDataStrategy(\n      \"action\",\n      fetchRequest,\n      [match],\n      requestMatches\n    );\n    let actionResult = actionResults[0];\n\n    if (fetchRequest.signal.aborted) {\n      // We can delete this so long as we weren't aborted by our own fetcher\n      // re-submit which would have put _new_ controller is in fetchControllers\n      if (fetchControllers.get(key) === abortController) {\n        fetchControllers.delete(key);\n      }\n      return;\n    }\n\n    // When using v7_fetcherPersist, we don't want errors bubbling up to the UI\n    // or redirects processed for unmounted fetchers so we just revert them to\n    // idle\n    if (future.v7_fetcherPersist && deletedFetchers.has(key)) {\n      if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      }\n      // Let SuccessResult's fall through for revalidation\n    } else {\n      if (isRedirectResult(actionResult)) {\n        fetchControllers.delete(key);\n        if (pendingNavigationLoadId > originatingLoadId) {\n          // A new navigation was kicked off after our action started, so that\n          // should take precedence over this redirect navigation.  We already\n          // set isRevalidationRequired so all loaders for the new route should\n          // fire unless opted out via shouldRevalidate\n          updateFetcherState(key, getDoneFetcher(undefined));\n          return;\n        } else {\n          fetchRedirectIds.add(key);\n          updateFetcherState(key, getLoadingFetcher(submission));\n          return startRedirectNavigation(fetchRequest, actionResult, {\n            fetcherSubmission: submission,\n          });\n        }\n      }\n\n      // Process any non-redirect errors thrown\n      if (isErrorResult(actionResult)) {\n        setFetcherError(key, routeId, actionResult.error);\n        return;\n      }\n    }\n\n    if (isDeferredResult(actionResult)) {\n      throw getInternalRouterError(400, { type: \"defer-action\" });\n    }\n\n    // Start the data load for current matches, or the next location if we're\n    // in the middle of a navigation\n    let nextLocation = state.navigation.location || state.location;\n    let revalidationRequest = createClientSideRequest(\n      init.history,\n      nextLocation,\n      abortController.signal\n    );\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let matches =\n      state.navigation.state !== \"idle\"\n        ? matchRoutes(routesToUse, state.navigation.location, basename)\n        : state.matches;\n\n    invariant(matches, \"Didn't find any matches after fetcher action\");\n\n    let loadId = ++incrementingLoadId;\n    fetchReloadIds.set(key, loadId);\n\n    let loadFetcher = getLoadingFetcher(submission, actionResult.data);\n    state.fetchers.set(key, loadFetcher);\n\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(\n      init.history,\n      state,\n      matches,\n      submission,\n      nextLocation,\n      false,\n      future.unstable_skipActionErrorRevalidation,\n      isRevalidationRequired,\n      cancelledDeferredRoutes,\n      cancelledFetcherLoads,\n      deletedFetchers,\n      fetchLoadMatches,\n      fetchRedirectIds,\n      routesToUse,\n      basename,\n      [match.route.id, actionResult]\n    );\n\n    // Put all revalidating fetchers into the loading state, except for the\n    // current fetcher which we want to keep in it's current loading state which\n    // contains it's action submission info + action data\n    revalidatingFetchers\n      .filter((rf) => rf.key !== key)\n      .forEach((rf) => {\n        let staleKey = rf.key;\n        let existingFetcher = state.fetchers.get(staleKey);\n        let revalidatingFetcher = getLoadingFetcher(\n          undefined,\n          existingFetcher ? existingFetcher.data : undefined\n        );\n        state.fetchers.set(staleKey, revalidatingFetcher);\n        if (fetchControllers.has(staleKey)) {\n          abortFetcher(staleKey);\n        }\n        if (rf.controller) {\n          fetchControllers.set(staleKey, rf.controller);\n        }\n      });\n\n    updateState({ fetchers: new Map(state.fetchers) });\n\n    let abortPendingFetchRevalidations = () =>\n      revalidatingFetchers.forEach((rf) => abortFetcher(rf.key));\n\n    abortController.signal.addEventListener(\n      \"abort\",\n      abortPendingFetchRevalidations\n    );\n\n    let { loaderResults, fetcherResults } =\n      await callLoadersAndMaybeResolveData(\n        state.matches,\n        matches,\n        matchesToLoad,\n        revalidatingFetchers,\n        revalidationRequest\n      );\n\n    if (abortController.signal.aborted) {\n      return;\n    }\n\n    abortController.signal.removeEventListener(\n      \"abort\",\n      abortPendingFetchRevalidations\n    );\n\n    fetchReloadIds.delete(key);\n    fetchControllers.delete(key);\n    revalidatingFetchers.forEach((r) => fetchControllers.delete(r.key));\n\n    let redirect = findRedirect([...loaderResults, ...fetcherResults]);\n    if (redirect) {\n      if (redirect.idx >= matchesToLoad.length) {\n        // If this redirect came from a fetcher make sure we mark it in\n        // fetchRedirectIds so it doesn't get revalidated on the next set of\n        // loader executions\n        let fetcherKey =\n          revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n        fetchRedirectIds.add(fetcherKey);\n      }\n      return startRedirectNavigation(revalidationRequest, redirect.result);\n    }\n\n    // Process and commit output from loaders\n    let { loaderData, errors } = processLoaderData(\n      state,\n      state.matches,\n      matchesToLoad,\n      loaderResults,\n      undefined,\n      revalidatingFetchers,\n      fetcherResults,\n      activeDeferreds\n    );\n\n    // Since we let revalidations complete even if the submitting fetcher was\n    // deleted, only put it back to idle if it hasn't been deleted\n    if (state.fetchers.has(key)) {\n      let doneFetcher = getDoneFetcher(actionResult.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n\n    abortStaleFetchLoads(loadId);\n\n    // If we are currently in a navigation loading state and this fetcher is\n    // more recent than the navigation, we want the newer data so abort the\n    // navigation and complete it with the fetcher data\n    if (\n      state.navigation.state === \"loading\" &&\n      loadId > pendingNavigationLoadId\n    ) {\n      invariant(pendingAction, \"Expected pending action\");\n      pendingNavigationController && pendingNavigationController.abort();\n\n      completeNavigation(state.navigation.location, {\n        matches,\n        loaderData,\n        errors,\n        fetchers: new Map(state.fetchers),\n      });\n    } else {\n      // otherwise just update with the fetcher data, preserving any existing\n      // loaderData for loaders that did not need to reload.  We have to\n      // manually merge here since we aren't going through completeNavigation\n      updateState({\n        errors,\n        loaderData: mergeLoaderData(\n          state.loaderData,\n          loaderData,\n          matches,\n          errors\n        ),\n        fetchers: new Map(state.fetchers),\n      });\n      isRevalidationRequired = false;\n    }\n  }\n\n  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n  async function handleFetcherLoader(\n    key: string,\n    routeId: string,\n    path: string,\n    match: AgnosticDataRouteMatch,\n    matches: AgnosticDataRouteMatch[],\n    flushSync: boolean,\n    submission?: Submission\n  ) {\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(\n      key,\n      getLoadingFetcher(\n        submission,\n        existingFetcher ? existingFetcher.data : undefined\n      ),\n      { flushSync }\n    );\n\n    // Call the loader for this fetcher route match\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(\n      init.history,\n      path,\n      abortController.signal\n    );\n    fetchControllers.set(key, abortController);\n\n    let originatingLoadId = incrementingLoadId;\n    let results = await callDataStrategy(\n      \"loader\",\n      fetchRequest,\n      [match],\n      matches\n    );\n    let result = results[0];\n\n    // Deferred isn't supported for fetcher loads, await everything and treat it\n    // as a normal load.  resolveDeferredData will return undefined if this\n    // fetcher gets aborted, so we just leave result untouched and short circuit\n    // below if that happens\n    if (isDeferredResult(result)) {\n      result =\n        (await resolveDeferredData(result, fetchRequest.signal, true)) ||\n        result;\n    }\n\n    // We can delete this so long as we weren't aborted by our our own fetcher\n    // re-load which would have put _new_ controller is in fetchControllers\n    if (fetchControllers.get(key) === abortController) {\n      fetchControllers.delete(key);\n    }\n\n    if (fetchRequest.signal.aborted) {\n      return;\n    }\n\n    // We don't want errors bubbling up or redirects followed for unmounted\n    // fetchers, so short circuit here if it was removed from the UI\n    if (deletedFetchers.has(key)) {\n      updateFetcherState(key, getDoneFetcher(undefined));\n      return;\n    }\n\n    // If the loader threw a redirect Response, start a new REPLACE navigation\n    if (isRedirectResult(result)) {\n      if (pendingNavigationLoadId > originatingLoadId) {\n        // A new navigation was kicked off after our loader started, so that\n        // should take precedence over this redirect navigation\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      } else {\n        fetchRedirectIds.add(key);\n        await startRedirectNavigation(fetchRequest, result);\n        return;\n      }\n    }\n\n    // Process any non-redirect errors thrown\n    if (isErrorResult(result)) {\n      setFetcherError(key, routeId, result.error);\n      return;\n    }\n\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n\n    // Put the fetcher back into an idle state\n    updateFetcherState(key, getDoneFetcher(result.data));\n  }\n\n  /**\n   * Utility function to handle redirects returned from an action or loader.\n   * Normally, a redirect \"replaces\" the navigation that triggered it.  So, for\n   * example:\n   *\n   *  - user is on /a\n   *  - user clicks a link to /b\n   *  - loader for /b redirects to /c\n   *\n   * In a non-JS app the browser would track the in-flight navigation to /b and\n   * then replace it with /c when it encountered the redirect response.  In\n   * the end it would only ever update the URL bar with /c.\n   *\n   * In client-side routing using pushState/replaceState, we aim to emulate\n   * this behavior and we also do not update history until the end of the\n   * navigation (including processed redirects).  This means that we never\n   * actually touch history until we've processed redirects, so we just use\n   * the history action from the original navigation (PUSH or REPLACE).\n   */\n  async function startRedirectNavigation(\n    request: Request,\n    redirect: RedirectResult,\n    {\n      submission,\n      fetcherSubmission,\n      replace,\n    }: {\n      submission?: Submission;\n      fetcherSubmission?: Submission;\n      replace?: boolean;\n    } = {}\n  ) {\n    if (redirect.response.headers.has(\"X-Remix-Revalidate\")) {\n      isRevalidationRequired = true;\n    }\n\n    let location = redirect.response.headers.get(\"Location\");\n    invariant(location, \"Expected a Location header on the redirect Response\");\n    location = normalizeRedirectLocation(\n      location,\n      new URL(request.url),\n      basename\n    );\n    let redirectLocation = createLocation(state.location, location, {\n      _isRedirect: true,\n    });\n\n    if (isBrowser) {\n      let isDocumentReload = false;\n\n      if (redirect.response.headers.has(\"X-Remix-Reload-Document\")) {\n        // Hard reload if the response contained X-Remix-Reload-Document\n        isDocumentReload = true;\n      } else if (ABSOLUTE_URL_REGEX.test(location)) {\n        const url = init.history.createURL(location);\n        isDocumentReload =\n          // Hard reload if it's an absolute URL to a new origin\n          url.origin !== routerWindow.location.origin ||\n          // Hard reload if it's an absolute URL that does not match our basename\n          stripBasename(url.pathname, basename) == null;\n      }\n\n      if (isDocumentReload) {\n        if (replace) {\n          routerWindow.location.replace(location);\n        } else {\n          routerWindow.location.assign(location);\n        }\n        return;\n      }\n    }\n\n    // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n    pendingNavigationController = null;\n\n    let redirectHistoryAction =\n      replace === true ? HistoryAction.Replace : HistoryAction.Push;\n\n    // Use the incoming submission if provided, fallback on the active one in\n    // state.navigation\n    let { formMethod, formAction, formEncType } = state.navigation;\n    if (\n      !submission &&\n      !fetcherSubmission &&\n      formMethod &&\n      formAction &&\n      formEncType\n    ) {\n      submission = getSubmissionFromNavigation(state.navigation);\n    }\n\n    // If this was a 307/308 submission we want to preserve the HTTP method and\n    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the\n    // redirected location\n    let activeSubmission = submission || fetcherSubmission;\n    if (\n      redirectPreserveMethodStatusCodes.has(redirect.response.status) &&\n      activeSubmission &&\n      isMutationMethod(activeSubmission.formMethod)\n    ) {\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        submission: {\n          ...activeSubmission,\n          formAction: location,\n        },\n        // Preserve this flag across redirects\n        preventScrollReset: pendingPreventScrollReset,\n      });\n    } else {\n      // If we have a navigation submission, we will preserve it through the\n      // redirect navigation\n      let overrideNavigation = getLoadingNavigation(\n        redirectLocation,\n        submission\n      );\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        overrideNavigation,\n        // Send fetcher submissions through for shouldRevalidate\n        fetcherSubmission,\n        // Preserve this flag across redirects\n        preventScrollReset: pendingPreventScrollReset,\n      });\n    }\n  }\n\n  // Utility wrapper for calling dataStrategy client-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(\n    type: \"loader\" | \"action\",\n    request: Request,\n    matchesToLoad: AgnosticDataRouteMatch[],\n    matches: AgnosticDataRouteMatch[]\n  ): Promise<DataResult[]> {\n    try {\n      let results = await callDataStrategyImpl(\n        dataStrategyImpl,\n        type,\n        request,\n        matchesToLoad,\n        matches,\n        manifest,\n        mapRouteProperties\n      );\n\n      return await Promise.all(\n        results.map((result, i) => {\n          if (isRedirectHandlerResult(result)) {\n            let response = result.result as Response;\n            return {\n              type: ResultType.redirect,\n              response: normalizeRelativeRoutingRedirectResponse(\n                response,\n                request,\n                matchesToLoad[i].route.id,\n                matches,\n                basename,\n                future.v7_relativeSplatPath\n              ),\n            };\n          }\n\n          return convertHandlerResultToDataResult(result);\n        })\n      );\n    } catch (e) {\n      // If the outer dataStrategy method throws, just return the error for all\n      // matches - and it'll naturally bubble to the root\n      return matchesToLoad.map(() => ({\n        type: ResultType.error,\n        error: e,\n      }));\n    }\n  }\n\n  async function callLoadersAndMaybeResolveData(\n    currentMatches: AgnosticDataRouteMatch[],\n    matches: AgnosticDataRouteMatch[],\n    matchesToLoad: AgnosticDataRouteMatch[],\n    fetchersToLoad: RevalidatingFetcher[],\n    request: Request\n  ) {\n    let [loaderResults, ...fetcherResults] = await Promise.all([\n      matchesToLoad.length\n        ? callDataStrategy(\"loader\", request, matchesToLoad, matches)\n        : [],\n      ...fetchersToLoad.map((f) => {\n        if (f.matches && f.match && f.controller) {\n          let fetcherRequest = createClientSideRequest(\n            init.history,\n            f.path,\n            f.controller.signal\n          );\n          return callDataStrategy(\n            \"loader\",\n            fetcherRequest,\n            [f.match],\n            f.matches\n          ).then((r) => r[0]);\n        } else {\n          return Promise.resolve<DataResult>({\n            type: ResultType.error,\n            error: getInternalRouterError(404, {\n              pathname: f.path,\n            }),\n          });\n        }\n      }),\n    ]);\n\n    await Promise.all([\n      resolveDeferredResults(\n        currentMatches,\n        matchesToLoad,\n        loaderResults,\n        loaderResults.map(() => request.signal),\n        false,\n        state.loaderData\n      ),\n      resolveDeferredResults(\n        currentMatches,\n        fetchersToLoad.map((f) => f.match),\n        fetcherResults,\n        fetchersToLoad.map((f) => (f.controller ? f.controller.signal : null)),\n        true\n      ),\n    ]);\n\n    return {\n      loaderResults,\n      fetcherResults,\n    };\n  }\n\n  function interruptActiveLoads() {\n    // Every interruption triggers a revalidation\n    isRevalidationRequired = true;\n\n    // Cancel pending route-level deferreds and mark cancelled routes for\n    // revalidation\n    cancelledDeferredRoutes.push(...cancelActiveDeferreds());\n\n    // Abort in-flight fetcher loads\n    fetchLoadMatches.forEach((_, key) => {\n      if (fetchControllers.has(key)) {\n        cancelledFetcherLoads.push(key);\n        abortFetcher(key);\n      }\n    });\n  }\n\n  function updateFetcherState(\n    key: string,\n    fetcher: Fetcher,\n    opts: { flushSync?: boolean } = {}\n  ) {\n    state.fetchers.set(key, fetcher);\n    updateState(\n      { fetchers: new Map(state.fetchers) },\n      { flushSync: (opts && opts.flushSync) === true }\n    );\n  }\n\n  function setFetcherError(\n    key: string,\n    routeId: string,\n    error: any,\n    opts: { flushSync?: boolean } = {}\n  ) {\n    let boundaryMatch = findNearestBoundary(state.matches, routeId);\n    deleteFetcher(key);\n    updateState(\n      {\n        errors: {\n          [boundaryMatch.route.id]: error,\n        },\n        fetchers: new Map(state.fetchers),\n      },\n      { flushSync: (opts && opts.flushSync) === true }\n    );\n  }\n\n  function getFetcher<TData = any>(key: string): Fetcher<TData> {\n    if (future.v7_fetcherPersist) {\n      activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);\n      // If this fetcher was previously marked for deletion, unmark it since we\n      // have a new instance\n      if (deletedFetchers.has(key)) {\n        deletedFetchers.delete(key);\n      }\n    }\n    return state.fetchers.get(key) || IDLE_FETCHER;\n  }\n\n  function deleteFetcher(key: string): void {\n    let fetcher = state.fetchers.get(key);\n    // Don't abort the controller if this is a deletion of a fetcher.submit()\n    // in it's loading phase since - we don't want to abort the corresponding\n    // revalidation and want them to complete and land\n    if (\n      fetchControllers.has(key) &&\n      !(fetcher && fetcher.state === \"loading\" && fetchReloadIds.has(key))\n    ) {\n      abortFetcher(key);\n    }\n    fetchLoadMatches.delete(key);\n    fetchReloadIds.delete(key);\n    fetchRedirectIds.delete(key);\n    deletedFetchers.delete(key);\n    state.fetchers.delete(key);\n  }\n\n  function deleteFetcherAndUpdateState(key: string): void {\n    if (future.v7_fetcherPersist) {\n      let count = (activeFetchers.get(key) || 0) - 1;\n      if (count <= 0) {\n        activeFetchers.delete(key);\n        deletedFetchers.add(key);\n      } else {\n        activeFetchers.set(key, count);\n      }\n    } else {\n      deleteFetcher(key);\n    }\n    updateState({ fetchers: new Map(state.fetchers) });\n  }\n\n  function abortFetcher(key: string) {\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: string[]) {\n    for (let key of keys) {\n      let fetcher = getFetcher(key);\n      let doneFetcher = getDoneFetcher(fetcher.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n\n  function markFetchRedirectsDone(): boolean {\n    let doneKeys = [];\n    let updatedFetchers = false;\n    for (let key of fetchRedirectIds) {\n      let fetcher = state.fetchers.get(key);\n      invariant(fetcher, `Expected fetcher: ${key}`);\n      if (fetcher.state === \"loading\") {\n        fetchRedirectIds.delete(key);\n        doneKeys.push(key);\n        updatedFetchers = true;\n      }\n    }\n    markFetchersDone(doneKeys);\n    return updatedFetchers;\n  }\n\n  function abortStaleFetchLoads(landedId: number): boolean {\n    let yeetedKeys = [];\n    for (let [key, id] of fetchReloadIds) {\n      if (id < landedId) {\n        let fetcher = state.fetchers.get(key);\n        invariant(fetcher, `Expected fetcher: ${key}`);\n        if (fetcher.state === \"loading\") {\n          abortFetcher(key);\n          fetchReloadIds.delete(key);\n          yeetedKeys.push(key);\n        }\n      }\n    }\n    markFetchersDone(yeetedKeys);\n    return yeetedKeys.length > 0;\n  }\n\n  function getBlocker(key: string, fn: BlockerFunction) {\n    let blocker: 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: string) {\n    state.blockers.delete(key);\n    blockerFunctions.delete(key);\n  }\n\n  // Utility function to update blockers, ensuring valid state transitions\n  function updateBlocker(key: string, newBlocker: Blocker) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n\n    // Poor mans state machine :)\n    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n    invariant(\n      (blocker.state === \"unblocked\" && newBlocker.state === \"blocked\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"blocked\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"proceeding\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"unblocked\") ||\n        (blocker.state === \"proceeding\" && newBlocker.state === \"unblocked\"),\n      `Invalid blocker state transition: ${blocker.state} -> ${newBlocker.state}`\n    );\n\n    let blockers = new Map(state.blockers);\n    blockers.set(key, newBlocker);\n    updateState({ blockers });\n  }\n\n  function shouldBlockNavigation({\n    currentLocation,\n    nextLocation,\n    historyAction,\n  }: {\n    currentLocation: Location;\n    nextLocation: Location;\n    historyAction: HistoryAction;\n  }): string | undefined {\n    if (blockerFunctions.size === 0) {\n      return;\n    }\n\n    // We ony support a single active blocker at the moment since we don't have\n    // any compelling use cases for multi-blocker yet\n    if (blockerFunctions.size > 1) {\n      warning(false, \"A router only supports one blocker at a time\");\n    }\n\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    }\n\n    // At this point, we know we're unblocked/blocked so we need to check the\n    // user-provided blocker function\n    if (blockerFunction({ currentLocation, nextLocation, historyAction })) {\n      return blockerKey;\n    }\n  }\n\n  function cancelActiveDeferreds(\n    predicate?: (routeId: string) => boolean\n  ): string[] {\n    let cancelledRouteIds: string[] = [];\n    activeDeferreds.forEach((dfd, routeId) => {\n      if (!predicate || predicate(routeId)) {\n        // Cancel the deferred - but do not remove from activeDeferreds here -\n        // we rely on the subscribers to do that so our tests can assert proper\n        // cleanup via _internalActiveDeferreds\n        dfd.cancel();\n        cancelledRouteIds.push(routeId);\n        activeDeferreds.delete(routeId);\n      }\n    });\n    return cancelledRouteIds;\n  }\n\n  // Opt in to capturing and reporting scroll positions during navigations,\n  // used by the <ScrollRestoration> component\n  function enableScrollRestoration(\n    positions: Record<string, number>,\n    getPosition: GetScrollPositionFunction,\n    getKey?: GetScrollRestorationKeyFunction\n  ) {\n    savedScrollPositions = positions;\n    getScrollPosition = getPosition;\n    getScrollRestorationKey = getKey || null;\n\n    // Perform initial hydration scroll restoration, since we miss the boat on\n    // the initial updateState() because we've not yet rendered <ScrollRestoration/>\n    // and therefore have no savedScrollPositions available\n    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n      initialScrollRestored = true;\n      let y = getSavedScrollPosition(state.location, state.matches);\n      if (y != null) {\n        updateState({ restoreScrollPosition: y });\n      }\n    }\n\n    return () => {\n      savedScrollPositions = null;\n      getScrollPosition = null;\n      getScrollRestorationKey = null;\n    };\n  }\n\n  function getScrollKey(location: Location, matches: AgnosticDataRouteMatch[]) {\n    if (getScrollRestorationKey) {\n      let key = getScrollRestorationKey(\n        location,\n        matches.map((m) => convertRouteMatchToUiMatch(m, state.loaderData))\n      );\n      return key || location.key;\n    }\n    return location.key;\n  }\n\n  function saveScrollPosition(\n    location: Location,\n    matches: AgnosticDataRouteMatch[]\n  ): void {\n    if (savedScrollPositions && getScrollPosition) {\n      let key = getScrollKey(location, matches);\n      savedScrollPositions[key] = getScrollPosition();\n    }\n  }\n\n  function getSavedScrollPosition(\n    location: Location,\n    matches: AgnosticDataRouteMatch[]\n  ): number | null {\n    if (savedScrollPositions) {\n      let key = getScrollKey(location, matches);\n      let y = savedScrollPositions[key];\n      if (typeof y === \"number\") {\n        return y;\n      }\n    }\n    return null;\n  }\n\n  function _internalSetRoutes(newRoutes: AgnosticDataRouteObject[]) {\n    manifest = {};\n    inFlightDataRoutes = convertRoutesToDataRoutes(\n      newRoutes,\n      mapRouteProperties,\n      undefined,\n      manifest\n    );\n  }\n\n  router = {\n    get basename() {\n      return basename;\n    },\n    get future() {\n      return future;\n    },\n    get state() {\n      return state;\n    },\n    get routes() {\n      return dataRoutes;\n    },\n    get window() {\n      return routerWindow;\n    },\n    initialize,\n    subscribe,\n    enableScrollRestoration,\n    navigate,\n    fetch,\n    revalidate,\n    // Passthrough to history-aware createHref used by useHref so we get proper\n    // hash-aware URLs in DOM paths\n    createHref: (to: To) => init.history.createHref(to),\n    encodeLocation: (to: To) => init.history.encodeLocation(to),\n    getFetcher,\n    deleteFetcher: deleteFetcherAndUpdateState,\n    dispose,\n    getBlocker,\n    deleteBlocker,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds,\n    // TODO: Remove setRoutes, it's temporary to avoid dealing with\n    // updating the tree while validating the update algorithm.\n    _internalSetRoutes,\n  };\n\n  return router;\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\n\nexport const UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\n\n/**\n * Future flags to toggle new feature behavior\n */\nexport interface StaticHandlerFutureConfig {\n  v7_relativeSplatPath: boolean;\n  v7_throwAbortReason: boolean;\n}\n\nexport interface CreateStaticHandlerOptions {\n  basename?: string;\n  /**\n   * @deprecated Use `mapRouteProperties` instead\n   */\n  detectErrorBoundary?: DetectErrorBoundaryFunction;\n  mapRouteProperties?: MapRoutePropertiesFunction;\n  future?: Partial<StaticHandlerFutureConfig>;\n}\n\nexport function createStaticHandler(\n  routes: AgnosticRouteObject[],\n  opts?: CreateStaticHandlerOptions\n): StaticHandler {\n  invariant(\n    routes.length > 0,\n    \"You must provide a non-empty routes array to createStaticHandler\"\n  );\n\n  let manifest: RouteManifest = {};\n  let basename = (opts ? opts.basename : null) || \"/\";\n  let mapRouteProperties: MapRoutePropertiesFunction;\n  if (opts?.mapRouteProperties) {\n    mapRouteProperties = opts.mapRouteProperties;\n  } else if (opts?.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = opts.detectErrorBoundary;\n    mapRouteProperties = (route) => ({\n      hasErrorBoundary: detectErrorBoundary(route),\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Config driven behavior flags\n  let future: StaticHandlerFutureConfig = {\n    v7_relativeSplatPath: false,\n    v7_throwAbortReason: false,\n    ...(opts ? opts.future : null),\n  };\n\n  let dataRoutes = convertRoutesToDataRoutes(\n    routes,\n    mapRouteProperties,\n    undefined,\n    manifest\n  );\n\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   * - `opts.requestContext` is an optional server context that will be passed\n   *   to actions/loaders in the `context` parameter\n   * - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent\n   *   the bubbling of errors which allows single-fetch-type implementations\n   *   where the client will handle the bubbling and we may need to return data\n   *   for the handling route\n   */\n  async function query(\n    request: Request,\n    {\n      requestContext,\n      skipLoaderErrorBubbling,\n      unstable_dataStrategy,\n    }: {\n      requestContext?: unknown;\n      skipLoaderErrorBubbling?: boolean;\n      unstable_dataStrategy?: DataStrategyFunction;\n    } = {}\n  ): Promise<StaticHandlerContext | Response> {\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\") {\n      let error = getInternalRouterError(405, { method });\n      let { matches: methodNotAllowedMatches, 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, { pathname: location.pathname });\n      let { matches: notFoundMatches, 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(\n      request,\n      location,\n      matches,\n      requestContext,\n      unstable_dataStrategy || null,\n      skipLoaderErrorBubbling === true,\n      null\n    );\n    if (isResponse(result)) {\n      return result;\n    }\n\n    // When returning StaticHandlerContext, we patch back in the location here\n    // since we need it for React Context.  But this helps keep our submit and\n    // loadRouteData operating on a Request instead of a Location\n    return { location, basename, ...result };\n  }\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   * - `opts.routeId` allows you to specify the specific route handler to call.\n   *   If not provided the handler will determine the proper route by matching\n   *   against `request.url`\n   * - `opts.requestContext` is an optional server context that will be passed\n   *    to actions/loaders in the `context` parameter\n   */\n  async function queryRoute(\n    request: Request,\n    {\n      routeId,\n      requestContext,\n    }: { requestContext?: unknown; routeId?: string } = {}\n  ): Promise<any> {\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\" && method !== \"OPTIONS\") {\n      throw getInternalRouterError(405, { method });\n    } else if (!matches) {\n      throw getInternalRouterError(404, { pathname: location.pathname });\n    }\n\n    let match = routeId\n      ? matches.find((m) => m.route.id === routeId)\n      : 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, { pathname: location.pathname });\n    }\n\n    let result = await queryImpl(\n      request,\n      location,\n      matches,\n      requestContext,\n      null,\n      false,\n      match\n    );\n\n    if (isResponse(result)) {\n      return result;\n    }\n\n    let error = result.errors ? Object.values(result.errors)[0] : undefined;\n    if (error !== undefined) {\n      // If we got back result.errors, that means the loader/action threw\n      // _something_ that wasn't a Response, but it's not guaranteed/required\n      // to be an `instanceof Error` either, so we have to use throw here to\n      // preserve the \"error\" state outside of queryImpl.\n      throw error;\n    }\n\n    // Pick off the right state value to return\n    if (result.actionData) {\n      return Object.values(result.actionData)[0];\n    }\n\n    if (result.loaderData) {\n      let data = Object.values(result.loaderData)[0];\n      if (result.activeDeferreds?.[match.route.id]) {\n        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];\n      }\n      return data;\n    }\n\n    return undefined;\n  }\n\n  async function queryImpl(\n    request: Request,\n    location: Location,\n    matches: AgnosticDataRouteMatch[],\n    requestContext: unknown,\n    unstable_dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    routeMatch: AgnosticDataRouteMatch | null\n  ): Promise<Omit<StaticHandlerContext, \"location\" | \"basename\"> | Response> {\n    invariant(\n      request.signal,\n      \"query()/queryRoute() requests must contain an AbortController signal\"\n    );\n\n    try {\n      if (isMutationMethod(request.method.toLowerCase())) {\n        let result = await submit(\n          request,\n          matches,\n          routeMatch || getTargetMatch(matches, location),\n          requestContext,\n          unstable_dataStrategy,\n          skipLoaderErrorBubbling,\n          routeMatch != null\n        );\n        return result;\n      }\n\n      let result = await loadRouteData(\n        request,\n        matches,\n        requestContext,\n        unstable_dataStrategy,\n        skipLoaderErrorBubbling,\n        routeMatch\n      );\n      return isResponse(result)\n        ? result\n        : {\n            ...result,\n            actionData: null,\n            actionHeaders: {},\n          };\n    } catch (e) {\n      // If the user threw/returned a Response in callLoaderOrAction for a\n      // `queryRoute` call, we throw the `HandlerResult` to bail out early\n      // and then return or throw the raw Response here accordingly\n      if (isHandlerResult(e) && isResponse(e.result)) {\n        if (e.type === ResultType.error) {\n          throw e.result;\n        }\n        return e.result;\n      }\n      // Redirects are always returned since they don't propagate to catch\n      // boundaries\n      if (isRedirectResponse(e)) {\n        return e;\n      }\n      throw e;\n    }\n  }\n\n  async function submit(\n    request: Request,\n    matches: AgnosticDataRouteMatch[],\n    actionMatch: AgnosticDataRouteMatch,\n    requestContext: unknown,\n    unstable_dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    isRouteRequest: boolean\n  ): Promise<Omit<StaticHandlerContext, \"location\" | \"basename\"> | Response> {\n    let result: DataResult;\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      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error,\n      };\n    } else {\n      let results = await callDataStrategy(\n        \"action\",\n        request,\n        [actionMatch],\n        matches,\n        isRouteRequest,\n        requestContext,\n        unstable_dataStrategy\n      );\n      result = results[0];\n\n      if (request.signal.aborted) {\n        throwStaticHandlerAbortedError(request, isRouteRequest, future);\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.response.status,\n        headers: {\n          Location: result.response.headers.get(\"Location\")!,\n        },\n      });\n    }\n\n    if (isDeferredResult(result)) {\n      let error = getInternalRouterError(400, { type: \"defer-action\" });\n      if (isRouteRequest) {\n        throw error;\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: { [actionMatch.route.id]: result.data },\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    // Create a GET request for the loaders\n    let loaderRequest = new Request(request.url, {\n      headers: request.headers,\n      redirect: request.redirect,\n      signal: request.signal,\n    });\n\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 = skipLoaderErrorBubbling\n        ? actionMatch\n        : findNearestBoundary(matches, actionMatch.route.id);\n\n      let context = await loadRouteData(\n        loaderRequest,\n        matches,\n        requestContext,\n        unstable_dataStrategy,\n        skipLoaderErrorBubbling,\n        null,\n        [boundaryMatch.route.id, result]\n      );\n\n      // action status codes take precedence over loader status codes\n      return {\n        ...context,\n        statusCode: isRouteErrorResponse(result.error)\n          ? result.error.status\n          : result.statusCode != null\n          ? result.statusCode\n          : 500,\n        actionData: null,\n        actionHeaders: {\n          ...(result.headers ? { [actionMatch.route.id]: result.headers } : {}),\n        },\n      };\n    }\n\n    let context = await loadRouteData(\n      loaderRequest,\n      matches,\n      requestContext,\n      unstable_dataStrategy,\n      skipLoaderErrorBubbling,\n      null\n    );\n\n    return {\n      ...context,\n      actionData: {\n        [actionMatch.route.id]: result.data,\n      },\n      // action status codes take precedence over loader status codes\n      ...(result.statusCode ? { statusCode: result.statusCode } : {}),\n      actionHeaders: result.headers\n        ? { [actionMatch.route.id]: result.headers }\n        : {},\n    };\n  }\n\n  async function loadRouteData(\n    request: Request,\n    matches: AgnosticDataRouteMatch[],\n    requestContext: unknown,\n    unstable_dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    routeMatch: AgnosticDataRouteMatch | null,\n    pendingActionResult?: PendingActionResult\n  ): Promise<\n    | Omit<\n        StaticHandlerContext,\n        \"location\" | \"basename\" | \"actionData\" | \"actionHeaders\"\n      >\n    | Response\n  > {\n    let isRouteRequest = routeMatch != null;\n\n    // Short circuit if we have no loaders to run (queryRoute())\n    if (\n      isRouteRequest &&\n      !routeMatch?.route.loader &&\n      !routeMatch?.route.lazy\n    ) {\n      throw getInternalRouterError(400, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: routeMatch?.route.id,\n      });\n    }\n\n    let requestMatches = routeMatch\n      ? [routeMatch]\n      : pendingActionResult && isErrorResult(pendingActionResult[1])\n      ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0])\n      : matches;\n    let matchesToLoad = requestMatches.filter(\n      (m) => m.route.loader || m.route.lazy\n    );\n\n    // Short circuit if we have no loaders to run (query())\n    if (matchesToLoad.length === 0) {\n      return {\n        matches,\n        // Add a null for all matched routes for proper revalidation on the client\n        loaderData: matches.reduce(\n          (acc, m) => Object.assign(acc, { [m.route.id]: null }),\n          {}\n        ),\n        errors:\n          pendingActionResult && isErrorResult(pendingActionResult[1])\n            ? {\n                [pendingActionResult[0]]: pendingActionResult[1].error,\n              }\n            : null,\n        statusCode: 200,\n        loaderHeaders: {},\n        activeDeferreds: null,\n      };\n    }\n\n    let results = await callDataStrategy(\n      \"loader\",\n      request,\n      matchesToLoad,\n      matches,\n      isRouteRequest,\n      requestContext,\n      unstable_dataStrategy\n    );\n\n    if (request.signal.aborted) {\n      throwStaticHandlerAbortedError(request, isRouteRequest, future);\n    }\n\n    // Process and commit output from loaders\n    let activeDeferreds = new Map<string, DeferredData>();\n    let context = processRouteLoaderData(\n      matches,\n      matchesToLoad,\n      results,\n      pendingActionResult,\n      activeDeferreds,\n      skipLoaderErrorBubbling\n    );\n\n    // Add a null for any non-loader matches for proper revalidation on the client\n    let executedLoaders = new Set<string>(\n      matchesToLoad.map((match) => match.route.id)\n    );\n    matches.forEach((match) => {\n      if (!executedLoaders.has(match.route.id)) {\n        context.loaderData[match.route.id] = null;\n      }\n    });\n\n    return {\n      ...context,\n      matches,\n      activeDeferreds:\n        activeDeferreds.size > 0\n          ? Object.fromEntries(activeDeferreds.entries())\n          : null,\n    };\n  }\n\n  // Utility wrapper for calling dataStrategy server-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(\n    type: \"loader\" | \"action\",\n    request: Request,\n    matchesToLoad: AgnosticDataRouteMatch[],\n    matches: AgnosticDataRouteMatch[],\n    isRouteRequest: boolean,\n    requestContext: unknown,\n    unstable_dataStrategy: DataStrategyFunction | null\n  ): Promise<DataResult[]> {\n    let results = await callDataStrategyImpl(\n      unstable_dataStrategy || defaultDataStrategy,\n      type,\n      request,\n      matchesToLoad,\n      matches,\n      manifest,\n      mapRouteProperties,\n      requestContext\n    );\n\n    return await Promise.all(\n      results.map((result, i) => {\n        if (isRedirectHandlerResult(result)) {\n          let response = result.result as Response;\n          // Throw redirects and let the server handle them with an HTTP redirect\n          throw normalizeRelativeRoutingRedirectResponse(\n            response,\n            request,\n            matchesToLoad[i].route.id,\n            matches,\n            basename,\n            future.v7_relativeSplatPath\n          );\n        }\n        if (isResponse(result.result) && isRouteRequest) {\n          // For SSR single-route requests, we want to hand Responses back\n          // directly without unwrapping\n          throw result;\n        }\n\n        return convertHandlerResultToDataResult(result);\n      })\n    );\n  }\n\n  return {\n    dataRoutes,\n    query,\n    queryRoute,\n  };\n}\n\n//#endregion\n\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 */\nexport function getStaticContextFromError(\n  routes: AgnosticDataRouteObject[],\n  context: StaticHandlerContext,\n  error: any\n) {\n  let newContext: StaticHandlerContext = {\n    ...context,\n    statusCode: isRouteErrorResponse(error) ? error.status : 500,\n    errors: {\n      [context._deepestRenderedBoundaryId || routes[0].id]: error,\n    },\n  };\n  return newContext;\n}\n\nfunction throwStaticHandlerAbortedError(\n  request: Request,\n  isRouteRequest: boolean,\n  future: StaticHandlerFutureConfig\n) {\n  if (future.v7_throwAbortReason && request.signal.reason !== undefined) {\n    throw request.signal.reason;\n  }\n\n  let method = isRouteRequest ? \"queryRoute\" : \"query\";\n  throw new Error(`${method}() call aborted: ${request.method} ${request.url}`);\n}\n\nfunction isSubmissionNavigation(\n  opts: BaseNavigateOrFetchOptions\n): opts is SubmissionNavigateOptions {\n  return (\n    opts != null &&\n    ((\"formData\" in opts && opts.formData != null) ||\n      (\"body\" in opts && opts.body !== undefined))\n  );\n}\n\nfunction normalizeTo(\n  location: Path,\n  matches: AgnosticDataRouteMatch[],\n  basename: string,\n  prependBasename: boolean,\n  to: To | null,\n  v7_relativeSplatPath: boolean,\n  fromRouteId?: string,\n  relative?: RelativeRoutingType\n) {\n  let contextualMatches: AgnosticDataRouteMatch[];\n  let activeRouteMatch: AgnosticDataRouteMatch | undefined;\n  if (fromRouteId) {\n    // Grab matches up to the calling route so our route-relative logic is\n    // relative to the correct source route\n    contextualMatches = [];\n    for (let match of matches) {\n      contextualMatches.push(match);\n      if (match.route.id === fromRouteId) {\n        activeRouteMatch = match;\n        break;\n      }\n    }\n  } else {\n    contextualMatches = matches;\n    activeRouteMatch = matches[matches.length - 1];\n  }\n\n  // Resolve the relative path\n  let path = resolveTo(\n    to ? to : \".\",\n    getResolveToMatches(contextualMatches, v7_relativeSplatPath),\n    stripBasename(location.pathname, basename) || location.pathname,\n    relative === \"path\"\n  );\n\n  // When `to` is not specified we inherit search/hash from the current\n  // location, unlike when to=\".\" and we just inherit the path.\n  // See https://github.com/remix-run/remix/issues/927\n  if (to == null) {\n    path.search = location.search;\n    path.hash = location.hash;\n  }\n\n  // Add an ?index param for matched index routes if we don't already have one\n  if (\n    (to == null || to === \"\" || to === \".\") &&\n    activeRouteMatch &&\n    activeRouteMatch.route.index &&\n    !hasNakedIndexQuery(path.search)\n  ) {\n    path.search = path.search\n      ? path.search.replace(/^\\?/, \"?index&\")\n      : \"?index\";\n  }\n\n  // If we're operating within a basename, prepend it to the pathname.  If\n  // this is a root navigation, then just use the raw basename which allows\n  // the basename to have full control over the presence of a trailing slash\n  // on root actions\n  if (prependBasename && basename !== \"/\") {\n    path.pathname =\n      path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n\n  return createPath(path);\n}\n\n// Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\nfunction normalizeNavigateOptions(\n  normalizeFormMethod: boolean,\n  isFetcher: boolean,\n  path: string,\n  opts?: BaseNavigateOrFetchOptions\n): {\n  path: string;\n  submission?: Submission;\n  error?: ErrorResponseImpl;\n} {\n  // Return location verbatim on non-submission navigations\n  if (!opts || !isSubmissionNavigation(opts)) {\n    return { path };\n  }\n\n  if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n    return {\n      path,\n      error: getInternalRouterError(405, { method: opts.formMethod }),\n    };\n  }\n\n  let getInvalidBodyError = () => ({\n    path,\n    error: getInternalRouterError(400, { type: \"invalid-body\" }),\n  });\n\n  // Create a Submission on non-GET navigations\n  let rawFormMethod = opts.formMethod || \"get\";\n  let formMethod = normalizeFormMethod\n    ? (rawFormMethod.toUpperCase() as V7_FormMethod)\n    : (rawFormMethod.toLowerCase() as FormMethod);\n  let formAction = stripHashFromPath(path);\n\n  if (opts.body !== undefined) {\n    if (opts.formEncType === \"text/plain\") {\n      // text only support POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n\n      let text =\n        typeof opts.body === \"string\"\n          ? opts.body\n          : opts.body instanceof FormData ||\n            opts.body instanceof URLSearchParams\n          ? // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data\n            Array.from(opts.body.entries()).reduce(\n              (acc, [name, value]) => `${acc}${name}=${value}\\n`,\n              \"\"\n            )\n          : String(opts.body);\n\n      return {\n        path,\n        submission: {\n          formMethod,\n          formAction,\n          formEncType: opts.formEncType,\n          formData: undefined,\n          json: undefined,\n          text,\n        },\n      };\n    } else if (opts.formEncType === \"application/json\") {\n      // json only supports POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n\n      try {\n        let json =\n          typeof opts.body === \"string\" ? JSON.parse(opts.body) : opts.body;\n\n        return {\n          path,\n          submission: {\n            formMethod,\n            formAction,\n            formEncType: opts.formEncType,\n            formData: undefined,\n            json,\n            text: undefined,\n          },\n        };\n      } catch (e) {\n        return getInvalidBodyError();\n      }\n    }\n  }\n\n  invariant(\n    typeof FormData === \"function\",\n    \"FormData is not available in this environment\"\n  );\n\n  let searchParams: URLSearchParams;\n  let formData: FormData;\n\n  if (opts.formData) {\n    searchParams = convertFormDataToSearchParams(opts.formData);\n    formData = opts.formData;\n  } else if (opts.body instanceof FormData) {\n    searchParams = convertFormDataToSearchParams(opts.body);\n    formData = opts.body;\n  } else if (opts.body instanceof URLSearchParams) {\n    searchParams = opts.body;\n    formData = convertSearchParamsToFormData(searchParams);\n  } else if (opts.body == null) {\n    searchParams = new URLSearchParams();\n    formData = new FormData();\n  } else {\n    try {\n      searchParams = new URLSearchParams(opts.body);\n      formData = convertSearchParamsToFormData(searchParams);\n    } catch (e) {\n      return getInvalidBodyError();\n    }\n  }\n\n  let submission: Submission = {\n    formMethod,\n    formAction,\n    formEncType:\n      (opts && opts.formEncType) || \"application/x-www-form-urlencoded\",\n    formData,\n    json: undefined,\n    text: undefined,\n  };\n\n  if (isMutationMethod(submission.formMethod)) {\n    return { path, submission };\n  }\n\n  // Flatten submission onto URLSearchParams for GET submissions\n  let parsedPath = parsePath(path);\n  // On GET navigation submissions we can drop the ?index param from the\n  // resulting location since all loaders will run.  But fetcher GET submissions\n  // only run a single loader so we need to preserve any incoming ?index params\n  if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n    searchParams.append(\"index\", \"\");\n  }\n  parsedPath.search = `?${searchParams}`;\n\n  return { path: createPath(parsedPath), submission };\n}\n\n// Filter out all routes below any caught error as they aren't going to\n// render so we don't need to load them\nfunction getLoaderMatchesUntilBoundary(\n  matches: AgnosticDataRouteMatch[],\n  boundaryId: string\n) {\n  let boundaryMatches = matches;\n  if (boundaryId) {\n    let index = matches.findIndex((m) => m.route.id === boundaryId);\n    if (index >= 0) {\n      boundaryMatches = matches.slice(0, index);\n    }\n  }\n  return boundaryMatches;\n}\n\nfunction getMatchesToLoad(\n  history: History,\n  state: RouterState,\n  matches: AgnosticDataRouteMatch[],\n  submission: Submission | undefined,\n  location: Location,\n  isInitialLoad: boolean,\n  skipActionErrorRevalidation: boolean,\n  isRevalidationRequired: boolean,\n  cancelledDeferredRoutes: string[],\n  cancelledFetcherLoads: string[],\n  deletedFetchers: Set<string>,\n  fetchLoadMatches: Map<string, FetchLoadMatch>,\n  fetchRedirectIds: Set<string>,\n  routesToUse: AgnosticDataRouteObject[],\n  basename: string | undefined,\n  pendingActionResult?: PendingActionResult\n): [AgnosticDataRouteMatch[], RevalidatingFetcher[]] {\n  let actionResult = pendingActionResult\n    ? isErrorResult(pendingActionResult[1])\n      ? pendingActionResult[1].error\n      : pendingActionResult[1].data\n    : undefined;\n  let currentUrl = history.createURL(state.location);\n  let nextUrl = history.createURL(location);\n\n  // Pick navigation matches that are net-new or qualify for revalidation\n  let boundaryId =\n    pendingActionResult && isErrorResult(pendingActionResult[1])\n      ? pendingActionResult[0]\n      : undefined;\n  let boundaryMatches = boundaryId\n    ? getLoaderMatchesUntilBoundary(matches, boundaryId)\n    : matches;\n\n  // Don't revalidate loaders by default after action 4xx/5xx responses\n  // when the flag is enabled.  They can still opt-into revalidation via\n  // `shouldRevalidate` via `actionResult`\n  let actionStatus = pendingActionResult\n    ? pendingActionResult[1].statusCode\n    : undefined;\n  let shouldSkipRevalidation =\n    skipActionErrorRevalidation && actionStatus && actionStatus >= 400;\n\n  let navigationMatches = boundaryMatches.filter((match, index) => {\n    let { route } = match;\n    if (route.lazy) {\n      // We haven't loaded this route yet so we don't know if it's got a loader!\n      return true;\n    }\n\n    if (route.loader == null) {\n      return false;\n    }\n\n    if (isInitialLoad) {\n      if (typeof route.loader !== \"function\" || route.loader.hydrate) {\n        return true;\n      }\n      return (\n        state.loaderData[route.id] === undefined &&\n        // Don't re-run if the loader ran and threw an error\n        (!state.errors || state.errors[route.id] === undefined)\n      );\n    }\n\n    // Always call the loader on new route instances and pending defer cancellations\n    if (\n      isNewLoader(state.loaderData, state.matches[index], match) ||\n      cancelledDeferredRoutes.some((id) => id === match.route.id)\n    ) {\n      return true;\n    }\n\n    // This is the default implementation for when we revalidate.  If the route\n    // provides it's own implementation, then we give them full control but\n    // provide this value so they can leverage it if needed after they check\n    // their own specific use cases\n    let currentRouteMatch = state.matches[index];\n    let nextRouteMatch = match;\n\n    return shouldRevalidateLoader(match, {\n      currentUrl,\n      currentParams: currentRouteMatch.params,\n      nextUrl,\n      nextParams: nextRouteMatch.params,\n      ...submission,\n      actionResult,\n      unstable_actionStatus: actionStatus,\n      defaultShouldRevalidate: shouldSkipRevalidation\n        ? false\n        : // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate\n          isRevalidationRequired ||\n          currentUrl.pathname + currentUrl.search ===\n            nextUrl.pathname + nextUrl.search ||\n          // Search params affect all loaders\n          currentUrl.search !== nextUrl.search ||\n          isNewRouteInstance(currentRouteMatch, nextRouteMatch),\n    });\n  });\n\n  // Pick fetcher.loads that need to be revalidated\n  let revalidatingFetchers: RevalidatingFetcher[] = [];\n  fetchLoadMatches.forEach((f, key) => {\n    // Don't revalidate:\n    //  - on initial load (shouldn't be any fetchers then anyway)\n    //  - if fetcher won't be present in the subsequent render\n    //    - no longer matches the URL (v7_fetcherPersist=false)\n    //    - was unmounted but persisted due to v7_fetcherPersist=true\n    if (\n      isInitialLoad ||\n      !matches.some((m) => m.route.id === f.routeId) ||\n      deletedFetchers.has(key)\n    ) {\n      return;\n    }\n\n    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);\n\n    // If the fetcher path no longer matches, push it in with null matches so\n    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is\n    // currently only a use-case for Remix HMR where the route tree can change\n    // at runtime and remove a route previously loaded via a fetcher\n    if (!fetcherMatches) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: null,\n        match: null,\n        controller: null,\n      });\n      return;\n    }\n\n    // Revalidating fetchers are decoupled from the route matches since they\n    // load from a static href.  They revalidate based on explicit revalidation\n    // (submission, useRevalidator, or X-Remix-Revalidate)\n    let fetcher = state.fetchers.get(key);\n    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);\n\n    let shouldRevalidate = false;\n    if (fetchRedirectIds.has(key)) {\n      // Never trigger a revalidation of an actively redirecting fetcher\n      shouldRevalidate = false;\n    } else if (cancelledFetcherLoads.includes(key)) {\n      // Always revalidate if the fetcher was cancelled\n      shouldRevalidate = true;\n    } else if (\n      fetcher &&\n      fetcher.state !== \"idle\" &&\n      fetcher.data === undefined\n    ) {\n      // If the fetcher hasn't ever completed loading yet, then this isn't a\n      // revalidation, it would just be a brand new load if an explicit\n      // revalidation is required\n      shouldRevalidate = isRevalidationRequired;\n    } else {\n      // Otherwise fall back on any user-defined shouldRevalidate, defaulting\n      // to explicit revalidations only\n      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, {\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        unstable_actionStatus: actionStatus,\n        defaultShouldRevalidate: shouldSkipRevalidation\n          ? false\n          : isRevalidationRequired,\n      });\n    }\n\n    if (shouldRevalidate) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: fetcherMatches,\n        match: fetcherMatch,\n        controller: new AbortController(),\n      });\n    }\n  });\n\n  return [navigationMatches, revalidatingFetchers];\n}\n\nfunction isNewLoader(\n  currentLoaderData: RouteData,\n  currentMatch: AgnosticDataRouteMatch,\n  match: AgnosticDataRouteMatch\n) {\n  let isNew =\n    // [a] -> [a, b]\n    !currentMatch ||\n    // [a, b] -> [a, c]\n    match.route.id !== currentMatch.route.id;\n\n  // Handle the case that we don't have data for a re-used route, potentially\n  // from a prior error or from a cancelled pending deferred\n  let isMissingData = currentLoaderData[match.route.id] === undefined;\n\n  // Always load if this is a net-new route or we don't yet have data\n  return isNew || isMissingData;\n}\n\nfunction isNewRouteInstance(\n  currentMatch: AgnosticDataRouteMatch,\n  match: AgnosticDataRouteMatch\n) {\n  let currentPath = currentMatch.route.path;\n  return (\n    // param change for this match, /users/123 -> /users/456\n    currentMatch.pathname !== match.pathname ||\n    // splat param changed, which is not present in match.path\n    // e.g. /files/images/avatar.jpg -> files/finances.xls\n    (currentPath != null &&\n      currentPath.endsWith(\"*\") &&\n      currentMatch.params[\"*\"] !== match.params[\"*\"])\n  );\n}\n\nfunction shouldRevalidateLoader(\n  loaderMatch: AgnosticDataRouteMatch,\n  arg: ShouldRevalidateFunctionArgs\n) {\n  if (loaderMatch.route.shouldRevalidate) {\n    let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n\n  return arg.defaultShouldRevalidate;\n}\n\n/**\n * Execute route.lazy() methods to lazily load route modules (loader, action,\n * shouldRevalidate) and update the routeManifest in place which shares objects\n * with dataRoutes so those get updated as well.\n */\nasync function loadLazyRouteModule(\n  route: AgnosticDataRouteObject,\n  mapRouteProperties: MapRoutePropertiesFunction,\n  manifest: RouteManifest\n) {\n  if (!route.lazy) {\n    return;\n  }\n\n  let lazyRoute = await route.lazy();\n\n  // If the lazy route function was executed and removed by another parallel\n  // call then we can return - first lazy() to finish wins because the return\n  // value of lazy is expected to be static\n  if (!route.lazy) {\n    return;\n  }\n\n  let routeToUpdate = manifest[route.id];\n  invariant(routeToUpdate, \"No route found in manifest\");\n\n  // Update the route in place.  This should be safe because there's no way\n  // we could yet be sitting on this route as we can't get there without\n  // resolving lazy() first.\n  //\n  // This is different than the HMR \"update\" use-case where we may actively be\n  // on the route being updated.  The main concern boils down to \"does this\n  // mutation affect any ongoing navigations or any current state.matches\n  // values?\".  If not, it should be safe to update in place.\n  let routeUpdates: Record<string, any> = {};\n  for (let lazyRouteProperty in lazyRoute) {\n    let staticRouteValue =\n      routeToUpdate[lazyRouteProperty as keyof typeof routeToUpdate];\n\n    let isPropertyStaticallyDefined =\n      staticRouteValue !== undefined &&\n      // This property isn't static since it should always be updated based\n      // on the route updates\n      lazyRouteProperty !== \"hasErrorBoundary\";\n\n    warning(\n      !isPropertyStaticallyDefined,\n      `Route \"${routeToUpdate.id}\" has a static property \"${lazyRouteProperty}\" ` +\n        `defined but its lazy function is also returning a value for this property. ` +\n        `The lazy route property \"${lazyRouteProperty}\" will be ignored.`\n    );\n\n    if (\n      !isPropertyStaticallyDefined &&\n      !immutableRouteKeys.has(lazyRouteProperty as ImmutableRouteKey)\n    ) {\n      routeUpdates[lazyRouteProperty] =\n        lazyRoute[lazyRouteProperty as keyof typeof lazyRoute];\n    }\n  }\n\n  // Mutate the route with the provided updates.  Do this first so we pass\n  // the updated version to mapRouteProperties\n  Object.assign(routeToUpdate, routeUpdates);\n\n  // Mutate the `hasErrorBoundary` property on the route based on the route\n  // updates and remove the `lazy` function so we don't resolve the lazy\n  // route again.\n  Object.assign(routeToUpdate, {\n    // To keep things framework agnostic, we use the provided\n    // `mapRouteProperties` (or wrapped `detectErrorBoundary`) function to\n    // set the framework-aware properties (`element`/`hasErrorBoundary`) since\n    // the logic will differ between frameworks.\n    ...mapRouteProperties(routeToUpdate),\n    lazy: undefined,\n  });\n}\n\n// Default implementation of `dataStrategy` which fetches all loaders in parallel\nfunction defaultDataStrategy(\n  opts: DataStrategyFunctionArgs\n): ReturnType<DataStrategyFunction> {\n  return Promise.all(opts.matches.map((m) => m.resolve()));\n}\n\nasync function callDataStrategyImpl(\n  dataStrategyImpl: DataStrategyFunction,\n  type: \"loader\" | \"action\",\n  request: Request,\n  matchesToLoad: AgnosticDataRouteMatch[],\n  matches: AgnosticDataRouteMatch[],\n  manifest: RouteManifest,\n  mapRouteProperties: MapRoutePropertiesFunction,\n  requestContext?: unknown\n): Promise<HandlerResult[]> {\n  let routeIdsToLoad = matchesToLoad.reduce(\n    (acc, m) => acc.add(m.route.id),\n    new Set<string>()\n  );\n  let loadedMatches = new Set<string>();\n\n  // Send all matches here to allow for a middleware-type implementation.\n  // handler will be a no-op for unneeded routes and we filter those results\n  // back out below.\n  let results = await dataStrategyImpl({\n    matches: matches.map((match) => {\n      let shouldLoad = routeIdsToLoad.has(match.route.id);\n      // `resolve` encapsulates the route.lazy, executing the\n      // loader/action, and mapping return values/thrown errors to a\n      // HandlerResult.  Users can pass a callback to take fine-grained control\n      // over the execution of the loader/action\n      let resolve: DataStrategyMatch[\"resolve\"] = (handlerOverride) => {\n        loadedMatches.add(match.route.id);\n        return shouldLoad\n          ? callLoaderOrAction(\n              type,\n              request,\n              match,\n              manifest,\n              mapRouteProperties,\n              handlerOverride,\n              requestContext\n            )\n          : Promise.resolve({ type: ResultType.data, result: undefined });\n      };\n\n      return {\n        ...match,\n        shouldLoad,\n        resolve,\n      };\n    }),\n    request,\n    params: matches[0].params,\n    context: requestContext,\n  });\n\n  // Throw if any loadRoute implementations not called since they are what\n  // ensures a route is fully loaded\n  matches.forEach((m) =>\n    invariant(\n      loadedMatches.has(m.route.id),\n      `\\`match.resolve()\\` was not called for route id \"${m.route.id}\". ` +\n        \"You must call `match.resolve()` on every match passed to \" +\n        \"`dataStrategy` to ensure all routes are properly loaded.\"\n    )\n  );\n\n  // Filter out any middleware-only matches for which we didn't need to run handlers\n  return results.filter((_, i) => routeIdsToLoad.has(matches[i].route.id));\n}\n\n// Default logic for calling a loader/action is the user has no specified a dataStrategy\nasync function callLoaderOrAction(\n  type: \"loader\" | \"action\",\n  request: Request,\n  match: AgnosticDataRouteMatch,\n  manifest: RouteManifest,\n  mapRouteProperties: MapRoutePropertiesFunction,\n  handlerOverride: Parameters<DataStrategyMatch[\"resolve\"]>[0],\n  staticContext?: unknown\n): Promise<HandlerResult> {\n  let result: HandlerResult;\n  let onReject: (() => void) | undefined;\n\n  let runHandler = (\n    handler: AgnosticRouteObject[\"loader\"] | AgnosticRouteObject[\"action\"]\n  ): Promise<HandlerResult> => {\n    // Setup a promise we can race against so that abort signals short circuit\n    let reject: () => void;\n    // This will never resolve so safe to type it as Promise<HandlerResult> to\n    // satisfy the function return value\n    let abortPromise = new Promise<HandlerResult>((_, r) => (reject = r));\n    onReject = () => reject();\n    request.signal.addEventListener(\"abort\", onReject);\n\n    let actualHandler = (ctx?: unknown) => {\n      if (typeof handler !== \"function\") {\n        return Promise.reject(\n          new Error(\n            `You cannot call the handler for a route which defines a boolean ` +\n              `\"${type}\" [routeId: ${match.route.id}]`\n          )\n        );\n      }\n      return handler(\n        {\n          request,\n          params: match.params,\n          context: staticContext,\n        },\n        ...(ctx !== undefined ? [ctx] : [])\n      );\n    };\n\n    let handlerPromise: Promise<HandlerResult>;\n    if (handlerOverride) {\n      handlerPromise = handlerOverride((ctx: unknown) => actualHandler(ctx));\n    } else {\n      handlerPromise = (async () => {\n        try {\n          let val = await actualHandler();\n          return { type: \"data\", result: val };\n        } catch (e) {\n          return { type: \"error\", result: e };\n        }\n      })();\n    }\n\n    return Promise.race([handlerPromise, 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 handlerError;\n        let [value] = await Promise.all([\n          // If the handler throws, don't let it immediately bubble out,\n          // since we need to let the lazy() execution finish so we know if this\n          // route has a boundary that can handle the error\n          runHandler(handler).catch((e) => {\n            handlerError = e;\n          }),\n          loadLazyRouteModule(match.route, mapRouteProperties, manifest),\n        ]);\n        if (handlerError !== undefined) {\n          throw handlerError;\n        }\n        result = value!;\n      } else {\n        // Load lazy route module, then run any returned handler\n        await loadLazyRouteModule(match.route, mapRouteProperties, manifest);\n\n        handler = match.route[type];\n        if (handler) {\n          // Handler still runs even if we got interrupted to maintain consistency\n          // with un-abortable behavior of handler execution on non-lazy or\n          // previously-lazy-loaded routes\n          result = await runHandler(handler);\n        } else if (type === \"action\") {\n          let url = new URL(request.url);\n          let pathname = url.pathname + url.search;\n          throw getInternalRouterError(405, {\n            method: request.method,\n            pathname,\n            routeId: match.route.id,\n          });\n        } else {\n          // lazy() route has no loader to run.  Short circuit here so we don't\n          // hit the invariant below that errors on returning undefined.\n          return { type: ResultType.data, result: undefined };\n        }\n      }\n    } else if (!handler) {\n      let url = new URL(request.url);\n      let pathname = url.pathname + url.search;\n      throw getInternalRouterError(404, {\n        pathname,\n      });\n    } else {\n      result = await runHandler(handler);\n    }\n\n    invariant(\n      result.result !== undefined,\n      `You defined ${type === \"action\" ? \"an action\" : \"a loader\"} for route ` +\n        `\"${match.route.id}\" but didn't return anything from your \\`${type}\\` ` +\n        `function. Please return a value or \\`null\\`.`\n    );\n  } catch (e) {\n    // We should already be catching and converting normal handler executions to\n    // HandlerResults and returning them, so anything that throws here is an\n    // unexpected error we still need to wrap\n    return { type: ResultType.error, result: e };\n  } finally {\n    if (onReject) {\n      request.signal.removeEventListener(\"abort\", onReject);\n    }\n  }\n\n  return result;\n}\n\nasync function convertHandlerResultToDataResult(\n  handlerResult: HandlerResult\n): Promise<DataResult> {\n  let { result, type, status } = handlerResult;\n\n  if (isResponse(result)) {\n    let data: any;\n\n    try {\n      let contentType = result.headers.get(\"Content-Type\");\n      // Check between word boundaries instead of startsWith() due to the last\n      // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type\n      if (contentType && /\\bapplication\\/json\\b/.test(contentType)) {\n        if (result.body == null) {\n          data = null;\n        } else {\n          data = await result.json();\n        }\n      } else {\n        data = await result.text();\n      }\n    } catch (e) {\n      return { type: ResultType.error, error: e };\n    }\n\n    if (type === ResultType.error) {\n      return {\n        type: ResultType.error,\n        error: new ErrorResponseImpl(result.status, result.statusText, data),\n        statusCode: result.status,\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 (type === ResultType.error) {\n    return {\n      type: ResultType.error,\n      error: result,\n      statusCode: isRouteErrorResponse(result) ? result.status : status,\n    };\n  }\n\n  if (isDeferredData(result)) {\n    return {\n      type: ResultType.deferred,\n      deferredData: result,\n      statusCode: result.init?.status,\n      headers: result.init?.headers && new Headers(result.init.headers),\n    };\n  }\n\n  return { type: ResultType.data, data: result, statusCode: status };\n}\n\n// Support relative routing in internal redirects\nfunction normalizeRelativeRoutingRedirectResponse(\n  response: Response,\n  request: Request,\n  routeId: string,\n  matches: AgnosticDataRouteMatch[],\n  basename: string,\n  v7_relativeSplatPath: boolean\n) {\n  let location = response.headers.get(\"Location\");\n  invariant(\n    location,\n    \"Redirects returned/thrown from loaders/actions must have a Location header\"\n  );\n\n  if (!ABSOLUTE_URL_REGEX.test(location)) {\n    let trimmedMatches = matches.slice(\n      0,\n      matches.findIndex((m) => m.route.id === routeId) + 1\n    );\n    location = normalizeTo(\n      new URL(request.url),\n      trimmedMatches,\n      basename,\n      true,\n      location,\n      v7_relativeSplatPath\n    );\n    response.headers.set(\"Location\", location);\n  }\n\n  return response;\n}\n\nfunction normalizeRedirectLocation(\n  location: string,\n  currentUrl: URL,\n  basename: string\n): string {\n  if (ABSOLUTE_URL_REGEX.test(location)) {\n    // Strip off the protocol+origin for same-origin + same-basename absolute redirects\n    let normalizedLocation = location;\n    let url = normalizedLocation.startsWith(\"//\")\n      ? new URL(currentUrl.protocol + normalizedLocation)\n      : new URL(normalizedLocation);\n    let isSameBasename = stripBasename(url.pathname, basename) != null;\n    if (url.origin === currentUrl.origin && isSameBasename) {\n      return url.pathname + url.search + url.hash;\n    }\n  }\n  return location;\n}\n\n// Utility method for creating the Request instances for loaders/actions during\n// client-side navigations and fetches.  During SSR we will always have a\n// Request instance from the static handler (query/queryRoute)\nfunction createClientSideRequest(\n  history: History,\n  location: string | Location,\n  signal: AbortSignal,\n  submission?: Submission\n): Request {\n  let url = history.createURL(stripHashFromPath(location)).toString();\n  let init: RequestInit = { signal };\n\n  if (submission && isMutationMethod(submission.formMethod)) {\n    let { formMethod, formEncType } = submission;\n    // Didn't think we needed this but it turns out unlike other methods, patch\n    // won't be properly normalized to uppercase and results in a 405 error.\n    // See: https://fetch.spec.whatwg.org/#concept-method\n    init.method = formMethod.toUpperCase();\n\n    if (formEncType === \"application/json\") {\n      init.headers = new Headers({ \"Content-Type\": formEncType });\n      init.body = JSON.stringify(submission.json);\n    } else if (formEncType === \"text/plain\") {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.text;\n    } else if (\n      formEncType === \"application/x-www-form-urlencoded\" &&\n      submission.formData\n    ) {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = convertFormDataToSearchParams(submission.formData);\n    } else {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.formData;\n    }\n  }\n\n  return new Request(url, init);\n}\n\nfunction convertFormDataToSearchParams(formData: FormData): URLSearchParams {\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, typeof value === \"string\" ? value : value.name);\n  }\n\n  return searchParams;\n}\n\nfunction convertSearchParamsToFormData(\n  searchParams: URLSearchParams\n): FormData {\n  let formData = new FormData();\n  for (let [key, value] of searchParams.entries()) {\n    formData.append(key, value);\n  }\n  return formData;\n}\n\nfunction processRouteLoaderData(\n  matches: AgnosticDataRouteMatch[],\n  matchesToLoad: AgnosticDataRouteMatch[],\n  results: DataResult[],\n  pendingActionResult: PendingActionResult | undefined,\n  activeDeferreds: Map<string, DeferredData>,\n  skipLoaderErrorBubbling: boolean\n): {\n  loaderData: RouterState[\"loaderData\"];\n  errors: RouterState[\"errors\"] | null;\n  statusCode: number;\n  loaderHeaders: Record<string, Headers>;\n} {\n  // Fill in loaderData/errors from our loaders\n  let loaderData: RouterState[\"loaderData\"] = {};\n  let errors: RouterState[\"errors\"] | null = null;\n  let statusCode: number | undefined;\n  let foundError = false;\n  let loaderHeaders: Record<string, Headers> = {};\n  let pendingError =\n    pendingActionResult && isErrorResult(pendingActionResult[1])\n      ? pendingActionResult[1].error\n      : undefined;\n\n  // Process loader results into state.loaderData/state.errors\n  results.forEach((result, index) => {\n    let id = matchesToLoad[index].route.id;\n    invariant(\n      !isRedirectResult(result),\n      \"Cannot handle redirect results in processLoaderData\"\n    );\n    if (isErrorResult(result)) {\n      let error = result.error;\n      // If we have a pending action error, we report it at the highest-route\n      // that throws a loader error, and then clear it out to indicate that\n      // it was consumed\n      if (pendingError !== undefined) {\n        error = pendingError;\n        pendingError = undefined;\n      }\n\n      errors = errors || {};\n\n      if (skipLoaderErrorBubbling) {\n        errors[id] = error;\n      } else {\n        // Look upwards from the matched route for the closest ancestor error\n        // boundary, defaulting to the root match.  Prefer higher error values\n        // if lower errors bubble to the same boundary\n        let boundaryMatch = findNearestBoundary(matches, id);\n        if (errors[boundaryMatch.route.id] == null) {\n          errors[boundaryMatch.route.id] = error;\n        }\n      }\n\n      // Clear our any prior loaderData for the throwing route\n      loaderData[id] = undefined;\n\n      // Once we find our first (highest) error, we set the status code and\n      // prevent deeper status codes from overriding\n      if (!foundError) {\n        foundError = true;\n        statusCode = isRouteErrorResponse(result.error)\n          ? result.error.status\n          : 500;\n      }\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    } else {\n      if (isDeferredResult(result)) {\n        activeDeferreds.set(id, result.deferredData);\n        loaderData[id] = result.deferredData.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (\n          result.statusCode != null &&\n          result.statusCode !== 200 &&\n          !foundError\n        ) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\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        if (result.statusCode && result.statusCode !== 200 && !foundError) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      }\n    }\n  });\n\n  // If we didn't consume the pending action error (i.e., all loaders\n  // resolved), then consume it here.  Also clear out any loaderData for the\n  // throwing route\n  if (pendingError !== undefined && pendingActionResult) {\n    errors = { [pendingActionResult[0]]: pendingError };\n    loaderData[pendingActionResult[0]] = undefined;\n  }\n\n  return {\n    loaderData,\n    errors,\n    statusCode: statusCode || 200,\n    loaderHeaders,\n  };\n}\n\nfunction processLoaderData(\n  state: RouterState,\n  matches: AgnosticDataRouteMatch[],\n  matchesToLoad: AgnosticDataRouteMatch[],\n  results: DataResult[],\n  pendingActionResult: PendingActionResult | undefined,\n  revalidatingFetchers: RevalidatingFetcher[],\n  fetcherResults: DataResult[],\n  activeDeferreds: Map<string, DeferredData>\n): {\n  loaderData: RouterState[\"loaderData\"];\n  errors?: RouterState[\"errors\"];\n} {\n  let { loaderData, errors } = processRouteLoaderData(\n    matches,\n    matchesToLoad,\n    results,\n    pendingActionResult,\n    activeDeferreds,\n    false // This method is only called client side so we always want to bubble\n  );\n\n  // Process results from our revalidating fetchers\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let { key, match, controller } = revalidatingFetchers[index];\n    invariant(\n      fetcherResults !== undefined && fetcherResults[index] !== undefined,\n      \"Did not find corresponding fetcher result\"\n    );\n    let result = fetcherResults[index];\n\n    // Process fetcher non-redirect errors\n    if (controller && controller.signal.aborted) {\n      // Nothing to do for aborted fetchers\n      continue;\n    } else if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, match?.route.id);\n      if (!(errors && errors[boundaryMatch.route.id])) {\n        errors = {\n          ...errors,\n          [boundaryMatch.route.id]: result.error,\n        };\n      }\n      state.fetchers.delete(key);\n    } else if (isRedirectResult(result)) {\n      // Should never get here, redirects should get processed above, but we\n      // keep this to type narrow to a success result in the else\n      invariant(false, \"Unhandled fetcher revalidation redirect\");\n    } else if (isDeferredResult(result)) {\n      // Should never get here, deferred data should be awaited for fetchers\n      // in resolveDeferredResults\n      invariant(false, \"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = getDoneFetcher(result.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n\n  return { loaderData, errors };\n}\n\nfunction mergeLoaderData(\n  loaderData: RouteData,\n  newLoaderData: RouteData,\n  matches: AgnosticDataRouteMatch[],\n  errors: RouteData | null | undefined\n): RouteData {\n  let mergedLoaderData = { ...newLoaderData };\n  for (let match of matches) {\n    let id = match.route.id;\n    if (newLoaderData.hasOwnProperty(id)) {\n      if (newLoaderData[id] !== undefined) {\n        mergedLoaderData[id] = newLoaderData[id];\n      } else {\n        // No-op - this is so we ignore existing data if we have a key in the\n        // incoming object with an undefined value, which is how we unset a prior\n        // loaderData if we encounter a loader error\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  return mergedLoaderData;\n}\n\nfunction getActionDataForCommit(\n  pendingActionResult: PendingActionResult | undefined\n) {\n  if (!pendingActionResult) {\n    return {};\n  }\n  return isErrorResult(pendingActionResult[1])\n    ? {\n        // Clear out prior actionData on errors\n        actionData: {},\n      }\n    : {\n        actionData: {\n          [pendingActionResult[0]]: pendingActionResult[1].data,\n        },\n      };\n}\n\n// Find the nearest error boundary, looking upwards from the leaf route (or the\n// route specified by routeId) for the closest ancestor error boundary,\n// defaulting to the root match\nfunction findNearestBoundary(\n  matches: AgnosticDataRouteMatch[],\n  routeId?: string\n): AgnosticDataRouteMatch {\n  let eligibleMatches = routeId\n    ? matches.slice(0, matches.findIndex((m) => m.route.id === routeId) + 1)\n    : [...matches];\n  return (\n    eligibleMatches.reverse().find((m) => m.route.hasErrorBoundary === true) ||\n    matches[0]\n  );\n}\n\nfunction getShortCircuitMatches(routes: AgnosticDataRouteObject[]): {\n  matches: AgnosticDataRouteMatch[];\n  route: AgnosticDataRouteObject;\n} {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route =\n    routes.length === 1\n      ? routes[0]\n      : routes.find((r) => r.index || !r.path || r.path === \"/\") || {\n          id: `__shim-error-route__`,\n        };\n\n  return {\n    matches: [\n      {\n        params: {},\n        pathname: \"\",\n        pathnameBase: \"\",\n        route,\n      },\n    ],\n    route,\n  };\n}\n\nfunction getInternalRouterError(\n  status: number,\n  {\n    pathname,\n    routeId,\n    method,\n    type,\n  }: {\n    pathname?: string;\n    routeId?: string;\n    method?: string;\n    type?: \"defer-action\" | \"invalid-body\";\n  } = {}\n) {\n  let statusText = \"Unknown Server Error\";\n  let errorMessage = \"Unknown @remix-run/router error\";\n\n  if (status === 400) {\n    statusText = \"Bad Request\";\n    if (method && pathname && routeId) {\n      errorMessage =\n        `You made a ${method} request to \"${pathname}\" but ` +\n        `did not provide a \\`loader\\` for route \"${routeId}\", ` +\n        `so there is no way to handle the request.`;\n    } else if (type === \"defer-action\") {\n      errorMessage = \"defer() is not supported in actions\";\n    } else if (type === \"invalid-body\") {\n      errorMessage = \"Unable to encode submission body\";\n    }\n  } else if (status === 403) {\n    statusText = \"Forbidden\";\n    errorMessage = `Route \"${routeId}\" does not match URL \"${pathname}\"`;\n  } else if (status === 404) {\n    statusText = \"Not Found\";\n    errorMessage = `No route matches URL \"${pathname}\"`;\n  } else if (status === 405) {\n    statusText = \"Method Not Allowed\";\n    if (method && pathname && routeId) {\n      errorMessage =\n        `You made a ${method.toUpperCase()} request to \"${pathname}\" but ` +\n        `did not provide an \\`action\\` for route \"${routeId}\", ` +\n        `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 ErrorResponseImpl(\n    status || 500,\n    statusText,\n    new Error(errorMessage),\n    true\n  );\n}\n\n// Find any returned redirect errors, starting from the lowest match\nfunction findRedirect(\n  results: DataResult[]\n): { result: RedirectResult; idx: number } | undefined {\n  for (let i = results.length - 1; i >= 0; i--) {\n    let result = results[i];\n    if (isRedirectResult(result)) {\n      return { result, idx: i };\n    }\n  }\n}\n\nfunction stripHashFromPath(path: To) {\n  let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n  return createPath({ ...parsedPath, hash: \"\" });\n}\n\nfunction isHashChangeOnly(a: Location, b: Location): boolean {\n  if (a.pathname !== b.pathname || a.search !== b.search) {\n    return false;\n  }\n\n  if (a.hash === \"\") {\n    // /page -> /page#hash\n    return b.hash !== \"\";\n  } else if (a.hash === b.hash) {\n    // /page#hash -> /page#hash\n    return true;\n  } else if (b.hash !== \"\") {\n    // /page#hash -> /page#other\n    return true;\n  }\n\n  // If the hash is removed the browser will re-perform a request to the server\n  // /page#hash -> /page\n  return false;\n}\n\nfunction isHandlerResult(result: unknown): result is HandlerResult {\n  return (\n    result != null &&\n    typeof result === \"object\" &&\n    \"type\" in result &&\n    \"result\" in result &&\n    (result.type === ResultType.data || result.type === ResultType.error)\n  );\n}\n\nfunction isRedirectHandlerResult(result: HandlerResult) {\n  return (\n    isResponse(result.result) && redirectStatusCodes.has(result.result.status)\n  );\n}\n\nfunction isDeferredResult(result: DataResult): result is DeferredResult {\n  return result.type === ResultType.deferred;\n}\n\nfunction isErrorResult(result: DataResult): result is ErrorResult {\n  return result.type === ResultType.error;\n}\n\nfunction isRedirectResult(result?: DataResult): result is RedirectResult {\n  return (result && result.type) === ResultType.redirect;\n}\n\nexport function isDeferredData(value: any): value is DeferredData {\n  let deferred: DeferredData = value;\n  return (\n    deferred &&\n    typeof deferred === \"object\" &&\n    typeof deferred.data === \"object\" &&\n    typeof deferred.subscribe === \"function\" &&\n    typeof deferred.cancel === \"function\" &&\n    typeof deferred.resolveData === \"function\"\n  );\n}\n\nfunction isResponse(value: any): value is Response {\n  return (\n    value != null &&\n    typeof value.status === \"number\" &&\n    typeof value.statusText === \"string\" &&\n    typeof value.headers === \"object\" &&\n    typeof value.body !== \"undefined\"\n  );\n}\n\nfunction isRedirectResponse(result: any): result is Response {\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 isValidMethod(method: string): method is FormMethod | V7_FormMethod {\n  return validRequestMethods.has(method.toLowerCase() as FormMethod);\n}\n\nfunction isMutationMethod(\n  method: string\n): method is MutationFormMethod | V7_MutationFormMethod {\n  return validMutationMethods.has(method.toLowerCase() as MutationFormMethod);\n}\n\nasync function resolveDeferredResults(\n  currentMatches: AgnosticDataRouteMatch[],\n  matchesToLoad: (AgnosticDataRouteMatch | null)[],\n  results: DataResult[],\n  signals: (AbortSignal | null)[],\n  isFetcher: boolean,\n  currentLoaderData?: RouteData\n) {\n  for (let index = 0; index < results.length; index++) {\n    let result = results[index];\n    let match = matchesToLoad[index];\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n\n    let currentMatch = currentMatches.find(\n      (m) => m.route.id === match!.route.id\n    );\n    let isRevalidatingLoader =\n      currentMatch != null &&\n      !isNewRouteInstance(currentMatch, match) &&\n      (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      let signal = signals[index];\n      invariant(\n        signal,\n        \"Expected an AbortSignal for revalidating fetcher deferred result\"\n      );\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(\n  result: DeferredResult,\n  signal: AbortSignal,\n  unwrap = false\n): Promise<SuccessResult | ErrorResult | undefined> {\n  let aborted = await result.deferredData.resolveData(signal);\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: string): boolean {\n  return new URLSearchParams(search).getAll(\"index\").some((v) => v === \"\");\n}\n\nfunction getTargetMatch(\n  matches: AgnosticDataRouteMatch[],\n  location: Location | string\n) {\n  let search =\n    typeof location === \"string\" ? parsePath(location).search : location.search;\n  if (\n    matches[matches.length - 1].route.index &&\n    hasNakedIndexQuery(search || \"\")\n  ) {\n    // Return the leaf index route when index is present\n    return matches[matches.length - 1];\n  }\n  // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n  // pathless layout routes)\n  let pathMatches = getPathContributingMatches(matches);\n  return pathMatches[pathMatches.length - 1];\n}\n\nfunction getSubmissionFromNavigation(\n  navigation: Navigation\n): Submission | undefined {\n  let { formMethod, formAction, formEncType, text, formData, json } =\n    navigation;\n  if (!formMethod || !formAction || !formEncType) {\n    return;\n  }\n\n  if (text != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json: undefined,\n      text,\n    };\n  } else if (formData != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData,\n      json: undefined,\n      text: undefined,\n    };\n  } else if (json !== undefined) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json,\n      text: undefined,\n    };\n  }\n}\n\nfunction getLoadingNavigation(\n  location: Location,\n  submission?: Submission\n): NavigationStates[\"Loading\"] {\n  if (submission) {\n    let navigation: NavigationStates[\"Loading\"] = {\n      state: \"loading\",\n      location,\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n    };\n    return navigation;\n  } else {\n    let navigation: NavigationStates[\"Loading\"] = {\n      state: \"loading\",\n      location,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n    };\n    return navigation;\n  }\n}\n\nfunction getSubmittingNavigation(\n  location: Location,\n  submission: Submission\n): NavigationStates[\"Submitting\"] {\n  let navigation: NavigationStates[\"Submitting\"] = {\n    state: \"submitting\",\n    location,\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n  };\n  return navigation;\n}\n\nfunction getLoadingFetcher(\n  submission?: Submission,\n  data?: Fetcher[\"data\"]\n): FetcherStates[\"Loading\"] {\n  if (submission) {\n    let fetcher: FetcherStates[\"Loading\"] = {\n      state: \"loading\",\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n      data,\n    };\n    return fetcher;\n  } else {\n    let fetcher: FetcherStates[\"Loading\"] = {\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n      data,\n    };\n    return fetcher;\n  }\n}\n\nfunction getSubmittingFetcher(\n  submission: Submission,\n  existingFetcher?: Fetcher\n): FetcherStates[\"Submitting\"] {\n  let fetcher: FetcherStates[\"Submitting\"] = {\n    state: \"submitting\",\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n    data: existingFetcher ? existingFetcher.data : undefined,\n  };\n  return fetcher;\n}\n\nfunction getDoneFetcher(data: Fetcher[\"data\"]): FetcherStates[\"Idle\"] {\n  let fetcher: FetcherStates[\"Idle\"] = {\n    state: \"idle\",\n    formMethod: undefined,\n    formAction: undefined,\n    formEncType: undefined,\n    formData: undefined,\n    json: undefined,\n    text: undefined,\n    data,\n  };\n  return fetcher;\n}\n\nfunction restoreAppliedTransitions(\n  _window: Window,\n  transitions: Map<string, Set<string>>\n) {\n  try {\n    let sessionPositions = _window.sessionStorage.getItem(\n      TRANSITIONS_STORAGE_KEY\n    );\n    if (sessionPositions) {\n      let json = JSON.parse(sessionPositions);\n      for (let [k, v] of Object.entries(json || {})) {\n        if (v && Array.isArray(v)) {\n          transitions.set(k, new Set(v || []));\n        }\n      }\n    }\n  } catch (e) {\n    // no-op, use default empty object\n  }\n}\n\nfunction persistAppliedTransitions(\n  _window: Window,\n  transitions: Map<string, Set<string>>\n) {\n  if (transitions.size > 0) {\n    let json: Record<string, string[]> = {};\n    for (let [k, v] of transitions) {\n      json[k] = [...v];\n    }\n    try {\n      _window.sessionStorage.setItem(\n        TRANSITIONS_STORAGE_KEY,\n        JSON.stringify(json)\n      );\n    } catch (error) {\n      warning(\n        false,\n        `Failed to save applied view transitions in sessionStorage (${error}).`\n      );\n    }\n  }\n}\n\n//#endregion\n","import useEffect from './useIsomorphicEffect';\nimport { useState } from 'react';\nconst matchersByWindow = new WeakMap();\nconst getMatcher = (query, targetWindow) => {\n  if (!query || !targetWindow) return undefined;\n  const matchers = matchersByWindow.get(targetWindow) || new Map();\n  matchersByWindow.set(targetWindow, matchers);\n  let mql = matchers.get(query);\n  if (!mql) {\n    mql = targetWindow.matchMedia(query);\n    mql.refCount = 0;\n    matchers.set(mql.media, mql);\n  }\n  return mql;\n};\n/**\n * Match a media query and get updates as the match changes. The media string is\n * passed directly to `window.matchMedia` and run as a Layout Effect, so initial\n * matches are returned before the browser has a chance to paint.\n *\n * ```tsx\n * function Page() {\n *   const isWide = useMediaQuery('min-width: 1000px')\n *\n *   return isWide ? \"very wide\" : 'not so wide'\n * }\n * ```\n *\n * Media query lists are also reused globally, hook calls for the same query\n * will only create a matcher once under the hood.\n *\n * @param query A media query\n * @param targetWindow The window to match against, uses the globally available one as a default.\n */\nexport default function useMediaQuery(query, targetWindow = typeof window === 'undefined' ? undefined : window) {\n  const mql = getMatcher(query, targetWindow);\n  const [matches, setMatches] = useState(() => mql ? mql.matches : false);\n  useEffect(() => {\n    let mql = getMatcher(query, targetWindow);\n    if (!mql) {\n      return setMatches(false);\n    }\n    let matchers = matchersByWindow.get(targetWindow);\n    const handleChange = () => {\n      setMatches(mql.matches);\n    };\n    mql.refCount++;\n    mql.addListener(handleChange);\n    handleChange();\n    return () => {\n      mql.removeListener(handleChange);\n      mql.refCount--;\n      if (mql.refCount <= 0) {\n        matchers == null ? void 0 : matchers.delete(mql.media);\n      }\n      mql = undefined;\n    };\n  }, [query]);\n  return matches;\n}","import useMediaQuery from './useMediaQuery';\nimport { useMemo } from 'react';\n/**\n * Create a responsive hook we a set of breakpoint names and widths.\n * You can use any valid css units as well as a numbers (for pixels).\n *\n * **NOTE:** The object key order is important! it's assumed to be in order from smallest to largest\n *\n * ```ts\n * const useBreakpoint = createBreakpointHook({\n *  xs: 0,\n *  sm: 576,\n *  md: 768,\n *  lg: 992,\n *  xl: 1200,\n * })\n * ```\n *\n * **Watch out!** using string values will sometimes construct media queries using css `calc()` which\n * is NOT supported in media queries by all browsers at the moment. use numbers for\n * the widest range of browser support.\n *\n * @param breakpointValues A object hash of names to breakpoint dimensions\n */\nexport function createBreakpointHook(breakpointValues) {\n  const names = Object.keys(breakpointValues);\n  function and(query, next) {\n    if (query === next) {\n      return next;\n    }\n    return query ? `${query} and ${next}` : next;\n  }\n  function getNext(breakpoint) {\n    return names[Math.min(names.indexOf(breakpoint) + 1, names.length - 1)];\n  }\n  function getMaxQuery(breakpoint) {\n    const next = getNext(breakpoint);\n    let value = breakpointValues[next];\n    if (typeof value === 'number') value = `${value - 0.2}px`;else value = `calc(${value} - 0.2px)`;\n    return `(max-width: ${value})`;\n  }\n  function getMinQuery(breakpoint) {\n    let value = breakpointValues[breakpoint];\n    if (typeof value === 'number') {\n      value = `${value}px`;\n    }\n    return `(min-width: ${value})`;\n  }\n\n  /**\n   * Match a set of breakpoints\n   *\n   * ```tsx\n   * const MidSizeOnly = () => {\n   *   const isMid = useBreakpoint({ lg: 'down', sm: 'up' });\n   *\n   *   if (isMid) return <div>On a Reasonable sized Screen!</div>\n   *   return null;\n   * }\n   * ```\n   * @param breakpointMap An object map of breakpoints and directions, queries are constructed using \"and\" to join\n   * breakpoints together\n   * @param window Optionally specify the target window to match against (useful when rendering into iframes)\n   */\n\n  /**\n   * Match a single breakpoint exactly, up, or down.\n   *\n   * ```tsx\n   * const PhoneOnly = () => {\n   *   const isSmall = useBreakpoint('sm', 'down');\n   *\n   *   if (isSmall) return <div>On a Small Screen!</div>\n   *   return null;\n   * }\n   * ```\n   *\n   * @param breakpoint The breakpoint key\n   * @param direction A direction 'up' for a max, 'down' for min, true to match only the breakpoint\n   * @param window Optionally specify the target window to match against (useful when rendering into iframes)\n   */\n\n  function useBreakpoint(breakpointOrMap, direction, window) {\n    let breakpointMap;\n    if (typeof breakpointOrMap === 'object') {\n      breakpointMap = breakpointOrMap;\n      window = direction;\n      direction = true;\n    } else {\n      direction = direction || true;\n      breakpointMap = {\n        [breakpointOrMap]: direction\n      };\n    }\n    let query = useMemo(() => Object.entries(breakpointMap).reduce((query, [key, direction]) => {\n      if (direction === 'up' || direction === true) {\n        query = and(query, getMinQuery(key));\n      }\n      if (direction === 'down' || direction === true) {\n        query = and(query, getMaxQuery(key));\n      }\n      return query;\n    }, ''), [JSON.stringify(breakpointMap)]);\n    return useMediaQuery(query, window);\n  }\n  return useBreakpoint;\n}\nconst useBreakpoint = createBreakpointHook({\n  xs: 0,\n  sm: 576,\n  md: 768,\n  lg: 992,\n  xl: 1200,\n  xxl: 1400\n});\nexport default useBreakpoint;","import { useState } from 'react';\n\n/**\n * A convenience hook around `useState` designed to be paired with\n * the component [callback ref](https://reactjs.org/docs/refs-and-the-dom.html#callback-refs) api.\n * Callback refs are useful over `useRef()` when you need to respond to the ref being set\n * instead of lazily accessing it in an effect.\n *\n * ```ts\n * const [element, attachRef] = useCallbackRef<HTMLDivElement>()\n *\n * useEffect(() => {\n *   if (!element) return\n *\n *   const calendar = new FullCalendar.Calendar(element)\n *\n *   return () => {\n *     calendar.destroy()\n *   }\n * }, [element])\n *\n * return <div ref={attachRef} />\n * ```\n *\n * @category refs\n */\nexport default function useCallbackRef() {\n  return useState(null);\n}","import { useEffect, useRef } from 'react';\n\n/**\n * Creates a `Ref` whose value is updated in an effect, ensuring the most recent\n * value is the one rendered with. Generally only required for Concurrent mode usage\n * where previous work in `render()` may be discarded before being used.\n *\n * This is safe to access in an event handler.\n *\n * @param value The `Ref` value\n */\nfunction useCommittedRef(value) {\n  const ref = useRef(value);\n  useEffect(() => {\n    ref.current = value;\n  }, [value]);\n  return ref;\n}\nexport default useCommittedRef;","import { useCallback } from 'react';\nimport useCommittedRef from './useCommittedRef';\nexport default function useEventCallback(fn) {\n  const ref = useCommittedRef(fn);\n  return useCallback(function (...args) {\n    return ref.current && ref.current(...args);\n  }, [ref]);\n}","import { useEffect } from 'react';\nimport useEventCallback from './useEventCallback';\n/**\n * Attaches an event handler outside directly to specified DOM element\n * bypassing the react synthetic event system.\n *\n * @param element The target to listen for events on\n * @param event The DOM event name\n * @param handler An event handler\n * @param capture Whether or not to listen during the capture event phase\n */\nexport default function useEventListener(eventTarget, event, listener, capture = false) {\n  const handler = useEventCallback(listener);\n  useEffect(() => {\n    const target = typeof eventTarget === 'function' ? eventTarget() : eventTarget;\n    target.addEventListener(event, handler, capture);\n    return () => target.removeEventListener(event, handler, capture);\n  }, [eventTarget]);\n}","import { useReducer } from 'react';\n\n/**\n * Returns a function that triggers a component update. the hook equivalent to\n * `this.forceUpdate()` in a class component. In most cases using a state value directly\n * is preferable but may be required in some advanced usages of refs for interop or\n * when direct DOM manipulation is required.\n *\n * ```ts\n * const forceUpdate = useForceUpdate();\n *\n * const updateOnClick = useCallback(() => {\n *  forceUpdate()\n * }, [forceUpdate])\n *\n * return <button type=\"button\" onClick={updateOnClick}>Hi there</button>\n * ```\n */\nexport default function useForceUpdate() {\n  // The toggling state value is designed to defeat React optimizations for skipping\n  // updates when they are strictly equal to the last state value\n  const [, dispatch] = useReducer(state => !state, false);\n  return dispatch;\n}","import { useEffect, useLayoutEffect } from 'react';\nconst isReactNative = typeof global !== 'undefined' &&\n// @ts-ignore\nglobal.navigator &&\n// @ts-ignore\nglobal.navigator.product === 'ReactNative';\nconst isDOM = typeof document !== 'undefined';\n\n/**\n * Is `useLayoutEffect` in a DOM or React Native environment, otherwise resolves to useEffect\n * Only useful to avoid the console warning.\n *\n * PREFER `useEffect` UNLESS YOU KNOW WHAT YOU ARE DOING.\n *\n * @category effects\n */\nexport default isDOM || isReactNative ? useLayoutEffect : useEffect;","import { useMemo } from 'react';\nconst toFnRef = ref => !ref || typeof ref === 'function' ? ref : value => {\n  ref.current = value;\n};\nexport function mergeRefs(refA, refB) {\n  const a = toFnRef(refA);\n  const b = toFnRef(refB);\n  return value => {\n    if (a) a(value);\n    if (b) b(value);\n  };\n}\n\n/**\n * Create and returns a single callback ref composed from two other Refs.\n *\n * ```tsx\n * const Button = React.forwardRef((props, ref) => {\n *   const [element, attachRef] = useCallbackRef<HTMLButtonElement>();\n *   const mergedRef = useMergedRefs(ref, attachRef);\n *\n *   return <button ref={mergedRef} {...props}/>\n * })\n * ```\n *\n * @param refA A Callback or mutable Ref\n * @param refB A Callback or mutable Ref\n * @category refs\n */\nfunction useMergedRefs(refA, refB) {\n  return useMemo(() => mergeRefs(refA, refB), [refA, refB]);\n}\nexport default useMergedRefs;","import { useRef, useEffect } from 'react';\n\n/**\n * Track whether a component is current mounted. Generally less preferable than\n * properlly canceling effects so they don't run after a component is unmounted,\n * but helpful in cases where that isn't feasible, such as a `Promise` resolution.\n *\n * @returns a function that returns the current isMounted state of the component\n *\n * ```ts\n * const [data, setData] = useState(null)\n * const isMounted = useMounted()\n *\n * useEffect(() => {\n *   fetchdata().then((newData) => {\n *      if (isMounted()) {\n *        setData(newData);\n *      }\n *   })\n * })\n * ```\n */\nexport default function useMounted() {\n  const mounted = useRef(true);\n  const isMounted = useRef(() => mounted.current);\n  useEffect(() => {\n    mounted.current = true;\n    return () => {\n      mounted.current = false;\n    };\n  }, []);\n  return isMounted.current;\n}","import { useEffect, useRef } from 'react';\n\n/**\n * Store the last of some value. Tracked via a `Ref` only updating it\n * after the component renders.\n *\n * Helpful if you need to compare a prop value to it's previous value during render.\n *\n * ```ts\n * function Component(props) {\n *   const lastProps = usePrevious(props)\n *\n *   if (lastProps.foo !== props.foo)\n *     resetValueFromProps(props.foo)\n * }\n * ```\n *\n * @param value the value to track\n */\nexport default function usePrevious(value) {\n  const ref = useRef(null);\n  useEffect(() => {\n    ref.current = value;\n  });\n  return ref.current;\n}","import { useMemo, useRef } from 'react';\nimport useMounted from './useMounted';\nimport useWillUnmount from './useWillUnmount';\n\n/*\n * Browsers including Internet Explorer, Chrome, Safari, and Firefox store the\n * delay as a 32-bit signed integer internally. This causes an integer overflow\n * when using delays larger than 2,147,483,647 ms (about 24.8 days),\n * resulting in the timeout being executed immediately.\n *\n * via: https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout\n */\nconst MAX_DELAY_MS = 2 ** 31 - 1;\nfunction setChainedTimeout(handleRef, fn, timeoutAtMs) {\n  const delayMs = timeoutAtMs - Date.now();\n  handleRef.current = delayMs <= MAX_DELAY_MS ? setTimeout(fn, delayMs) : setTimeout(() => setChainedTimeout(handleRef, fn, timeoutAtMs), MAX_DELAY_MS);\n}\n\n/**\n * Returns a controller object for setting a timeout that is properly cleaned up\n * once the component unmounts. New timeouts cancel and replace existing ones.\n *\n *\n *\n * ```tsx\n * const { set, clear } = useTimeout();\n * const [hello, showHello] = useState(false);\n * //Display hello after 5 seconds\n * set(() => showHello(true), 5000);\n * return (\n *   <div className=\"App\">\n *     {hello ? <h3>Hello</h3> : null}\n *   </div>\n * );\n * ```\n */\nexport default function useTimeout() {\n  const isMounted = useMounted();\n\n  // types are confused between node and web here IDK\n  const handleRef = useRef();\n  useWillUnmount(() => clearTimeout(handleRef.current));\n  return useMemo(() => {\n    const clear = () => clearTimeout(handleRef.current);\n    function set(fn, delayMs = 0) {\n      if (!isMounted()) return;\n      clear();\n      if (delayMs <= MAX_DELAY_MS) {\n        // For simplicity, if the timeout is short, just set a normal timeout.\n        handleRef.current = setTimeout(fn, delayMs);\n      } else {\n        setChainedTimeout(handleRef, fn, Date.now() + delayMs);\n      }\n    }\n    return {\n      set,\n      clear,\n      handleRef\n    };\n  }, []);\n}","import useUpdatedRef from './useUpdatedRef';\nimport { useEffect } from 'react';\n\n/**\n * Attach a callback that fires when a component unmounts\n *\n * @param fn Handler to run when the component unmounts\n * @category effects\n */\nexport default function useWillUnmount(fn) {\n  const onUnmount = useUpdatedRef(fn);\n  useEffect(() => () => onUnmount.current(), []);\n}","import { useRef } from 'react';\n\n/**\n * Returns a ref that is immediately updated with the new value\n *\n * @param value The Ref value\n * @category refs\n */\nexport default function useUpdatedRef(value) {\n  const valueRef = useRef(value);\n  valueRef.current = value;\n  return valueRef;\n}","import { useState } from 'react';\nimport useEffect from './useIsomorphicEffect';\nconst targetMap = new WeakMap();\nlet resizeObserver;\nfunction getResizeObserver() {\n  // eslint-disable-next-line no-return-assign\n  return resizeObserver = resizeObserver || new window.ResizeObserver(entries => {\n    entries.forEach(entry => {\n      const handler = targetMap.get(entry.target);\n      if (handler) handler(entry.contentRect);\n    });\n  });\n}\n\n/**\n * Efficiently observe size changes on an element. Depends on the `ResizeObserver` api,\n * and polyfills are needed in older browsers.\n *\n * ```ts\n * const [ref, attachRef] = useCallbackRef(null);\n *\n * const rect = useResizeObserver(ref);\n *\n * return (\n *  <div ref={attachRef}>\n *    {JSON.stringify(rect)}\n *  </div>\n * )\n * ```\n *\n * @param element The DOM element to observe\n */\nexport default function useResizeObserver(element) {\n  const [rect, setRect] = useState(null);\n  useEffect(() => {\n    if (!element) return;\n    getResizeObserver().observe(element);\n    setRect(element.getBoundingClientRect());\n    targetMap.set(element, rect => {\n      setRect(rect);\n    });\n    return () => {\n      targetMap.delete(element);\n    };\n  }, [element]);\n  return rect;\n}","const _excluded = [\"onKeyDown\"];\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\n/* eslint-disable jsx-a11y/no-static-element-interactions */\n/* eslint-disable jsx-a11y/anchor-has-content */\n\nimport * as React from 'react';\nimport { useEventCallback } from '@restart/hooks';\nimport { useButtonProps } from './Button';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport function isTrivialHref(href) {\n  return !href || href.trim() === '#';\n}\n/**\n * An generic `<a>` component that covers a few A11y cases, ensuring that\n * cases where the `href` is missing or trivial like \"#\" are treated like buttons.\n */\nconst Anchor = /*#__PURE__*/React.forwardRef((_ref, ref) => {\n  let {\n      onKeyDown\n    } = _ref,\n    props = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const [buttonProps] = useButtonProps(Object.assign({\n    tagName: 'a'\n  }, props));\n  const handleKeyDown = useEventCallback(e => {\n    buttonProps.onKeyDown(e);\n    onKeyDown == null ? void 0 : onKeyDown(e);\n  });\n  if (isTrivialHref(props.href) || props.role === 'button') {\n    return /*#__PURE__*/_jsx(\"a\", Object.assign({\n      ref: ref\n    }, props, buttonProps, {\n      onKeyDown: handleKeyDown\n    }));\n  }\n  return /*#__PURE__*/_jsx(\"a\", Object.assign({\n    ref: ref\n  }, props, {\n    onKeyDown: onKeyDown\n  }));\n});\nAnchor.displayName = 'Anchor';\nexport default Anchor;","const _excluded = [\"as\", \"disabled\"];\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\nimport * as React from 'react';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport function isTrivialHref(href) {\n  return !href || href.trim() === '#';\n}\nexport function useButtonProps({\n  tagName,\n  disabled,\n  href,\n  target,\n  rel,\n  role,\n  onClick,\n  tabIndex = 0,\n  type\n}) {\n  if (!tagName) {\n    if (href != null || target != null || rel != null) {\n      tagName = 'a';\n    } else {\n      tagName = 'button';\n    }\n  }\n  const meta = {\n    tagName\n  };\n  if (tagName === 'button') {\n    return [{\n      type: type || 'button',\n      disabled\n    }, meta];\n  }\n  const handleClick = event => {\n    if (disabled || tagName === 'a' && isTrivialHref(href)) {\n      event.preventDefault();\n    }\n    if (disabled) {\n      event.stopPropagation();\n      return;\n    }\n    onClick == null ? void 0 : onClick(event);\n  };\n  const handleKeyDown = event => {\n    if (event.key === ' ') {\n      event.preventDefault();\n      handleClick(event);\n    }\n  };\n  if (tagName === 'a') {\n    // Ensure there's a href so Enter can trigger anchor button.\n    href || (href = '#');\n    if (disabled) {\n      href = undefined;\n    }\n  }\n  return [{\n    role: role != null ? role : 'button',\n    // explicitly undefined so that it overrides the props disabled in a spread\n    // e.g. <Tag {...props} {...hookProps} />\n    disabled: undefined,\n    tabIndex: disabled ? undefined : tabIndex,\n    href,\n    target: tagName === 'a' ? target : undefined,\n    'aria-disabled': !disabled ? undefined : disabled,\n    rel: tagName === 'a' ? rel : undefined,\n    onClick: handleClick,\n    onKeyDown: handleKeyDown\n  }, meta];\n}\nconst Button = /*#__PURE__*/React.forwardRef((_ref, ref) => {\n  let {\n      as: asProp,\n      disabled\n    } = _ref,\n    props = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const [buttonProps, {\n    tagName: Component\n  }] = useButtonProps(Object.assign({\n    tagName: asProp,\n    disabled\n  }, props));\n  return /*#__PURE__*/_jsx(Component, Object.assign({}, props, buttonProps, {\n    ref: ref\n  }));\n});\nButton.displayName = 'Button';\nexport default Button;","export const ATTRIBUTE_PREFIX = `data-rr-ui-`;\nexport const PROPERTY_PREFIX = `rrUi`;\nexport function dataAttr(property) {\n  return `${ATTRIBUTE_PREFIX}${property}`;\n}\nexport function dataProp(property) {\n  return `${PROPERTY_PREFIX}${property}`;\n}","import qsa from 'dom-helpers/querySelectorAll';\nimport addEventListener from 'dom-helpers/addEventListener';\nimport { useCallback, useRef, useEffect, useMemo, useContext } from 'react';\nimport * as React from 'react';\nimport { useUncontrolledProp } from 'uncontrollable';\nimport usePrevious from '@restart/hooks/usePrevious';\nimport useForceUpdate from '@restart/hooks/useForceUpdate';\nimport useEventListener from '@restart/hooks/useEventListener';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport DropdownContext from './DropdownContext';\nimport DropdownMenu from './DropdownMenu';\nimport DropdownToggle, { isRoleMenu } from './DropdownToggle';\nimport DropdownItem from './DropdownItem';\nimport SelectableContext from './SelectableContext';\nimport { dataAttr } from './DataKey';\nimport useWindow from './useWindow';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction useRefWithUpdate() {\n  const forceUpdate = useForceUpdate();\n  const ref = useRef(null);\n  const attachRef = useCallback(element => {\n    ref.current = element;\n    // ensure that a menu set triggers an update for consumers\n    forceUpdate();\n  }, [forceUpdate]);\n  return [ref, attachRef];\n}\n\n/**\n * @displayName Dropdown\n * @public\n */\nfunction Dropdown({\n  defaultShow,\n  show: rawShow,\n  onSelect,\n  onToggle: rawOnToggle,\n  itemSelector = `* [${dataAttr('dropdown-item')}]`,\n  focusFirstItemOnShow,\n  placement = 'bottom-start',\n  children\n}) {\n  const window = useWindow();\n  const [show, onToggle] = useUncontrolledProp(rawShow, defaultShow, rawOnToggle);\n\n  // We use normal refs instead of useCallbackRef in order to populate the\n  // the value as quickly as possible, otherwise the effect to focus the element\n  // may run before the state value is set\n  const [menuRef, setMenu] = useRefWithUpdate();\n  const menuElement = menuRef.current;\n  const [toggleRef, setToggle] = useRefWithUpdate();\n  const toggleElement = toggleRef.current;\n  const lastShow = usePrevious(show);\n  const lastSourceEvent = useRef(null);\n  const focusInDropdown = useRef(false);\n  const onSelectCtx = useContext(SelectableContext);\n  const toggle = useCallback((nextShow, event, source = event == null ? void 0 : event.type) => {\n    onToggle(nextShow, {\n      originalEvent: event,\n      source\n    });\n  }, [onToggle]);\n  const handleSelect = useEventCallback((key, event) => {\n    onSelect == null ? void 0 : onSelect(key, event);\n    toggle(false, event, 'select');\n    if (!event.isPropagationStopped()) {\n      onSelectCtx == null ? void 0 : onSelectCtx(key, event);\n    }\n  });\n  const context = useMemo(() => ({\n    toggle,\n    placement,\n    show,\n    menuElement,\n    toggleElement,\n    setMenu,\n    setToggle\n  }), [toggle, placement, show, menuElement, toggleElement, setMenu, setToggle]);\n  if (menuElement && lastShow && !show) {\n    focusInDropdown.current = menuElement.contains(menuElement.ownerDocument.activeElement);\n  }\n  const focusToggle = useEventCallback(() => {\n    if (toggleElement && toggleElement.focus) {\n      toggleElement.focus();\n    }\n  });\n  const maybeFocusFirst = useEventCallback(() => {\n    const type = lastSourceEvent.current;\n    let focusType = focusFirstItemOnShow;\n    if (focusType == null) {\n      focusType = menuRef.current && isRoleMenu(menuRef.current) ? 'keyboard' : false;\n    }\n    if (focusType === false || focusType === 'keyboard' && !/^key.+$/.test(type)) {\n      return;\n    }\n    const first = qsa(menuRef.current, itemSelector)[0];\n    if (first && first.focus) first.focus();\n  });\n  useEffect(() => {\n    if (show) maybeFocusFirst();else if (focusInDropdown.current) {\n      focusInDropdown.current = false;\n      focusToggle();\n    }\n    // only `show` should be changing\n  }, [show, focusInDropdown, focusToggle, maybeFocusFirst]);\n  useEffect(() => {\n    lastSourceEvent.current = null;\n  });\n  const getNextFocusedChild = (current, offset) => {\n    if (!menuRef.current) return null;\n    const items = qsa(menuRef.current, itemSelector);\n    let index = items.indexOf(current) + offset;\n    index = Math.max(0, Math.min(index, items.length));\n    return items[index];\n  };\n  useEventListener(useCallback(() => window.document, [window]), 'keydown', event => {\n    var _menuRef$current, _toggleRef$current;\n    const {\n      key\n    } = event;\n    const target = event.target;\n    const fromMenu = (_menuRef$current = menuRef.current) == null ? void 0 : _menuRef$current.contains(target);\n    const fromToggle = (_toggleRef$current = toggleRef.current) == null ? void 0 : _toggleRef$current.contains(target);\n\n    // Second only to https://github.com/twbs/bootstrap/blob/8cfbf6933b8a0146ac3fbc369f19e520bd1ebdac/js/src/dropdown.js#L400\n    // in inscrutability\n    const isInput = /input|textarea/i.test(target.tagName);\n    if (isInput && (key === ' ' || key !== 'Escape' && fromMenu || key === 'Escape' && target.type === 'search')) {\n      return;\n    }\n    if (!fromMenu && !fromToggle) {\n      return;\n    }\n    if (key === 'Tab' && (!menuRef.current || !show)) {\n      return;\n    }\n    lastSourceEvent.current = event.type;\n    const meta = {\n      originalEvent: event,\n      source: event.type\n    };\n    switch (key) {\n      case 'ArrowUp':\n        {\n          const next = getNextFocusedChild(target, -1);\n          if (next && next.focus) next.focus();\n          event.preventDefault();\n          return;\n        }\n      case 'ArrowDown':\n        event.preventDefault();\n        if (!show) {\n          onToggle(true, meta);\n        } else {\n          const next = getNextFocusedChild(target, 1);\n          if (next && next.focus) next.focus();\n        }\n        return;\n      case 'Tab':\n        // on keydown the target is the element being tabbed FROM, we need that\n        // to know if this event is relevant to this dropdown (e.g. in this menu).\n        // On `keyup` the target is the element being tagged TO which we use to check\n        // if focus has left the menu\n        addEventListener(target.ownerDocument, 'keyup', e => {\n          var _menuRef$current2;\n          if (e.key === 'Tab' && !e.target || !((_menuRef$current2 = menuRef.current) != null && _menuRef$current2.contains(e.target))) {\n            onToggle(false, meta);\n          }\n        }, {\n          once: true\n        });\n        break;\n      case 'Escape':\n        if (key === 'Escape') {\n          event.preventDefault();\n          event.stopPropagation();\n        }\n        onToggle(false, meta);\n        break;\n      default:\n    }\n  });\n  return /*#__PURE__*/_jsx(SelectableContext.Provider, {\n    value: handleSelect,\n    children: /*#__PURE__*/_jsx(DropdownContext.Provider, {\n      value: context,\n      children: children\n    })\n  });\n}\nDropdown.displayName = 'Dropdown';\nDropdown.Menu = DropdownMenu;\nDropdown.Toggle = DropdownToggle;\nDropdown.Item = DropdownItem;\nexport default Dropdown;","import * as React from 'react';\nconst DropdownContext = /*#__PURE__*/React.createContext(null);\nexport default DropdownContext;","const _excluded = [\"eventKey\", \"disabled\", \"onClick\", \"active\", \"as\"];\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\nimport * as React from 'react';\nimport { useContext } from 'react';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport SelectableContext, { makeEventKey } from './SelectableContext';\nimport NavContext from './NavContext';\nimport Button from './Button';\nimport { dataAttr } from './DataKey';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n/**\n * Create a dropdown item. Returns a set of props for the dropdown item component\n * including an `onClick` handler that prevents selection when the item is disabled\n */\nexport function useDropdownItem({\n  key,\n  href,\n  active,\n  disabled,\n  onClick\n}) {\n  const onSelectCtx = useContext(SelectableContext);\n  const navContext = useContext(NavContext);\n  const {\n    activeKey\n  } = navContext || {};\n  const eventKey = makeEventKey(key, href);\n  const isActive = active == null && key != null ? makeEventKey(activeKey) === eventKey : active;\n  const handleClick = useEventCallback(event => {\n    if (disabled) return;\n    onClick == null ? void 0 : onClick(event);\n    if (onSelectCtx && !event.isPropagationStopped()) {\n      onSelectCtx(eventKey, event);\n    }\n  });\n  return [{\n    onClick: handleClick,\n    'aria-disabled': disabled || undefined,\n    'aria-selected': isActive,\n    [dataAttr('dropdown-item')]: ''\n  }, {\n    isActive\n  }];\n}\nconst DropdownItem = /*#__PURE__*/React.forwardRef((_ref, ref) => {\n  let {\n      eventKey,\n      disabled,\n      onClick,\n      active,\n      as: Component = Button\n    } = _ref,\n    props = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const [dropdownItemProps] = useDropdownItem({\n    key: eventKey,\n    href: props.href,\n    disabled,\n    onClick,\n    active\n  });\n  return /*#__PURE__*/_jsx(Component, Object.assign({}, props, {\n    ref: ref\n  }, dropdownItemProps));\n});\nDropdownItem.displayName = 'DropdownItem';\nexport default DropdownItem;","const _excluded = [\"children\"];\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\nimport { useContext, useRef } from 'react';\nimport * as React from 'react';\nimport useCallbackRef from '@restart/hooks/useCallbackRef';\nimport DropdownContext from './DropdownContext';\nimport usePopper from './usePopper';\nimport useClickOutside from './useClickOutside';\nimport mergeOptionsWithPopperConfig from './mergeOptionsWithPopperConfig';\nimport { Fragment as _Fragment } from \"react/jsx-runtime\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst noop = () => {};\n\n/**\n * @memberOf Dropdown\n * @param {object}  options\n * @param {boolean} options.flip Automatically adjust the menu `drop` position based on viewport edge detection\n * @param {[number, number]} options.offset Define an offset distance between the Menu and the Toggle\n * @param {boolean} options.show Display the menu manually, ignored in the context of a `Dropdown`\n * @param {boolean} options.usePopper opt in/out of using PopperJS to position menus. When disabled you must position it yourself.\n * @param {string}  options.rootCloseEvent The pointer event to listen for when determining \"clicks outside\" the menu for triggering a close.\n * @param {object}  options.popperConfig Options passed to the [`usePopper`](/api/usePopper) hook.\n */\nexport function useDropdownMenu(options = {}) {\n  const context = useContext(DropdownContext);\n  const [arrowElement, attachArrowRef] = useCallbackRef();\n  const hasShownRef = useRef(false);\n  const {\n    flip,\n    offset,\n    rootCloseEvent,\n    fixed = false,\n    placement: placementOverride,\n    popperConfig = {},\n    enableEventListeners = true,\n    usePopper: shouldUsePopper = !!context\n  } = options;\n  const show = (context == null ? void 0 : context.show) == null ? !!options.show : context.show;\n  if (show && !hasShownRef.current) {\n    hasShownRef.current = true;\n  }\n  const handleClose = e => {\n    context == null ? void 0 : context.toggle(false, e);\n  };\n  const {\n    placement,\n    setMenu,\n    menuElement,\n    toggleElement\n  } = context || {};\n  const popper = usePopper(toggleElement, menuElement, mergeOptionsWithPopperConfig({\n    placement: placementOverride || placement || 'bottom-start',\n    enabled: shouldUsePopper,\n    enableEvents: enableEventListeners == null ? show : enableEventListeners,\n    offset,\n    flip,\n    fixed,\n    arrowElement,\n    popperConfig\n  }));\n  const menuProps = Object.assign({\n    ref: setMenu || noop,\n    'aria-labelledby': toggleElement == null ? void 0 : toggleElement.id\n  }, popper.attributes.popper, {\n    style: popper.styles.popper\n  });\n  const metadata = {\n    show,\n    placement,\n    hasShown: hasShownRef.current,\n    toggle: context == null ? void 0 : context.toggle,\n    popper: shouldUsePopper ? popper : null,\n    arrowProps: shouldUsePopper ? Object.assign({\n      ref: attachArrowRef\n    }, popper.attributes.arrow, {\n      style: popper.styles.arrow\n    }) : {}\n  };\n  useClickOutside(menuElement, handleClose, {\n    clickTrigger: rootCloseEvent,\n    disabled: !show\n  });\n  return [menuProps, metadata];\n}\nconst defaultProps = {\n  usePopper: true\n};\n/**\n * Also exported as `<Dropdown.Menu>` from `Dropdown`.\n *\n * @displayName DropdownMenu\n * @memberOf Dropdown\n */\nfunction DropdownMenu(_ref) {\n  let {\n      children\n    } = _ref,\n    options = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const [props, meta] = useDropdownMenu(options);\n  return /*#__PURE__*/_jsx(_Fragment, {\n    children: children(props, meta)\n  });\n}\nDropdownMenu.displayName = 'DropdownMenu';\nDropdownMenu.defaultProps = defaultProps;\n\n/** @component */\nexport default DropdownMenu;","import { useContext, useCallback } from 'react';\nimport * as React from 'react';\nimport { useSSRSafeId } from './ssr';\nimport DropdownContext from './DropdownContext';\nimport { Fragment as _Fragment } from \"react/jsx-runtime\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport const isRoleMenu = el => {\n  var _el$getAttribute;\n  return ((_el$getAttribute = el.getAttribute('role')) == null ? void 0 : _el$getAttribute.toLowerCase()) === 'menu';\n};\nconst noop = () => {};\n\n/**\n * Wires up Dropdown toggle functionality, returning a set a props to attach\n * to the element that functions as the dropdown toggle (generally a button).\n *\n * @memberOf Dropdown\n */\nexport function useDropdownToggle() {\n  const id = useSSRSafeId();\n  const {\n    show = false,\n    toggle = noop,\n    setToggle,\n    menuElement\n  } = useContext(DropdownContext) || {};\n  const handleClick = useCallback(e => {\n    toggle(!show, e);\n  }, [show, toggle]);\n  const props = {\n    id,\n    ref: setToggle || noop,\n    onClick: handleClick,\n    'aria-expanded': !!show\n  };\n\n  // This is maybe better down in an effect, but\n  // the component is going to update anyway when the menu element\n  // is set so might return new props.\n  if (menuElement && isRoleMenu(menuElement)) {\n    props['aria-haspopup'] = true;\n  }\n  return [props, {\n    show,\n    toggle\n  }];\n}\n/**\n * Also exported as `<Dropdown.Toggle>` from `Dropdown`.\n *\n * @displayName DropdownToggle\n * @memberOf Dropdown\n */\nfunction DropdownToggle({\n  children\n}) {\n  const [props, meta] = useDropdownToggle();\n  return /*#__PURE__*/_jsx(_Fragment, {\n    children: children(props, meta)\n  });\n}\nDropdownToggle.displayName = 'DropdownToggle';\n\n/** @component */\nexport default DropdownToggle;","import useMergedRefs from '@restart/hooks/useMergedRefs';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport useIsomorphicEffect from '@restart/hooks/useIsomorphicEffect';\nimport React, { useRef, cloneElement, useState } from 'react';\nimport NoopTransition from './NoopTransition';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport function useTransition({\n  in: inProp,\n  onTransition\n}) {\n  const ref = useRef(null);\n  const isInitialRef = useRef(true);\n  const handleTransition = useEventCallback(onTransition);\n  useIsomorphicEffect(() => {\n    if (!ref.current) {\n      return undefined;\n    }\n    let stale = false;\n    handleTransition({\n      in: inProp,\n      element: ref.current,\n      initial: isInitialRef.current,\n      isStale: () => stale\n    });\n    return () => {\n      stale = true;\n    };\n  }, [inProp, handleTransition]);\n  useIsomorphicEffect(() => {\n    isInitialRef.current = false;\n    // this is for strict mode\n    return () => {\n      isInitialRef.current = true;\n    };\n  }, []);\n  return ref;\n}\n/**\n * Adapts an imperative transition function to a subset of the RTG `<Transition>` component API.\n *\n * ImperativeTransition does not support mounting options or `appear` at the moment, meaning\n * that it always acts like: `mountOnEnter={true} unmountOnExit={true} appear={true}`\n */\nexport default function ImperativeTransition({\n  children,\n  in: inProp,\n  onExited,\n  onEntered,\n  transition\n}) {\n  const [exited, setExited] = useState(!inProp);\n\n  // TODO: I think this needs to be in an effect\n  if (inProp && exited) {\n    setExited(false);\n  }\n  const ref = useTransition({\n    in: !!inProp,\n    onTransition: options => {\n      const onFinish = () => {\n        if (options.isStale()) return;\n        if (options.in) {\n          onEntered == null ? void 0 : onEntered(options.element, options.initial);\n        } else {\n          setExited(true);\n          onExited == null ? void 0 : onExited(options.element);\n        }\n      };\n      Promise.resolve(transition(options)).then(onFinish, error => {\n        if (!options.in) setExited(true);\n        throw error;\n      });\n    }\n  });\n  const combinedRef = useMergedRefs(ref, children.ref);\n  return exited && !inProp ? null : /*#__PURE__*/cloneElement(children, {\n    ref: combinedRef\n  });\n}\nexport function renderTransition(Component, runTransition, props) {\n  if (Component) {\n    return /*#__PURE__*/_jsx(Component, Object.assign({}, props));\n  }\n  if (runTransition) {\n    return /*#__PURE__*/_jsx(ImperativeTransition, Object.assign({}, props, {\n      transition: runTransition\n    }));\n  }\n  return /*#__PURE__*/_jsx(NoopTransition, Object.assign({}, props));\n}","const _excluded = [\"show\", \"role\", \"className\", \"style\", \"children\", \"backdrop\", \"keyboard\", \"onBackdropClick\", \"onEscapeKeyDown\", \"transition\", \"runTransition\", \"backdropTransition\", \"runBackdropTransition\", \"autoFocus\", \"enforceFocus\", \"restoreFocus\", \"restoreFocusOptions\", \"renderDialog\", \"renderBackdrop\", \"manager\", \"container\", \"onShow\", \"onHide\", \"onExit\", \"onExited\", \"onExiting\", \"onEnter\", \"onEntering\", \"onEntered\"];\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\n/* eslint-disable @typescript-eslint/no-use-before-define, react/prop-types */\n\nimport activeElement from 'dom-helpers/activeElement';\nimport contains from 'dom-helpers/contains';\nimport canUseDOM from 'dom-helpers/canUseDOM';\nimport listen from 'dom-helpers/listen';\nimport { useState, useRef, useCallback, useImperativeHandle, forwardRef, useEffect } from 'react';\nimport * as React from 'react';\nimport ReactDOM from 'react-dom';\nimport useMounted from '@restart/hooks/useMounted';\nimport useWillUnmount from '@restart/hooks/useWillUnmount';\nimport usePrevious from '@restart/hooks/usePrevious';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport ModalManager from './ModalManager';\nimport useWaitForDOMRef from './useWaitForDOMRef';\nimport useWindow from './useWindow';\nimport { renderTransition } from './ImperativeTransition';\nimport { isEscKey } from './utils';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { Fragment as _Fragment } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\nlet manager;\nfunction getManager(window) {\n  if (!manager) manager = new ModalManager({\n    ownerDocument: window == null ? void 0 : window.document\n  });\n  return manager;\n}\nfunction useModalManager(provided) {\n  const window = useWindow();\n  const modalManager = provided || getManager(window);\n  const modal = useRef({\n    dialog: null,\n    backdrop: null\n  });\n  return Object.assign(modal.current, {\n    add: () => modalManager.add(modal.current),\n    remove: () => modalManager.remove(modal.current),\n    isTopModal: () => modalManager.isTopModal(modal.current),\n    setDialogRef: useCallback(ref => {\n      modal.current.dialog = ref;\n    }, []),\n    setBackdropRef: useCallback(ref => {\n      modal.current.backdrop = ref;\n    }, [])\n  });\n}\nconst Modal = /*#__PURE__*/forwardRef((_ref, ref) => {\n  let {\n      show = false,\n      role = 'dialog',\n      className,\n      style,\n      children,\n      backdrop = true,\n      keyboard = true,\n      onBackdropClick,\n      onEscapeKeyDown,\n      transition,\n      runTransition,\n      backdropTransition,\n      runBackdropTransition,\n      autoFocus = true,\n      enforceFocus = true,\n      restoreFocus = true,\n      restoreFocusOptions,\n      renderDialog,\n      renderBackdrop = props => /*#__PURE__*/_jsx(\"div\", Object.assign({}, props)),\n      manager: providedManager,\n      container: containerRef,\n      onShow,\n      onHide = () => {},\n      onExit,\n      onExited,\n      onExiting,\n      onEnter,\n      onEntering,\n      onEntered\n    } = _ref,\n    rest = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const ownerWindow = useWindow();\n  const container = useWaitForDOMRef(containerRef);\n  const modal = useModalManager(providedManager);\n  const isMounted = useMounted();\n  const prevShow = usePrevious(show);\n  const [exited, setExited] = useState(!show);\n  const lastFocusRef = useRef(null);\n  useImperativeHandle(ref, () => modal, [modal]);\n  if (canUseDOM && !prevShow && show) {\n    lastFocusRef.current = activeElement(ownerWindow == null ? void 0 : ownerWindow.document);\n  }\n\n  // TODO: I think this needs to be in an effect\n  if (show && exited) {\n    setExited(false);\n  }\n  const handleShow = useEventCallback(() => {\n    modal.add();\n    removeKeydownListenerRef.current = listen(document, 'keydown', handleDocumentKeyDown);\n    removeFocusListenerRef.current = listen(document, 'focus',\n    // the timeout is necessary b/c this will run before the new modal is mounted\n    // and so steals focus from it\n    () => setTimeout(handleEnforceFocus), true);\n    if (onShow) {\n      onShow();\n    }\n\n    // autofocus after onShow to not trigger a focus event for previous\n    // modals before this one is shown.\n    if (autoFocus) {\n      var _modal$dialog$ownerDo, _modal$dialog;\n      const currentActiveElement = activeElement((_modal$dialog$ownerDo = (_modal$dialog = modal.dialog) == null ? void 0 : _modal$dialog.ownerDocument) != null ? _modal$dialog$ownerDo : ownerWindow == null ? void 0 : ownerWindow.document);\n      if (modal.dialog && currentActiveElement && !contains(modal.dialog, currentActiveElement)) {\n        lastFocusRef.current = currentActiveElement;\n        modal.dialog.focus();\n      }\n    }\n  });\n  const handleHide = useEventCallback(() => {\n    modal.remove();\n    removeKeydownListenerRef.current == null ? void 0 : removeKeydownListenerRef.current();\n    removeFocusListenerRef.current == null ? void 0 : removeFocusListenerRef.current();\n    if (restoreFocus) {\n      var _lastFocusRef$current;\n      // Support: <=IE11 doesn't support `focus()` on svg elements (RB: #917)\n      (_lastFocusRef$current = lastFocusRef.current) == null ? void 0 : _lastFocusRef$current.focus == null ? void 0 : _lastFocusRef$current.focus(restoreFocusOptions);\n      lastFocusRef.current = null;\n    }\n  });\n\n  // TODO: try and combine these effects: https://github.com/react-bootstrap/react-overlays/pull/794#discussion_r409954120\n\n  // Show logic when:\n  //  - show is `true` _and_ `container` has resolved\n  useEffect(() => {\n    if (!show || !container) return;\n    handleShow();\n  }, [show, container, /* should never change: */handleShow]);\n\n  // Hide cleanup logic when:\n  //  - `exited` switches to true\n  //  - component unmounts;\n  useEffect(() => {\n    if (!exited) return;\n    handleHide();\n  }, [exited, handleHide]);\n  useWillUnmount(() => {\n    handleHide();\n  });\n\n  // --------------------------------\n\n  const handleEnforceFocus = useEventCallback(() => {\n    if (!enforceFocus || !isMounted() || !modal.isTopModal()) {\n      return;\n    }\n    const currentActiveElement = activeElement(ownerWindow == null ? void 0 : ownerWindow.document);\n    if (modal.dialog && currentActiveElement && !contains(modal.dialog, currentActiveElement)) {\n      modal.dialog.focus();\n    }\n  });\n  const handleBackdropClick = useEventCallback(e => {\n    if (e.target !== e.currentTarget) {\n      return;\n    }\n    onBackdropClick == null ? void 0 : onBackdropClick(e);\n    if (backdrop === true) {\n      onHide();\n    }\n  });\n  const handleDocumentKeyDown = useEventCallback(e => {\n    if (keyboard && isEscKey(e) && modal.isTopModal()) {\n      onEscapeKeyDown == null ? void 0 : onEscapeKeyDown(e);\n      if (!e.defaultPrevented) {\n        onHide();\n      }\n    }\n  });\n  const removeFocusListenerRef = useRef();\n  const removeKeydownListenerRef = useRef();\n  const handleHidden = (...args) => {\n    setExited(true);\n    onExited == null ? void 0 : onExited(...args);\n  };\n  if (!container) {\n    return null;\n  }\n  const dialogProps = Object.assign({\n    role,\n    ref: modal.setDialogRef,\n    // apparently only works on the dialog role element\n    'aria-modal': role === 'dialog' ? true : undefined\n  }, rest, {\n    style,\n    className,\n    tabIndex: -1\n  });\n  let dialog = renderDialog ? renderDialog(dialogProps) : /*#__PURE__*/_jsx(\"div\", Object.assign({}, dialogProps, {\n    children: /*#__PURE__*/React.cloneElement(children, {\n      role: 'document'\n    })\n  }));\n  dialog = renderTransition(transition, runTransition, {\n    unmountOnExit: true,\n    mountOnEnter: true,\n    appear: true,\n    in: !!show,\n    onExit,\n    onExiting,\n    onExited: handleHidden,\n    onEnter,\n    onEntering,\n    onEntered,\n    children: dialog\n  });\n  let backdropElement = null;\n  if (backdrop) {\n    backdropElement = renderBackdrop({\n      ref: modal.setBackdropRef,\n      onClick: handleBackdropClick\n    });\n    backdropElement = renderTransition(backdropTransition, runBackdropTransition, {\n      in: !!show,\n      appear: true,\n      mountOnEnter: true,\n      unmountOnExit: true,\n      children: backdropElement\n    });\n  }\n  return /*#__PURE__*/_jsx(_Fragment, {\n    children: /*#__PURE__*/ReactDOM.createPortal( /*#__PURE__*/_jsxs(_Fragment, {\n      children: [backdropElement, dialog]\n    }), container)\n  });\n});\nModal.displayName = 'Modal';\nexport default Object.assign(Modal, {\n  Manager: ModalManager\n});","import css from 'dom-helpers/css';\nimport { dataAttr } from './DataKey';\nimport getBodyScrollbarWidth from './getScrollbarWidth';\nexport const OPEN_DATA_ATTRIBUTE = dataAttr('modal-open');\n\n/**\n * Manages a stack of Modals as well as ensuring\n * body scrolling is is disabled and padding accounted for\n */\nclass ModalManager {\n  constructor({\n    ownerDocument,\n    handleContainerOverflow = true,\n    isRTL = false\n  } = {}) {\n    this.handleContainerOverflow = handleContainerOverflow;\n    this.isRTL = isRTL;\n    this.modals = [];\n    this.ownerDocument = ownerDocument;\n  }\n  getScrollbarWidth() {\n    return getBodyScrollbarWidth(this.ownerDocument);\n  }\n  getElement() {\n    return (this.ownerDocument || document).body;\n  }\n  setModalAttributes(_modal) {\n    // For overriding\n  }\n  removeModalAttributes(_modal) {\n    // For overriding\n  }\n  setContainerStyle(containerState) {\n    const style = {\n      overflow: 'hidden'\n    };\n\n    // we are only interested in the actual `style` here\n    // because we will override it\n    const paddingProp = this.isRTL ? 'paddingLeft' : 'paddingRight';\n    const container = this.getElement();\n    containerState.style = {\n      overflow: container.style.overflow,\n      [paddingProp]: container.style[paddingProp]\n    };\n    if (containerState.scrollBarWidth) {\n      // use computed style, here to get the real padding\n      // to add our scrollbar width\n      style[paddingProp] = `${parseInt(css(container, paddingProp) || '0', 10) + containerState.scrollBarWidth}px`;\n    }\n    container.setAttribute(OPEN_DATA_ATTRIBUTE, '');\n    css(container, style);\n  }\n  reset() {\n    [...this.modals].forEach(m => this.remove(m));\n  }\n  removeContainerStyle(containerState) {\n    const container = this.getElement();\n    container.removeAttribute(OPEN_DATA_ATTRIBUTE);\n    Object.assign(container.style, containerState.style);\n  }\n  add(modal) {\n    let modalIdx = this.modals.indexOf(modal);\n    if (modalIdx !== -1) {\n      return modalIdx;\n    }\n    modalIdx = this.modals.length;\n    this.modals.push(modal);\n    this.setModalAttributes(modal);\n    if (modalIdx !== 0) {\n      return modalIdx;\n    }\n    this.state = {\n      scrollBarWidth: this.getScrollbarWidth(),\n      style: {}\n    };\n    if (this.handleContainerOverflow) {\n      this.setContainerStyle(this.state);\n    }\n    return modalIdx;\n  }\n  remove(modal) {\n    const modalIdx = this.modals.indexOf(modal);\n    if (modalIdx === -1) {\n      return;\n    }\n    this.modals.splice(modalIdx, 1);\n\n    // if that was the last modal in a container,\n    // clean up the container\n    if (!this.modals.length && this.handleContainerOverflow) {\n      this.removeContainerStyle(this.state);\n    }\n    this.removeModalAttributes(modal);\n  }\n  isTopModal(modal) {\n    return !!this.modals.length && this.modals[this.modals.length - 1] === modal;\n  }\n}\nexport default ModalManager;","/**\n * Get the width of the vertical window scrollbar if it's visible\n */\nexport default function getBodyScrollbarWidth(ownerDocument = document) {\n  const window = ownerDocument.defaultView;\n  return Math.abs(window.innerWidth - ownerDocument.documentElement.clientWidth);\n}","const _excluded = [\"as\", \"onSelect\", \"activeKey\", \"role\", \"onKeyDown\"];\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\nimport qsa from 'dom-helpers/querySelectorAll';\nimport * as React from 'react';\nimport { useContext, useEffect, useRef } from 'react';\nimport useForceUpdate from '@restart/hooks/useForceUpdate';\nimport useMergedRefs from '@restart/hooks/useMergedRefs';\nimport NavContext from './NavContext';\nimport SelectableContext, { makeEventKey } from './SelectableContext';\nimport TabContext from './TabContext';\nimport { dataAttr, dataProp } from './DataKey';\nimport NavItem from './NavItem';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nconst noop = () => {};\nconst EVENT_KEY_ATTR = dataAttr('event-key');\nconst Nav = /*#__PURE__*/React.forwardRef((_ref, ref) => {\n  let {\n      // Need to define the default \"as\" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595\n      as: Component = 'div',\n      onSelect,\n      activeKey,\n      role,\n      onKeyDown\n    } = _ref,\n    props = _objectWithoutPropertiesLoose(_ref, _excluded);\n  // A ref and forceUpdate for refocus, b/c we only want to trigger when needed\n  // and don't want to reset the set in the effect\n  const forceUpdate = useForceUpdate();\n  const needsRefocusRef = useRef(false);\n  const parentOnSelect = useContext(SelectableContext);\n  const tabContext = useContext(TabContext);\n  let getControlledId, getControllerId;\n  if (tabContext) {\n    role = role || 'tablist';\n    activeKey = tabContext.activeKey;\n    // TODO: do we need to duplicate these?\n    getControlledId = tabContext.getControlledId;\n    getControllerId = tabContext.getControllerId;\n  }\n  const listNode = useRef(null);\n  const getNextActiveTab = offset => {\n    const currentListNode = listNode.current;\n    if (!currentListNode) return null;\n    const items = qsa(currentListNode, `[${EVENT_KEY_ATTR}]:not([aria-disabled=true])`);\n    const activeChild = currentListNode.querySelector('[aria-selected=true]');\n    if (!activeChild || activeChild !== document.activeElement) return null;\n    const index = items.indexOf(activeChild);\n    if (index === -1) return null;\n    let nextIndex = index + offset;\n    if (nextIndex >= items.length) nextIndex = 0;\n    if (nextIndex < 0) nextIndex = items.length - 1;\n    return items[nextIndex];\n  };\n  const handleSelect = (key, event) => {\n    if (key == null) return;\n    onSelect == null ? void 0 : onSelect(key, event);\n    parentOnSelect == null ? void 0 : parentOnSelect(key, event);\n  };\n  const handleKeyDown = event => {\n    onKeyDown == null ? void 0 : onKeyDown(event);\n    if (!tabContext) {\n      return;\n    }\n    let nextActiveChild;\n    switch (event.key) {\n      case 'ArrowLeft':\n      case 'ArrowUp':\n        nextActiveChild = getNextActiveTab(-1);\n        break;\n      case 'ArrowRight':\n      case 'ArrowDown':\n        nextActiveChild = getNextActiveTab(1);\n        break;\n      default:\n        return;\n    }\n    if (!nextActiveChild) return;\n    event.preventDefault();\n    handleSelect(nextActiveChild.dataset[dataProp('EventKey')] || null, event);\n    needsRefocusRef.current = true;\n    forceUpdate();\n  };\n  useEffect(() => {\n    if (listNode.current && needsRefocusRef.current) {\n      const activeChild = listNode.current.querySelector(`[${EVENT_KEY_ATTR}][aria-selected=true]`);\n      activeChild == null ? void 0 : activeChild.focus();\n    }\n    needsRefocusRef.current = false;\n  });\n  const mergedRef = useMergedRefs(ref, listNode);\n  return /*#__PURE__*/_jsx(SelectableContext.Provider, {\n    value: handleSelect,\n    children: /*#__PURE__*/_jsx(NavContext.Provider, {\n      value: {\n        role,\n        // used by NavLink to determine it's role\n        activeKey: makeEventKey(activeKey),\n        getControlledId: getControlledId || noop,\n        getControllerId: getControllerId || noop\n      },\n      children: /*#__PURE__*/_jsx(Component, Object.assign({}, props, {\n        onKeyDown: handleKeyDown,\n        ref: mergedRef,\n        role: role\n      }))\n    })\n  });\n});\nNav.displayName = 'Nav';\nexport default Object.assign(Nav, {\n  Item: NavItem\n});","import * as React from 'react';\nconst NavContext = /*#__PURE__*/React.createContext(null);\nNavContext.displayName = 'NavContext';\nexport default NavContext;","const _excluded = [\"as\", \"active\", \"eventKey\"];\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\nimport * as React from 'react';\nimport { useContext } from 'react';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport NavContext from './NavContext';\nimport SelectableContext, { makeEventKey } from './SelectableContext';\nimport Button from './Button';\nimport { dataAttr } from './DataKey';\nimport TabContext from './TabContext';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport function useNavItem({\n  key,\n  onClick,\n  active,\n  id,\n  role,\n  disabled\n}) {\n  const parentOnSelect = useContext(SelectableContext);\n  const navContext = useContext(NavContext);\n  const tabContext = useContext(TabContext);\n  let isActive = active;\n  const props = {\n    role\n  };\n  if (navContext) {\n    if (!role && navContext.role === 'tablist') props.role = 'tab';\n    const contextControllerId = navContext.getControllerId(key != null ? key : null);\n    const contextControlledId = navContext.getControlledId(key != null ? key : null);\n\n    // @ts-ignore\n    props[dataAttr('event-key')] = key;\n    props.id = contextControllerId || id;\n    isActive = active == null && key != null ? navContext.activeKey === key : active;\n\n    /**\n     * Simplified scenario for `mountOnEnter`.\n     *\n     * While it would make sense to keep 'aria-controls' for tabs that have been mounted at least\n     * once, it would also complicate the code quite a bit, for very little gain.\n     * The following implementation is probably good enough.\n     *\n     * @see https://github.com/react-restart/ui/pull/40#issuecomment-1009971561\n     */\n    if (isActive || !(tabContext != null && tabContext.unmountOnExit) && !(tabContext != null && tabContext.mountOnEnter)) props['aria-controls'] = contextControlledId;\n  }\n  if (props.role === 'tab') {\n    props['aria-selected'] = isActive;\n    if (!isActive) {\n      props.tabIndex = -1;\n    }\n    if (disabled) {\n      props.tabIndex = -1;\n      props['aria-disabled'] = true;\n    }\n  }\n  props.onClick = useEventCallback(e => {\n    if (disabled) return;\n    onClick == null ? void 0 : onClick(e);\n    if (key == null) {\n      return;\n    }\n    if (parentOnSelect && !e.isPropagationStopped()) {\n      parentOnSelect(key, e);\n    }\n  });\n  return [props, {\n    isActive\n  }];\n}\nconst NavItem = /*#__PURE__*/React.forwardRef((_ref, ref) => {\n  let {\n      as: Component = Button,\n      active,\n      eventKey\n    } = _ref,\n    options = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const [props, meta] = useNavItem(Object.assign({\n    key: makeEventKey(eventKey, options.href),\n    active\n  }, options));\n\n  // @ts-ignore\n  props[dataAttr('active')] = meta.isActive;\n  return /*#__PURE__*/_jsx(Component, Object.assign({}, options, props, {\n    ref: ref\n  }));\n});\nNavItem.displayName = 'NavItem';\nexport default NavItem;","import useEventCallback from '@restart/hooks/useEventCallback';\nimport useMergedRefs from '@restart/hooks/useMergedRefs';\nimport { cloneElement, useEffect, useRef } from 'react';\nfunction NoopTransition({\n  children,\n  in: inProp,\n  onExited,\n  mountOnEnter,\n  unmountOnExit\n}) {\n  const ref = useRef(null);\n  const hasEnteredRef = useRef(inProp);\n  const handleExited = useEventCallback(onExited);\n  useEffect(() => {\n    if (inProp) hasEnteredRef.current = true;else {\n      handleExited(ref.current);\n    }\n  }, [inProp, handleExited]);\n  const combinedRef = useMergedRefs(ref, children.ref);\n  const child = /*#__PURE__*/cloneElement(children, {\n    ref: combinedRef\n  });\n  if (inProp) return child;\n  if (unmountOnExit) {\n    return null;\n  }\n  if (!hasEnteredRef.current && mountOnEnter) {\n    return null;\n  }\n  return child;\n}\nexport default NoopTransition;","import listen from 'dom-helpers/listen';\nimport ownerDocument from 'dom-helpers/ownerDocument';\nimport { useEffect } from 'react';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport useClickOutside, { getRefTarget } from './useClickOutside';\nimport { isEscKey } from './utils';\nconst noop = () => {};\n/**\n * The `useRootClose` hook registers your callback on the document\n * when rendered. Powers the `<Overlay/>` component. This is used achieve modal\n * style behavior where your callback is triggered when the user tries to\n * interact with the rest of the document or hits the `esc` key.\n *\n * @param {Ref<HTMLElement>| HTMLElement} ref  The element boundary\n * @param {function} onRootClose\n * @param {object=}  options\n * @param {boolean=} options.disabled\n * @param {string=}  options.clickTrigger The DOM event name (click, mousedown, etc) to attach listeners on\n */\nfunction useRootClose(ref, onRootClose, {\n  disabled,\n  clickTrigger\n} = {}) {\n  const onClose = onRootClose || noop;\n  useClickOutside(ref, onClose, {\n    disabled,\n    clickTrigger\n  });\n  const handleKeyUp = useEventCallback(e => {\n    if (isEscKey(e)) {\n      onClose(e);\n    }\n  });\n  useEffect(() => {\n    if (disabled || ref == null) return undefined;\n    const doc = ownerDocument(getRefTarget(ref));\n\n    // Store the current event to avoid triggering handlers immediately\n    // https://github.com/facebook/react/issues/20074\n    let currentEvent = (doc.defaultView || window).event;\n    const removeKeyupListener = listen(doc, 'keyup', e => {\n      // skip if this event is the same as the one running when we added the handlers\n      if (e === currentEvent) {\n        currentEvent = undefined;\n        return;\n      }\n      handleKeyUp(e);\n    });\n    return () => {\n      removeKeyupListener();\n    };\n  }, [ref, disabled, handleKeyUp]);\n}\nexport default useRootClose;","import * as React from 'react';\nimport ReactDOM from 'react-dom';\nimport useCallbackRef from '@restart/hooks/useCallbackRef';\nimport useMergedRefs from '@restart/hooks/useMergedRefs';\nimport { useState } from 'react';\nimport usePopper from './usePopper';\nimport useRootClose from './useRootClose';\nimport useWaitForDOMRef from './useWaitForDOMRef';\nimport mergeOptionsWithPopperConfig from './mergeOptionsWithPopperConfig';\nimport { renderTransition } from './ImperativeTransition';\n/**\n * Built on top of `Popper.js`, the overlay component is\n * great for custom tooltip overlays.\n */\nconst Overlay = /*#__PURE__*/React.forwardRef((props, outerRef) => {\n  const {\n    flip,\n    offset,\n    placement,\n    containerPadding,\n    popperConfig = {},\n    transition: Transition,\n    runTransition\n  } = props;\n  const [rootElement, attachRef] = useCallbackRef();\n  const [arrowElement, attachArrowRef] = useCallbackRef();\n  const mergedRef = useMergedRefs(attachRef, outerRef);\n  const container = useWaitForDOMRef(props.container);\n  const target = useWaitForDOMRef(props.target);\n  const [exited, setExited] = useState(!props.show);\n  const popper = usePopper(target, rootElement, mergeOptionsWithPopperConfig({\n    placement,\n    enableEvents: !!props.show,\n    containerPadding: containerPadding || 5,\n    flip,\n    offset,\n    arrowElement,\n    popperConfig\n  }));\n\n  // TODO: I think this needs to be in an effect\n  if (props.show && exited) {\n    setExited(false);\n  }\n  const handleHidden = (...args) => {\n    setExited(true);\n    if (props.onExited) {\n      props.onExited(...args);\n    }\n  };\n\n  // Don't un-render the overlay while it's transitioning out.\n  const mountOverlay = props.show || !exited;\n  useRootClose(rootElement, props.onHide, {\n    disabled: !props.rootClose || props.rootCloseDisabled,\n    clickTrigger: props.rootCloseEvent\n  });\n  if (!mountOverlay) {\n    // Don't bother showing anything if we don't have to.\n    return null;\n  }\n  const {\n    onExit,\n    onExiting,\n    onEnter,\n    onEntering,\n    onEntered\n  } = props;\n  let child = props.children(Object.assign({}, popper.attributes.popper, {\n    style: popper.styles.popper,\n    ref: mergedRef\n  }), {\n    popper,\n    placement,\n    show: !!props.show,\n    arrowProps: Object.assign({}, popper.attributes.arrow, {\n      style: popper.styles.arrow,\n      ref: attachArrowRef\n    })\n  });\n  child = renderTransition(Transition, runTransition, {\n    in: !!props.show,\n    appear: true,\n    mountOnEnter: true,\n    unmountOnExit: true,\n    children: child,\n    onExit,\n    onExiting,\n    onExited: handleHidden,\n    onEnter,\n    onEntering,\n    onEntered\n  });\n  return container ? /*#__PURE__*/ReactDOM.createPortal(child, container) : null;\n});\nOverlay.displayName = 'Overlay';\nexport default Overlay;","import * as React from 'react';\nconst SelectableContext = /*#__PURE__*/React.createContext(null);\nexport const makeEventKey = (eventKey, href = null) => {\n  if (eventKey != null) return String(eventKey);\n  return href || null;\n};\nexport default SelectableContext;","import * as React from 'react';\nconst TabContext = /*#__PURE__*/React.createContext(null);\nexport default TabContext;","const _excluded = [\"active\", \"eventKey\", \"mountOnEnter\", \"transition\", \"unmountOnExit\", \"role\", \"onEnter\", \"onEntering\", \"onEntered\", \"onExit\", \"onExiting\", \"onExited\"],\n  _excluded2 = [\"activeKey\", \"getControlledId\", \"getControllerId\"],\n  _excluded3 = [\"as\"];\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\nimport * as React from 'react';\nimport { useContext } from 'react';\nimport TabContext from './TabContext';\nimport SelectableContext, { makeEventKey } from './SelectableContext';\nimport NoopTransition from './NoopTransition';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport function useTabPanel(_ref) {\n  let {\n      active,\n      eventKey,\n      mountOnEnter,\n      transition,\n      unmountOnExit,\n      role = 'tabpanel',\n      onEnter,\n      onEntering,\n      onEntered,\n      onExit,\n      onExiting,\n      onExited\n    } = _ref,\n    props = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const context = useContext(TabContext);\n  if (!context) return [Object.assign({}, props, {\n    role\n  }), {\n    eventKey,\n    isActive: active,\n    mountOnEnter,\n    transition,\n    unmountOnExit,\n    onEnter,\n    onEntering,\n    onEntered,\n    onExit,\n    onExiting,\n    onExited\n  }];\n  const {\n      activeKey,\n      getControlledId,\n      getControllerId\n    } = context,\n    rest = _objectWithoutPropertiesLoose(context, _excluded2);\n  const key = makeEventKey(eventKey);\n  return [Object.assign({}, props, {\n    role,\n    id: getControlledId(eventKey),\n    'aria-labelledby': getControllerId(eventKey)\n  }), {\n    eventKey,\n    isActive: active == null && key != null ? makeEventKey(activeKey) === key : active,\n    transition: transition || rest.transition,\n    mountOnEnter: mountOnEnter != null ? mountOnEnter : rest.mountOnEnter,\n    unmountOnExit: unmountOnExit != null ? unmountOnExit : rest.unmountOnExit,\n    onEnter,\n    onEntering,\n    onEntered,\n    onExit,\n    onExiting,\n    onExited\n  }];\n}\nconst TabPanel = /*#__PURE__*/React.forwardRef(\n// Need to define the default \"as\" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595\n(_ref2, ref) => {\n  let {\n      as: Component = 'div'\n    } = _ref2,\n    props = _objectWithoutPropertiesLoose(_ref2, _excluded3);\n  const [tabPanelProps, {\n    isActive,\n    onEnter,\n    onEntering,\n    onEntered,\n    onExit,\n    onExiting,\n    onExited,\n    mountOnEnter,\n    unmountOnExit,\n    transition: Transition = NoopTransition\n  }] = useTabPanel(props);\n  // We provide an empty the TabContext so `<Nav>`s in `<TabPanel>`s don't\n  // conflict with the top level one.\n  return /*#__PURE__*/_jsx(TabContext.Provider, {\n    value: null,\n    children: /*#__PURE__*/_jsx(SelectableContext.Provider, {\n      value: null,\n      children: /*#__PURE__*/_jsx(Transition, {\n        in: isActive,\n        onEnter: onEnter,\n        onEntering: onEntering,\n        onEntered: onEntered,\n        onExit: onExit,\n        onExiting: onExiting,\n        onExited: onExited,\n        mountOnEnter: mountOnEnter,\n        unmountOnExit: unmountOnExit,\n        children: /*#__PURE__*/_jsx(Component, Object.assign({}, tabPanelProps, {\n          ref: ref,\n          hidden: !isActive,\n          \"aria-hidden\": !isActive\n        }))\n      })\n    })\n  });\n});\nTabPanel.displayName = 'TabPanel';\nexport default TabPanel;","import * as React from 'react';\nimport { useMemo } from 'react';\nimport { useUncontrolledProp } from 'uncontrollable';\nimport { useSSRSafeId } from './ssr';\nimport TabContext from './TabContext';\nimport SelectableContext from './SelectableContext';\nimport TabPanel from './TabPanel';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst Tabs = props => {\n  const {\n    id: userId,\n    generateChildId: generateCustomChildId,\n    onSelect: propsOnSelect,\n    activeKey: propsActiveKey,\n    defaultActiveKey,\n    transition,\n    mountOnEnter,\n    unmountOnExit,\n    children\n  } = props;\n  const [activeKey, onSelect] = useUncontrolledProp(propsActiveKey, defaultActiveKey, propsOnSelect);\n  const id = useSSRSafeId(userId);\n  const generateChildId = useMemo(() => generateCustomChildId || ((key, type) => id ? `${id}-${type}-${key}` : null), [id, generateCustomChildId]);\n  const tabContext = useMemo(() => ({\n    onSelect,\n    activeKey,\n    transition,\n    mountOnEnter: mountOnEnter || false,\n    unmountOnExit: unmountOnExit || false,\n    getControlledId: key => generateChildId(key, 'tabpane'),\n    getControllerId: key => generateChildId(key, 'tab')\n  }), [onSelect, activeKey, transition, mountOnEnter, unmountOnExit, generateChildId]);\n  return /*#__PURE__*/_jsx(TabContext.Provider, {\n    value: tabContext,\n    children: /*#__PURE__*/_jsx(SelectableContext.Provider, {\n      value: onSelect || null,\n      children: children\n    })\n  });\n};\nTabs.Panel = TabPanel;\nexport default Tabs;","export function toModifierMap(modifiers) {\n  const result = {};\n  if (!Array.isArray(modifiers)) {\n    return modifiers || result;\n  }\n\n  // eslint-disable-next-line no-unused-expressions\n  modifiers == null ? void 0 : modifiers.forEach(m => {\n    result[m.name] = m;\n  });\n  return result;\n}\nexport function toModifierArray(map = {}) {\n  if (Array.isArray(map)) return map;\n  return Object.keys(map).map(k => {\n    map[k].name = k;\n    return map[k];\n  });\n}\nexport default function mergeOptionsWithPopperConfig({\n  enabled,\n  enableEvents,\n  placement,\n  flip,\n  offset,\n  fixed,\n  containerPadding,\n  arrowElement,\n  popperConfig = {}\n}) {\n  var _modifiers$eventListe, _modifiers$preventOve, _modifiers$preventOve2, _modifiers$offset, _modifiers$arrow;\n  const modifiers = toModifierMap(popperConfig.modifiers);\n  return Object.assign({}, popperConfig, {\n    placement,\n    enabled,\n    strategy: fixed ? 'fixed' : popperConfig.strategy,\n    modifiers: toModifierArray(Object.assign({}, modifiers, {\n      eventListeners: {\n        enabled: enableEvents,\n        options: (_modifiers$eventListe = modifiers.eventListeners) == null ? void 0 : _modifiers$eventListe.options\n      },\n      preventOverflow: Object.assign({}, modifiers.preventOverflow, {\n        options: containerPadding ? Object.assign({\n          padding: containerPadding\n        }, (_modifiers$preventOve = modifiers.preventOverflow) == null ? void 0 : _modifiers$preventOve.options) : (_modifiers$preventOve2 = modifiers.preventOverflow) == null ? void 0 : _modifiers$preventOve2.options\n      }),\n      offset: {\n        options: Object.assign({\n          offset\n        }, (_modifiers$offset = modifiers.offset) == null ? void 0 : _modifiers$offset.options)\n      },\n      arrow: Object.assign({}, modifiers.arrow, {\n        enabled: !!arrowElement,\n        options: Object.assign({}, (_modifiers$arrow = modifiers.arrow) == null ? void 0 : _modifiers$arrow.options, {\n          element: arrowElement\n        })\n      }),\n      flip: Object.assign({\n        enabled: !!flip\n      }, modifiers.flip)\n    }))\n  });\n}","import contains from 'dom-helpers/contains';\nimport listen from 'dom-helpers/listen';\nimport ownerDocument from 'dom-helpers/ownerDocument';\nimport { useCallback, useEffect, useRef } from 'react';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport warning from 'warning';\nconst noop = () => {};\nfunction isLeftClickEvent(event) {\n  return event.button === 0;\n}\nfunction isModifiedEvent(event) {\n  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\nexport const getRefTarget = ref => ref && ('current' in ref ? ref.current : ref);\nconst InitialTriggerEvents = {\n  click: 'mousedown',\n  mouseup: 'mousedown',\n  pointerup: 'pointerdown'\n};\n\n/**\n * The `useClickOutside` hook registers your callback on the document that fires\n * when a pointer event is registered outside of the provided ref or element.\n *\n * @param {Ref<HTMLElement>| HTMLElement} ref  The element boundary\n * @param {function} onClickOutside\n * @param {object=}  options\n * @param {boolean=} options.disabled\n * @param {string=}  options.clickTrigger The DOM event name (click, mousedown, etc) to attach listeners on\n */\nfunction useClickOutside(ref, onClickOutside = noop, {\n  disabled,\n  clickTrigger = 'click'\n} = {}) {\n  const preventMouseClickOutsideRef = useRef(false);\n  const waitingForTrigger = useRef(false);\n  const handleMouseCapture = useCallback(e => {\n    const currentTarget = getRefTarget(ref);\n    warning(!!currentTarget, 'ClickOutside captured a close event but does not have a ref to compare it to. ' + 'useClickOutside(), should be passed a ref that resolves to a DOM node');\n    preventMouseClickOutsideRef.current = !currentTarget || isModifiedEvent(e) || !isLeftClickEvent(e) || !!contains(currentTarget, e.target) || waitingForTrigger.current;\n    waitingForTrigger.current = false;\n  }, [ref]);\n  const handleInitialMouse = useEventCallback(e => {\n    const currentTarget = getRefTarget(ref);\n    if (currentTarget && contains(currentTarget, e.target)) {\n      waitingForTrigger.current = true;\n    }\n  });\n  const handleMouse = useEventCallback(e => {\n    if (!preventMouseClickOutsideRef.current) {\n      onClickOutside(e);\n    }\n  });\n  useEffect(() => {\n    var _ownerWindow$event, _ownerWindow$parent;\n    if (disabled || ref == null) return undefined;\n    const doc = ownerDocument(getRefTarget(ref));\n    const ownerWindow = doc.defaultView || window;\n\n    // Store the current event to avoid triggering handlers immediately\n    // For things rendered in an iframe, the event might originate on the parent window\n    // so we should fall back to that global event if the local one doesn't exist\n    // https://github.com/facebook/react/issues/20074\n    let currentEvent = (_ownerWindow$event = ownerWindow.event) != null ? _ownerWindow$event : (_ownerWindow$parent = ownerWindow.parent) == null ? void 0 : _ownerWindow$parent.event;\n    let removeInitialTriggerListener = null;\n    if (InitialTriggerEvents[clickTrigger]) {\n      removeInitialTriggerListener = listen(doc, InitialTriggerEvents[clickTrigger], handleInitialMouse, true);\n    }\n\n    // Use capture for this listener so it fires before React's listener, to\n    // avoid false positives in the contains() check below if the target DOM\n    // element is removed in the React mouse callback.\n    const removeMouseCaptureListener = listen(doc, clickTrigger, handleMouseCapture, true);\n    const removeMouseListener = listen(doc, clickTrigger, e => {\n      // skip if this event is the same as the one running when we added the handlers\n      if (e === currentEvent) {\n        currentEvent = undefined;\n        return;\n      }\n      handleMouse(e);\n    });\n    let mobileSafariHackListeners = [];\n    if ('ontouchstart' in doc.documentElement) {\n      mobileSafariHackListeners = [].slice.call(doc.body.children).map(el => listen(el, 'mousemove', noop));\n    }\n    return () => {\n      removeInitialTriggerListener == null ? void 0 : removeInitialTriggerListener();\n      removeMouseCaptureListener();\n      removeMouseListener();\n      mobileSafariHackListeners.forEach(remove => remove());\n    };\n  }, [ref, disabled, clickTrigger, handleMouseCapture, handleInitialMouse, handleMouse]);\n}\nexport default useClickOutside;","import { useCallback } from 'react';\nimport useMounted from './useMounted';\n\n/**\n * `useSafeState` takes the return value of a `useState` hook and wraps the\n * setter to prevent updates onces the component has unmounted. Can used\n * with `useMergeState` and `useStateAsync` as well\n *\n * @param state The return value of a useStateHook\n *\n * ```ts\n * const [show, setShow] = useSafeState(useState(true));\n * ```\n */\n\nfunction useSafeState(state) {\n  const isMounted = useMounted();\n  return [state[0], useCallback(nextState => {\n    if (!isMounted()) return;\n    return state[1](nextState);\n  }, [isMounted, state[1]])];\n}\nexport default useSafeState;","import arrow from '@popperjs/core/lib/modifiers/arrow';\nimport computeStyles from '@popperjs/core/lib/modifiers/computeStyles';\nimport eventListeners from '@popperjs/core/lib/modifiers/eventListeners';\nimport flip from '@popperjs/core/lib/modifiers/flip';\nimport hide from '@popperjs/core/lib/modifiers/hide';\nimport offset from '@popperjs/core/lib/modifiers/offset';\nimport popperOffsets from '@popperjs/core/lib/modifiers/popperOffsets';\nimport preventOverflow from '@popperjs/core/lib/modifiers/preventOverflow';\nimport { placements } from '@popperjs/core/lib/enums';\nimport { popperGenerator } from '@popperjs/core/lib/popper-base';\n\n// For the common JS build we will turn this file into a bundle with no imports.\n// This is b/c the Popper lib is all esm files, and would break in a common js only environment\nexport const createPopper = popperGenerator({\n  defaultModifiers: [hide, popperOffsets, computeStyles, eventListeners, offset, flip, preventOverflow, arrow]\n});\nexport { placements };","const _excluded = [\"enabled\", \"placement\", \"strategy\", \"modifiers\"];\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react';\nimport { dequal } from 'dequal';\nimport useSafeState from '@restart/hooks/useSafeState';\nimport { createPopper } from './popper';\nconst disabledApplyStylesModifier = {\n  name: 'applyStyles',\n  enabled: false,\n  phase: 'afterWrite',\n  fn: () => undefined\n};\n\n// until docjs supports type exports...\n\nconst ariaDescribedByModifier = {\n  name: 'ariaDescribedBy',\n  enabled: true,\n  phase: 'afterWrite',\n  effect: ({\n    state\n  }) => () => {\n    const {\n      reference,\n      popper\n    } = state.elements;\n    if ('removeAttribute' in reference) {\n      const ids = (reference.getAttribute('aria-describedby') || '').split(',').filter(id => id.trim() !== popper.id);\n      if (!ids.length) reference.removeAttribute('aria-describedby');else reference.setAttribute('aria-describedby', ids.join(','));\n    }\n  },\n  fn: ({\n    state\n  }) => {\n    var _popper$getAttribute;\n    const {\n      popper,\n      reference\n    } = state.elements;\n    const role = (_popper$getAttribute = popper.getAttribute('role')) == null ? void 0 : _popper$getAttribute.toLowerCase();\n    if (popper.id && role === 'tooltip' && 'setAttribute' in reference) {\n      const ids = reference.getAttribute('aria-describedby');\n      if (ids && ids.split(',').indexOf(popper.id) !== -1) {\n        return;\n      }\n      reference.setAttribute('aria-describedby', ids ? `${ids},${popper.id}` : popper.id);\n    }\n  }\n};\nconst EMPTY_MODIFIERS = [];\n/**\n * Position an element relative some reference element using Popper.js\n *\n * @param referenceElement\n * @param popperElement\n * @param {object}      options\n * @param {object=}     options.modifiers Popper.js modifiers\n * @param {boolean=}    options.enabled toggle the popper functionality on/off\n * @param {string=}     options.placement The popper element placement relative to the reference element\n * @param {string=}     options.strategy the positioning strategy\n * @param {function=}   options.onCreate called when the popper is created\n * @param {function=}   options.onUpdate called when the popper is updated\n *\n * @returns {UsePopperState} The popper state\n */\nfunction usePopper(referenceElement, popperElement, _ref = {}) {\n  let {\n      enabled = true,\n      placement = 'bottom',\n      strategy = 'absolute',\n      modifiers = EMPTY_MODIFIERS\n    } = _ref,\n    config = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const prevModifiers = useRef(modifiers);\n  const popperInstanceRef = useRef();\n  const update = useCallback(() => {\n    var _popperInstanceRef$cu;\n    (_popperInstanceRef$cu = popperInstanceRef.current) == null ? void 0 : _popperInstanceRef$cu.update();\n  }, []);\n  const forceUpdate = useCallback(() => {\n    var _popperInstanceRef$cu2;\n    (_popperInstanceRef$cu2 = popperInstanceRef.current) == null ? void 0 : _popperInstanceRef$cu2.forceUpdate();\n  }, []);\n  const [popperState, setState] = useSafeState(useState({\n    placement,\n    update,\n    forceUpdate,\n    attributes: {},\n    styles: {\n      popper: {},\n      arrow: {}\n    }\n  }));\n  const updateModifier = useMemo(() => ({\n    name: 'updateStateModifier',\n    enabled: true,\n    phase: 'write',\n    requires: ['computeStyles'],\n    fn: ({\n      state\n    }) => {\n      const styles = {};\n      const attributes = {};\n      Object.keys(state.elements).forEach(element => {\n        styles[element] = state.styles[element];\n        attributes[element] = state.attributes[element];\n      });\n      setState({\n        state,\n        styles,\n        attributes,\n        update,\n        forceUpdate,\n        placement: state.placement\n      });\n    }\n  }), [update, forceUpdate, setState]);\n  const nextModifiers = useMemo(() => {\n    if (!dequal(prevModifiers.current, modifiers)) {\n      prevModifiers.current = modifiers;\n    }\n    return prevModifiers.current;\n  }, [modifiers]);\n  useEffect(() => {\n    if (!popperInstanceRef.current || !enabled) return;\n    popperInstanceRef.current.setOptions({\n      placement,\n      strategy,\n      modifiers: [...nextModifiers, updateModifier, disabledApplyStylesModifier]\n    });\n  }, [strategy, placement, updateModifier, enabled, nextModifiers]);\n  useEffect(() => {\n    if (!enabled || referenceElement == null || popperElement == null) {\n      return undefined;\n    }\n    popperInstanceRef.current = createPopper(referenceElement, popperElement, Object.assign({}, config, {\n      placement,\n      strategy,\n      modifiers: [...nextModifiers, ariaDescribedByModifier, updateModifier]\n    }));\n    return () => {\n      if (popperInstanceRef.current != null) {\n        popperInstanceRef.current.destroy();\n        popperInstanceRef.current = undefined;\n        setState(s => Object.assign({}, s, {\n          attributes: {},\n          styles: {\n            popper: {}\n          }\n        }));\n      }\n    };\n    // This is only run once to _create_ the popper\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [enabled, referenceElement, popperElement]);\n  return popperState;\n}\nexport default usePopper;","import ownerDocument from 'dom-helpers/ownerDocument';\nimport canUseDOM from 'dom-helpers/canUseDOM';\nimport { useState, useEffect } from 'react';\nimport useWindow from './useWindow';\nexport const resolveContainerRef = (ref, document) => {\n  if (!canUseDOM) return null;\n  if (ref == null) return (document || ownerDocument()).body;\n  if (typeof ref === 'function') ref = ref();\n  if (ref && 'current' in ref) ref = ref.current;\n  if (ref && ('nodeType' in ref || ref.getBoundingClientRect)) return ref;\n  return null;\n};\nexport default function useWaitForDOMRef(ref, onResolved) {\n  const window = useWindow();\n  const [resolvedRef, setRef] = useState(() => resolveContainerRef(ref, window == null ? void 0 : window.document));\n  if (!resolvedRef) {\n    const earlyRef = resolveContainerRef(ref);\n    if (earlyRef) setRef(earlyRef);\n  }\n  useEffect(() => {\n    if (onResolved && resolvedRef) {\n      onResolved(resolvedRef);\n    }\n  }, [onResolved, resolvedRef]);\n  useEffect(() => {\n    const nextRef = resolveContainerRef(ref);\n    if (nextRef !== resolvedRef) {\n      setRef(nextRef);\n    }\n  }, [ref, resolvedRef]);\n  return resolvedRef;\n}","import { createContext, useContext } from 'react';\nimport canUseDOM from 'dom-helpers/canUseDOM';\nconst Context = /*#__PURE__*/createContext(canUseDOM ? window : undefined);\nexport const WindowProvider = Context.Provider;\n\n/**\n * The document \"window\" placed in React context. Helpful for determining\n * SSR context, or when rendering into an iframe.\n *\n * @returns the current window\n */\nexport default function useWindow() {\n  return useContext(Context);\n}","/* eslint-disable import/prefer-default-export */\nexport function isEscKey(e) {\n  return e.code === 'Escape' || e.keyCode === 27;\n}","module.exports = require('./lib/axios');","'use strict';\n\nvar utils = require('./../utils');\nvar settle = require('./../core/settle');\nvar cookies = require('./../helpers/cookies');\nvar buildURL = require('./../helpers/buildURL');\nvar buildFullPath = require('../core/buildFullPath');\nvar parseHeaders = require('./../helpers/parseHeaders');\nvar isURLSameOrigin = require('./../helpers/isURLSameOrigin');\nvar transitionalDefaults = require('../defaults/transitional');\nvar AxiosError = require('../core/AxiosError');\nvar CanceledError = require('../cancel/CanceledError');\nvar parseProtocol = require('../helpers/parseProtocol');\nvar platform = require('../platform');\n\nmodule.exports = function xhrAdapter(config) {\n  return new Promise(function dispatchXhrRequest(resolve, reject) {\n    var requestData = config.data;\n    var requestHeaders = config.headers;\n    var responseType = config.responseType;\n    var withXSRFToken = config.withXSRFToken;\n    var onCanceled;\n    function done() {\n      if (config.cancelToken) {\n        config.cancelToken.unsubscribe(onCanceled);\n      }\n\n      if (config.signal) {\n        config.signal.removeEventListener('abort', onCanceled);\n      }\n    }\n\n    if (utils.isFormData(requestData) && utils.isStandardBrowserEnv()) {\n      delete requestHeaders['Content-Type']; // Let the browser set it\n    }\n\n    var request = new XMLHttpRequest();\n\n    // HTTP basic authentication\n    if (config.auth) {\n      var username = config.auth.username || '';\n      var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';\n      requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);\n    }\n\n    var fullPath = buildFullPath(config.baseURL, config.url);\n\n    request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);\n\n    // Set the request timeout in MS\n    request.timeout = config.timeout;\n\n    function onloadend() {\n      if (!request) {\n        return;\n      }\n      // Prepare the response\n      var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;\n      var responseData = !responseType || responseType === 'text' ||  responseType === 'json' ?\n        request.responseText : request.response;\n      var response = {\n        data: responseData,\n        status: request.status,\n        statusText: request.statusText,\n        headers: responseHeaders,\n        config: config,\n        request: request\n      };\n\n      settle(function _resolve(value) {\n        resolve(value);\n        done();\n      }, function _reject(err) {\n        reject(err);\n        done();\n      }, response);\n\n      // Clean up request\n      request = null;\n    }\n\n    if ('onloadend' in request) {\n      // Use onloadend if available\n      request.onloadend = onloadend;\n    } else {\n      // Listen for ready state to emulate onloadend\n      request.onreadystatechange = function handleLoad() {\n        if (!request || request.readyState !== 4) {\n          return;\n        }\n\n        // The request errored out and we didn't get a response, this will be\n        // handled by onerror instead\n        // With one exception: request that using file: protocol, most browsers\n        // will return status as 0 even though it's a successful request\n        if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n          return;\n        }\n        // readystate handler is calling before onerror or ontimeout handlers,\n        // so we should call onloadend on the next 'tick'\n        setTimeout(onloadend);\n      };\n    }\n\n    // Handle browser request cancellation (as opposed to a manual cancellation)\n    request.onabort = function handleAbort() {\n      if (!request) {\n        return;\n      }\n\n      reject(new AxiosError('Request aborted', AxiosError.ECONNABORTED, config, request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle low level network errors\n    request.onerror = function handleError() {\n      // Real errors are hidden from us by the browser\n      // onerror should only fire if it's a network error\n      reject(new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle timeout\n    request.ontimeout = function handleTimeout() {\n      var timeoutErrorMessage = config.timeout ? 'timeout of ' + config.timeout + 'ms exceeded' : 'timeout exceeded';\n      var transitional = config.transitional || transitionalDefaults;\n      if (config.timeoutErrorMessage) {\n        timeoutErrorMessage = config.timeoutErrorMessage;\n      }\n      reject(new AxiosError(\n        timeoutErrorMessage,\n        transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,\n        config,\n        request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Add xsrf header\n    // This is only done if running in a standard browser environment.\n    // Specifically not if we're in a web worker, or react-native.\n    if (utils.isStandardBrowserEnv()) {\n      // Add xsrf header\n      withXSRFToken && utils.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(config));\n      if (withXSRFToken || (withXSRFToken !== false && isURLSameOrigin(fullPath))) {\n        // Add xsrf header\n        var xsrfValue = config.xsrfHeaderName && config.xsrfCookieName && cookies.read(config.xsrfCookieName);\n        if (xsrfValue) {\n          requestHeaders[config.xsrfHeaderName] = xsrfValue;\n        }\n      }\n    }\n\n    // Add headers to the request\n    if ('setRequestHeader' in request) {\n      utils.forEach(requestHeaders, function setRequestHeader(val, key) {\n        if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {\n          // Remove Content-Type if data is undefined\n          delete requestHeaders[key];\n        } else {\n          // Otherwise add header to the request\n          request.setRequestHeader(key, val);\n        }\n      });\n    }\n\n    // Add withCredentials to request if needed\n    if (!utils.isUndefined(config.withCredentials)) {\n      request.withCredentials = !!config.withCredentials;\n    }\n\n    // Add responseType to request if needed\n    if (responseType && responseType !== 'json') {\n      request.responseType = config.responseType;\n    }\n\n    // Handle progress if needed\n    if (typeof config.onDownloadProgress === 'function') {\n      request.addEventListener('progress', config.onDownloadProgress);\n    }\n\n    // Not all browsers support upload events\n    if (typeof config.onUploadProgress === 'function' && request.upload) {\n      request.upload.addEventListener('progress', config.onUploadProgress);\n    }\n\n    if (config.cancelToken || config.signal) {\n      // Handle cancellation\n      // eslint-disable-next-line func-names\n      onCanceled = function(cancel) {\n        if (!request) {\n          return;\n        }\n        reject(!cancel || cancel.type ? new CanceledError(null, config, request) : cancel);\n        request.abort();\n        request = null;\n      };\n\n      config.cancelToken && config.cancelToken.subscribe(onCanceled);\n      if (config.signal) {\n        config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled);\n      }\n    }\n\n    // false, 0 (zero number), and '' (empty string) are valid JSON values\n    if (!requestData && requestData !== false && requestData !== 0 && requestData !== '') {\n      requestData = null;\n    }\n\n    var protocol = parseProtocol(fullPath);\n\n    if (protocol && platform.protocols.indexOf(protocol) === -1) {\n      reject(new AxiosError('Unsupported protocol ' + protocol + ':', AxiosError.ERR_BAD_REQUEST, config));\n      return;\n    }\n\n\n    // Send the request\n    request.send(requestData);\n  });\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar bind = require('./helpers/bind');\nvar Axios = require('./core/Axios');\nvar mergeConfig = require('./core/mergeConfig');\nvar defaults = require('./defaults');\nvar formDataToJSON = require('./helpers/formDataToJSON');\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n * @return {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n  var context = new Axios(defaultConfig);\n  var instance = bind(Axios.prototype.request, context);\n\n  // Copy axios.prototype to instance\n  utils.extend(instance, Axios.prototype, context);\n\n  // Copy context to instance\n  utils.extend(instance, context);\n\n  // Factory for creating new instances\n  instance.create = function create(instanceConfig) {\n    return createInstance(mergeConfig(defaultConfig, instanceConfig));\n  };\n\n  return instance;\n}\n\n// Create the default instance to be exported\nvar axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Expose Cancel & CancelToken\naxios.CanceledError = require('./cancel/CanceledError');\naxios.CancelToken = require('./cancel/CancelToken');\naxios.isCancel = require('./cancel/isCancel');\naxios.VERSION = require('./env/data').version;\naxios.toFormData = require('./helpers/toFormData');\n\n// Expose AxiosError class\naxios.AxiosError = require('../lib/core/AxiosError');\n\n// alias for CanceledError for backward compatibility\naxios.Cancel = axios.CanceledError;\n\n// Expose all/spread\naxios.all = function all(promises) {\n  return Promise.all(promises);\n};\naxios.spread = require('./helpers/spread');\n\n// Expose isAxiosError\naxios.isAxiosError = require('./helpers/isAxiosError');\n\naxios.formToJSON = function(thing) {\n  return formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);\n};\n\nmodule.exports = axios;\n\n// Allow use of default import syntax in TypeScript\nmodule.exports.default = axios;\n","'use strict';\n\nvar CanceledError = require('./CanceledError');\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @class\n * @param {Function} executor The executor function.\n */\nfunction CancelToken(executor) {\n  if (typeof executor !== 'function') {\n    throw new TypeError('executor must be a function.');\n  }\n\n  var resolvePromise;\n\n  this.promise = new Promise(function promiseExecutor(resolve) {\n    resolvePromise = resolve;\n  });\n\n  var token = this;\n\n  // eslint-disable-next-line func-names\n  this.promise.then(function(cancel) {\n    if (!token._listeners) return;\n\n    var i = token._listeners.length;\n\n    while (i-- > 0) {\n      token._listeners[i](cancel);\n    }\n    token._listeners = null;\n  });\n\n  // eslint-disable-next-line func-names\n  this.promise.then = function(onfulfilled) {\n    var _resolve;\n    // eslint-disable-next-line func-names\n    var promise = new Promise(function(resolve) {\n      token.subscribe(resolve);\n      _resolve = resolve;\n    }).then(onfulfilled);\n\n    promise.cancel = function reject() {\n      token.unsubscribe(_resolve);\n    };\n\n    return promise;\n  };\n\n  executor(function cancel(message, config, request) {\n    if (token.reason) {\n      // Cancellation has already been requested\n      return;\n    }\n\n    token.reason = new CanceledError(message, config, request);\n    resolvePromise(token.reason);\n  });\n}\n\n/**\n * Throws a `CanceledError` if cancellation has been requested.\n */\nCancelToken.prototype.throwIfRequested = function throwIfRequested() {\n  if (this.reason) {\n    throw this.reason;\n  }\n};\n\n/**\n * Subscribe to the cancel signal\n */\n\nCancelToken.prototype.subscribe = function subscribe(listener) {\n  if (this.reason) {\n    listener(this.reason);\n    return;\n  }\n\n  if (this._listeners) {\n    this._listeners.push(listener);\n  } else {\n    this._listeners = [listener];\n  }\n};\n\n/**\n * Unsubscribe from the cancel signal\n */\n\nCancelToken.prototype.unsubscribe = function unsubscribe(listener) {\n  if (!this._listeners) {\n    return;\n  }\n  var index = this._listeners.indexOf(listener);\n  if (index !== -1) {\n    this._listeners.splice(index, 1);\n  }\n};\n\n/**\n * Returns an object that contains a new `CancelToken` and a function that, when called,\n * cancels the `CancelToken`.\n */\nCancelToken.source = function source() {\n  var cancel;\n  var token = new CancelToken(function executor(c) {\n    cancel = c;\n  });\n  return {\n    token: token,\n    cancel: cancel\n  };\n};\n\nmodule.exports = CancelToken;\n","'use strict';\n\nvar AxiosError = require('../core/AxiosError');\nvar utils = require('../utils');\n\n/**\n * A `CanceledError` is an object that is thrown when an operation is canceled.\n *\n * @class\n * @param {string=} message The message.\n * @param {Object=} config The config.\n * @param {Object=} request The request.\n */\nfunction CanceledError(message, config, request) {\n  // eslint-disable-next-line no-eq-null,eqeqeq\n  AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);\n  this.name = 'CanceledError';\n}\n\nutils.inherits(CanceledError, AxiosError, {\n  __CANCEL__: true\n});\n\nmodule.exports = CanceledError;\n","'use strict';\n\nmodule.exports = function isCancel(value) {\n  return !!(value && value.__CANCEL__);\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar buildURL = require('../helpers/buildURL');\nvar InterceptorManager = require('./InterceptorManager');\nvar dispatchRequest = require('./dispatchRequest');\nvar mergeConfig = require('./mergeConfig');\nvar buildFullPath = require('./buildFullPath');\nvar validator = require('../helpers/validator');\n\nvar validators = validator.validators;\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n */\nfunction Axios(instanceConfig) {\n  this.defaults = instanceConfig;\n  this.interceptors = {\n    request: new InterceptorManager(),\n    response: new InterceptorManager()\n  };\n}\n\n/**\n * Dispatch a request\n *\n * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)\n * @param {?Object} config\n */\nAxios.prototype.request = function request(configOrUrl, config) {\n  /*eslint no-param-reassign:0*/\n  // Allow for axios('example/url'[, config]) a la fetch API\n  if (typeof configOrUrl === 'string') {\n    config = config || {};\n    config.url = configOrUrl;\n  } else {\n    config = configOrUrl || {};\n  }\n\n  config = mergeConfig(this.defaults, config);\n\n  // Set config.method\n  if (config.method) {\n    config.method = config.method.toLowerCase();\n  } else if (this.defaults.method) {\n    config.method = this.defaults.method.toLowerCase();\n  } else {\n    config.method = 'get';\n  }\n\n  var transitional = config.transitional;\n\n  if (transitional !== undefined) {\n    validator.assertOptions(transitional, {\n      silentJSONParsing: validators.transitional(validators.boolean),\n      forcedJSONParsing: validators.transitional(validators.boolean),\n      clarifyTimeoutError: validators.transitional(validators.boolean)\n    }, false);\n  }\n\n  var paramsSerializer = config.paramsSerializer;\n\n  if (paramsSerializer !== undefined) {\n    validator.assertOptions(paramsSerializer, {\n      encode: validators.function,\n      serialize: validators.function\n    }, true);\n  }\n\n  utils.isFunction(paramsSerializer) && (config.paramsSerializer = {serialize: paramsSerializer});\n\n  // filter out skipped interceptors\n  var requestInterceptorChain = [];\n  var synchronousRequestInterceptors = true;\n  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n    if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {\n      return;\n    }\n\n    synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;\n\n    requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);\n  });\n\n  var responseInterceptorChain = [];\n  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n    responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);\n  });\n\n  var promise;\n\n  if (!synchronousRequestInterceptors) {\n    var chain = [dispatchRequest, undefined];\n\n    Array.prototype.unshift.apply(chain, requestInterceptorChain);\n    chain = chain.concat(responseInterceptorChain);\n\n    promise = Promise.resolve(config);\n    while (chain.length) {\n      promise = promise.then(chain.shift(), chain.shift());\n    }\n\n    return promise;\n  }\n\n\n  var newConfig = config;\n  while (requestInterceptorChain.length) {\n    var onFulfilled = requestInterceptorChain.shift();\n    var onRejected = requestInterceptorChain.shift();\n    try {\n      newConfig = onFulfilled(newConfig);\n    } catch (error) {\n      onRejected(error);\n      break;\n    }\n  }\n\n  try {\n    promise = dispatchRequest(newConfig);\n  } catch (error) {\n    return Promise.reject(error);\n  }\n\n  while (responseInterceptorChain.length) {\n    promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());\n  }\n\n  return promise;\n};\n\nAxios.prototype.getUri = function getUri(config) {\n  config = mergeConfig(this.defaults, config);\n  var fullPath = buildFullPath(config.baseURL, config.url);\n  return buildURL(fullPath, config.params, config.paramsSerializer);\n};\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function(url, config) {\n    return this.request(mergeConfig(config || {}, {\n      method: method,\n      url: url,\n      data: (config || {}).data\n    }));\n  };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  /*eslint func-names:0*/\n\n  function generateHTTPMethod(isForm) {\n    return function httpMethod(url, data, config) {\n      return this.request(mergeConfig(config || {}, {\n        method: method,\n        headers: isForm ? {\n          'Content-Type': 'multipart/form-data'\n        } : {},\n        url: url,\n        data: data\n      }));\n    };\n  }\n\n  Axios.prototype[method] = generateHTTPMethod();\n\n  Axios.prototype[method + 'Form'] = generateHTTPMethod(true);\n});\n\nmodule.exports = Axios;\n","'use strict';\n\nvar utils = require('../utils');\n\n/**\n * Create an Error with the specified message, config, error code, request and response.\n *\n * @param {string} message The error message.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n * @param {Object} [config] The config.\n * @param {Object} [request] The request.\n * @param {Object} [response] The response.\n * @returns {Error} The created error.\n */\nfunction AxiosError(message, code, config, request, response) {\n  Error.call(this);\n\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, this.constructor);\n  } else {\n    this.stack = (new Error()).stack;\n  }\n\n  this.message = message;\n  this.name = 'AxiosError';\n  code && (this.code = code);\n  config && (this.config = config);\n  request && (this.request = request);\n  response && (this.response = response);\n}\n\nutils.inherits(AxiosError, Error, {\n  toJSON: function toJSON() {\n    return {\n      // Standard\n      message: this.message,\n      name: this.name,\n      // Microsoft\n      description: this.description,\n      number: this.number,\n      // Mozilla\n      fileName: this.fileName,\n      lineNumber: this.lineNumber,\n      columnNumber: this.columnNumber,\n      stack: this.stack,\n      // Axios\n      config: this.config,\n      code: this.code,\n      status: this.response && this.response.status ? this.response.status : null\n    };\n  }\n});\n\nvar prototype = AxiosError.prototype;\nvar descriptors = {};\n\n[\n  'ERR_BAD_OPTION_VALUE',\n  'ERR_BAD_OPTION',\n  'ECONNABORTED',\n  'ETIMEDOUT',\n  'ERR_NETWORK',\n  'ERR_FR_TOO_MANY_REDIRECTS',\n  'ERR_DEPRECATED',\n  'ERR_BAD_RESPONSE',\n  'ERR_BAD_REQUEST',\n  'ERR_CANCELED',\n  'ERR_NOT_SUPPORT',\n  'ERR_INVALID_URL'\n// eslint-disable-next-line func-names\n].forEach(function(code) {\n  descriptors[code] = {value: code};\n});\n\nObject.defineProperties(AxiosError, descriptors);\nObject.defineProperty(prototype, 'isAxiosError', {value: true});\n\n// eslint-disable-next-line func-names\nAxiosError.from = function(error, code, config, request, response, customProps) {\n  var axiosError = Object.create(prototype);\n\n  utils.toFlatObject(error, axiosError, function filter(obj) {\n    return obj !== Error.prototype;\n  });\n\n  AxiosError.call(axiosError, error.message, code, config, request, response);\n\n  axiosError.cause = error;\n\n  axiosError.name = error.name;\n\n  customProps && Object.assign(axiosError, customProps);\n\n  return axiosError;\n};\n\nmodule.exports = AxiosError;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction InterceptorManager() {\n  this.handlers = [];\n}\n\n/**\n * Add a new interceptor to the stack\n *\n * @param {Function} fulfilled The function to handle `then` for a `Promise`\n * @param {Function} rejected The function to handle `reject` for a `Promise`\n *\n * @return {Number} An ID used to remove interceptor later\n */\nInterceptorManager.prototype.use = function use(fulfilled, rejected, options) {\n  this.handlers.push({\n    fulfilled: fulfilled,\n    rejected: rejected,\n    synchronous: options ? options.synchronous : false,\n    runWhen: options ? options.runWhen : null\n  });\n  return this.handlers.length - 1;\n};\n\n/**\n * Remove an interceptor from the stack\n *\n * @param {Number} id The ID that was returned by `use`\n */\nInterceptorManager.prototype.eject = function eject(id) {\n  if (this.handlers[id]) {\n    this.handlers[id] = null;\n  }\n};\n\n/**\n * Clear all interceptors from the stack\n */\nInterceptorManager.prototype.clear = function clear() {\n  if (this.handlers) {\n    this.handlers = [];\n  }\n};\n\n/**\n * Iterate over all the registered interceptors\n *\n * This method is particularly useful for skipping over any\n * interceptors that may have become `null` calling `eject`.\n *\n * @param {Function} fn The function to call for each interceptor\n */\nInterceptorManager.prototype.forEach = function forEach(fn) {\n  utils.forEach(this.handlers, function forEachHandler(h) {\n    if (h !== null) {\n      fn(h);\n    }\n  });\n};\n\nmodule.exports = InterceptorManager;\n","'use strict';\n\nvar isAbsoluteURL = require('../helpers/isAbsoluteURL');\nvar combineURLs = require('../helpers/combineURLs');\n\n/**\n * Creates a new URL by combining the baseURL with the requestedURL,\n * only when the requestedURL is not already an absolute URL.\n * If the requestURL is absolute, this function returns the requestedURL untouched.\n *\n * @param {string} baseURL The base URL\n * @param {string} requestedURL Absolute or relative URL to combine\n * @returns {string} The combined full path\n */\nmodule.exports = function buildFullPath(baseURL, requestedURL) {\n  if (baseURL && !isAbsoluteURL(requestedURL)) {\n    return combineURLs(baseURL, requestedURL);\n  }\n  return requestedURL;\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar transformData = require('./transformData');\nvar isCancel = require('../cancel/isCancel');\nvar defaults = require('../defaults');\nvar CanceledError = require('../cancel/CanceledError');\nvar normalizeHeaderName = require('../helpers/normalizeHeaderName');\n\n/**\n * Throws a `CanceledError` if cancellation has been requested.\n */\nfunction throwIfCancellationRequested(config) {\n  if (config.cancelToken) {\n    config.cancelToken.throwIfRequested();\n  }\n\n  if (config.signal && config.signal.aborted) {\n    throw new CanceledError();\n  }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n * @returns {Promise} The Promise to be fulfilled\n */\nmodule.exports = function dispatchRequest(config) {\n  throwIfCancellationRequested(config);\n\n  // Ensure headers exist\n  config.headers = config.headers || {};\n\n  // Transform request data\n  config.data = transformData.call(\n    config,\n    config.data,\n    config.headers,\n    null,\n    config.transformRequest\n  );\n\n  normalizeHeaderName(config.headers, 'Accept');\n  normalizeHeaderName(config.headers, 'Content-Type');\n\n  // Flatten headers\n  config.headers = utils.merge(\n    config.headers.common || {},\n    config.headers[config.method] || {},\n    config.headers\n  );\n\n  utils.forEach(\n    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n    function cleanHeaderConfig(method) {\n      delete config.headers[method];\n    }\n  );\n\n  var adapter = config.adapter || defaults.adapter;\n\n  return adapter(config).then(function onAdapterResolution(response) {\n    throwIfCancellationRequested(config);\n\n    // Transform response data\n    response.data = transformData.call(\n      config,\n      response.data,\n      response.headers,\n      response.status,\n      config.transformResponse\n    );\n\n    return response;\n  }, function onAdapterRejection(reason) {\n    if (!isCancel(reason)) {\n      throwIfCancellationRequested(config);\n\n      // Transform response data\n      if (reason && reason.response) {\n        reason.response.data = transformData.call(\n          config,\n          reason.response.data,\n          reason.response.headers,\n          reason.response.status,\n          config.transformResponse\n        );\n      }\n    }\n\n    return Promise.reject(reason);\n  });\n};\n","'use strict';\n\nvar utils = require('../utils');\n\n/**\n * Config-specific merge-function which creates a new config-object\n * by merging two configuration objects together.\n *\n * @param {Object} config1\n * @param {Object} config2\n * @returns {Object} New object resulting from merging config2 to config1\n */\nmodule.exports = function mergeConfig(config1, config2) {\n  // eslint-disable-next-line no-param-reassign\n  config2 = config2 || {};\n  var config = {};\n\n  function getMergedValue(target, source) {\n    if (utils.isPlainObject(target) && utils.isPlainObject(source)) {\n      return utils.merge(target, source);\n    } else if (utils.isEmptyObject(source)) {\n      return utils.merge({}, target);\n    } else if (utils.isPlainObject(source)) {\n      return utils.merge({}, source);\n    } else if (utils.isArray(source)) {\n      return source.slice();\n    }\n    return source;\n  }\n\n  // eslint-disable-next-line consistent-return\n  function mergeDeepProperties(prop) {\n    if (!utils.isUndefined(config2[prop])) {\n      return getMergedValue(config1[prop], config2[prop]);\n    } else if (!utils.isUndefined(config1[prop])) {\n      return getMergedValue(undefined, config1[prop]);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function valueFromConfig2(prop) {\n    if (!utils.isUndefined(config2[prop])) {\n      return getMergedValue(undefined, config2[prop]);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function defaultToConfig2(prop) {\n    if (!utils.isUndefined(config2[prop])) {\n      return getMergedValue(undefined, config2[prop]);\n    } else if (!utils.isUndefined(config1[prop])) {\n      return getMergedValue(undefined, config1[prop]);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function mergeDirectKeys(prop) {\n    if (prop in config2) {\n      return getMergedValue(config1[prop], config2[prop]);\n    } else if (prop in config1) {\n      return getMergedValue(undefined, config1[prop]);\n    }\n  }\n\n  var mergeMap = {\n    'url': valueFromConfig2,\n    'method': valueFromConfig2,\n    'data': valueFromConfig2,\n    'baseURL': defaultToConfig2,\n    'transformRequest': defaultToConfig2,\n    'transformResponse': defaultToConfig2,\n    'paramsSerializer': defaultToConfig2,\n    'timeout': defaultToConfig2,\n    'timeoutMessage': defaultToConfig2,\n    'withCredentials': defaultToConfig2,\n    'withXSRFToken': defaultToConfig2,\n    'adapter': defaultToConfig2,\n    'responseType': defaultToConfig2,\n    'xsrfCookieName': defaultToConfig2,\n    'xsrfHeaderName': defaultToConfig2,\n    'onUploadProgress': defaultToConfig2,\n    'onDownloadProgress': defaultToConfig2,\n    'decompress': defaultToConfig2,\n    'maxContentLength': defaultToConfig2,\n    'maxBodyLength': defaultToConfig2,\n    'beforeRedirect': defaultToConfig2,\n    'transport': defaultToConfig2,\n    'httpAgent': defaultToConfig2,\n    'httpsAgent': defaultToConfig2,\n    'cancelToken': defaultToConfig2,\n    'socketPath': defaultToConfig2,\n    'responseEncoding': defaultToConfig2,\n    'validateStatus': mergeDirectKeys\n  };\n\n  utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {\n    var merge = mergeMap[prop] || mergeDeepProperties;\n    var configValue = merge(prop);\n    (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);\n  });\n\n  return config;\n};\n","'use strict';\n\nvar AxiosError = require('./AxiosError');\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n */\nmodule.exports = function settle(resolve, reject, response) {\n  var validateStatus = response.config.validateStatus;\n  if (!response.status || !validateStatus || validateStatus(response.status)) {\n    resolve(response);\n  } else {\n    reject(new AxiosError(\n      'Request failed with status code ' + response.status,\n      [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],\n      response.config,\n      response.request,\n      response\n    ));\n  }\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar defaults = require('../defaults');\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Object|String} data The data to be transformed\n * @param {Array} headers The headers for the request or response\n * @param {Number} status HTTP status code\n * @param {Array|Function} fns A single function or Array of functions\n * @returns {*} The resulting transformed data\n */\nmodule.exports = function transformData(data, headers, status, fns) {\n  var context = this || defaults;\n  /*eslint no-param-reassign:0*/\n  utils.forEach(fns, function transform(fn) {\n    data = fn.call(context, data, headers, status);\n  });\n\n  return data;\n};\n","'use strict';\n\nvar utils = require('../utils');\nvar normalizeHeaderName = require('../helpers/normalizeHeaderName');\nvar AxiosError = require('../core/AxiosError');\nvar transitionalDefaults = require('./transitional');\nvar toFormData = require('../helpers/toFormData');\nvar toURLEncodedForm = require('../helpers/toURLEncodedForm');\nvar platform = require('../platform');\nvar formDataToJSON = require('../helpers/formDataToJSON');\n\nvar DEFAULT_CONTENT_TYPE = {\n  'Content-Type': 'application/x-www-form-urlencoded'\n};\n\nfunction setContentTypeIfUnset(headers, value) {\n  if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {\n    headers['Content-Type'] = value;\n  }\n}\n\nfunction getDefaultAdapter() {\n  var adapter;\n  if (typeof XMLHttpRequest !== 'undefined') {\n    // For browsers use XHR adapter\n    adapter = require('../adapters/xhr');\n  } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {\n    // For node use HTTP adapter\n    adapter = require('../adapters/http');\n  }\n  return adapter;\n}\n\nfunction stringifySafely(rawValue, parser, encoder) {\n  if (utils.isString(rawValue)) {\n    try {\n      (parser || JSON.parse)(rawValue);\n      return utils.trim(rawValue);\n    } catch (e) {\n      if (e.name !== 'SyntaxError') {\n        throw e;\n      }\n    }\n  }\n\n  return (encoder || JSON.stringify)(rawValue);\n}\n\nvar defaults = {\n\n  transitional: transitionalDefaults,\n\n  adapter: getDefaultAdapter(),\n\n  transformRequest: [function transformRequest(data, headers) {\n    normalizeHeaderName(headers, 'Accept');\n    normalizeHeaderName(headers, 'Content-Type');\n\n    var contentType = headers && headers['Content-Type'] || '';\n    var hasJSONContentType = contentType.indexOf('application/json') > -1;\n    var isObjectPayload = utils.isObject(data);\n\n    if (isObjectPayload && utils.isHTMLForm(data)) {\n      data = new FormData(data);\n    }\n\n    var isFormData = utils.isFormData(data);\n\n    if (isFormData) {\n      return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;\n    }\n\n    if (utils.isArrayBuffer(data) ||\n      utils.isBuffer(data) ||\n      utils.isStream(data) ||\n      utils.isFile(data) ||\n      utils.isBlob(data)\n    ) {\n      return data;\n    }\n    if (utils.isArrayBufferView(data)) {\n      return data.buffer;\n    }\n    if (utils.isURLSearchParams(data)) {\n      setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');\n      return data.toString();\n    }\n\n    var isFileList;\n\n    if (isObjectPayload) {\n      if (contentType.indexOf('application/x-www-form-urlencoded') !== -1) {\n        return toURLEncodedForm(data, this.formSerializer).toString();\n      }\n\n      if ((isFileList = utils.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {\n        var _FormData = this.env && this.env.FormData;\n\n        return toFormData(\n          isFileList ? {'files[]': data} : data,\n          _FormData && new _FormData(),\n          this.formSerializer\n        );\n      }\n    }\n\n    if (isObjectPayload || hasJSONContentType ) {\n      setContentTypeIfUnset(headers, 'application/json');\n      return stringifySafely(data);\n    }\n\n    return data;\n  }],\n\n  transformResponse: [function transformResponse(data) {\n    var transitional = this.transitional || defaults.transitional;\n    var forcedJSONParsing = transitional && transitional.forcedJSONParsing;\n    var JSONRequested = this.responseType === 'json';\n\n    if (data && utils.isString(data) && ((forcedJSONParsing && !this.responseType) || JSONRequested)) {\n      var silentJSONParsing = transitional && transitional.silentJSONParsing;\n      var strictJSONParsing = !silentJSONParsing && JSONRequested;\n\n      try {\n        return JSON.parse(data);\n      } catch (e) {\n        if (strictJSONParsing) {\n          if (e.name === 'SyntaxError') {\n            throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);\n          }\n          throw e;\n        }\n      }\n    }\n\n    return data;\n  }],\n\n  /**\n   * A timeout in milliseconds to abort a request. If set to 0 (default) a\n   * timeout is not created.\n   */\n  timeout: 0,\n\n  xsrfCookieName: 'XSRF-TOKEN',\n  xsrfHeaderName: 'X-XSRF-TOKEN',\n\n  maxContentLength: -1,\n  maxBodyLength: -1,\n\n  env: {\n    FormData: platform.classes.FormData,\n    Blob: platform.classes.Blob\n  },\n\n  validateStatus: function validateStatus(status) {\n    return status >= 200 && status < 300;\n  },\n\n  headers: {\n    common: {\n      'Accept': 'application/json, text/plain, */*'\n    }\n  }\n};\n\nutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n  defaults.headers[method] = {};\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);\n});\n\nmodule.exports = defaults;\n","'use strict';\n\nmodule.exports = {\n  silentJSONParsing: true,\n  forcedJSONParsing: true,\n  clarifyTimeoutError: false\n};\n","// eslint-disable-next-line strict\nmodule.exports = require('form-data');\n","module.exports = {\n  \"version\": \"0.28.1\"\n};","'use strict';\n\nvar toFormData = require('./toFormData');\n\nfunction encode(str) {\n  var charMap = {\n    '!': '%21',\n    \"'\": '%27',\n    '(': '%28',\n    ')': '%29',\n    '~': '%7E',\n    '%20': '+',\n    '%00': '\\x00'\n  };\n  return encodeURIComponent(str).replace(/[!'\\(\\)~]|%20|%00/g, function replacer(match) {\n    return charMap[match];\n  });\n}\n\nfunction AxiosURLSearchParams(params, options) {\n  this._pairs = [];\n\n  params && toFormData(params, this, options);\n}\n\nvar prototype = AxiosURLSearchParams.prototype;\n\nprototype.append = function append(name, value) {\n  this._pairs.push([name, value]);\n};\n\nprototype.toString = function toString(encoder) {\n  var _encode = encoder ? function(value) {\n    return encoder.call(this, value, encode);\n  } : encode;\n\n  return this._pairs.map(function each(pair) {\n    return _encode(pair[0]) + '=' + _encode(pair[1]);\n  }, '').join('&');\n};\n\nmodule.exports = AxiosURLSearchParams;\n","'use strict';\n\nmodule.exports = function bind(fn, thisArg) {\n  return function wrap() {\n    return fn.apply(thisArg, arguments);\n  };\n};\n","'use strict';\n\nvar utils = require('../utils');\nvar AxiosURLSearchParams = require('../helpers/AxiosURLSearchParams');\n\nfunction encode(val) {\n  return encodeURIComponent(val).\n    replace(/%3A/gi, ':').\n    replace(/%24/g, '$').\n    replace(/%2C/gi, ',').\n    replace(/%20/g, '+').\n    replace(/%5B/gi, '[').\n    replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @param {?object} options\n * @returns {string} The formatted url\n */\nmodule.exports = function buildURL(url, params, options) {\n  /*eslint no-param-reassign:0*/\n  if (!params) {\n    return url;\n  }\n\n  var hashmarkIndex = url.indexOf('#');\n\n  if (hashmarkIndex !== -1) {\n    url = url.slice(0, hashmarkIndex);\n  }\n\n  var _encode = options && options.encode || encode;\n\n  var serializeFn = options && options.serialize;\n\n  var serializedParams;\n\n  if (serializeFn) {\n    serializedParams = serializeFn(params, options);\n  } else {\n    serializedParams = utils.isURLSearchParams(params) ?\n      params.toString() :\n      new AxiosURLSearchParams(params, options).toString(_encode);\n  }\n\n  if (serializedParams) {\n    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n  }\n\n  return url;\n};\n","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n * @returns {string} The combined URL\n */\nmodule.exports = function combineURLs(baseURL, relativeURL) {\n  return relativeURL\n    ? baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '')\n    : baseURL;\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n  utils.isStandardBrowserEnv() ?\n\n  // Standard browser envs support document.cookie\n    (function standardBrowserEnv() {\n      return {\n        write: function write(name, value, expires, path, domain, secure) {\n          var cookie = [];\n          cookie.push(name + '=' + encodeURIComponent(value));\n\n          if (utils.isNumber(expires)) {\n            cookie.push('expires=' + new Date(expires).toGMTString());\n          }\n\n          if (utils.isString(path)) {\n            cookie.push('path=' + path);\n          }\n\n          if (utils.isString(domain)) {\n            cookie.push('domain=' + domain);\n          }\n\n          if (secure === true) {\n            cookie.push('secure');\n          }\n\n          document.cookie = cookie.join('; ');\n        },\n\n        read: function read(name) {\n          var match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n          return (match ? decodeURIComponent(match[3]) : null);\n        },\n\n        remove: function remove(name) {\n          this.write(name, '', Date.now() - 86400000);\n        }\n      };\n    })() :\n\n  // Non standard browser env (web workers, react-native) lack needed support.\n    (function nonStandardBrowserEnv() {\n      return {\n        write: function write() {},\n        read: function read() { return null; },\n        remove: function remove() {}\n      };\n    })()\n);\n","'use strict';\n\nvar utils = require('../utils');\n\nfunction parsePropPath(name) {\n  // foo[x][y][z]\n  // foo.x.y.z\n  // foo-x-y-z\n  // foo x y z\n  return utils.matchAll(/\\w+|\\[(\\w*)]/g, name).map(function(match) {\n    return match[0] === '[]' ? '' : match[1] || match[0];\n  });\n}\n\nfunction arrayToObject(arr) {\n  var obj = {};\n  var keys = Object.keys(arr);\n  var i;\n  var len = keys.length;\n  var key;\n  for (i = 0; i < len; i++) {\n    key = keys[i];\n    obj[key] = arr[key];\n  }\n  return obj;\n}\n\nfunction formDataToJSON(formData) {\n  function buildPath(path, value, target, index) {\n    var name = path[index++];\n    var isNumericKey = Number.isFinite(+name);\n    var isLast = index >= path.length;\n    name = !name && utils.isArray(target) ? target.length : name;\n\n    if (isLast) {\n      if (utils.hasOwnProperty(target, name)) {\n        target[name] = [target[name], value];\n      } else {\n        target[name] = value;\n      }\n\n      return !isNumericKey;\n    }\n\n    if (!target[name] || !utils.isObject(target[name])) {\n      target[name] = [];\n    }\n\n    var result = buildPath(path, value, target[name], index);\n\n    if (result && utils.isArray(target[name])) {\n      target[name] = arrayToObject(target[name]);\n    }\n\n    return !isNumericKey;\n  }\n\n  if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {\n    var obj = {};\n\n    utils.forEachEntry(formData, function(name, value) {\n      buildPath(parsePropPath(name), value, obj, 0);\n    });\n\n    return obj;\n  }\n\n  return null;\n}\n\nmodule.exports = formDataToJSON;\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nmodule.exports = function isAbsoluteURL(url) {\n  // A URL is considered absolute if it begins with \"<scheme>://\" or \"//\" (protocol-relative URL).\n  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n  // by any combination of letters, digits, plus, period, or hyphen.\n  return /^([a-z][a-z\\d+\\-.]*:)?\\/\\//i.test(url);\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Determines whether the payload is an error thrown by Axios\n *\n * @param {*} payload The value to test\n * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false\n */\nmodule.exports = function isAxiosError(payload) {\n  return utils.isObject(payload) && (payload.isAxiosError === true);\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n  utils.isStandardBrowserEnv() ?\n\n  // Standard browser envs have full support of the APIs needed to test\n  // whether the request URL is of the same origin as current location.\n    (function standardBrowserEnv() {\n      var msie = /(msie|trident)/i.test(navigator.userAgent);\n      var urlParsingNode = document.createElement('a');\n      var originURL;\n\n      /**\n      * Parse a URL to discover it's components\n      *\n      * @param {String} url The URL to be parsed\n      * @returns {Object}\n      */\n      function resolveURL(url) {\n        var href = url;\n\n        if (msie) {\n          // IE needs attribute set twice to normalize properties\n          urlParsingNode.setAttribute('href', href);\n          href = urlParsingNode.href;\n        }\n\n        urlParsingNode.setAttribute('href', href);\n\n        // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n        return {\n          href: urlParsingNode.href,\n          protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n          host: urlParsingNode.host,\n          search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n          hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n          hostname: urlParsingNode.hostname,\n          port: urlParsingNode.port,\n          pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n            urlParsingNode.pathname :\n            '/' + urlParsingNode.pathname\n        };\n      }\n\n      originURL = resolveURL(window.location.href);\n\n      /**\n      * Determine if a URL shares the same origin as the current location\n      *\n      * @param {String} requestURL The URL to test\n      * @returns {boolean} True if URL shares the same origin, otherwise false\n      */\n      return function isURLSameOrigin(requestURL) {\n        var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n        return (parsed.protocol === originURL.protocol &&\n            parsed.host === originURL.host);\n      };\n    })() :\n\n    // Non standard browser envs (web workers, react-native) lack needed support.\n    (function nonStandardBrowserEnv() {\n      return function isURLSameOrigin() {\n        return true;\n      };\n    })()\n);\n","'use strict';\n\nvar utils = require('../utils');\n\nmodule.exports = function normalizeHeaderName(headers, normalizedName) {\n  utils.forEach(headers, function processHeader(value, name) {\n    if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {\n      headers[normalizedName] = value;\n      delete headers[name];\n    }\n  });\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n// Headers whose duplicates are ignored by node\n// c.f. https://nodejs.org/api/http.html#http_message_headers\nvar ignoreDuplicateOf = [\n  'age', 'authorization', 'content-length', 'content-type', 'etag',\n  'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',\n  'last-modified', 'location', 'max-forwards', 'proxy-authorization',\n  'referer', 'retry-after', 'user-agent'\n];\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} headers Headers needing to be parsed\n * @returns {Object} Headers parsed into an object\n */\nmodule.exports = function parseHeaders(headers) {\n  var parsed = {};\n  var key;\n  var val;\n  var i;\n\n  if (!headers) { return parsed; }\n\n  utils.forEach(headers.split('\\n'), function parser(line) {\n    i = line.indexOf(':');\n    key = utils.trim(line.slice(0, i)).toLowerCase();\n    val = utils.trim(line.slice(i + 1));\n\n    if (key) {\n      if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {\n        return;\n      }\n      if (key === 'set-cookie') {\n        parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);\n      } else {\n        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n      }\n    }\n  });\n\n  return parsed;\n};\n","'use strict';\n\nmodule.exports = function parseProtocol(url) {\n  var match = /^([-+\\w]{1,25})(:?\\/\\/|:)/.exec(url);\n  return match && match[1] || '';\n};\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n *  ```js\n *  function f(x, y, z) {}\n *  var args = [1, 2, 3];\n *  f.apply(null, args);\n *  ```\n *\n * With `spread` this example can be re-written.\n *\n *  ```js\n *  spread(function(x, y, z) {})([1, 2, 3]);\n *  ```\n *\n * @param {Function} callback\n * @returns {Function}\n */\nmodule.exports = function spread(callback) {\n  return function wrap(arr) {\n    return callback.apply(null, arr);\n  };\n};\n","'use strict';\n\nvar utils = require('../utils');\nvar AxiosError = require('../core/AxiosError');\nvar envFormData = require('../env/classes/FormData');\n\nfunction isVisitable(thing) {\n  return utils.isPlainObject(thing) || utils.isArray(thing);\n}\n\nfunction removeBrackets(key) {\n  return utils.endsWith(key, '[]') ? key.slice(0, -2) : key;\n}\n\nfunction renderKey(path, key, dots) {\n  if (!path) return key;\n  return path.concat(key).map(function each(token, i) {\n    // eslint-disable-next-line no-param-reassign\n    token = removeBrackets(token);\n    return !dots && i ? '[' + token + ']' : token;\n  }).join(dots ? '.' : '');\n}\n\nfunction isFlatArray(arr) {\n  return utils.isArray(arr) && !arr.some(isVisitable);\n}\n\nvar predicates = utils.toFlatObject(utils, {}, null, function filter(prop) {\n  return /^is[A-Z]/.test(prop);\n});\n\nfunction isSpecCompliant(thing) {\n  return thing && utils.isFunction(thing.append) && thing[Symbol.toStringTag] === 'FormData' && thing[Symbol.iterator];\n}\n\n/**\n * Convert a data object to FormData\n * @param {Object} obj\n * @param {?Object} [formData]\n * @param {?Object} [options]\n * @param {Function} [options.visitor]\n * @param {Boolean} [options.metaTokens = true]\n * @param {Boolean} [options.dots = false]\n * @param {?Boolean} [options.indexes = false]\n * @returns {Object}\n **/\n\nfunction toFormData(obj, formData, options) {\n  if (!utils.isObject(obj)) {\n    throw new TypeError('target must be an object');\n  }\n\n  // eslint-disable-next-line no-param-reassign\n  formData = formData || new (envFormData || FormData)();\n\n  // eslint-disable-next-line no-param-reassign\n  options = utils.toFlatObject(options, {\n    metaTokens: true,\n    dots: false,\n    indexes: false\n  }, false, function defined(option, source) {\n    // eslint-disable-next-line no-eq-null,eqeqeq\n    return !utils.isUndefined(source[option]);\n  });\n\n  var metaTokens = options.metaTokens;\n  // eslint-disable-next-line no-use-before-define\n  var visitor = options.visitor || defaultVisitor;\n  var dots = options.dots;\n  var indexes = options.indexes;\n  var _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;\n  var useBlob = _Blob && isSpecCompliant(formData);\n\n  if (!utils.isFunction(visitor)) {\n    throw new TypeError('visitor must be a function');\n  }\n\n  function convertValue(value) {\n    if (value === null) return '';\n\n    if (utils.isDate(value)) {\n      return value.toISOString();\n    }\n\n    if (!useBlob && utils.isBlob(value)) {\n      throw new AxiosError('Blob is not supported. Use a Buffer instead.');\n    }\n\n    if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) {\n      return useBlob && typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);\n    }\n\n    return value;\n  }\n\n  /**\n   *\n   * @param {*} value\n   * @param {String|Number} key\n   * @param {Array<String|Number>} path\n   * @this {FormData}\n   * @returns {boolean} return true to visit the each prop of the value recursively\n   */\n  function defaultVisitor(value, key, path) {\n    var arr = value;\n\n    if (value && !path && typeof value === 'object') {\n      if (utils.endsWith(key, '{}')) {\n        // eslint-disable-next-line no-param-reassign\n        key = metaTokens ? key : key.slice(0, -2);\n        // eslint-disable-next-line no-param-reassign\n        value = JSON.stringify(value);\n      } else if (\n        (utils.isArray(value) && isFlatArray(value)) ||\n        (utils.isFileList(value) || utils.endsWith(key, '[]') && (arr = utils.toArray(value))\n        )) {\n        // eslint-disable-next-line no-param-reassign\n        key = removeBrackets(key);\n\n        arr.forEach(function each(el, index) {\n          !utils.isUndefined(el) && formData.append(\n            // eslint-disable-next-line no-nested-ternary\n            indexes === true ? renderKey([key], index, dots) : (indexes === null ? key : key + '[]'),\n            convertValue(el)\n          );\n        });\n        return false;\n      }\n    }\n\n    if (isVisitable(value)) {\n      return true;\n    }\n\n    formData.append(renderKey(path, key, dots), convertValue(value));\n\n    return false;\n  }\n\n  var stack = [];\n\n  var exposedHelpers = Object.assign(predicates, {\n    defaultVisitor: defaultVisitor,\n    convertValue: convertValue,\n    isVisitable: isVisitable\n  });\n\n  function build(value, path) {\n    if (utils.isUndefined(value)) return;\n\n    if (stack.indexOf(value) !== -1) {\n      throw Error('Circular reference detected in ' + path.join('.'));\n    }\n\n    stack.push(value);\n\n    utils.forEach(value, function each(el, key) {\n      var result = !utils.isUndefined(el) && visitor.call(\n        formData, el, utils.isString(key) ? key.trim() : key, path, exposedHelpers\n      );\n\n      if (result === true) {\n        build(el, path ? path.concat(key) : [key]);\n      }\n    });\n\n    stack.pop();\n  }\n\n  if (!utils.isObject(obj)) {\n    throw new TypeError('data must be an object');\n  }\n\n  build(obj);\n\n  return formData;\n}\n\nmodule.exports = toFormData;\n","'use strict';\n\nvar utils = require('../utils');\nvar toFormData = require('./toFormData');\nvar platform = require('../platform/');\n\nmodule.exports = function toURLEncodedForm(data, options) {\n  return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({\n    visitor: function(value, key, path, helpers) {\n      if (platform.isNode && utils.isBuffer(value)) {\n        this.append(key, value.toString('base64'));\n        return false;\n      }\n\n      return helpers.defaultVisitor.apply(this, arguments);\n    }\n  }, options));\n};\n","'use strict';\n\nvar VERSION = require('../env/data').version;\nvar AxiosError = require('../core/AxiosError');\n\nvar validators = {};\n\n// eslint-disable-next-line func-names\n['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach(function(type, i) {\n  validators[type] = function validator(thing) {\n    return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;\n  };\n});\n\nvar deprecatedWarnings = {};\n\n/**\n * Transitional option validator\n * @param {function|boolean?} validator - set to false if the transitional option has been removed\n * @param {string?} version - deprecated version / removed since version\n * @param {string?} message - some message with additional info\n * @returns {function}\n */\nvalidators.transitional = function transitional(validator, version, message) {\n  function formatMessage(opt, desc) {\n    return '[Axios v' + VERSION + '] Transitional option \\'' + opt + '\\'' + desc + (message ? '. ' + message : '');\n  }\n\n  // eslint-disable-next-line func-names\n  return function(value, opt, opts) {\n    if (validator === false) {\n      throw new AxiosError(\n        formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),\n        AxiosError.ERR_DEPRECATED\n      );\n    }\n\n    if (version && !deprecatedWarnings[opt]) {\n      deprecatedWarnings[opt] = true;\n      // eslint-disable-next-line no-console\n      console.warn(\n        formatMessage(\n          opt,\n          ' has been deprecated since v' + version + ' and will be removed in the near future'\n        )\n      );\n    }\n\n    return validator ? validator(value, opt, opts) : true;\n  };\n};\n\n/**\n * Assert object's properties type\n * @param {object} options\n * @param {object} schema\n * @param {boolean?} allowUnknown\n */\n\nfunction assertOptions(options, schema, allowUnknown) {\n  if (typeof options !== 'object') {\n    throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE);\n  }\n  var keys = Object.keys(options);\n  var i = keys.length;\n  while (i-- > 0) {\n    var opt = keys[i];\n    var validator = schema[opt];\n    if (validator) {\n      var value = options[opt];\n      var result = value === undefined || validator(value, opt, options);\n      if (result !== true) {\n        throw new AxiosError('option ' + opt + ' must be ' + result, AxiosError.ERR_BAD_OPTION_VALUE);\n      }\n      continue;\n    }\n    if (allowUnknown !== true) {\n      throw new AxiosError('Unknown option ' + opt, AxiosError.ERR_BAD_OPTION);\n    }\n  }\n}\n\nmodule.exports = {\n  assertOptions: assertOptions,\n  validators: validators\n};\n","'use strict';\n\nmodule.exports = FormData;\n","'use strict';\n\nvar AxiosURLSearchParams = require('../../../helpers/AxiosURLSearchParams');\n\nmodule.exports = typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;\n","'use strict';\n\nmodule.exports = {\n  isBrowser: true,\n  classes: {\n    URLSearchParams: require('./classes/URLSearchParams'),\n    FormData: require('./classes/FormData'),\n    Blob: Blob\n  },\n  protocols: ['http', 'https', 'file', 'blob', 'url', 'data']\n};\n","'use strict';\n\nmodule.exports = require('./node/');\n","'use strict';\n\nvar bind = require('./helpers/bind');\n\n// utils is a library of generic helper functions non-specific to axios\n\nvar toString = Object.prototype.toString;\n\n// eslint-disable-next-line func-names\nvar kindOf = (function(cache) {\n  // eslint-disable-next-line func-names\n  return function(thing) {\n    var str = toString.call(thing);\n    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());\n  };\n})(Object.create(null));\n\nfunction kindOfTest(type) {\n  type = type.toLowerCase();\n  return function isKindOf(thing) {\n    return kindOf(thing) === type;\n  };\n}\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Array, otherwise false\n */\nfunction isArray(val) {\n  return Array.isArray(val);\n}\n\n/**\n * Determine if a value is undefined\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nfunction isUndefined(val) {\n  return typeof val === 'undefined';\n}\n\n/**\n * Determine if a value is a Buffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Buffer, otherwise false\n */\nfunction isBuffer(val) {\n  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)\n    && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val);\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @function\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nvar isArrayBuffer = kindOfTest('ArrayBuffer');\n\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n  var result;\n  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n    result = ArrayBuffer.isView(val);\n  } else {\n    result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));\n  }\n  return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a String, otherwise false\n */\nfunction isString(val) {\n  return typeof val === 'string';\n}\n\n/**\n * Determine if a value is a Number\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Number, otherwise false\n */\nfunction isNumber(val) {\n  return typeof val === 'number';\n}\n\n/**\n * Determine if a value is an Object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Object, otherwise false\n */\nfunction isObject(val) {\n  return val !== null && typeof val === 'object';\n}\n\n/**\n * Determine if a value is a plain Object\n *\n * @param {Object} val The value to test\n * @return {boolean} True if value is a plain Object, otherwise false\n */\nfunction isPlainObject(val) {\n  if (kindOf(val) !== 'object') {\n    return false;\n  }\n\n  var prototype = Object.getPrototypeOf(val);\n  return prototype === null || prototype === Object.prototype;\n}\n\n/**\n * Determine if a value is a empty Object\n *\n * @param {Object} val The value to test\n * @return {boolean} True if value is a empty Object, otherwise false\n */\nfunction isEmptyObject(val) {\n  return val && Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;\n}\n\n/**\n * Determine if a value is a Date\n *\n * @function\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Date, otherwise false\n */\nvar isDate = kindOfTest('Date');\n\n/**\n * Determine if a value is a File\n *\n * @function\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nvar isFile = kindOfTest('File');\n\n/**\n * Determine if a value is a Blob\n *\n * @function\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nvar isBlob = kindOfTest('Blob');\n\n/**\n * Determine if a value is a FileList\n *\n * @function\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nvar isFileList = kindOfTest('FileList');\n\n/**\n * Determine if a value is a Function\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nfunction isFunction(val) {\n  return toString.call(val) === '[object Function]';\n}\n\n/**\n * Determine if a value is a Stream\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nfunction isStream(val) {\n  return isObject(val) && isFunction(val.pipe);\n}\n\n/**\n * Determine if a value is a FormData\n *\n * @param {Object} thing The value to test\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nfunction isFormData(thing) {\n  var pattern = '[object FormData]';\n  return thing && (\n    (typeof FormData === 'function' && thing instanceof FormData) ||\n    toString.call(thing) === pattern ||\n    (isFunction(thing.toString) && thing.toString() === pattern)\n  );\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n * @function\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nvar isURLSearchParams = kindOfTest('URLSearchParams');\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n * @returns {String} The String freed of excess whitespace\n */\nfunction trim(str) {\n  return str.trim ? str.trim() : str.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '');\n}\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n *  typeof window -> undefined\n *  typeof document -> undefined\n *\n * react-native:\n *  navigator.product -> 'ReactNative'\n * nativescript\n *  navigator.product -> 'NativeScript' or 'NS'\n */\nfunction isStandardBrowserEnv() {\n  var product;\n  if (typeof navigator !== 'undefined' && (\n    (product = navigator.product) === 'ReactNative' ||\n    product === 'NativeScript' ||\n    product === 'NS')\n  ) {\n    return false;\n  }\n\n  return typeof window !== 'undefined' && typeof document !== 'undefined';\n}\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n */\nfunction forEach(obj, fn) {\n  // Don't bother if no value provided\n  if (obj === null || typeof obj === 'undefined') {\n    return;\n  }\n\n  // Force an array if not already something iterable\n  if (typeof obj !== 'object') {\n    /*eslint no-param-reassign:0*/\n    obj = [obj];\n  }\n\n  if (isArray(obj)) {\n    // Iterate over array values\n    for (var i = 0, l = obj.length; i < l; i++) {\n      fn.call(null, obj[i], i, obj);\n    }\n  } else {\n    // Iterate over object keys\n    for (var key in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, key)) {\n        fn.call(null, obj[key], key, obj);\n      }\n    }\n  }\n}\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n  var result = {};\n  function assignValue(val, key) {\n    if (isPlainObject(result[key]) && isPlainObject(val)) {\n      result[key] = merge(result[key], val);\n    } else if (isPlainObject(val)) {\n      result[key] = merge({}, val);\n    } else if (isArray(val)) {\n      result[key] = val.slice();\n    } else {\n      result[key] = val;\n    }\n  }\n\n  for (var i = 0, l = arguments.length; i < l; i++) {\n    forEach(arguments[i], assignValue);\n  }\n  return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n * @return {Object} The resulting value of object a\n */\nfunction extend(a, b, thisArg) {\n  forEach(b, function assignValue(val, key) {\n    if (thisArg && typeof val === 'function') {\n      a[key] = bind(val, thisArg);\n    } else {\n      a[key] = val;\n    }\n  });\n  return a;\n}\n\n/**\n * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)\n *\n * @param {string} content with BOM\n * @return {string} content value without BOM\n */\nfunction stripBOM(content) {\n  if (content.charCodeAt(0) === 0xFEFF) {\n    content = content.slice(1);\n  }\n  return content;\n}\n\n/**\n * Inherit the prototype methods from one constructor into another\n * @param {function} constructor\n * @param {function} superConstructor\n * @param {object} [props]\n * @param {object} [descriptors]\n */\n\nfunction inherits(constructor, superConstructor, props, descriptors) {\n  constructor.prototype = Object.create(superConstructor.prototype, descriptors);\n  constructor.prototype.constructor = constructor;\n  props && Object.assign(constructor.prototype, props);\n}\n\n/**\n * Resolve object with deep prototype chain to a flat object\n * @param {Object} sourceObj source object\n * @param {Object} [destObj]\n * @param {Function|Boolean} [filter]\n * @param {Function} [propFilter]\n * @returns {Object}\n */\n\nfunction toFlatObject(sourceObj, destObj, filter, propFilter) {\n  var props;\n  var i;\n  var prop;\n  var merged = {};\n\n  destObj = destObj || {};\n  // eslint-disable-next-line no-eq-null,eqeqeq\n  if (sourceObj == null) return destObj;\n\n  do {\n    props = Object.getOwnPropertyNames(sourceObj);\n    i = props.length;\n    while (i-- > 0) {\n      prop = props[i];\n      if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {\n        destObj[prop] = sourceObj[prop];\n        merged[prop] = true;\n      }\n    }\n    sourceObj = filter !== false && Object.getPrototypeOf(sourceObj);\n  } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);\n\n  return destObj;\n}\n\n/*\n * determines whether a string ends with the characters of a specified string\n * @param {String} str\n * @param {String} searchString\n * @param {Number} [position= 0]\n * @returns {boolean}\n */\nfunction endsWith(str, searchString, position) {\n  str = String(str);\n  if (position === undefined || position > str.length) {\n    position = str.length;\n  }\n  position -= searchString.length;\n  var lastIndex = str.indexOf(searchString, position);\n  return lastIndex !== -1 && lastIndex === position;\n}\n\n\n/**\n * Returns new array from array like object or null if failed\n * @param {*} [thing]\n * @returns {?Array}\n */\nfunction toArray(thing) {\n  if (!thing) return null;\n  if (isArray(thing)) return thing;\n  var i = thing.length;\n  if (!isNumber(i)) return null;\n  var arr = new Array(i);\n  while (i-- > 0) {\n    arr[i] = thing[i];\n  }\n  return arr;\n}\n\n// eslint-disable-next-line func-names\nvar isTypedArray = (function(TypedArray) {\n  // eslint-disable-next-line func-names\n  return function(thing) {\n    return TypedArray && thing instanceof TypedArray;\n  };\n})(typeof Uint8Array !== 'undefined' && Object.getPrototypeOf(Uint8Array));\n\nfunction forEachEntry(obj, fn) {\n  var generator = obj && obj[Symbol.iterator];\n\n  var iterator = generator.call(obj);\n\n  var result;\n\n  while ((result = iterator.next()) && !result.done) {\n    var pair = result.value;\n    fn.call(obj, pair[0], pair[1]);\n  }\n}\n\nfunction matchAll(regExp, str) {\n  var matches;\n  var arr = [];\n\n  while ((matches = regExp.exec(str)) !== null) {\n    arr.push(matches);\n  }\n\n  return arr;\n}\n\nvar isHTMLForm = kindOfTest('HTMLFormElement');\n\nvar hasOwnProperty = (function resolver(_hasOwnProperty) {\n  return function(obj, prop) {\n    return _hasOwnProperty.call(obj, prop);\n  };\n})(Object.prototype.hasOwnProperty);\n\nmodule.exports = {\n  isArray: isArray,\n  isArrayBuffer: isArrayBuffer,\n  isBuffer: isBuffer,\n  isFormData: isFormData,\n  isArrayBufferView: isArrayBufferView,\n  isString: isString,\n  isNumber: isNumber,\n  isObject: isObject,\n  isPlainObject: isPlainObject,\n  isEmptyObject: isEmptyObject,\n  isUndefined: isUndefined,\n  isDate: isDate,\n  isFile: isFile,\n  isBlob: isBlob,\n  isFunction: isFunction,\n  isStream: isStream,\n  isURLSearchParams: isURLSearchParams,\n  isStandardBrowserEnv: isStandardBrowserEnv,\n  forEach: forEach,\n  merge: merge,\n  extend: extend,\n  trim: trim,\n  stripBOM: stripBOM,\n  inherits: inherits,\n  toFlatObject: toFlatObject,\n  kindOf: kindOf,\n  kindOfTest: kindOfTest,\n  endsWith: endsWith,\n  toArray: toArray,\n  isTypedArray: isTypedArray,\n  isFileList: isFileList,\n  forEachEntry: forEachEntry,\n  matchAll: matchAll,\n  isHTMLForm: isHTMLForm,\n  hasOwnProperty: hasOwnProperty\n};\n","// See: http://code.google.com/p/google-diff-match-patch/wiki/API\nexport function convertChangesToDMP(changes) {\n  let ret = [],\n      change,\n      operation;\n  for (let i = 0; i < changes.length; i++) {\n    change = changes[i];\n    if (change.added) {\n      operation = 1;\n    } else if (change.removed) {\n      operation = -1;\n    } else {\n      operation = 0;\n    }\n\n    ret.push([operation, change.value]);\n  }\n  return ret;\n}\n","export function convertChangesToXML(changes) {\n  let ret = [];\n  for (let i = 0; i < changes.length; i++) {\n    let change = changes[i];\n    if (change.added) {\n      ret.push('<ins>');\n    } else if (change.removed) {\n      ret.push('<del>');\n    }\n\n    ret.push(escapeHTML(change.value));\n\n    if (change.added) {\n      ret.push('</ins>');\n    } else if (change.removed) {\n      ret.push('</del>');\n    }\n  }\n  return ret.join('');\n}\n\nfunction escapeHTML(s) {\n  let n = s;\n  n = n.replace(/&/g, '&amp;');\n  n = n.replace(/</g, '&lt;');\n  n = n.replace(/>/g, '&gt;');\n  n = n.replace(/\"/g, '&quot;');\n\n  return n;\n}\n","import Diff from './base';\n\nexport const arrayDiff = new Diff();\narrayDiff.tokenize = function(value) {\n  return value.slice();\n};\narrayDiff.join = arrayDiff.removeEmpty = function(value) {\n  return value;\n};\n\nexport function diffArrays(oldArr, newArr, callback) { return arrayDiff.diff(oldArr, newArr, callback); }\n","export default function Diff() {}\n\nDiff.prototype = {\n  diff(oldString, newString, options = {}) {\n    let callback = options.callback;\n    if (typeof options === 'function') {\n      callback = options;\n      options = {};\n    }\n    this.options = options;\n\n    let self = this;\n\n    function done(value) {\n      if (callback) {\n        setTimeout(function() { callback(undefined, value); }, 0);\n        return true;\n      } else {\n        return value;\n      }\n    }\n\n    // Allow subclasses to massage the input prior to running\n    oldString = this.castInput(oldString);\n    newString = this.castInput(newString);\n\n    oldString = this.removeEmpty(this.tokenize(oldString));\n    newString = this.removeEmpty(this.tokenize(newString));\n\n    let newLen = newString.length, oldLen = oldString.length;\n    let editLength = 1;\n    let maxEditLength = newLen + oldLen;\n    if(options.maxEditLength) {\n      maxEditLength = Math.min(maxEditLength, options.maxEditLength);\n    }\n\n    let bestPath = [{ newPos: -1, components: [] }];\n\n    // Seed editLength = 0, i.e. the content starts with the same values\n    let oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);\n    if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {\n      // Identity per the equality and tokenizer\n      return done([{value: this.join(newString), count: newString.length}]);\n    }\n\n    // Main worker method. checks all permutations of a given edit length for acceptance.\n    function execEditLength() {\n      for (let diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {\n        let basePath;\n        let addPath = bestPath[diagonalPath - 1],\n            removePath = bestPath[diagonalPath + 1],\n            oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;\n        if (addPath) {\n          // No one else is going to attempt to use this value, clear it\n          bestPath[diagonalPath - 1] = undefined;\n        }\n\n        let canAdd = addPath && addPath.newPos + 1 < newLen,\n            canRemove = removePath && 0 <= oldPos && oldPos < oldLen;\n        if (!canAdd && !canRemove) {\n          // If this path is a terminal then prune\n          bestPath[diagonalPath] = undefined;\n          continue;\n        }\n\n        // Select the diagonal that we want to branch from. We select the prior\n        // path whose position in the new string is the farthest from the origin\n        // and does not pass the bounds of the diff graph\n        if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) {\n          basePath = clonePath(removePath);\n          self.pushComponent(basePath.components, undefined, true);\n        } else {\n          basePath = addPath; // No need to clone, we've pulled it from the list\n          basePath.newPos++;\n          self.pushComponent(basePath.components, true, undefined);\n        }\n\n        oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath);\n\n        // If we have hit the end of both strings, then we are done\n        if (basePath.newPos + 1 >= newLen && oldPos + 1 >= oldLen) {\n          return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken));\n        } else {\n          // Otherwise track this path as a potential candidate and continue.\n          bestPath[diagonalPath] = basePath;\n        }\n      }\n\n      editLength++;\n    }\n\n    // Performs the length of edit iteration. Is a bit fugly as this has to support the\n    // sync and async mode which is never fun. Loops over execEditLength until a value\n    // is produced, or until the edit length exceeds options.maxEditLength (if given),\n    // in which case it will return undefined.\n    if (callback) {\n      (function exec() {\n        setTimeout(function() {\n          if (editLength > maxEditLength) {\n            return callback();\n          }\n\n          if (!execEditLength()) {\n            exec();\n          }\n        }, 0);\n      }());\n    } else {\n      while (editLength <= maxEditLength) {\n        let ret = execEditLength();\n        if (ret) {\n          return ret;\n        }\n      }\n    }\n  },\n\n  pushComponent(components, added, removed) {\n    let last = components[components.length - 1];\n    if (last && last.added === added && last.removed === removed) {\n      // We need to clone here as the component clone operation is just\n      // as shallow array clone\n      components[components.length - 1] = {count: last.count + 1, added: added, removed: removed };\n    } else {\n      components.push({count: 1, added: added, removed: removed });\n    }\n  },\n  extractCommon(basePath, newString, oldString, diagonalPath) {\n    let newLen = newString.length,\n        oldLen = oldString.length,\n        newPos = basePath.newPos,\n        oldPos = newPos - diagonalPath,\n\n        commonCount = 0;\n    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {\n      newPos++;\n      oldPos++;\n      commonCount++;\n    }\n\n    if (commonCount) {\n      basePath.components.push({count: commonCount});\n    }\n\n    basePath.newPos = newPos;\n    return oldPos;\n  },\n\n  equals(left, right) {\n    if (this.options.comparator) {\n      return this.options.comparator(left, right);\n    } else {\n      return left === right\n        || (this.options.ignoreCase && left.toLowerCase() === right.toLowerCase());\n    }\n  },\n  removeEmpty(array) {\n    let ret = [];\n    for (let i = 0; i < array.length; i++) {\n      if (array[i]) {\n        ret.push(array[i]);\n      }\n    }\n    return ret;\n  },\n  castInput(value) {\n    return value;\n  },\n  tokenize(value) {\n    return value.split('');\n  },\n  join(chars) {\n    return chars.join('');\n  }\n};\n\nfunction buildValues(diff, components, newString, oldString, useLongestToken) {\n  let componentPos = 0,\n      componentLen = components.length,\n      newPos = 0,\n      oldPos = 0;\n\n  for (; componentPos < componentLen; componentPos++) {\n    let component = components[componentPos];\n    if (!component.removed) {\n      if (!component.added && useLongestToken) {\n        let value = newString.slice(newPos, newPos + component.count);\n        value = value.map(function(value, i) {\n          let oldValue = oldString[oldPos + i];\n          return oldValue.length > value.length ? oldValue : value;\n        });\n\n        component.value = diff.join(value);\n      } else {\n        component.value = diff.join(newString.slice(newPos, newPos + component.count));\n      }\n      newPos += component.count;\n\n      // Common case\n      if (!component.added) {\n        oldPos += component.count;\n      }\n    } else {\n      component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));\n      oldPos += component.count;\n\n      // Reverse add and remove so removes are output first to match common convention\n      // The diffing algorithm is tied to add then remove output and this is the simplest\n      // route to get the desired output with minimal overhead.\n      if (componentPos && components[componentPos - 1].added) {\n        let tmp = components[componentPos - 1];\n        components[componentPos - 1] = components[componentPos];\n        components[componentPos] = tmp;\n      }\n    }\n  }\n\n  // Special case handle for when one terminal is ignored (i.e. whitespace).\n  // For this case we merge the terminal into the prior string and drop the change.\n  // This is only available for string mode.\n  let lastComponent = components[componentLen - 1];\n  if (componentLen > 1\n      && typeof lastComponent.value === 'string'\n      && (lastComponent.added || lastComponent.removed)\n      && diff.equals('', lastComponent.value)) {\n    components[componentLen - 2].value += lastComponent.value;\n    components.pop();\n  }\n\n  return components;\n}\n\nfunction clonePath(path) {\n  return { newPos: path.newPos, components: path.components.slice(0) };\n}\n","import Diff from './base';\n\nexport const characterDiff = new Diff();\nexport function diffChars(oldStr, newStr, options) { return characterDiff.diff(oldStr, newStr, options); }\n","import Diff from './base';\n\nexport const cssDiff = new Diff();\ncssDiff.tokenize = function(value) {\n  return value.split(/([{}:;,]|\\s+)/);\n};\n\nexport function diffCss(oldStr, newStr, callback) { return cssDiff.diff(oldStr, newStr, callback); }\n","import Diff from './base';\nimport {lineDiff} from './line';\n\nconst objectPrototypeToString = Object.prototype.toString;\n\n\nexport const jsonDiff = new Diff();\n// Discriminate between two lines of pretty-printed, serialized JSON where one of them has a\n// dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:\njsonDiff.useLongestToken = true;\n\njsonDiff.tokenize = lineDiff.tokenize;\njsonDiff.castInput = function(value) {\n  const {undefinedReplacement, stringifyReplacer = (k, v) => typeof v === 'undefined' ? undefinedReplacement : v} = this.options;\n\n  return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, '  ');\n};\njsonDiff.equals = function(left, right) {\n  return Diff.prototype.equals.call(jsonDiff, left.replace(/,([\\r\\n])/g, '$1'), right.replace(/,([\\r\\n])/g, '$1'));\n};\n\nexport function diffJson(oldObj, newObj, options) { return jsonDiff.diff(oldObj, newObj, options); }\n\n// This function handles the presence of circular references by bailing out when encountering an\n// object that is already on the \"stack\" of items being processed. Accepts an optional replacer\nexport function canonicalize(obj, stack, replacementStack, replacer, key) {\n  stack = stack || [];\n  replacementStack = replacementStack || [];\n\n  if (replacer) {\n    obj = replacer(key, obj);\n  }\n\n  let i;\n\n  for (i = 0; i < stack.length; i += 1) {\n    if (stack[i] === obj) {\n      return replacementStack[i];\n    }\n  }\n\n  let canonicalizedObj;\n\n  if ('[object Array]' === objectPrototypeToString.call(obj)) {\n    stack.push(obj);\n    canonicalizedObj = new Array(obj.length);\n    replacementStack.push(canonicalizedObj);\n    for (i = 0; i < obj.length; i += 1) {\n      canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key);\n    }\n    stack.pop();\n    replacementStack.pop();\n    return canonicalizedObj;\n  }\n\n  if (obj && obj.toJSON) {\n    obj = obj.toJSON();\n  }\n\n  if (typeof obj === 'object' && obj !== null) {\n    stack.push(obj);\n    canonicalizedObj = {};\n    replacementStack.push(canonicalizedObj);\n    let sortedKeys = [],\n        key;\n    for (key in obj) {\n      /* istanbul ignore else */\n      if (obj.hasOwnProperty(key)) {\n        sortedKeys.push(key);\n      }\n    }\n    sortedKeys.sort();\n    for (i = 0; i < sortedKeys.length; i += 1) {\n      key = sortedKeys[i];\n      canonicalizedObj[key] = canonicalize(obj[key], stack, replacementStack, replacer, key);\n    }\n    stack.pop();\n    replacementStack.pop();\n  } else {\n    canonicalizedObj = obj;\n  }\n  return canonicalizedObj;\n}\n","import Diff from './base';\nimport {generateOptions} from '../util/params';\n\nexport const lineDiff = new Diff();\nlineDiff.tokenize = function(value) {\n  let retLines = [],\n      linesAndNewlines = value.split(/(\\n|\\r\\n)/);\n\n  // Ignore the final empty token that occurs if the string ends with a new line\n  if (!linesAndNewlines[linesAndNewlines.length - 1]) {\n    linesAndNewlines.pop();\n  }\n\n  // Merge the content and line separators into single tokens\n  for (let i = 0; i < linesAndNewlines.length; i++) {\n    let line = linesAndNewlines[i];\n\n    if (i % 2 && !this.options.newlineIsToken) {\n      retLines[retLines.length - 1] += line;\n    } else {\n      if (this.options.ignoreWhitespace) {\n        line = line.trim();\n      }\n      retLines.push(line);\n    }\n  }\n\n  return retLines;\n};\n\nexport function diffLines(oldStr, newStr, callback) { return lineDiff.diff(oldStr, newStr, callback); }\nexport function diffTrimmedLines(oldStr, newStr, callback) {\n  let options = generateOptions(callback, {ignoreWhitespace: true});\n  return lineDiff.diff(oldStr, newStr, options);\n}\n","import Diff from './base';\n\n\nexport const sentenceDiff = new Diff();\nsentenceDiff.tokenize = function(value) {\n  return value.split(/(\\S.+?[.!?])(?=\\s+|$)/);\n};\n\nexport function diffSentences(oldStr, newStr, callback) { return sentenceDiff.diff(oldStr, newStr, callback); }\n","import Diff from './base';\nimport {generateOptions} from '../util/params';\n\n// Based on https://en.wikipedia.org/wiki/Latin_script_in_Unicode\n//\n// Ranges and exceptions:\n// Latin-1 Supplement, 0080–00FF\n//  - U+00D7  × Multiplication sign\n//  - U+00F7  ÷ Division sign\n// Latin Extended-A, 0100–017F\n// Latin Extended-B, 0180–024F\n// IPA Extensions, 0250–02AF\n// Spacing Modifier Letters, 02B0–02FF\n//  - U+02C7  ˇ &#711;  Caron\n//  - U+02D8  ˘ &#728;  Breve\n//  - U+02D9  ˙ &#729;  Dot Above\n//  - U+02DA  ˚ &#730;  Ring Above\n//  - U+02DB  ˛ &#731;  Ogonek\n//  - U+02DC  ˜ &#732;  Small Tilde\n//  - U+02DD  ˝ &#733;  Double Acute Accent\n// Latin Extended Additional, 1E00–1EFF\nconst extendedWordChars = /^[a-zA-Z\\u{C0}-\\u{FF}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}]+$/u;\n\nconst reWhitespace = /\\S/;\n\nexport const wordDiff = new Diff();\nwordDiff.equals = function(left, right) {\n  if (this.options.ignoreCase) {\n    left = left.toLowerCase();\n    right = right.toLowerCase();\n  }\n  return left === right || (this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right));\n};\nwordDiff.tokenize = function(value) {\n  // All whitespace symbols except newline group into one token, each newline - in separate token\n  let tokens = value.split(/([^\\S\\r\\n]+|[()[\\]{}'\"\\r\\n]|\\b)/);\n\n  // Join the boundary splits that we do not consider to be boundaries. This is primarily the extended Latin character set.\n  for (let i = 0; i < tokens.length - 1; i++) {\n    // If we have an empty string in the next field and we have only word chars before and after, merge\n    if (!tokens[i + 1] && tokens[i + 2]\n          && extendedWordChars.test(tokens[i])\n          && extendedWordChars.test(tokens[i + 2])) {\n      tokens[i] += tokens[i + 2];\n      tokens.splice(i + 1, 2);\n      i--;\n    }\n  }\n\n  return tokens;\n};\n\nexport function diffWords(oldStr, newStr, options) {\n  options = generateOptions(options, {ignoreWhitespace: true});\n  return wordDiff.diff(oldStr, newStr, options);\n}\n\nexport function diffWordsWithSpace(oldStr, newStr, options) {\n  return wordDiff.diff(oldStr, newStr, options);\n}\n","/* See LICENSE file for terms of use */\n\n/*\n * Text diff implementation.\n *\n * This library supports the following APIS:\n * JsDiff.diffChars: Character by character diff\n * JsDiff.diffWords: Word (as defined by \\b regex) diff which ignores whitespace\n * JsDiff.diffLines: Line based diff\n *\n * JsDiff.diffCss: Diff targeted at CSS content\n *\n * These methods are based on the implementation proposed in\n * \"An O(ND) Difference Algorithm and its Variations\" (Myers, 1986).\n * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927\n */\nimport Diff from './diff/base';\nimport {diffChars} from './diff/character';\nimport {diffWords, diffWordsWithSpace} from './diff/word';\nimport {diffLines, diffTrimmedLines} from './diff/line';\nimport {diffSentences} from './diff/sentence';\n\nimport {diffCss} from './diff/css';\nimport {diffJson, canonicalize} from './diff/json';\n\nimport {diffArrays} from './diff/array';\n\nimport {applyPatch, applyPatches} from './patch/apply';\nimport {parsePatch} from './patch/parse';\nimport {merge} from './patch/merge';\nimport {structuredPatch, createTwoFilesPatch, createPatch} from './patch/create';\n\nimport {convertChangesToDMP} from './convert/dmp';\nimport {convertChangesToXML} from './convert/xml';\n\nexport {\n  Diff,\n\n  diffChars,\n  diffWords,\n  diffWordsWithSpace,\n  diffLines,\n  diffTrimmedLines,\n  diffSentences,\n\n  diffCss,\n  diffJson,\n\n  diffArrays,\n\n  structuredPatch,\n  createTwoFilesPatch,\n  createPatch,\n  applyPatch,\n  applyPatches,\n  parsePatch,\n  merge,\n  convertChangesToDMP,\n  convertChangesToXML,\n  canonicalize\n};\n","import {parsePatch} from './parse';\nimport distanceIterator from '../util/distance-iterator';\n\nexport function applyPatch(source, uniDiff, options = {}) {\n  if (typeof uniDiff === 'string') {\n    uniDiff = parsePatch(uniDiff);\n  }\n\n  if (Array.isArray(uniDiff)) {\n    if (uniDiff.length > 1) {\n      throw new Error('applyPatch only works with a single input.');\n    }\n\n    uniDiff = uniDiff[0];\n  }\n\n  // Apply the diff to the input\n  let lines = source.split(/\\r\\n|[\\n\\v\\f\\r\\x85]/),\n      delimiters = source.match(/\\r\\n|[\\n\\v\\f\\r\\x85]/g) || [],\n      hunks = uniDiff.hunks,\n\n      compareLine = options.compareLine || ((lineNumber, line, operation, patchContent) => line === patchContent),\n      errorCount = 0,\n      fuzzFactor = options.fuzzFactor || 0,\n      minLine = 0,\n      offset = 0,\n\n      removeEOFNL,\n      addEOFNL;\n\n  /**\n   * Checks if the hunk exactly fits on the provided location\n   */\n  function hunkFits(hunk, toPos) {\n    for (let j = 0; j < hunk.lines.length; j++) {\n      let line = hunk.lines[j],\n          operation = (line.length > 0 ? line[0] : ' '),\n          content = (line.length > 0 ? line.substr(1) : line);\n\n      if (operation === ' ' || operation === '-') {\n        // Context sanity check\n        if (!compareLine(toPos + 1, lines[toPos], operation, content)) {\n          errorCount++;\n\n          if (errorCount > fuzzFactor) {\n            return false;\n          }\n        }\n        toPos++;\n      }\n    }\n\n    return true;\n  }\n\n  // Search best fit offsets for each hunk based on the previous ones\n  for (let i = 0; i < hunks.length; i++) {\n    let hunk = hunks[i],\n        maxLine = lines.length - hunk.oldLines,\n        localOffset = 0,\n        toPos = offset + hunk.oldStart - 1;\n\n    let iterator = distanceIterator(toPos, minLine, maxLine);\n\n    for (; localOffset !== undefined; localOffset = iterator()) {\n      if (hunkFits(hunk, toPos + localOffset)) {\n        hunk.offset = offset += localOffset;\n        break;\n      }\n    }\n\n    if (localOffset === undefined) {\n      return false;\n    }\n\n    // Set lower text limit to end of the current hunk, so next ones don't try\n    // to fit over already patched text\n    minLine = hunk.offset + hunk.oldStart + hunk.oldLines;\n  }\n\n  // Apply patch hunks\n  let diffOffset = 0;\n  for (let i = 0; i < hunks.length; i++) {\n    let hunk = hunks[i],\n        toPos = hunk.oldStart + hunk.offset + diffOffset - 1;\n    diffOffset += hunk.newLines - hunk.oldLines;\n\n    for (let j = 0; j < hunk.lines.length; j++) {\n      let line = hunk.lines[j],\n          operation = (line.length > 0 ? line[0] : ' '),\n          content = (line.length > 0 ? line.substr(1) : line),\n          delimiter = hunk.linedelimiters[j];\n\n      if (operation === ' ') {\n        toPos++;\n      } else if (operation === '-') {\n        lines.splice(toPos, 1);\n        delimiters.splice(toPos, 1);\n      /* istanbul ignore else */\n      } else if (operation === '+') {\n        lines.splice(toPos, 0, content);\n        delimiters.splice(toPos, 0, delimiter);\n        toPos++;\n      } else if (operation === '\\\\') {\n        let previousOperation = hunk.lines[j - 1] ? hunk.lines[j - 1][0] : null;\n        if (previousOperation === '+') {\n          removeEOFNL = true;\n        } else if (previousOperation === '-') {\n          addEOFNL = true;\n        }\n      }\n    }\n  }\n\n  // Handle EOFNL insertion/removal\n  if (removeEOFNL) {\n    while (!lines[lines.length - 1]) {\n      lines.pop();\n      delimiters.pop();\n    }\n  } else if (addEOFNL) {\n    lines.push('');\n    delimiters.push('\\n');\n  }\n  for (let _k = 0; _k < lines.length - 1; _k++) {\n    lines[_k] = lines[_k] + delimiters[_k];\n  }\n  return lines.join('');\n}\n\n// Wrapper that supports multiple file patches via callbacks.\nexport function applyPatches(uniDiff, options) {\n  if (typeof uniDiff === 'string') {\n    uniDiff = parsePatch(uniDiff);\n  }\n\n  let currentIndex = 0;\n  function processIndex() {\n    let index = uniDiff[currentIndex++];\n    if (!index) {\n      return options.complete();\n    }\n\n    options.loadFile(index, function(err, data) {\n      if (err) {\n        return options.complete(err);\n      }\n\n      let updatedContent = applyPatch(data, index, options);\n      options.patched(index, updatedContent, function(err) {\n        if (err) {\n          return options.complete(err);\n        }\n\n        processIndex();\n      });\n    });\n  }\n  processIndex();\n}\n","import {diffLines} from '../diff/line';\n\nexport function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n  if (!options) {\n    options = {};\n  }\n  if (typeof options.context === 'undefined') {\n    options.context = 4;\n  }\n\n  const diff = diffLines(oldStr, newStr, options);\n  if(!diff) {\n    return;\n  }\n\n  diff.push({value: '', lines: []}); // Append an empty value to make cleanup easier\n\n  function contextLines(lines) {\n    return lines.map(function(entry) { return ' ' + entry; });\n  }\n\n  let hunks = [];\n  let oldRangeStart = 0, newRangeStart = 0, curRange = [],\n      oldLine = 1, newLine = 1;\n  for (let i = 0; i < diff.length; i++) {\n    const current = diff[i],\n          lines = current.lines || current.value.replace(/\\n$/, '').split('\\n');\n    current.lines = lines;\n\n    if (current.added || current.removed) {\n      // If we have previous context, start with that\n      if (!oldRangeStart) {\n        const prev = diff[i - 1];\n        oldRangeStart = oldLine;\n        newRangeStart = newLine;\n\n        if (prev) {\n          curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];\n          oldRangeStart -= curRange.length;\n          newRangeStart -= curRange.length;\n        }\n      }\n\n      // Output our changes\n      curRange.push(... lines.map(function(entry) {\n        return (current.added ? '+' : '-') + entry;\n      }));\n\n      // Track the updated file position\n      if (current.added) {\n        newLine += lines.length;\n      } else {\n        oldLine += lines.length;\n      }\n    } else {\n      // Identical context lines. Track line changes\n      if (oldRangeStart) {\n        // Close out any changes that have been output (or join overlapping)\n        if (lines.length <= options.context * 2 && i < diff.length - 2) {\n          // Overlapping\n          curRange.push(... contextLines(lines));\n        } else {\n          // end the range and output\n          let contextSize = Math.min(lines.length, options.context);\n          curRange.push(... contextLines(lines.slice(0, contextSize)));\n\n          let hunk = {\n            oldStart: oldRangeStart,\n            oldLines: (oldLine - oldRangeStart + contextSize),\n            newStart: newRangeStart,\n            newLines: (newLine - newRangeStart + contextSize),\n            lines: curRange\n          };\n          if (i >= diff.length - 2 && lines.length <= options.context) {\n            // EOF is inside this hunk\n            let oldEOFNewline = ((/\\n$/).test(oldStr));\n            let newEOFNewline = ((/\\n$/).test(newStr));\n            let noNlBeforeAdds = lines.length == 0 && curRange.length > hunk.oldLines;\n            if (!oldEOFNewline && noNlBeforeAdds && oldStr.length > 0) {\n              // special case: old has no eol and no trailing context; no-nl can end up before adds\n              // however, if the old file is empty, do not output the no-nl line\n              curRange.splice(hunk.oldLines, 0, '\\\\ No newline at end of file');\n            }\n            if ((!oldEOFNewline && !noNlBeforeAdds) || !newEOFNewline) {\n              curRange.push('\\\\ No newline at end of file');\n            }\n          }\n          hunks.push(hunk);\n\n          oldRangeStart = 0;\n          newRangeStart = 0;\n          curRange = [];\n        }\n      }\n      oldLine += lines.length;\n      newLine += lines.length;\n    }\n  }\n\n  return {\n    oldFileName: oldFileName, newFileName: newFileName,\n    oldHeader: oldHeader, newHeader: newHeader,\n    hunks: hunks\n  };\n}\n\nexport function formatPatch(diff) {\n  const ret = [];\n  if (diff.oldFileName == diff.newFileName) {\n    ret.push('Index: ' + diff.oldFileName);\n  }\n  ret.push('===================================================================');\n  ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\\t' + diff.oldHeader));\n  ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\\t' + diff.newHeader));\n\n  for (let i = 0; i < diff.hunks.length; i++) {\n    const hunk = diff.hunks[i];\n    // Unified Diff Format quirk: If the chunk size is 0,\n    // the first number is one lower than one would expect.\n    // https://www.artima.com/weblogs/viewpost.jsp?thread=164293\n    if (hunk.oldLines === 0) {\n      hunk.oldStart -= 1;\n    }\n    if (hunk.newLines === 0) {\n      hunk.newStart -= 1;\n    }\n    ret.push(\n      '@@ -' + hunk.oldStart + ',' + hunk.oldLines\n      + ' +' + hunk.newStart + ',' + hunk.newLines\n      + ' @@'\n    );\n    ret.push.apply(ret, hunk.lines);\n  }\n\n  return ret.join('\\n') + '\\n';\n}\n\nexport function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n  return formatPatch(structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options));\n}\n\nexport function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {\n  return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);\n}\n","import {structuredPatch} from './create';\nimport {parsePatch} from './parse';\n\nimport {arrayEqual, arrayStartsWith} from '../util/array';\n\nexport function calcLineCount(hunk) {\n  const {oldLines, newLines} = calcOldNewLineCount(hunk.lines);\n\n  if (oldLines !== undefined) {\n    hunk.oldLines = oldLines;\n  } else {\n    delete hunk.oldLines;\n  }\n\n  if (newLines !== undefined) {\n    hunk.newLines = newLines;\n  } else {\n    delete hunk.newLines;\n  }\n}\n\nexport function merge(mine, theirs, base) {\n  mine = loadPatch(mine, base);\n  theirs = loadPatch(theirs, base);\n\n  let ret = {};\n\n  // For index we just let it pass through as it doesn't have any necessary meaning.\n  // Leaving sanity checks on this to the API consumer that may know more about the\n  // meaning in their own context.\n  if (mine.index || theirs.index) {\n    ret.index = mine.index || theirs.index;\n  }\n\n  if (mine.newFileName || theirs.newFileName) {\n    if (!fileNameChanged(mine)) {\n      // No header or no change in ours, use theirs (and ours if theirs does not exist)\n      ret.oldFileName = theirs.oldFileName || mine.oldFileName;\n      ret.newFileName = theirs.newFileName || mine.newFileName;\n      ret.oldHeader = theirs.oldHeader || mine.oldHeader;\n      ret.newHeader = theirs.newHeader || mine.newHeader;\n    } else if (!fileNameChanged(theirs)) {\n      // No header or no change in theirs, use ours\n      ret.oldFileName = mine.oldFileName;\n      ret.newFileName = mine.newFileName;\n      ret.oldHeader = mine.oldHeader;\n      ret.newHeader = mine.newHeader;\n    } else {\n      // Both changed... figure it out\n      ret.oldFileName = selectField(ret, mine.oldFileName, theirs.oldFileName);\n      ret.newFileName = selectField(ret, mine.newFileName, theirs.newFileName);\n      ret.oldHeader = selectField(ret, mine.oldHeader, theirs.oldHeader);\n      ret.newHeader = selectField(ret, mine.newHeader, theirs.newHeader);\n    }\n  }\n\n  ret.hunks = [];\n\n  let mineIndex = 0,\n      theirsIndex = 0,\n      mineOffset = 0,\n      theirsOffset = 0;\n\n  while (mineIndex < mine.hunks.length || theirsIndex < theirs.hunks.length) {\n    let mineCurrent = mine.hunks[mineIndex] || {oldStart: Infinity},\n        theirsCurrent = theirs.hunks[theirsIndex] || {oldStart: Infinity};\n\n    if (hunkBefore(mineCurrent, theirsCurrent)) {\n      // This patch does not overlap with any of the others, yay.\n      ret.hunks.push(cloneHunk(mineCurrent, mineOffset));\n      mineIndex++;\n      theirsOffset += mineCurrent.newLines - mineCurrent.oldLines;\n    } else if (hunkBefore(theirsCurrent, mineCurrent)) {\n      // This patch does not overlap with any of the others, yay.\n      ret.hunks.push(cloneHunk(theirsCurrent, theirsOffset));\n      theirsIndex++;\n      mineOffset += theirsCurrent.newLines - theirsCurrent.oldLines;\n    } else {\n      // Overlap, merge as best we can\n      let mergedHunk = {\n        oldStart: Math.min(mineCurrent.oldStart, theirsCurrent.oldStart),\n        oldLines: 0,\n        newStart: Math.min(mineCurrent.newStart + mineOffset, theirsCurrent.oldStart + theirsOffset),\n        newLines: 0,\n        lines: []\n      };\n      mergeLines(mergedHunk, mineCurrent.oldStart, mineCurrent.lines, theirsCurrent.oldStart, theirsCurrent.lines);\n      theirsIndex++;\n      mineIndex++;\n\n      ret.hunks.push(mergedHunk);\n    }\n  }\n\n  return ret;\n}\n\nfunction loadPatch(param, base) {\n  if (typeof param === 'string') {\n    if ((/^@@/m).test(param) || ((/^Index:/m).test(param))) {\n      return parsePatch(param)[0];\n    }\n\n    if (!base) {\n      throw new Error('Must provide a base reference or pass in a patch');\n    }\n    return structuredPatch(undefined, undefined, base, param);\n  }\n\n  return param;\n}\n\nfunction fileNameChanged(patch) {\n  return patch.newFileName && patch.newFileName !== patch.oldFileName;\n}\n\nfunction selectField(index, mine, theirs) {\n  if (mine === theirs) {\n    return mine;\n  } else {\n    index.conflict = true;\n    return {mine, theirs};\n  }\n}\n\nfunction hunkBefore(test, check) {\n  return test.oldStart < check.oldStart\n    && (test.oldStart + test.oldLines) < check.oldStart;\n}\n\nfunction cloneHunk(hunk, offset) {\n  return {\n    oldStart: hunk.oldStart, oldLines: hunk.oldLines,\n    newStart: hunk.newStart + offset, newLines: hunk.newLines,\n    lines: hunk.lines\n  };\n}\n\nfunction mergeLines(hunk, mineOffset, mineLines, theirOffset, theirLines) {\n  // This will generally result in a conflicted hunk, but there are cases where the context\n  // is the only overlap where we can successfully merge the content here.\n  let mine = {offset: mineOffset, lines: mineLines, index: 0},\n      their = {offset: theirOffset, lines: theirLines, index: 0};\n\n  // Handle any leading content\n  insertLeading(hunk, mine, their);\n  insertLeading(hunk, their, mine);\n\n  // Now in the overlap content. Scan through and select the best changes from each.\n  while (mine.index < mine.lines.length && their.index < their.lines.length) {\n    let mineCurrent = mine.lines[mine.index],\n        theirCurrent = their.lines[their.index];\n\n    if ((mineCurrent[0] === '-' || mineCurrent[0] === '+')\n        && (theirCurrent[0] === '-' || theirCurrent[0] === '+')) {\n      // Both modified ...\n      mutualChange(hunk, mine, their);\n    } else if (mineCurrent[0] === '+' && theirCurrent[0] === ' ') {\n      // Mine inserted\n      hunk.lines.push(... collectChange(mine));\n    } else if (theirCurrent[0] === '+' && mineCurrent[0] === ' ') {\n      // Theirs inserted\n      hunk.lines.push(... collectChange(their));\n    } else if (mineCurrent[0] === '-' && theirCurrent[0] === ' ') {\n      // Mine removed or edited\n      removal(hunk, mine, their);\n    } else if (theirCurrent[0] === '-' && mineCurrent[0] === ' ') {\n      // Their removed or edited\n      removal(hunk, their, mine, true);\n    } else if (mineCurrent === theirCurrent) {\n      // Context identity\n      hunk.lines.push(mineCurrent);\n      mine.index++;\n      their.index++;\n    } else {\n      // Context mismatch\n      conflict(hunk, collectChange(mine), collectChange(their));\n    }\n  }\n\n  // Now push anything that may be remaining\n  insertTrailing(hunk, mine);\n  insertTrailing(hunk, their);\n\n  calcLineCount(hunk);\n}\n\nfunction mutualChange(hunk, mine, their) {\n  let myChanges = collectChange(mine),\n      theirChanges = collectChange(their);\n\n  if (allRemoves(myChanges) && allRemoves(theirChanges)) {\n    // Special case for remove changes that are supersets of one another\n    if (arrayStartsWith(myChanges, theirChanges)\n        && skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)) {\n      hunk.lines.push(... myChanges);\n      return;\n    } else if (arrayStartsWith(theirChanges, myChanges)\n        && skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)) {\n      hunk.lines.push(... theirChanges);\n      return;\n    }\n  } else if (arrayEqual(myChanges, theirChanges)) {\n    hunk.lines.push(... myChanges);\n    return;\n  }\n\n  conflict(hunk, myChanges, theirChanges);\n}\n\nfunction removal(hunk, mine, their, swap) {\n  let myChanges = collectChange(mine),\n      theirChanges = collectContext(their, myChanges);\n  if (theirChanges.merged) {\n    hunk.lines.push(... theirChanges.merged);\n  } else {\n    conflict(hunk, swap ? theirChanges : myChanges, swap ? myChanges : theirChanges);\n  }\n}\n\nfunction conflict(hunk, mine, their) {\n  hunk.conflict = true;\n  hunk.lines.push({\n    conflict: true,\n    mine: mine,\n    theirs: their\n  });\n}\n\nfunction insertLeading(hunk, insert, their) {\n  while (insert.offset < their.offset && insert.index < insert.lines.length) {\n    let line = insert.lines[insert.index++];\n    hunk.lines.push(line);\n    insert.offset++;\n  }\n}\nfunction insertTrailing(hunk, insert) {\n  while (insert.index < insert.lines.length) {\n    let line = insert.lines[insert.index++];\n    hunk.lines.push(line);\n  }\n}\n\nfunction collectChange(state) {\n  let ret = [],\n      operation = state.lines[state.index][0];\n  while (state.index < state.lines.length) {\n    let line = state.lines[state.index];\n\n    // Group additions that are immediately after subtractions and treat them as one \"atomic\" modify change.\n    if (operation === '-' && line[0] === '+') {\n      operation = '+';\n    }\n\n    if (operation === line[0]) {\n      ret.push(line);\n      state.index++;\n    } else {\n      break;\n    }\n  }\n\n  return ret;\n}\nfunction collectContext(state, matchChanges) {\n  let changes = [],\n      merged = [],\n      matchIndex = 0,\n      contextChanges = false,\n      conflicted = false;\n  while (matchIndex < matchChanges.length\n        && state.index < state.lines.length) {\n    let change = state.lines[state.index],\n        match = matchChanges[matchIndex];\n\n    // Once we've hit our add, then we are done\n    if (match[0] === '+') {\n      break;\n    }\n\n    contextChanges = contextChanges || change[0] !== ' ';\n\n    merged.push(match);\n    matchIndex++;\n\n    // Consume any additions in the other block as a conflict to attempt\n    // to pull in the remaining context after this\n    if (change[0] === '+') {\n      conflicted = true;\n\n      while (change[0] === '+') {\n        changes.push(change);\n        change = state.lines[++state.index];\n      }\n    }\n\n    if (match.substr(1) === change.substr(1)) {\n      changes.push(change);\n      state.index++;\n    } else {\n      conflicted = true;\n    }\n  }\n\n  if ((matchChanges[matchIndex] || '')[0] === '+'\n      && contextChanges) {\n    conflicted = true;\n  }\n\n  if (conflicted) {\n    return changes;\n  }\n\n  while (matchIndex < matchChanges.length) {\n    merged.push(matchChanges[matchIndex++]);\n  }\n\n  return {\n    merged,\n    changes\n  };\n}\n\nfunction allRemoves(changes) {\n  return changes.reduce(function(prev, change) {\n    return prev && change[0] === '-';\n  }, true);\n}\nfunction skipRemoveSuperset(state, removeChanges, delta) {\n  for (let i = 0; i < delta; i++) {\n    let changeContent = removeChanges[removeChanges.length - delta + i].substr(1);\n    if (state.lines[state.index + i] !== ' ' + changeContent) {\n      return false;\n    }\n  }\n\n  state.index += delta;\n  return true;\n}\n\nfunction calcOldNewLineCount(lines) {\n  let oldLines = 0;\n  let newLines = 0;\n\n  lines.forEach(function(line) {\n    if (typeof line !== 'string') {\n      let myCount = calcOldNewLineCount(line.mine);\n      let theirCount = calcOldNewLineCount(line.theirs);\n\n      if (oldLines !== undefined) {\n        if (myCount.oldLines === theirCount.oldLines) {\n          oldLines += myCount.oldLines;\n        } else {\n          oldLines = undefined;\n        }\n      }\n\n      if (newLines !== undefined) {\n        if (myCount.newLines === theirCount.newLines) {\n          newLines += myCount.newLines;\n        } else {\n          newLines = undefined;\n        }\n      }\n    } else {\n      if (newLines !== undefined && (line[0] === '+' || line[0] === ' ')) {\n        newLines++;\n      }\n      if (oldLines !== undefined && (line[0] === '-' || line[0] === ' ')) {\n        oldLines++;\n      }\n    }\n  });\n\n  return {oldLines, newLines};\n}\n","export function parsePatch(uniDiff, options = {}) {\n  let diffstr = uniDiff.split(/\\r\\n|[\\n\\v\\f\\r\\x85]/),\n      delimiters = uniDiff.match(/\\r\\n|[\\n\\v\\f\\r\\x85]/g) || [],\n      list = [],\n      i = 0;\n\n  function parseIndex() {\n    let index = {};\n    list.push(index);\n\n    // Parse diff metadata\n    while (i < diffstr.length) {\n      let line = diffstr[i];\n\n      // File header found, end parsing diff metadata\n      if ((/^(\\-\\-\\-|\\+\\+\\+|@@)\\s/).test(line)) {\n        break;\n      }\n\n      // Diff index\n      let header = (/^(?:Index:|diff(?: -r \\w+)+)\\s+(.+?)\\s*$/).exec(line);\n      if (header) {\n        index.index = header[1];\n      }\n\n      i++;\n    }\n\n    // Parse file headers if they are defined. Unified diff requires them, but\n    // there's no technical issues to have an isolated hunk without file header\n    parseFileHeader(index);\n    parseFileHeader(index);\n\n    // Parse hunks\n    index.hunks = [];\n\n    while (i < diffstr.length) {\n      let line = diffstr[i];\n\n      if ((/^(Index:|diff|\\-\\-\\-|\\+\\+\\+)\\s/).test(line)) {\n        break;\n      } else if ((/^@@/).test(line)) {\n        index.hunks.push(parseHunk());\n      } else if (line && options.strict) {\n        // Ignore unexpected content unless in strict mode\n        throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(line));\n      } else {\n        i++;\n      }\n    }\n  }\n\n  // Parses the --- and +++ headers, if none are found, no lines\n  // are consumed.\n  function parseFileHeader(index) {\n    const fileHeader = (/^(---|\\+\\+\\+)\\s+(.*)$/).exec(diffstr[i]);\n    if (fileHeader) {\n      let keyPrefix = fileHeader[1] === '---' ? 'old' : 'new';\n      const data = fileHeader[2].split('\\t', 2);\n      let fileName = data[0].replace(/\\\\\\\\/g, '\\\\');\n      if ((/^\".*\"$/).test(fileName)) {\n        fileName = fileName.substr(1, fileName.length - 2);\n      }\n      index[keyPrefix + 'FileName'] = fileName;\n      index[keyPrefix + 'Header'] = (data[1] || '').trim();\n\n      i++;\n    }\n  }\n\n  // Parses a hunk\n  // This assumes that we are at the start of a hunk.\n  function parseHunk() {\n    let chunkHeaderIndex = i,\n        chunkHeaderLine = diffstr[i++],\n        chunkHeader = chunkHeaderLine.split(/@@ -(\\d+)(?:,(\\d+))? \\+(\\d+)(?:,(\\d+))? @@/);\n\n    let hunk = {\n      oldStart: +chunkHeader[1],\n      oldLines: typeof chunkHeader[2] === 'undefined' ? 1 : +chunkHeader[2],\n      newStart: +chunkHeader[3],\n      newLines: typeof chunkHeader[4] === 'undefined' ? 1 : +chunkHeader[4],\n      lines: [],\n      linedelimiters: []\n    };\n\n    // Unified Diff Format quirk: If the chunk size is 0,\n    // the first number is one lower than one would expect.\n    // https://www.artima.com/weblogs/viewpost.jsp?thread=164293\n    if (hunk.oldLines === 0) {\n      hunk.oldStart += 1;\n    }\n    if (hunk.newLines === 0) {\n      hunk.newStart += 1;\n    }\n\n    let addCount = 0,\n        removeCount = 0;\n    for (; i < diffstr.length; i++) {\n      // Lines starting with '---' could be mistaken for the \"remove line\" operation\n      // But they could be the header for the next file. Therefore prune such cases out.\n      if (diffstr[i].indexOf('--- ') === 0\n            && (i + 2 < diffstr.length)\n            && diffstr[i + 1].indexOf('+++ ') === 0\n            && diffstr[i + 2].indexOf('@@') === 0) {\n          break;\n      }\n      let operation = (diffstr[i].length == 0 && i != (diffstr.length - 1)) ? ' ' : diffstr[i][0];\n\n      if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\\\') {\n        hunk.lines.push(diffstr[i]);\n        hunk.linedelimiters.push(delimiters[i] || '\\n');\n\n        if (operation === '+') {\n          addCount++;\n        } else if (operation === '-') {\n          removeCount++;\n        } else if (operation === ' ') {\n          addCount++;\n          removeCount++;\n        }\n      } else {\n        break;\n      }\n    }\n\n    // Handle the empty block count case\n    if (!addCount && hunk.newLines === 1) {\n      hunk.newLines = 0;\n    }\n    if (!removeCount && hunk.oldLines === 1) {\n      hunk.oldLines = 0;\n    }\n\n    // Perform optional sanity checking\n    if (options.strict) {\n      if (addCount !== hunk.newLines) {\n        throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1));\n      }\n      if (removeCount !== hunk.oldLines) {\n        throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1));\n      }\n    }\n\n    return hunk;\n  }\n\n  while (i < diffstr.length) {\n    parseIndex();\n  }\n\n  return list;\n}\n","export function arrayEqual(a, b) {\n  if (a.length !== b.length) {\n    return false;\n  }\n\n  return arrayStartsWith(a, b);\n}\n\nexport function arrayStartsWith(array, start) {\n  if (start.length > array.length) {\n    return false;\n  }\n\n  for (let i = 0; i < start.length; i++) {\n    if (start[i] !== array[i]) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","// Iterator that traverses in the range of [min, max], stepping\n// by distance from a given start position. I.e. for [0, 4], with\n// start of 2, this will iterate 2, 3, 1, 4, 0.\nexport default function(start, minLine, maxLine) {\n  let wantForward = true,\n      backwardExhausted = false,\n      forwardExhausted = false,\n      localOffset = 1;\n\n  return function iterator() {\n    if (wantForward && !forwardExhausted) {\n      if (backwardExhausted) {\n        localOffset++;\n      } else {\n        wantForward = false;\n      }\n\n      // Check if trying to fit beyond text length, and if not, check it fits\n      // after offset location (or desired location on first iteration)\n      if (start + localOffset <= maxLine) {\n        return localOffset;\n      }\n\n      forwardExhausted = true;\n    }\n\n    if (!backwardExhausted) {\n      if (!forwardExhausted) {\n        wantForward = true;\n      }\n\n      // Check if trying to fit before text beginning, and if not, check it fits\n      // before offset location\n      if (minLine <= start - localOffset) {\n        return -localOffset++;\n      }\n\n      backwardExhausted = true;\n      return iterator();\n    }\n\n    // We tried to fit hunk before text beginning and beyond text length, then\n    // hunk can't fit on the text. Return undefined\n  };\n}\n","export function generateOptions(options, defaults) {\n  if (typeof options === 'function') {\n    defaults.callback = options;\n  } else if (options) {\n    for (let name in options) {\n      /* istanbul ignore else */\n      if (options.hasOwnProperty(name)) {\n        defaults[name] = options[name];\n      }\n    }\n  }\n  return defaults;\n}\n"],"names":["Action","PopStateEventType","createBrowserHistory","options","getUrlBasedHistory","window","globalHistory","pathname","search","hash","location","createLocation","state","usr","key","to","createPath","invariant","value","message","Error","warning","cond","console","warn","e","getHistoryState","index","idx","current","parsePath","Math","random","toString","substr","_ref","charAt","path","parsedPath","hashIndex","indexOf","searchIndex","getLocation","createHref","validateLocation","document","defaultView","v5Compat","history","action","Pop","listener","getIndex","handlePop","nextIndex","delta","createURL","base","origin","href","replace","URL","replaceState","_extends","listen","fn","addEventListener","removeEventListener","encodeLocation","url","push","Push","historyState","pushState","error","DOMException","name","assign","Replace","go","n","ResultType","immutableRouteKeys","Set","convertRoutesToDataRoutes","routes","mapRouteProperties","parentPath","manifest","map","route","treePath","id","join","children","isIndexRoute","indexRoute","pathOrLayoutRoute","undefined","matchRoutes","locationArg","basename","stripBasename","branches","flattenRoutes","sort","a","b","score","length","slice","every","i","compareIndexes","routesMeta","meta","childrenIndex","rankRouteBranches","matches","decoded","decodePath","matchRouteBranch","convertRouteMatchToUiMatch","match","loaderData","params","data","handle","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","isSplat","s","initialScore","some","filter","reduce","segment","test","branch","matchedParams","matchedPathname","end","remainingPathname","matchPath","Object","pathnameBase","normalizePathname","pattern","matcher","compiledParams","regexpSource","_","paramName","RegExp","compilePath","captureGroups","memo","splatValue","v","decodeURIComponent","toLowerCase","startIndex","nextChar","getInvalidPathError","char","field","dest","JSON","stringify","getPathContributingMatches","getResolveToMatches","v7_relativeSplatPath","pathMatches","resolveTo","toArg","routePathnames","locationPathname","isPathRelative","from","isEmptyPath","toPathname","routePathnameIndex","toSegments","shift","fromPathname","pop","resolvePathname","normalizeSearch","normalizeHash","resolvePath","hasExplicitTrailingSlash","hasCurrentTrailingSlash","paths","AbortedDeferredError","ErrorResponseImpl","constructor","statusText","internal","this","status","isRouteErrorResponse","validMutationMethodsArr","validMutationMethods","validRequestMethodsArr","validRequestMethods","redirectStatusCodes","redirectPreserveMethodStatusCodes","IDLE_NAVIGATION","formMethod","formAction","formEncType","formData","json","text","IDLE_FETCHER","IDLE_BLOCKER","proceed","reset","ABSOLUTE_URL_REGEX","defaultMapRouteProperties","hasErrorBoundary","Boolean","TRANSITIONS_STORAGE_KEY","createRouter","init","routerWindow","isBrowser","createElement","isServer","detectErrorBoundary","inFlightDataRoutes","initialized","dataRoutes","dataStrategyImpl","unstable_dataStrategy","defaultDataStrategy","future","v7_fetcherPersist","v7_normalizeFormMethod","v7_partialHydration","v7_prependBasename","unstable_skipActionErrorRevalidation","unlistenHistory","subscribers","savedScrollPositions","getScrollRestorationKey","getScrollPosition","initialScrollRestored","hydrationData","initialMatches","initialErrors","getInternalRouterError","getShortCircuitMatches","router","hasLazyRoutes","m","lazy","hasLoaders","loader","errors","isRouteInitialized","hydrate","findIndex","pendingNavigationController","historyAction","navigation","restoreScrollPosition","preventScrollReset","revalidation","actionData","fetchers","Map","blockers","pendingAction","HistoryAction","pendingPreventScrollReset","pendingViewTransitionEnabled","appliedViewTransitions","removePageHideEventListener","isUninterruptedRevalidation","isRevalidationRequired","cancelledDeferredRoutes","cancelledFetcherLoads","fetchControllers","incrementingLoadId","pendingNavigationLoadId","fetchReloadIds","fetchRedirectIds","fetchLoadMatches","activeFetchers","deletedFetchers","activeDeferreds","blockerFunctions","ignoreNextHistoryUpdate","updateState","newState","opts","completedFetchers","deletedFetchersKeys","fetcher","has","subscriber","unstable_viewTransitionOpts","viewTransitionOpts","unstable_flushSync","flushSync","delete","deleteFetcher","completeNavigation","_temp","isActionReload","isMutationMethod","_isRedirect","keys","mergeLoaderData","size","k","set","priorPaths","get","currentLocation","nextLocation","toPaths","add","getSavedScrollPosition","async","startNavigation","abort","startUninterruptedRevalidation","getScrollKey","saveScrollPosition","enableViewTransition","routesToUse","loadingNavigation","overrideNavigation","notFoundMatches","cancelActiveDeferreds","isHashChangeOnly","submission","AbortController","pendingActionResult","request","createClientSideRequest","signal","pendingError","findNearestBoundary","type","actionResult","interruptActiveLoads","getSubmittingNavigation","actionMatch","getTargetMatch","callDataStrategy","aborted","shortCircuited","method","routeId","isRedirectResult","normalizeRedirectLocation","response","headers","startRedirectNavigation","isDeferredResult","isErrorResult","boundaryMatch","handleAction","getLoadingNavigation","fetcherSubmission","initialHydration","activeSubmission","getSubmissionFromNavigation","matchesToLoad","revalidatingFetchers","getMatchesToLoad","updatedFetchers","markFetchRedirectsDone","getActionDataForCommit","rf","revalidatingFetcher","getLoadingFetcher","abortFetcher","controller","abortPendingFetchRevalidations","f","loaderResults","fetcherResults","callLoadersAndMaybeResolveData","redirect","findRedirect","fetcherKey","processLoaderData","deferredData","subscribe","done","entries","_ref2","_ref3","didAbortFetchLoads","abortStaleFetchLoads","shouldUpdateFetchers","handleLoaders","_temp2","redirectLocation","isDocumentReload","redirectHistoryAction","results","callDataStrategyImpl","Promise","all","isRedirectHandlerResult","normalizeRelativeRoutingRedirectResponse","convertHandlerResultToDataResult","currentMatches","fetchersToLoad","then","r","resolve","resolveDeferredResults","updateFetcherState","setFetcherError","getFetcher","markFetchersDone","doneFetcher","getDoneFetcher","doneKeys","landedId","yeetedKeys","deleteBlocker","updateBlocker","newBlocker","blocker","shouldBlockNavigation","_ref4","Array","blockerKey","blockerFunction","predicate","cancelledRouteIds","dfd","cancel","y","initialize","_window","transitions","sessionPositions","sessionStorage","getItem","parse","isArray","restoreAppliedTransitions","_saveAppliedTransitions","setItem","persistAppliedTransitions","enableScrollRestoration","positions","getPosition","getKey","navigate","normalizedPath","normalizeTo","fromRouteId","relative","normalizeNavigateOptions","userReplace","unstable_viewTransition","fetch","requestMatches","existingFetcher","getSubmittingFetcher","abortController","fetchRequest","originatingLoadId","revalidationRequest","loadId","loadFetcher","staleKey","handleFetcherAction","resolveDeferredData","handleFetcherLoader","revalidate","count","dispose","clear","getBlocker","_internalFetchControllers","_internalActiveDeferreds","_internalSetRoutes","newRoutes","Symbol","prependBasename","contextualMatches","activeRouteMatch","hasNakedIndexQuery","normalizeFormMethod","isFetcher","body","isSubmissionNavigation","isValidMethod","searchParams","getInvalidBodyError","rawFormMethod","toUpperCase","stripHashFromPath","FormData","URLSearchParams","acc","_ref5","String","convertFormDataToSearchParams","convertSearchParamsToFormData","append","getLoaderMatchesUntilBoundary","boundaryId","boundaryMatches","isInitialLoad","skipActionErrorRevalidation","currentUrl","nextUrl","actionStatus","statusCode","shouldSkipRevalidation","navigationMatches","currentLoaderData","currentMatch","isNew","isMissingData","isNewLoader","currentRouteMatch","nextRouteMatch","shouldRevalidateLoader","currentParams","nextParams","unstable_actionStatus","defaultShouldRevalidate","isNewRouteInstance","fetcherMatches","fetcherMatch","shouldRevalidate","currentPath","loaderMatch","arg","routeChoice","loadLazyRouteModule","lazyRoute","routeToUpdate","routeUpdates","lazyRouteProperty","isPropertyStaticallyDefined","requestContext","routeIdsToLoad","loadedMatches","shouldLoad","handlerOverride","staticContext","onReject","runHandler","handler","reject","abortPromise","handlerPromise","actualHandler","ctx","context","race","handlerError","catch","callLoaderOrAction","handlerResult","isResponse","contentType","deferred","resolveData","isDeferredData","_result$init","_result$init2","Headers","trimmedMatches","normalizedLocation","protocol","isSameBasename","Request","processRouteLoaderData","skipLoaderErrorBubbling","foundError","loaderHeaders","newLoaderData","mergedLoaderData","hasOwnProperty","reverse","find","_temp5","errorMessage","signals","isRevalidatingLoader","unwrap","unwrappedData","getAll","matchersByWindow","WeakMap","getMatcher","query","targetWindow","matchers","mql","matchMedia","refCount","media","useMediaQuery","setMatches","useState","useEffect","handleChange","addListener","removeListener","breakpointValues","names","and","next","getMaxQuery","breakpoint","min","getNext","breakpointOrMap","direction","breakpointMap","useMemo","getMinQuery","createBreakpointHook","xs","sm","md","lg","xl","xxl","useCallbackRef","ref","useRef","useEventCallback","useCommittedRef","useCallback","args","useEventListener","eventTarget","event","capture","target","useForceUpdate","dispatch","useReducer","isReactNative","global","navigator","product","useLayoutEffect","toFnRef","refA","refB","mergeRefs","useMounted","mounted","isMounted","usePrevious","MAX_DELAY_MS","setChainedTimeout","handleRef","timeoutAtMs","delayMs","Date","now","setTimeout","useTimeout","useWillUnmount","clearTimeout","onUnmount","valueRef","useUpdatedRef","_excluded","Anchor","React","onKeyDown","props","source","excluded","sourceKeys","_objectWithoutPropertiesLoose","buttonProps","useButtonProps","tagName","handleKeyDown","trim","role","_jsx","displayName","disabled","rel","onClick","tabIndex","handleClick","isTrivialHref","preventDefault","stopPropagation","Button","as","asProp","Component","dataAttr","property","dataProp","useRefWithUpdate","forceUpdate","attachRef","element","Dropdown","defaultShow","show","rawShow","onSelect","onToggle","rawOnToggle","itemSelector","focusFirstItemOnShow","placement","useWindow","useUncontrolledProp","menuRef","setMenu","menuElement","toggleRef","setToggle","toggleElement","lastShow","lastSourceEvent","focusInDropdown","onSelectCtx","useContext","SelectableContext","toggle","nextShow","originalEvent","handleSelect","isPropagationStopped","contains","ownerDocument","activeElement","focusToggle","focus","maybeFocusFirst","focusType","isRoleMenu","qsa","getNextFocusedChild","offset","items","max","_menuRef$current","_toggleRef$current","fromMenu","fromToggle","_menuRef$current2","once","DropdownContext","Menu","DropdownMenu","Toggle","DropdownToggle","Item","DropdownItem","useDropdownItem","active","navContext","NavContext","activeKey","eventKey","makeEventKey","isActive","dropdownItemProps","noop","useDropdownMenu","arrowElement","attachArrowRef","hasShownRef","flip","rootCloseEvent","fixed","placementOverride","popperConfig","enableEventListeners","usePopper","shouldUsePopper","popper","mergeOptionsWithPopperConfig","enabled","enableEvents","menuProps","attributes","style","styles","metadata","hasShown","arrowProps","arrow","useClickOutside","clickTrigger","_Fragment","defaultProps","el","_el$getAttribute","getAttribute","useDropdownToggle","useSSRSafeId","ImperativeTransition","in","inProp","onExited","onEntered","transition","exited","setExited","onTransition","isInitialRef","handleTransition","useIsomorphicEffect","stale","initial","isStale","useTransition","combinedRef","useMergedRefs","cloneElement","renderTransition","runTransition","NoopTransition","manager","useModalManager","provided","modalManager","ModalManager","getManager","modal","dialog","backdrop","remove","isTopModal","setDialogRef","setBackdropRef","Modal","forwardRef","className","keyboard","onBackdropClick","onEscapeKeyDown","backdropTransition","runBackdropTransition","autoFocus","enforceFocus","restoreFocus","restoreFocusOptions","renderDialog","renderBackdrop","providedManager","container","containerRef","onShow","onHide","onExit","onExiting","onEnter","onEntering","ownerWindow","useWaitForDOMRef","prevShow","lastFocusRef","useImperativeHandle","canUseDOM","handleShow","removeKeydownListenerRef","handleDocumentKeyDown","removeFocusListenerRef","handleEnforceFocus","_modal$dialog$ownerDo","_modal$dialog","currentActiveElement","handleHide","_lastFocusRef$current","handleBackdropClick","currentTarget","isEscKey","defaultPrevented","dialogProps","unmountOnExit","mountOnEnter","appear","backdropElement","ReactDOM","_jsxs","Manager","OPEN_DATA_ATTRIBUTE","handleContainerOverflow","isRTL","modals","getScrollbarWidth","abs","innerWidth","documentElement","clientWidth","getBodyScrollbarWidth","getElement","setModalAttributes","_modal","removeModalAttributes","setContainerStyle","containerState","overflow","paddingProp","scrollBarWidth","parseInt","css","setAttribute","removeContainerStyle","removeAttribute","modalIdx","splice","EVENT_KEY_ATTR","Nav","needsRefocusRef","parentOnSelect","tabContext","TabContext","getControlledId","getControllerId","listNode","getNextActiveTab","currentListNode","activeChild","querySelector","mergedRef","nextActiveChild","dataset","NavItem","useNavItem","contextControllerId","contextControlledId","hasEnteredRef","handleExited","child","onRootClose","onClose","handleKeyUp","doc","getRefTarget","currentEvent","removeKeyupListener","Overlay","outerRef","containerPadding","Transition","rootElement","mountOverlay","useRootClose","rootClose","rootCloseDisabled","_excluded2","_excluded3","useTabPanel","TabPanel","tabPanelProps","hidden","Tabs","userId","generateChildId","generateCustomChildId","propsOnSelect","propsActiveKey","defaultActiveKey","Panel","toModifierArray","_modifiers$eventListe","_modifiers$preventOve","_modifiers$preventOve2","_modifiers$offset","_modifiers$arrow","modifiers","toModifierMap","strategy","eventListeners","preventOverflow","padding","InitialTriggerEvents","click","mouseup","pointerup","onClickOutside","preventMouseClickOutsideRef","waitingForTrigger","handleMouseCapture","metaKey","altKey","ctrlKey","shiftKey","button","isLeftClickEvent","handleInitialMouse","handleMouse","_ownerWindow$event","_ownerWindow$parent","parent","removeInitialTriggerListener","removeMouseCaptureListener","removeMouseListener","mobileSafariHackListeners","call","nextState","createPopper","popperGenerator","defaultModifiers","hide","popperOffsets","computeStyles","disabledApplyStylesModifier","phase","ariaDescribedByModifier","effect","reference","elements","ids","_popper$getAttribute","EMPTY_MODIFIERS","referenceElement","popperElement","config","prevModifiers","popperInstanceRef","update","_popperInstanceRef$cu","_popperInstanceRef$cu2","popperState","setState","useSafeState","updateModifier","requires","nextModifiers","dequal","setOptions","destroy","resolveContainerRef","getBoundingClientRect","onResolved","resolvedRef","setRef","earlyRef","nextRef","Context","createContext","Provider","code","keyCode","module","exports","utils","require","settle","cookies","buildURL","buildFullPath","parseHeaders","isURLSameOrigin","transitionalDefaults","AxiosError","CanceledError","parseProtocol","platform","onCanceled","requestData","requestHeaders","responseType","withXSRFToken","cancelToken","unsubscribe","isFormData","isStandardBrowserEnv","XMLHttpRequest","auth","username","password","unescape","encodeURIComponent","Authorization","btoa","fullPath","baseURL","onloadend","responseHeaders","getAllResponseHeaders","responseText","err","open","paramsSerializer","timeout","onreadystatechange","readyState","responseURL","onabort","ECONNABORTED","onerror","ERR_NETWORK","ontimeout","timeoutErrorMessage","transitional","clarifyTimeoutError","ETIMEDOUT","isFunction","xsrfValue","xsrfHeaderName","xsrfCookieName","read","val","setRequestHeader","isUndefined","withCredentials","onDownloadProgress","onUploadProgress","upload","protocols","ERR_BAD_REQUEST","send","bind","Axios","mergeConfig","defaults","formDataToJSON","axios","createInstance","defaultConfig","instance","prototype","extend","create","instanceConfig","CancelToken","isCancel","VERSION","toFormData","Cancel","promises","spread","isAxiosError","formToJSON","thing","isHTMLForm","executor","TypeError","resolvePromise","promise","token","_listeners","onfulfilled","_resolve","reason","throwIfRequested","c","ERR_CANCELED","inherits","__CANCEL__","InterceptorManager","dispatchRequest","validator","validators","interceptors","configOrUrl","assertOptions","silentJSONParsing","boolean","forcedJSONParsing","encode","function","serialize","requestInterceptorChain","synchronousRequestInterceptors","interceptor","runWhen","synchronous","unshift","fulfilled","rejected","responseInterceptorChain","chain","apply","newConfig","onFulfilled","onRejected","getUri","generateHTTPMethod","isForm","captureStackTrace","stack","toJSON","description","number","fileName","lineNumber","columnNumber","descriptors","defineProperties","defineProperty","customProps","axiosError","toFlatObject","obj","cause","handlers","use","eject","h","isAbsoluteURL","combineURLs","requestedURL","transformData","normalizeHeaderName","throwIfCancellationRequested","transformRequest","merge","common","adapter","transformResponse","config1","config2","getMergedValue","isPlainObject","isEmptyObject","mergeDeepProperties","prop","valueFromConfig2","defaultToConfig2","mergeDirectKeys","mergeMap","configValue","validateStatus","ERR_BAD_RESPONSE","floor","fns","toURLEncodedForm","DEFAULT_CONTENT_TYPE","setContentTypeIfUnset","process","getDefaultAdapter","isFileList","hasJSONContentType","isObjectPayload","isObject","isArrayBuffer","isBuffer","isStream","isFile","isBlob","isArrayBufferView","buffer","isURLSearchParams","formSerializer","_FormData","env","rawValue","parser","encoder","isString","stringifySafely","JSONRequested","strictJSONParsing","maxContentLength","maxBodyLength","classes","Blob","str","charMap","AxiosURLSearchParams","_pairs","_encode","pair","thisArg","arguments","hashmarkIndex","serializedParams","serializeFn","relativeURL","write","expires","domain","secure","cookie","isNumber","toGMTString","buildPath","isNumericKey","Number","isFinite","isLast","arr","len","arrayToObject","forEachEntry","matchAll","parsePropPath","payload","originURL","msie","userAgent","urlParsingNode","resolveURL","host","hostname","port","requestURL","parsed","normalizedName","ignoreDuplicateOf","line","exec","callback","envFormData","isVisitable","removeBrackets","renderKey","dots","predicates","metaTokens","indexes","option","visitor","defaultVisitor","useBlob","toStringTag","iterator","convertValue","isDate","toISOString","isTypedArray","Buffer","isFlatArray","toArray","exposedHelpers","build","helpers","isNode","deprecatedWarnings","version","formatMessage","opt","desc","ERR_DEPRECATED","schema","allowUnknown","ERR_BAD_OPTION_VALUE","ERR_BAD_OPTION","cache","kindOf","kindOfTest","getPrototypeOf","l","TypedArray","Uint8Array","_hasOwnProperty","ArrayBuffer","isView","pipe","assignValue","stripBOM","content","charCodeAt","superConstructor","sourceObj","destObj","propFilter","merged","getOwnPropertyNames","searchString","position","lastIndex","regExp","changes","change","operation","ret","added","removed","escapeHTML","oldArr","newArr","arrayDiff","diff","_base","Diff","tokenize","removeEmpty","buildValues","components","newString","oldString","useLongestToken","componentPos","componentLen","newPos","oldPos","component","tmp","oldValue","lastComponent","equals","clonePath","self","castInput","newLen","oldLen","editLength","maxEditLength","bestPath","extractCommon","execEditLength","diagonalPath","basePath","addPath","removePath","canAdd","canRemove","pushComponent","last","commonCount","left","right","comparator","ignoreCase","array","chars","oldStr","newStr","characterDiff","cssDiff","oldObj","newObj","jsonDiff","_line","objectPrototypeToString","canonicalize","replacementStack","replacer","canonicalizedObj","_typeof","sortedKeys","lineDiff","undefinedReplacement","stringifyReplacer","generateOptions","ignoreWhitespace","_params","retLines","linesAndNewlines","newlineIsToken","sentenceDiff","wordDiff","extendedWordChars","reWhitespace","tokens","_character","_word","_sentence","_css","_json","_array","_apply","_parse","_merge","_create","_dmp","_xml","uniDiff","parsePatch","currentIndex","processIndex","complete","loadFile","updatedContent","applyPatch","patched","_distanceIterator","removeEOFNL","addEOFNL","lines","delimiters","hunks","compareLine","patchContent","errorCount","fuzzFactor","minLine","hunkFits","hunk","toPos","j","maxLine","oldLines","localOffset","oldStart","distanceIterator","diffOffset","newLines","delimiter","linedelimiters","previousOperation","_k","oldHeader","newHeader","createTwoFilesPatch","structuredPatch","oldFileName","newFileName","diffLines","oldRangeStart","newRangeStart","curRange","oldLine","newLine","prev","contextLines","_curRange","_toConsumableArray","entry","_curRange2","contextSize","_curRange3","newStart","oldEOFNewline","newEOFNewline","noNlBeforeAdds","_loop","formatPatch","mine","theirs","loadPatch","fileNameChanged","selectField","mineIndex","theirsIndex","mineOffset","theirsOffset","mineCurrent","Infinity","theirsCurrent","hunkBefore","cloneHunk","mergedHunk","mergeLines","calcLineCount","calcOldNewLineCount","param","patch","conflict","check","mineLines","theirOffset","theirLines","their","insertLeading","theirCurrent","_hunk$lines","collectChange","_hunk$lines2","removal","mutualChange","insertTrailing","myChanges","theirChanges","allRemoves","arrayStartsWith","skipRemoveSuperset","_hunk$lines3","_hunk$lines4","arrayEqual","_hunk$lines5","swap","matchChanges","matchIndex","contextChanges","conflicted","collectContext","_hunk$lines6","insert","removeChanges","changeContent","myCount","theirCount","diffstr","list","parseIndex","header","parseFileHeader","parseHunk","strict","fileHeader","keyPrefix","chunkHeaderIndex","chunkHeader","addCount","removeCount","start","wantForward","backwardExhausted","forwardExhausted"],"sourceRoot":""}