{"version":3,"file":"static/js/chunk-mix3.e94515bd.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/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","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/bind.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/utils.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/core/AxiosError.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/toFormData.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/AxiosURLSearchParams.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/buildURL.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/core/InterceptorManager.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/defaults/transitional.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/platform/browser/index.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/platform/browser/classes/URLSearchParams.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/platform/browser/classes/FormData.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/platform/browser/classes/Blob.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/platform/common/utils.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/platform/index.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/formDataToJSON.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/defaults/index.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/toURLEncodedForm.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/parseHeaders.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/core/AxiosHeaders.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/core/transformData.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/cancel/isCancel.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/cancel/CanceledError.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/core/settle.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/speedometer.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/throttle.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/progressEventReducer.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/isURLSameOrigin.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/cookies.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/core/buildFullPath.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/isAbsoluteURL.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/combineURLs.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/core/mergeConfig.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/resolveConfig.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/adapters/xhr.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/parseProtocol.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/composeSignals.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/trackStream.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/adapters/fetch.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/adapters/adapters.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/null.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/core/dispatchRequest.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/env/data.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/validator.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/core/Axios.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/cancel/CancelToken.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/HttpStatusCode.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/axios.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/spread.js","../node_modules/.pnpm/axios@1.7.7/node_modules/axios/lib/helpers/isAxiosError.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}","// 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","'use strict';\n\nexport default function bind(fn, thisArg) {\n  return function wrap() {\n    return fn.apply(thisArg, arguments);\n  };\n}\n","'use strict';\n\nimport bind from './helpers/bind.js';\n\n// utils is a library of generic helper functions non-specific to axios\n\nconst {toString} = Object.prototype;\nconst {getPrototypeOf} = Object;\n\nconst kindOf = (cache => thing => {\n    const str = toString.call(thing);\n    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());\n})(Object.create(null));\n\nconst kindOfTest = (type) => {\n  type = type.toLowerCase();\n  return (thing) => kindOf(thing) === type\n}\n\nconst typeOfTest = type => thing => typeof thing === type;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n *\n * @returns {boolean} True if value is an Array, otherwise false\n */\nconst {isArray} = Array;\n\n/**\n * Determine if a value is undefined\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nconst isUndefined = typeOfTest('undefined');\n\n/**\n * Determine if a value is a Buffer\n *\n * @param {*} val The value to test\n *\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    && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nconst isArrayBuffer = kindOfTest('ArrayBuffer');\n\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n  let 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 {*} val The value to test\n *\n * @returns {boolean} True if value is a String, otherwise false\n */\nconst isString = typeOfTest('string');\n\n/**\n * Determine if a value is a Function\n *\n * @param {*} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nconst isFunction = typeOfTest('function');\n\n/**\n * Determine if a value is a Number\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Number, otherwise false\n */\nconst isNumber = typeOfTest('number');\n\n/**\n * Determine if a value is an Object\n *\n * @param {*} thing The value to test\n *\n * @returns {boolean} True if value is an Object, otherwise false\n */\nconst isObject = (thing) => thing !== null && typeof thing === 'object';\n\n/**\n * Determine if a value is a Boolean\n *\n * @param {*} thing The value to test\n * @returns {boolean} True if value is a Boolean, otherwise false\n */\nconst isBoolean = thing => thing === true || thing === false;\n\n/**\n * Determine if a value is a plain Object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a plain Object, otherwise false\n */\nconst isPlainObject = (val) => {\n  if (kindOf(val) !== 'object') {\n    return false;\n  }\n\n  const prototype = getPrototypeOf(val);\n  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in val) && !(Symbol.iterator in val);\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Date, otherwise false\n */\nconst isDate = kindOfTest('Date');\n\n/**\n * Determine if a value is a File\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a File, otherwise false\n */\nconst isFile = kindOfTest('File');\n\n/**\n * Determine if a value is a Blob\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nconst isBlob = kindOfTest('Blob');\n\n/**\n * Determine if a value is a FileList\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a File, otherwise false\n */\nconst isFileList = kindOfTest('FileList');\n\n/**\n * Determine if a value is a Stream\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nconst isStream = (val) => isObject(val) && isFunction(val.pipe);\n\n/**\n * Determine if a value is a FormData\n *\n * @param {*} thing The value to test\n *\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nconst isFormData = (thing) => {\n  let kind;\n  return thing && (\n    (typeof FormData === 'function' && thing instanceof FormData) || (\n      isFunction(thing.append) && (\n        (kind = kindOf(thing)) === 'formdata' ||\n        // detect form-data instance\n        (kind === 'object' && isFunction(thing.toString) && thing.toString() === '[object FormData]')\n      )\n    )\n  )\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nconst isURLSearchParams = kindOfTest('URLSearchParams');\n\nconst [isReadableStream, isRequest, isResponse, isHeaders] = ['ReadableStream', 'Request', 'Response', 'Headers'].map(kindOfTest);\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n *\n * @returns {String} The String freed of excess whitespace\n */\nconst trim = (str) => str.trim ?\n  str.trim() : str.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '');\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 *\n * @param {Boolean} [allOwnKeys = false]\n * @returns {any}\n */\nfunction forEach(obj, fn, {allOwnKeys = false} = {}) {\n  // Don't bother if no value provided\n  if (obj === null || typeof obj === 'undefined') {\n    return;\n  }\n\n  let i;\n  let l;\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 (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    const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);\n    const len = keys.length;\n    let key;\n\n    for (i = 0; i < len; i++) {\n      key = keys[i];\n      fn.call(null, obj[key], key, obj);\n    }\n  }\n}\n\nfunction findKey(obj, key) {\n  key = key.toLowerCase();\n  const keys = Object.keys(obj);\n  let i = keys.length;\n  let _key;\n  while (i-- > 0) {\n    _key = keys[i];\n    if (key === _key.toLowerCase()) {\n      return _key;\n    }\n  }\n  return null;\n}\n\nconst _global = (() => {\n  /*eslint no-undef:0*/\n  if (typeof globalThis !== \"undefined\") return globalThis;\n  return typeof self !== \"undefined\" ? self : (typeof window !== 'undefined' ? window : global)\n})();\n\nconst isContextDefined = (context) => !isUndefined(context) && context !== _global;\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 *\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n  const {caseless} = isContextDefined(this) && this || {};\n  const result = {};\n  const assignValue = (val, key) => {\n    const targetKey = caseless && findKey(result, key) || key;\n    if (isPlainObject(result[targetKey]) && isPlainObject(val)) {\n      result[targetKey] = merge(result[targetKey], val);\n    } else if (isPlainObject(val)) {\n      result[targetKey] = merge({}, val);\n    } else if (isArray(val)) {\n      result[targetKey] = val.slice();\n    } else {\n      result[targetKey] = val;\n    }\n  }\n\n  for (let i = 0, l = arguments.length; i < l; i++) {\n    arguments[i] && 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 *\n * @param {Boolean} [allOwnKeys]\n * @returns {Object} The resulting value of object a\n */\nconst extend = (a, b, thisArg, {allOwnKeys}= {}) => {\n  forEach(b, (val, key) => {\n    if (thisArg && isFunction(val)) {\n      a[key] = bind(val, thisArg);\n    } else {\n      a[key] = val;\n    }\n  }, {allOwnKeys});\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 *\n * @returns {string} content value without BOM\n */\nconst 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 * @returns {void}\n */\nconst inherits = (constructor, superConstructor, props, descriptors) => {\n  constructor.prototype = Object.create(superConstructor.prototype, descriptors);\n  constructor.prototype.constructor = constructor;\n  Object.defineProperty(constructor, 'super', {\n    value: superConstructor.prototype\n  });\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 *\n * @returns {Object}\n */\nconst toFlatObject = (sourceObj, destObj, filter, propFilter) => {\n  let props;\n  let i;\n  let prop;\n  const 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 && 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 *\n * @param {String} str\n * @param {String} searchString\n * @param {Number} [position= 0]\n *\n * @returns {boolean}\n */\nconst 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  const 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 *\n * @param {*} [thing]\n *\n * @returns {?Array}\n */\nconst toArray = (thing) => {\n  if (!thing) return null;\n  if (isArray(thing)) return thing;\n  let i = thing.length;\n  if (!isNumber(i)) return null;\n  const arr = new Array(i);\n  while (i-- > 0) {\n    arr[i] = thing[i];\n  }\n  return arr;\n}\n\n/**\n * Checking if the Uint8Array exists and if it does, it returns a function that checks if the\n * thing passed in is an instance of Uint8Array\n *\n * @param {TypedArray}\n *\n * @returns {Array}\n */\n// eslint-disable-next-line func-names\nconst isTypedArray = (TypedArray => {\n  // eslint-disable-next-line func-names\n  return thing => {\n    return TypedArray && thing instanceof TypedArray;\n  };\n})(typeof Uint8Array !== 'undefined' && getPrototypeOf(Uint8Array));\n\n/**\n * For each entry in the object, call the function with the key and value.\n *\n * @param {Object<any, any>} obj - The object to iterate over.\n * @param {Function} fn - The function to call for each entry.\n *\n * @returns {void}\n */\nconst forEachEntry = (obj, fn) => {\n  const generator = obj && obj[Symbol.iterator];\n\n  const iterator = generator.call(obj);\n\n  let result;\n\n  while ((result = iterator.next()) && !result.done) {\n    const pair = result.value;\n    fn.call(obj, pair[0], pair[1]);\n  }\n}\n\n/**\n * It takes a regular expression and a string, and returns an array of all the matches\n *\n * @param {string} regExp - The regular expression to match against.\n * @param {string} str - The string to search.\n *\n * @returns {Array<boolean>}\n */\nconst matchAll = (regExp, str) => {\n  let matches;\n  const arr = [];\n\n  while ((matches = regExp.exec(str)) !== null) {\n    arr.push(matches);\n  }\n\n  return arr;\n}\n\n/* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */\nconst isHTMLForm = kindOfTest('HTMLFormElement');\n\nconst toCamelCase = str => {\n  return str.toLowerCase().replace(/[-_\\s]([a-z\\d])(\\w*)/g,\n    function replacer(m, p1, p2) {\n      return p1.toUpperCase() + p2;\n    }\n  );\n};\n\n/* Creating a function that will check if an object has a property. */\nconst hasOwnProperty = (({hasOwnProperty}) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype);\n\n/**\n * Determine if a value is a RegExp object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a RegExp object, otherwise false\n */\nconst isRegExp = kindOfTest('RegExp');\n\nconst reduceDescriptors = (obj, reducer) => {\n  const descriptors = Object.getOwnPropertyDescriptors(obj);\n  const reducedDescriptors = {};\n\n  forEach(descriptors, (descriptor, name) => {\n    let ret;\n    if ((ret = reducer(descriptor, name, obj)) !== false) {\n      reducedDescriptors[name] = ret || descriptor;\n    }\n  });\n\n  Object.defineProperties(obj, reducedDescriptors);\n}\n\n/**\n * Makes all methods read-only\n * @param {Object} obj\n */\n\nconst freezeMethods = (obj) => {\n  reduceDescriptors(obj, (descriptor, name) => {\n    // skip restricted props in strict mode\n    if (isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {\n      return false;\n    }\n\n    const value = obj[name];\n\n    if (!isFunction(value)) return;\n\n    descriptor.enumerable = false;\n\n    if ('writable' in descriptor) {\n      descriptor.writable = false;\n      return;\n    }\n\n    if (!descriptor.set) {\n      descriptor.set = () => {\n        throw Error('Can not rewrite read-only method \\'' + name + '\\'');\n      };\n    }\n  });\n}\n\nconst toObjectSet = (arrayOrString, delimiter) => {\n  const obj = {};\n\n  const define = (arr) => {\n    arr.forEach(value => {\n      obj[value] = true;\n    });\n  }\n\n  isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));\n\n  return obj;\n}\n\nconst noop = () => {}\n\nconst toFiniteNumber = (value, defaultValue) => {\n  return value != null && Number.isFinite(value = +value) ? value : defaultValue;\n}\n\nconst ALPHA = 'abcdefghijklmnopqrstuvwxyz'\n\nconst DIGIT = '0123456789';\n\nconst ALPHABET = {\n  DIGIT,\n  ALPHA,\n  ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT\n}\n\nconst generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => {\n  let str = '';\n  const {length} = alphabet;\n  while (size--) {\n    str += alphabet[Math.random() * length|0]\n  }\n\n  return str;\n}\n\n/**\n * If the thing is a FormData object, return true, otherwise return false.\n *\n * @param {unknown} thing - The thing to check.\n *\n * @returns {boolean}\n */\nfunction isSpecCompliantForm(thing) {\n  return !!(thing && isFunction(thing.append) && thing[Symbol.toStringTag] === 'FormData' && thing[Symbol.iterator]);\n}\n\nconst toJSONObject = (obj) => {\n  const stack = new Array(10);\n\n  const visit = (source, i) => {\n\n    if (isObject(source)) {\n      if (stack.indexOf(source) >= 0) {\n        return;\n      }\n\n      if(!('toJSON' in source)) {\n        stack[i] = source;\n        const target = isArray(source) ? [] : {};\n\n        forEach(source, (value, key) => {\n          const reducedValue = visit(value, i + 1);\n          !isUndefined(reducedValue) && (target[key] = reducedValue);\n        });\n\n        stack[i] = undefined;\n\n        return target;\n      }\n    }\n\n    return source;\n  }\n\n  return visit(obj, 0);\n}\n\nconst isAsyncFn = kindOfTest('AsyncFunction');\n\nconst isThenable = (thing) =>\n  thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);\n\n// original code\n// https://github.com/DigitalBrainJS/AxiosPromise/blob/16deab13710ec09779922131f3fa5954320f83ab/lib/utils.js#L11-L34\n\nconst _setImmediate = ((setImmediateSupported, postMessageSupported) => {\n  if (setImmediateSupported) {\n    return setImmediate;\n  }\n\n  return postMessageSupported ? ((token, callbacks) => {\n    _global.addEventListener(\"message\", ({source, data}) => {\n      if (source === _global && data === token) {\n        callbacks.length && callbacks.shift()();\n      }\n    }, false);\n\n    return (cb) => {\n      callbacks.push(cb);\n      _global.postMessage(token, \"*\");\n    }\n  })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);\n})(\n  typeof setImmediate === 'function',\n  isFunction(_global.postMessage)\n);\n\nconst asap = typeof queueMicrotask !== 'undefined' ?\n  queueMicrotask.bind(_global) : ( typeof process !== 'undefined' && process.nextTick || _setImmediate);\n\n// *********************\n\nexport default {\n  isArray,\n  isArrayBuffer,\n  isBuffer,\n  isFormData,\n  isArrayBufferView,\n  isString,\n  isNumber,\n  isBoolean,\n  isObject,\n  isPlainObject,\n  isReadableStream,\n  isRequest,\n  isResponse,\n  isHeaders,\n  isUndefined,\n  isDate,\n  isFile,\n  isBlob,\n  isRegExp,\n  isFunction,\n  isStream,\n  isURLSearchParams,\n  isTypedArray,\n  isFileList,\n  forEach,\n  merge,\n  extend,\n  trim,\n  stripBOM,\n  inherits,\n  toFlatObject,\n  kindOf,\n  kindOfTest,\n  endsWith,\n  toArray,\n  forEachEntry,\n  matchAll,\n  isHTMLForm,\n  hasOwnProperty,\n  hasOwnProp: hasOwnProperty, // an alias to avoid ESLint no-prototype-builtins detection\n  reduceDescriptors,\n  freezeMethods,\n  toObjectSet,\n  toCamelCase,\n  noop,\n  toFiniteNumber,\n  findKey,\n  global: _global,\n  isContextDefined,\n  ALPHABET,\n  generateString,\n  isSpecCompliantForm,\n  toJSONObject,\n  isAsyncFn,\n  isThenable,\n  setImmediate: _setImmediate,\n  asap\n};\n","'use strict';\n\nimport utils from '../utils.js';\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 *\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  if (response) {\n    this.response = response;\n    this.status = response.status ? response.status : null;\n  }\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: utils.toJSONObject(this.config),\n      code: this.code,\n      status: this.status\n    };\n  }\n});\n\nconst prototype = AxiosError.prototype;\nconst 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(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 = (error, code, config, request, response, customProps) => {\n  const axiosError = Object.create(prototype);\n\n  utils.toFlatObject(error, axiosError, function filter(obj) {\n    return obj !== Error.prototype;\n  }, prop => {\n    return prop !== 'isAxiosError';\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\nexport default AxiosError;\n","'use strict';\n\nimport utils from '../utils.js';\nimport AxiosError from '../core/AxiosError.js';\n// temporary hotfix to avoid circular references until AxiosURLSearchParams is refactored\nimport PlatformFormData from '../platform/node/classes/FormData.js';\n\n/**\n * Determines if the given thing is a array or js object.\n *\n * @param {string} thing - The object or array to be visited.\n *\n * @returns {boolean}\n */\nfunction isVisitable(thing) {\n  return utils.isPlainObject(thing) || utils.isArray(thing);\n}\n\n/**\n * It removes the brackets from the end of a string\n *\n * @param {string} key - The key of the parameter.\n *\n * @returns {string} the key without the brackets.\n */\nfunction removeBrackets(key) {\n  return utils.endsWith(key, '[]') ? key.slice(0, -2) : key;\n}\n\n/**\n * It takes a path, a key, and a boolean, and returns a string\n *\n * @param {string} path - The path to the current key.\n * @param {string} key - The key of the current object being iterated over.\n * @param {string} dots - If true, the key will be rendered with dots instead of brackets.\n *\n * @returns {string} The path to the current key.\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\n/**\n * If the array is an array and none of its elements are visitable, then it's a flat array.\n *\n * @param {Array<any>} arr - The array to check\n *\n * @returns {boolean}\n */\nfunction isFlatArray(arr) {\n  return utils.isArray(arr) && !arr.some(isVisitable);\n}\n\nconst predicates = utils.toFlatObject(utils, {}, null, function filter(prop) {\n  return /^is[A-Z]/.test(prop);\n});\n\n/**\n * Convert a data object to FormData\n *\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 *\n * @returns {Object}\n **/\n\n/**\n * It converts an object into a FormData object\n *\n * @param {Object<any, any>} obj - The object to convert to form data.\n * @param {string} formData - The FormData object to append to.\n * @param {Object<string, any>} options\n *\n * @returns\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 (PlatformFormData || 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  const metaTokens = options.metaTokens;\n  // eslint-disable-next-line no-use-before-define\n  const visitor = options.visitor || defaultVisitor;\n  const dots = options.dots;\n  const indexes = options.indexes;\n  const _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;\n  const useBlob = _Blob && utils.isSpecCompliantForm(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   * Default visitor.\n   *\n   * @param {*} value\n   * @param {String|Number} key\n   * @param {Array<String|Number>} path\n   * @this {FormData}\n   *\n   * @returns {boolean} return true to visit the each prop of the value recursively\n   */\n  function defaultVisitor(value, key, path) {\n    let 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) || el === null) && 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  const stack = [];\n\n  const exposedHelpers = Object.assign(predicates, {\n    defaultVisitor,\n    convertValue,\n    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      const result = !(utils.isUndefined(el) || el === null) && 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\nexport default toFormData;\n","'use strict';\n\nimport toFormData from './toFormData.js';\n\n/**\n * It encodes a string by replacing all characters that are not in the unreserved set with\n * their percent-encoded equivalents\n *\n * @param {string} str - The string to encode.\n *\n * @returns {string} The encoded string.\n */\nfunction encode(str) {\n  const 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\n/**\n * It takes a params object and converts it to a FormData object\n *\n * @param {Object<string, any>} params - The parameters to be converted to a FormData object.\n * @param {Object<string, any>} options - The options object passed to the Axios constructor.\n *\n * @returns {void}\n */\nfunction AxiosURLSearchParams(params, options) {\n  this._pairs = [];\n\n  params && toFormData(params, this, options);\n}\n\nconst prototype = AxiosURLSearchParams.prototype;\n\nprototype.append = function append(name, value) {\n  this._pairs.push([name, value]);\n};\n\nprototype.toString = function toString(encoder) {\n  const _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\nexport default AxiosURLSearchParams;\n","'use strict';\n\nimport utils from '../utils.js';\nimport AxiosURLSearchParams from '../helpers/AxiosURLSearchParams.js';\n\n/**\n * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their\n * URI encoded counterparts\n *\n * @param {string} val The value to be encoded.\n *\n * @returns {string} The encoded value.\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 *\n * @returns {string} The formatted url\n */\nexport default function buildURL(url, params, options) {\n  /*eslint no-param-reassign:0*/\n  if (!params) {\n    return url;\n  }\n  \n  const _encode = options && options.encode || encode;\n\n  const serializeFn = options && options.serialize;\n\n  let 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    const hashmarkIndex = url.indexOf(\"#\");\n\n    if (hashmarkIndex !== -1) {\n      url = url.slice(0, hashmarkIndex);\n    }\n    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n  }\n\n  return url;\n}\n","'use strict';\n\nimport utils from './../utils.js';\n\nclass InterceptorManager {\n  constructor() {\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   */\n  use(fulfilled, rejected, options) {\n    this.handlers.push({\n      fulfilled,\n      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   *\n   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise\n   */\n  eject(id) {\n    if (this.handlers[id]) {\n      this.handlers[id] = null;\n    }\n  }\n\n  /**\n   * Clear all interceptors from the stack\n   *\n   * @returns {void}\n   */\n  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   *\n   * @returns {void}\n   */\n  forEach(fn) {\n    utils.forEach(this.handlers, function forEachHandler(h) {\n      if (h !== null) {\n        fn(h);\n      }\n    });\n  }\n}\n\nexport default InterceptorManager;\n","'use strict';\n\nexport default {\n  silentJSONParsing: true,\n  forcedJSONParsing: true,\n  clarifyTimeoutError: false\n};\n","import URLSearchParams from './classes/URLSearchParams.js'\nimport FormData from './classes/FormData.js'\nimport Blob from './classes/Blob.js'\n\nexport default {\n  isBrowser: true,\n  classes: {\n    URLSearchParams,\n    FormData,\n    Blob\n  },\n  protocols: ['http', 'https', 'file', 'blob', 'url', 'data']\n};\n","'use strict';\n\nimport AxiosURLSearchParams from '../../../helpers/AxiosURLSearchParams.js';\nexport default typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;\n","'use strict';\n\nexport default typeof FormData !== 'undefined' ? FormData : null;\n","'use strict'\n\nexport default typeof Blob !== 'undefined' ? Blob : null\n","const hasBrowserEnv = typeof window !== 'undefined' && typeof document !== 'undefined';\n\nconst _navigator = typeof navigator === 'object' && navigator || undefined;\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 *\n * @returns {boolean}\n */\nconst hasStandardBrowserEnv = hasBrowserEnv &&\n  (!_navigator || ['ReactNative', 'NativeScript', 'NS'].indexOf(_navigator.product) < 0);\n\n/**\n * Determine if we're running in a standard browser webWorker environment\n *\n * Although the `isStandardBrowserEnv` method indicates that\n * `allows axios to run in a web worker`, the WebWorker will still be\n * filtered out due to its judgment standard\n * `typeof window !== 'undefined' && typeof document !== 'undefined'`.\n * This leads to a problem when axios post `FormData` in webWorker\n */\nconst hasStandardBrowserWebWorkerEnv = (() => {\n  return (\n    typeof WorkerGlobalScope !== 'undefined' &&\n    // eslint-disable-next-line no-undef\n    self instanceof WorkerGlobalScope &&\n    typeof self.importScripts === 'function'\n  );\n})();\n\nconst origin = hasBrowserEnv && window.location.href || 'http://localhost';\n\nexport {\n  hasBrowserEnv,\n  hasStandardBrowserWebWorkerEnv,\n  hasStandardBrowserEnv,\n  _navigator as navigator,\n  origin\n}\n","import platform from './node/index.js';\nimport * as utils from './common/utils.js';\n\nexport default {\n  ...utils,\n  ...platform\n}\n","'use strict';\n\nimport utils from '../utils.js';\n\n/**\n * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']\n *\n * @param {string} name - The name of the property to get.\n *\n * @returns An array of strings.\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(match => {\n    return match[0] === '[]' ? '' : match[1] || match[0];\n  });\n}\n\n/**\n * Convert an array to an object.\n *\n * @param {Array<any>} arr - The array to convert to an object.\n *\n * @returns An object with the same keys and values as the array.\n */\nfunction arrayToObject(arr) {\n  const obj = {};\n  const keys = Object.keys(arr);\n  let i;\n  const len = keys.length;\n  let key;\n  for (i = 0; i < len; i++) {\n    key = keys[i];\n    obj[key] = arr[key];\n  }\n  return obj;\n}\n\n/**\n * It takes a FormData object and returns a JavaScript object\n *\n * @param {string} formData The FormData object to convert to JSON.\n *\n * @returns {Object<string, any> | null} The converted object.\n */\nfunction formDataToJSON(formData) {\n  function buildPath(path, value, target, index) {\n    let name = path[index++];\n\n    if (name === '__proto__') return true;\n\n    const isNumericKey = Number.isFinite(+name);\n    const isLast = index >= path.length;\n    name = !name && utils.isArray(target) ? target.length : name;\n\n    if (isLast) {\n      if (utils.hasOwnProp(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    const 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    const obj = {};\n\n    utils.forEachEntry(formData, (name, value) => {\n      buildPath(parsePropPath(name), value, obj, 0);\n    });\n\n    return obj;\n  }\n\n  return null;\n}\n\nexport default formDataToJSON;\n","'use strict';\n\nimport utils from '../utils.js';\nimport AxiosError from '../core/AxiosError.js';\nimport transitionalDefaults from './transitional.js';\nimport toFormData from '../helpers/toFormData.js';\nimport toURLEncodedForm from '../helpers/toURLEncodedForm.js';\nimport platform from '../platform/index.js';\nimport formDataToJSON from '../helpers/formDataToJSON.js';\n\n/**\n * It takes a string, tries to parse it, and if it fails, it returns the stringified version\n * of the input\n *\n * @param {any} rawValue - The value to be stringified.\n * @param {Function} parser - A function that parses a string into a JavaScript object.\n * @param {Function} encoder - A function that takes a value and returns a string.\n *\n * @returns {string} A stringified version of the rawValue.\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\nconst defaults = {\n\n  transitional: transitionalDefaults,\n\n  adapter: ['xhr', 'http', 'fetch'],\n\n  transformRequest: [function transformRequest(data, headers) {\n    const contentType = headers.getContentType() || '';\n    const hasJSONContentType = contentType.indexOf('application/json') > -1;\n    const isObjectPayload = utils.isObject(data);\n\n    if (isObjectPayload && utils.isHTMLForm(data)) {\n      data = new FormData(data);\n    }\n\n    const 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      utils.isReadableStream(data)\n    ) {\n      return data;\n    }\n    if (utils.isArrayBufferView(data)) {\n      return data.buffer;\n    }\n    if (utils.isURLSearchParams(data)) {\n      headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);\n      return data.toString();\n    }\n\n    let 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        const _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      headers.setContentType('application/json', false);\n      return stringifySafely(data);\n    }\n\n    return data;\n  }],\n\n  transformResponse: [function transformResponse(data) {\n    const transitional = this.transitional || defaults.transitional;\n    const forcedJSONParsing = transitional && transitional.forcedJSONParsing;\n    const JSONRequested = this.responseType === 'json';\n\n    if (utils.isResponse(data) || utils.isReadableStream(data)) {\n      return data;\n    }\n\n    if (data && utils.isString(data) && ((forcedJSONParsing && !this.responseType) || JSONRequested)) {\n      const silentJSONParsing = transitional && transitional.silentJSONParsing;\n      const 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      'Content-Type': undefined\n    }\n  }\n};\n\nutils.forEach(['delete', 'get', 'head', 'post', 'put', 'patch'], (method) => {\n  defaults.headers[method] = {};\n});\n\nexport default defaults;\n","'use strict';\n\nimport utils from '../utils.js';\nimport toFormData from './toFormData.js';\nimport platform from '../platform/index.js';\n\nexport default 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\nimport utils from './../utils.js';\n\n// RawAxiosHeaders whose duplicates are ignored by node\n// c.f. https://nodejs.org/api/http.html#http_message_headers\nconst ignoreDuplicateOf = utils.toObjectSet([\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} rawHeaders Headers needing to be parsed\n *\n * @returns {Object} Headers parsed into an object\n */\nexport default rawHeaders => {\n  const parsed = {};\n  let key;\n  let val;\n  let i;\n\n  rawHeaders && rawHeaders.split('\\n').forEach(function parser(line) {\n    i = line.indexOf(':');\n    key = line.substring(0, i).trim().toLowerCase();\n    val = line.substring(i + 1).trim();\n\n    if (!key || (parsed[key] && ignoreDuplicateOf[key])) {\n      return;\n    }\n\n    if (key === 'set-cookie') {\n      if (parsed[key]) {\n        parsed[key].push(val);\n      } else {\n        parsed[key] = [val];\n      }\n    } else {\n      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n    }\n  });\n\n  return parsed;\n};\n","'use strict';\n\nimport utils from '../utils.js';\nimport parseHeaders from '../helpers/parseHeaders.js';\n\nconst $internals = Symbol('internals');\n\nfunction normalizeHeader(header) {\n  return header && String(header).trim().toLowerCase();\n}\n\nfunction normalizeValue(value) {\n  if (value === false || value == null) {\n    return value;\n  }\n\n  return utils.isArray(value) ? value.map(normalizeValue) : String(value);\n}\n\nfunction parseTokens(str) {\n  const tokens = Object.create(null);\n  const tokensRE = /([^\\s,;=]+)\\s*(?:=\\s*([^,;]+))?/g;\n  let match;\n\n  while ((match = tokensRE.exec(str))) {\n    tokens[match[1]] = match[2];\n  }\n\n  return tokens;\n}\n\nconst isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());\n\nfunction matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {\n  if (utils.isFunction(filter)) {\n    return filter.call(this, value, header);\n  }\n\n  if (isHeaderNameFilter) {\n    value = header;\n  }\n\n  if (!utils.isString(value)) return;\n\n  if (utils.isString(filter)) {\n    return value.indexOf(filter) !== -1;\n  }\n\n  if (utils.isRegExp(filter)) {\n    return filter.test(value);\n  }\n}\n\nfunction formatHeader(header) {\n  return header.trim()\n    .toLowerCase().replace(/([a-z\\d])(\\w*)/g, (w, char, str) => {\n      return char.toUpperCase() + str;\n    });\n}\n\nfunction buildAccessors(obj, header) {\n  const accessorName = utils.toCamelCase(' ' + header);\n\n  ['get', 'set', 'has'].forEach(methodName => {\n    Object.defineProperty(obj, methodName + accessorName, {\n      value: function(arg1, arg2, arg3) {\n        return this[methodName].call(this, header, arg1, arg2, arg3);\n      },\n      configurable: true\n    });\n  });\n}\n\nclass AxiosHeaders {\n  constructor(headers) {\n    headers && this.set(headers);\n  }\n\n  set(header, valueOrRewrite, rewrite) {\n    const self = this;\n\n    function setHeader(_value, _header, _rewrite) {\n      const lHeader = normalizeHeader(_header);\n\n      if (!lHeader) {\n        throw new Error('header name must be a non-empty string');\n      }\n\n      const key = utils.findKey(self, lHeader);\n\n      if(!key || self[key] === undefined || _rewrite === true || (_rewrite === undefined && self[key] !== false)) {\n        self[key || _header] = normalizeValue(_value);\n      }\n    }\n\n    const setHeaders = (headers, _rewrite) =>\n      utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));\n\n    if (utils.isPlainObject(header) || header instanceof this.constructor) {\n      setHeaders(header, valueOrRewrite)\n    } else if(utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {\n      setHeaders(parseHeaders(header), valueOrRewrite);\n    } else if (utils.isHeaders(header)) {\n      for (const [key, value] of header.entries()) {\n        setHeader(value, key, rewrite);\n      }\n    } else {\n      header != null && setHeader(valueOrRewrite, header, rewrite);\n    }\n\n    return this;\n  }\n\n  get(header, parser) {\n    header = normalizeHeader(header);\n\n    if (header) {\n      const key = utils.findKey(this, header);\n\n      if (key) {\n        const value = this[key];\n\n        if (!parser) {\n          return value;\n        }\n\n        if (parser === true) {\n          return parseTokens(value);\n        }\n\n        if (utils.isFunction(parser)) {\n          return parser.call(this, value, key);\n        }\n\n        if (utils.isRegExp(parser)) {\n          return parser.exec(value);\n        }\n\n        throw new TypeError('parser must be boolean|regexp|function');\n      }\n    }\n  }\n\n  has(header, matcher) {\n    header = normalizeHeader(header);\n\n    if (header) {\n      const key = utils.findKey(this, header);\n\n      return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));\n    }\n\n    return false;\n  }\n\n  delete(header, matcher) {\n    const self = this;\n    let deleted = false;\n\n    function deleteHeader(_header) {\n      _header = normalizeHeader(_header);\n\n      if (_header) {\n        const key = utils.findKey(self, _header);\n\n        if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {\n          delete self[key];\n\n          deleted = true;\n        }\n      }\n    }\n\n    if (utils.isArray(header)) {\n      header.forEach(deleteHeader);\n    } else {\n      deleteHeader(header);\n    }\n\n    return deleted;\n  }\n\n  clear(matcher) {\n    const keys = Object.keys(this);\n    let i = keys.length;\n    let deleted = false;\n\n    while (i--) {\n      const key = keys[i];\n      if(!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {\n        delete this[key];\n        deleted = true;\n      }\n    }\n\n    return deleted;\n  }\n\n  normalize(format) {\n    const self = this;\n    const headers = {};\n\n    utils.forEach(this, (value, header) => {\n      const key = utils.findKey(headers, header);\n\n      if (key) {\n        self[key] = normalizeValue(value);\n        delete self[header];\n        return;\n      }\n\n      const normalized = format ? formatHeader(header) : String(header).trim();\n\n      if (normalized !== header) {\n        delete self[header];\n      }\n\n      self[normalized] = normalizeValue(value);\n\n      headers[normalized] = true;\n    });\n\n    return this;\n  }\n\n  concat(...targets) {\n    return this.constructor.concat(this, ...targets);\n  }\n\n  toJSON(asStrings) {\n    const obj = Object.create(null);\n\n    utils.forEach(this, (value, header) => {\n      value != null && value !== false && (obj[header] = asStrings && utils.isArray(value) ? value.join(', ') : value);\n    });\n\n    return obj;\n  }\n\n  [Symbol.iterator]() {\n    return Object.entries(this.toJSON())[Symbol.iterator]();\n  }\n\n  toString() {\n    return Object.entries(this.toJSON()).map(([header, value]) => header + ': ' + value).join('\\n');\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'AxiosHeaders';\n  }\n\n  static from(thing) {\n    return thing instanceof this ? thing : new this(thing);\n  }\n\n  static concat(first, ...targets) {\n    const computed = new this(first);\n\n    targets.forEach((target) => computed.set(target));\n\n    return computed;\n  }\n\n  static accessor(header) {\n    const internals = this[$internals] = (this[$internals] = {\n      accessors: {}\n    });\n\n    const accessors = internals.accessors;\n    const prototype = this.prototype;\n\n    function defineAccessor(_header) {\n      const lHeader = normalizeHeader(_header);\n\n      if (!accessors[lHeader]) {\n        buildAccessors(prototype, _header);\n        accessors[lHeader] = true;\n      }\n    }\n\n    utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);\n\n    return this;\n  }\n}\n\nAxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']);\n\n// reserved names hotfix\nutils.reduceDescriptors(AxiosHeaders.prototype, ({value}, key) => {\n  let mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set`\n  return {\n    get: () => value,\n    set(headerValue) {\n      this[mapped] = headerValue;\n    }\n  }\n});\n\nutils.freezeMethods(AxiosHeaders);\n\nexport default AxiosHeaders;\n","'use strict';\n\nimport utils from './../utils.js';\nimport defaults from '../defaults/index.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Array|Function} fns A single function or Array of functions\n * @param {?Object} response The response object\n *\n * @returns {*} The resulting transformed data\n */\nexport default function transformData(fns, response) {\n  const config = this || defaults;\n  const context = response || config;\n  const headers = AxiosHeaders.from(context.headers);\n  let data = context.data;\n\n  utils.forEach(fns, function transform(fn) {\n    data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);\n  });\n\n  headers.normalize();\n\n  return data;\n}\n","'use strict';\n\nexport default function isCancel(value) {\n  return !!(value && value.__CANCEL__);\n}\n","'use strict';\n\nimport AxiosError from '../core/AxiosError.js';\nimport utils from '../utils.js';\n\n/**\n * A `CanceledError` is an object that is thrown when an operation is canceled.\n *\n * @param {string=} message The message.\n * @param {Object=} config The config.\n * @param {Object=} request The request.\n *\n * @returns {CanceledError} The created error.\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\nexport default CanceledError;\n","'use strict';\n\nimport AxiosError from './AxiosError.js';\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 *\n * @returns {object} The response.\n */\nexport default function settle(resolve, reject, response) {\n  const 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\n/**\n * Calculate data maxRate\n * @param {Number} [samplesCount= 10]\n * @param {Number} [min= 1000]\n * @returns {Function}\n */\nfunction speedometer(samplesCount, min) {\n  samplesCount = samplesCount || 10;\n  const bytes = new Array(samplesCount);\n  const timestamps = new Array(samplesCount);\n  let head = 0;\n  let tail = 0;\n  let firstSampleTS;\n\n  min = min !== undefined ? min : 1000;\n\n  return function push(chunkLength) {\n    const now = Date.now();\n\n    const startedAt = timestamps[tail];\n\n    if (!firstSampleTS) {\n      firstSampleTS = now;\n    }\n\n    bytes[head] = chunkLength;\n    timestamps[head] = now;\n\n    let i = tail;\n    let bytesCount = 0;\n\n    while (i !== head) {\n      bytesCount += bytes[i++];\n      i = i % samplesCount;\n    }\n\n    head = (head + 1) % samplesCount;\n\n    if (head === tail) {\n      tail = (tail + 1) % samplesCount;\n    }\n\n    if (now - firstSampleTS < min) {\n      return;\n    }\n\n    const passed = startedAt && now - startedAt;\n\n    return passed ? Math.round(bytesCount * 1000 / passed) : undefined;\n  };\n}\n\nexport default speedometer;\n","/**\n * Throttle decorator\n * @param {Function} fn\n * @param {Number} freq\n * @return {Function}\n */\nfunction throttle(fn, freq) {\n  let timestamp = 0;\n  let threshold = 1000 / freq;\n  let lastArgs;\n  let timer;\n\n  const invoke = (args, now = Date.now()) => {\n    timestamp = now;\n    lastArgs = null;\n    if (timer) {\n      clearTimeout(timer);\n      timer = null;\n    }\n    fn.apply(null, args);\n  }\n\n  const throttled = (...args) => {\n    const now = Date.now();\n    const passed = now - timestamp;\n    if ( passed >= threshold) {\n      invoke(args, now);\n    } else {\n      lastArgs = args;\n      if (!timer) {\n        timer = setTimeout(() => {\n          timer = null;\n          invoke(lastArgs)\n        }, threshold - passed);\n      }\n    }\n  }\n\n  const flush = () => lastArgs && invoke(lastArgs);\n\n  return [throttled, flush];\n}\n\nexport default throttle;\n","import speedometer from \"./speedometer.js\";\nimport throttle from \"./throttle.js\";\nimport utils from \"../utils.js\";\n\nexport const progressEventReducer = (listener, isDownloadStream, freq = 3) => {\n  let bytesNotified = 0;\n  const _speedometer = speedometer(50, 250);\n\n  return throttle(e => {\n    const loaded = e.loaded;\n    const total = e.lengthComputable ? e.total : undefined;\n    const progressBytes = loaded - bytesNotified;\n    const rate = _speedometer(progressBytes);\n    const inRange = loaded <= total;\n\n    bytesNotified = loaded;\n\n    const data = {\n      loaded,\n      total,\n      progress: total ? (loaded / total) : undefined,\n      bytes: progressBytes,\n      rate: rate ? rate : undefined,\n      estimated: rate && total && inRange ? (total - loaded) / rate : undefined,\n      event: e,\n      lengthComputable: total != null,\n      [isDownloadStream ? 'download' : 'upload']: true\n    };\n\n    listener(data);\n  }, freq);\n}\n\nexport const progressEventDecorator = (total, throttled) => {\n  const lengthComputable = total != null;\n\n  return [(loaded) => throttled[0]({\n    lengthComputable,\n    total,\n    loaded\n  }), throttled[1]];\n}\n\nexport const asyncDecorator = (fn) => (...args) => utils.asap(() => fn(...args));\n","'use strict';\n\nimport utils from './../utils.js';\nimport platform from '../platform/index.js';\n\nexport default platform.hasStandardBrowserEnv ?\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    const msie = platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent);\n    const urlParsingNode = document.createElement('a');\n    let originURL;\n\n    /**\n    * Parse a URL to discover its components\n    *\n    * @param {String} url The URL to be parsed\n    * @returns {Object}\n    */\n    function resolveURL(url) {\n      let 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      const 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","import utils from './../utils.js';\nimport platform from '../platform/index.js';\n\nexport default platform.hasStandardBrowserEnv ?\n\n  // Standard browser envs support document.cookie\n  {\n    write(name, value, expires, path, domain, secure) {\n      const cookie = [name + '=' + encodeURIComponent(value)];\n\n      utils.isNumber(expires) && cookie.push('expires=' + new Date(expires).toGMTString());\n\n      utils.isString(path) && cookie.push('path=' + path);\n\n      utils.isString(domain) && cookie.push('domain=' + domain);\n\n      secure === true && cookie.push('secure');\n\n      document.cookie = cookie.join('; ');\n    },\n\n    read(name) {\n      const match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n      return (match ? decodeURIComponent(match[3]) : null);\n    },\n\n    remove(name) {\n      this.write(name, '', Date.now() - 86400000);\n    }\n  }\n\n  :\n\n  // Non-standard browser env (web workers, react-native) lack needed support.\n  {\n    write() {},\n    read() {\n      return null;\n    },\n    remove() {}\n  };\n\n","'use strict';\n\nimport isAbsoluteURL from '../helpers/isAbsoluteURL.js';\nimport combineURLs from '../helpers/combineURLs.js';\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 *\n * @returns {string} The combined full path\n */\nexport default function buildFullPath(baseURL, requestedURL) {\n  if (baseURL && !isAbsoluteURL(requestedURL)) {\n    return combineURLs(baseURL, requestedURL);\n  }\n  return requestedURL;\n}\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n *\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nexport default 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\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 *\n * @returns {string} The combined URL\n */\nexport default function combineURLs(baseURL, relativeURL) {\n  return relativeURL\n    ? baseURL.replace(/\\/?\\/$/, '') + '/' + relativeURL.replace(/^\\/+/, '')\n    : baseURL;\n}\n","'use strict';\n\nimport utils from '../utils.js';\nimport AxiosHeaders from \"./AxiosHeaders.js\";\n\nconst headersToObject = (thing) => thing instanceof AxiosHeaders ? { ...thing } : thing;\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 *\n * @returns {Object} New object resulting from merging config2 to config1\n */\nexport default function mergeConfig(config1, config2) {\n  // eslint-disable-next-line no-param-reassign\n  config2 = config2 || {};\n  const config = {};\n\n  function getMergedValue(target, source, caseless) {\n    if (utils.isPlainObject(target) && utils.isPlainObject(source)) {\n      return utils.merge.call({caseless}, target, source);\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(a, b, caseless) {\n    if (!utils.isUndefined(b)) {\n      return getMergedValue(a, b, caseless);\n    } else if (!utils.isUndefined(a)) {\n      return getMergedValue(undefined, a, caseless);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function valueFromConfig2(a, b) {\n    if (!utils.isUndefined(b)) {\n      return getMergedValue(undefined, b);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function defaultToConfig2(a, b) {\n    if (!utils.isUndefined(b)) {\n      return getMergedValue(undefined, b);\n    } else if (!utils.isUndefined(a)) {\n      return getMergedValue(undefined, a);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function mergeDirectKeys(a, b, prop) {\n    if (prop in config2) {\n      return getMergedValue(a, b);\n    } else if (prop in config1) {\n      return getMergedValue(undefined, a);\n    }\n  }\n\n  const 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    headers: (a, b) => mergeDeepProperties(headersToObject(a), headersToObject(b), true)\n  };\n\n  utils.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {\n    const merge = mergeMap[prop] || mergeDeepProperties;\n    const configValue = merge(config1[prop], config2[prop], prop);\n    (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);\n  });\n\n  return config;\n}\n","import platform from \"../platform/index.js\";\nimport utils from \"../utils.js\";\nimport isURLSameOrigin from \"./isURLSameOrigin.js\";\nimport cookies from \"./cookies.js\";\nimport buildFullPath from \"../core/buildFullPath.js\";\nimport mergeConfig from \"../core/mergeConfig.js\";\nimport AxiosHeaders from \"../core/AxiosHeaders.js\";\nimport buildURL from \"./buildURL.js\";\n\nexport default (config) => {\n  const newConfig = mergeConfig({}, config);\n\n  let {data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth} = newConfig;\n\n  newConfig.headers = headers = AxiosHeaders.from(headers);\n\n  newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url), config.params, config.paramsSerializer);\n\n  // HTTP basic authentication\n  if (auth) {\n    headers.set('Authorization', 'Basic ' +\n      btoa((auth.username || '') + ':' + (auth.password ? unescape(encodeURIComponent(auth.password)) : ''))\n    );\n  }\n\n  let contentType;\n\n  if (utils.isFormData(data)) {\n    if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {\n      headers.setContentType(undefined); // Let the browser set it\n    } else if ((contentType = headers.getContentType()) !== false) {\n      // fix semicolon duplication issue for ReactNative FormData implementation\n      const [type, ...tokens] = contentType ? contentType.split(';').map(token => token.trim()).filter(Boolean) : [];\n      headers.setContentType([type || 'multipart/form-data', ...tokens].join('; '));\n    }\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\n  if (platform.hasStandardBrowserEnv) {\n    withXSRFToken && utils.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(newConfig));\n\n    if (withXSRFToken || (withXSRFToken !== false && isURLSameOrigin(newConfig.url))) {\n      // Add xsrf header\n      const xsrfValue = xsrfHeaderName && xsrfCookieName && cookies.read(xsrfCookieName);\n\n      if (xsrfValue) {\n        headers.set(xsrfHeaderName, xsrfValue);\n      }\n    }\n  }\n\n  return newConfig;\n}\n\n","import utils from './../utils.js';\nimport settle from './../core/settle.js';\nimport transitionalDefaults from '../defaults/transitional.js';\nimport AxiosError from '../core/AxiosError.js';\nimport CanceledError from '../cancel/CanceledError.js';\nimport parseProtocol from '../helpers/parseProtocol.js';\nimport platform from '../platform/index.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\nimport {progressEventReducer} from '../helpers/progressEventReducer.js';\nimport resolveConfig from \"../helpers/resolveConfig.js\";\n\nconst isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined';\n\nexport default isXHRAdapterSupported && function (config) {\n  return new Promise(function dispatchXhrRequest(resolve, reject) {\n    const _config = resolveConfig(config);\n    let requestData = _config.data;\n    const requestHeaders = AxiosHeaders.from(_config.headers).normalize();\n    let {responseType, onUploadProgress, onDownloadProgress} = _config;\n    let onCanceled;\n    let uploadThrottled, downloadThrottled;\n    let flushUpload, flushDownload;\n\n    function done() {\n      flushUpload && flushUpload(); // flush events\n      flushDownload && flushDownload(); // flush events\n\n      _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);\n\n      _config.signal && _config.signal.removeEventListener('abort', onCanceled);\n    }\n\n    let request = new XMLHttpRequest();\n\n    request.open(_config.method.toUpperCase(), _config.url, 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      const responseHeaders = AxiosHeaders.from(\n        'getAllResponseHeaders' in request && request.getAllResponseHeaders()\n      );\n      const responseData = !responseType || responseType === 'text' || responseType === 'json' ?\n        request.responseText : request.response;\n      const response = {\n        data: responseData,\n        status: request.status,\n        statusText: request.statusText,\n        headers: responseHeaders,\n        config,\n        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      let timeoutErrorMessage = _config.timeout ? 'timeout of ' + _config.timeout + 'ms exceeded' : 'timeout exceeded';\n      const 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    // Remove Content-Type if data is undefined\n    requestData === undefined && requestHeaders.setContentType(null);\n\n    // Add headers to the request\n    if ('setRequestHeader' in request) {\n      utils.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {\n        request.setRequestHeader(key, val);\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 (onDownloadProgress) {\n      ([downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true));\n      request.addEventListener('progress', downloadThrottled);\n    }\n\n    // Not all browsers support upload events\n    if (onUploadProgress && request.upload) {\n      ([uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress));\n\n      request.upload.addEventListener('progress', uploadThrottled);\n\n      request.upload.addEventListener('loadend', flushUpload);\n    }\n\n    if (_config.cancelToken || _config.signal) {\n      // Handle cancellation\n      // eslint-disable-next-line func-names\n      onCanceled = 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    const protocol = parseProtocol(_config.url);\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 || null);\n  });\n}\n","'use strict';\n\nexport default function parseProtocol(url) {\n  const match = /^([-+\\w]{1,25})(:?\\/\\/|:)/.exec(url);\n  return match && match[1] || '';\n}\n","import CanceledError from \"../cancel/CanceledError.js\";\nimport AxiosError from \"../core/AxiosError.js\";\nimport utils from '../utils.js';\n\nconst composeSignals = (signals, timeout) => {\n  const {length} = (signals = signals ? signals.filter(Boolean) : []);\n\n  if (timeout || length) {\n    let controller = new AbortController();\n\n    let aborted;\n\n    const onabort = function (reason) {\n      if (!aborted) {\n        aborted = true;\n        unsubscribe();\n        const err = reason instanceof Error ? reason : this.reason;\n        controller.abort(err instanceof AxiosError ? err : new CanceledError(err instanceof Error ? err.message : err));\n      }\n    }\n\n    let timer = timeout && setTimeout(() => {\n      timer = null;\n      onabort(new AxiosError(`timeout ${timeout} of ms exceeded`, AxiosError.ETIMEDOUT))\n    }, timeout)\n\n    const unsubscribe = () => {\n      if (signals) {\n        timer && clearTimeout(timer);\n        timer = null;\n        signals.forEach(signal => {\n          signal.unsubscribe ? signal.unsubscribe(onabort) : signal.removeEventListener('abort', onabort);\n        });\n        signals = null;\n      }\n    }\n\n    signals.forEach((signal) => signal.addEventListener('abort', onabort));\n\n    const {signal} = controller;\n\n    signal.unsubscribe = () => utils.asap(unsubscribe);\n\n    return signal;\n  }\n}\n\nexport default composeSignals;\n","\nexport const streamChunk = function* (chunk, chunkSize) {\n  let len = chunk.byteLength;\n\n  if (!chunkSize || len < chunkSize) {\n    yield chunk;\n    return;\n  }\n\n  let pos = 0;\n  let end;\n\n  while (pos < len) {\n    end = pos + chunkSize;\n    yield chunk.slice(pos, end);\n    pos = end;\n  }\n}\n\nexport const readBytes = async function* (iterable, chunkSize) {\n  for await (const chunk of readStream(iterable)) {\n    yield* streamChunk(chunk, chunkSize);\n  }\n}\n\nconst readStream = async function* (stream) {\n  if (stream[Symbol.asyncIterator]) {\n    yield* stream;\n    return;\n  }\n\n  const reader = stream.getReader();\n  try {\n    for (;;) {\n      const {done, value} = await reader.read();\n      if (done) {\n        break;\n      }\n      yield value;\n    }\n  } finally {\n    await reader.cancel();\n  }\n}\n\nexport const trackStream = (stream, chunkSize, onProgress, onFinish) => {\n  const iterator = readBytes(stream, chunkSize);\n\n  let bytes = 0;\n  let done;\n  let _onFinish = (e) => {\n    if (!done) {\n      done = true;\n      onFinish && onFinish(e);\n    }\n  }\n\n  return new ReadableStream({\n    async pull(controller) {\n      try {\n        const {done, value} = await iterator.next();\n\n        if (done) {\n         _onFinish();\n          controller.close();\n          return;\n        }\n\n        let len = value.byteLength;\n        if (onProgress) {\n          let loadedBytes = bytes += len;\n          onProgress(loadedBytes);\n        }\n        controller.enqueue(new Uint8Array(value));\n      } catch (err) {\n        _onFinish(err);\n        throw err;\n      }\n    },\n    cancel(reason) {\n      _onFinish(reason);\n      return iterator.return();\n    }\n  }, {\n    highWaterMark: 2\n  })\n}\n","import platform from \"../platform/index.js\";\nimport utils from \"../utils.js\";\nimport AxiosError from \"../core/AxiosError.js\";\nimport composeSignals from \"../helpers/composeSignals.js\";\nimport {trackStream} from \"../helpers/trackStream.js\";\nimport AxiosHeaders from \"../core/AxiosHeaders.js\";\nimport {progressEventReducer, progressEventDecorator, asyncDecorator} from \"../helpers/progressEventReducer.js\";\nimport resolveConfig from \"../helpers/resolveConfig.js\";\nimport settle from \"../core/settle.js\";\n\nconst isFetchSupported = typeof fetch === 'function' && typeof Request === 'function' && typeof Response === 'function';\nconst isReadableStreamSupported = isFetchSupported && typeof ReadableStream === 'function';\n\n// used only inside the fetch adapter\nconst encodeText = isFetchSupported && (typeof TextEncoder === 'function' ?\n    ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) :\n    async (str) => new Uint8Array(await new Response(str).arrayBuffer())\n);\n\nconst test = (fn, ...args) => {\n  try {\n    return !!fn(...args);\n  } catch (e) {\n    return false\n  }\n}\n\nconst supportsRequestStream = isReadableStreamSupported && test(() => {\n  let duplexAccessed = false;\n\n  const hasContentType = new Request(platform.origin, {\n    body: new ReadableStream(),\n    method: 'POST',\n    get duplex() {\n      duplexAccessed = true;\n      return 'half';\n    },\n  }).headers.has('Content-Type');\n\n  return duplexAccessed && !hasContentType;\n});\n\nconst DEFAULT_CHUNK_SIZE = 64 * 1024;\n\nconst supportsResponseStream = isReadableStreamSupported &&\n  test(() => utils.isReadableStream(new Response('').body));\n\n\nconst resolvers = {\n  stream: supportsResponseStream && ((res) => res.body)\n};\n\nisFetchSupported && (((res) => {\n  ['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach(type => {\n    !resolvers[type] && (resolvers[type] = utils.isFunction(res[type]) ? (res) => res[type]() :\n      (_, config) => {\n        throw new AxiosError(`Response type '${type}' is not supported`, AxiosError.ERR_NOT_SUPPORT, config);\n      })\n  });\n})(new Response));\n\nconst getBodyLength = async (body) => {\n  if (body == null) {\n    return 0;\n  }\n\n  if(utils.isBlob(body)) {\n    return body.size;\n  }\n\n  if(utils.isSpecCompliantForm(body)) {\n    const _request = new Request(platform.origin, {\n      method: 'POST',\n      body,\n    });\n    return (await _request.arrayBuffer()).byteLength;\n  }\n\n  if(utils.isArrayBufferView(body) || utils.isArrayBuffer(body)) {\n    return body.byteLength;\n  }\n\n  if(utils.isURLSearchParams(body)) {\n    body = body + '';\n  }\n\n  if(utils.isString(body)) {\n    return (await encodeText(body)).byteLength;\n  }\n}\n\nconst resolveBodyLength = async (headers, body) => {\n  const length = utils.toFiniteNumber(headers.getContentLength());\n\n  return length == null ? getBodyLength(body) : length;\n}\n\nexport default isFetchSupported && (async (config) => {\n  let {\n    url,\n    method,\n    data,\n    signal,\n    cancelToken,\n    timeout,\n    onDownloadProgress,\n    onUploadProgress,\n    responseType,\n    headers,\n    withCredentials = 'same-origin',\n    fetchOptions\n  } = resolveConfig(config);\n\n  responseType = responseType ? (responseType + '').toLowerCase() : 'text';\n\n  let composedSignal = composeSignals([signal, cancelToken && cancelToken.toAbortSignal()], timeout);\n\n  let request;\n\n  const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {\n      composedSignal.unsubscribe();\n  });\n\n  let requestContentLength;\n\n  try {\n    if (\n      onUploadProgress && supportsRequestStream && method !== 'get' && method !== 'head' &&\n      (requestContentLength = await resolveBodyLength(headers, data)) !== 0\n    ) {\n      let _request = new Request(url, {\n        method: 'POST',\n        body: data,\n        duplex: \"half\"\n      });\n\n      let contentTypeHeader;\n\n      if (utils.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {\n        headers.setContentType(contentTypeHeader)\n      }\n\n      if (_request.body) {\n        const [onProgress, flush] = progressEventDecorator(\n          requestContentLength,\n          progressEventReducer(asyncDecorator(onUploadProgress))\n        );\n\n        data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);\n      }\n    }\n\n    if (!utils.isString(withCredentials)) {\n      withCredentials = withCredentials ? 'include' : 'omit';\n    }\n\n    // Cloudflare Workers throws when credentials are defined\n    // see https://github.com/cloudflare/workerd/issues/902\n    const isCredentialsSupported = \"credentials\" in Request.prototype;\n    request = new Request(url, {\n      ...fetchOptions,\n      signal: composedSignal,\n      method: method.toUpperCase(),\n      headers: headers.normalize().toJSON(),\n      body: data,\n      duplex: \"half\",\n      credentials: isCredentialsSupported ? withCredentials : undefined\n    });\n\n    let response = await fetch(request);\n\n    const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response');\n\n    if (supportsResponseStream && (onDownloadProgress || (isStreamResponse && unsubscribe))) {\n      const options = {};\n\n      ['status', 'statusText', 'headers'].forEach(prop => {\n        options[prop] = response[prop];\n      });\n\n      const responseContentLength = utils.toFiniteNumber(response.headers.get('content-length'));\n\n      const [onProgress, flush] = onDownloadProgress && progressEventDecorator(\n        responseContentLength,\n        progressEventReducer(asyncDecorator(onDownloadProgress), true)\n      ) || [];\n\n      response = new Response(\n        trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {\n          flush && flush();\n          unsubscribe && unsubscribe();\n        }),\n        options\n      );\n    }\n\n    responseType = responseType || 'text';\n\n    let responseData = await resolvers[utils.findKey(resolvers, responseType) || 'text'](response, config);\n\n    !isStreamResponse && unsubscribe && unsubscribe();\n\n    return await new Promise((resolve, reject) => {\n      settle(resolve, reject, {\n        data: responseData,\n        headers: AxiosHeaders.from(response.headers),\n        status: response.status,\n        statusText: response.statusText,\n        config,\n        request\n      })\n    })\n  } catch (err) {\n    unsubscribe && unsubscribe();\n\n    if (err && err.name === 'TypeError' && /fetch/i.test(err.message)) {\n      throw Object.assign(\n        new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request),\n        {\n          cause: err.cause || err\n        }\n      )\n    }\n\n    throw AxiosError.from(err, err && err.code, config, request);\n  }\n});\n\n\n","import utils from '../utils.js';\nimport httpAdapter from './http.js';\nimport xhrAdapter from './xhr.js';\nimport fetchAdapter from './fetch.js';\nimport AxiosError from \"../core/AxiosError.js\";\n\nconst knownAdapters = {\n  http: httpAdapter,\n  xhr: xhrAdapter,\n  fetch: fetchAdapter\n}\n\nutils.forEach(knownAdapters, (fn, value) => {\n  if (fn) {\n    try {\n      Object.defineProperty(fn, 'name', {value});\n    } catch (e) {\n      // eslint-disable-next-line no-empty\n    }\n    Object.defineProperty(fn, 'adapterName', {value});\n  }\n});\n\nconst renderReason = (reason) => `- ${reason}`;\n\nconst isResolvedHandle = (adapter) => utils.isFunction(adapter) || adapter === null || adapter === false;\n\nexport default {\n  getAdapter: (adapters) => {\n    adapters = utils.isArray(adapters) ? adapters : [adapters];\n\n    const {length} = adapters;\n    let nameOrAdapter;\n    let adapter;\n\n    const rejectedReasons = {};\n\n    for (let i = 0; i < length; i++) {\n      nameOrAdapter = adapters[i];\n      let id;\n\n      adapter = nameOrAdapter;\n\n      if (!isResolvedHandle(nameOrAdapter)) {\n        adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];\n\n        if (adapter === undefined) {\n          throw new AxiosError(`Unknown adapter '${id}'`);\n        }\n      }\n\n      if (adapter) {\n        break;\n      }\n\n      rejectedReasons[id || '#' + i] = adapter;\n    }\n\n    if (!adapter) {\n\n      const reasons = Object.entries(rejectedReasons)\n        .map(([id, state]) => `adapter ${id} ` +\n          (state === false ? 'is not supported by the environment' : 'is not available in the build')\n        );\n\n      let s = length ?\n        (reasons.length > 1 ? 'since :\\n' + reasons.map(renderReason).join('\\n') : ' ' + renderReason(reasons[0])) :\n        'as no adapter specified';\n\n      throw new AxiosError(\n        `There is no suitable adapter to dispatch the request ` + s,\n        'ERR_NOT_SUPPORT'\n      );\n    }\n\n    return adapter;\n  },\n  adapters: knownAdapters\n}\n","// eslint-disable-next-line strict\nexport default null;\n","'use strict';\n\nimport transformData from './transformData.js';\nimport isCancel from '../cancel/isCancel.js';\nimport defaults from '../defaults/index.js';\nimport CanceledError from '../cancel/CanceledError.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\nimport adapters from \"../adapters/adapters.js\";\n\n/**\n * Throws a `CanceledError` if cancellation has been requested.\n *\n * @param {Object} config The config that is to be used for the request\n *\n * @returns {void}\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(null, config);\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 *\n * @returns {Promise} The Promise to be fulfilled\n */\nexport default function dispatchRequest(config) {\n  throwIfCancellationRequested(config);\n\n  config.headers = AxiosHeaders.from(config.headers);\n\n  // Transform request data\n  config.data = transformData.call(\n    config,\n    config.transformRequest\n  );\n\n  if (['post', 'put', 'patch'].indexOf(config.method) !== -1) {\n    config.headers.setContentType('application/x-www-form-urlencoded', false);\n  }\n\n  const adapter = adapters.getAdapter(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      config.transformResponse,\n      response\n    );\n\n    response.headers = AxiosHeaders.from(response.headers);\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          config.transformResponse,\n          reason.response\n        );\n        reason.response.headers = AxiosHeaders.from(reason.response.headers);\n      }\n    }\n\n    return Promise.reject(reason);\n  });\n}\n","export const VERSION = \"1.7.7\";","'use strict';\n\nimport {VERSION} from '../env/data.js';\nimport AxiosError from '../core/AxiosError.js';\n\nconst validators = {};\n\n// eslint-disable-next-line func-names\n['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach((type, i) => {\n  validators[type] = function validator(thing) {\n    return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;\n  };\n});\n\nconst deprecatedWarnings = {};\n\n/**\n * Transitional option validator\n *\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 *\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 (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 *\n * @param {object} options\n * @param {object} schema\n * @param {boolean?} allowUnknown\n *\n * @returns {object}\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  const keys = Object.keys(options);\n  let i = keys.length;\n  while (i-- > 0) {\n    const opt = keys[i];\n    const validator = schema[opt];\n    if (validator) {\n      const value = options[opt];\n      const 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\nexport default {\n  assertOptions,\n  validators\n};\n","'use strict';\n\nimport utils from './../utils.js';\nimport buildURL from '../helpers/buildURL.js';\nimport InterceptorManager from './InterceptorManager.js';\nimport dispatchRequest from './dispatchRequest.js';\nimport mergeConfig from './mergeConfig.js';\nimport buildFullPath from './buildFullPath.js';\nimport validator from '../helpers/validator.js';\nimport AxiosHeaders from './AxiosHeaders.js';\n\nconst validators = validator.validators;\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n *\n * @return {Axios} A new instance of Axios\n */\nclass Axios {\n  constructor(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   *\n   * @returns {Promise} The Promise to be fulfilled\n   */\n  async request(configOrUrl, config) {\n    try {\n      return await this._request(configOrUrl, config);\n    } catch (err) {\n      if (err instanceof Error) {\n        let dummy;\n\n        Error.captureStackTrace ? Error.captureStackTrace(dummy = {}) : (dummy = new Error());\n\n        // slice off the Error: ... line\n        const stack = dummy.stack ? dummy.stack.replace(/^.+\\n/, '') : '';\n        try {\n          if (!err.stack) {\n            err.stack = stack;\n            // match without the 2 top stack lines\n          } else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\\n.+\\n/, ''))) {\n            err.stack += '\\n' + stack\n          }\n        } catch (e) {\n          // ignore the case where \"stack\" is an un-writable property\n        }\n      }\n\n      throw err;\n    }\n  }\n\n  _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    const {transitional, paramsSerializer, headers} = config;\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    if (paramsSerializer != null) {\n      if (utils.isFunction(paramsSerializer)) {\n        config.paramsSerializer = {\n          serialize: paramsSerializer\n        }\n      } else {\n        validator.assertOptions(paramsSerializer, {\n          encode: validators.function,\n          serialize: validators.function\n        }, true);\n      }\n    }\n\n    // Set config.method\n    config.method = (config.method || this.defaults.method || 'get').toLowerCase();\n\n    // Flatten headers\n    let contextHeaders = headers && utils.merge(\n      headers.common,\n      headers[config.method]\n    );\n\n    headers && utils.forEach(\n      ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n      (method) => {\n        delete headers[method];\n      }\n    );\n\n    config.headers = AxiosHeaders.concat(contextHeaders, headers);\n\n    // filter out skipped interceptors\n    const requestInterceptorChain = [];\n    let 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    const responseInterceptorChain = [];\n    this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n      responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);\n    });\n\n    let promise;\n    let i = 0;\n    let len;\n\n    if (!synchronousRequestInterceptors) {\n      const chain = [dispatchRequest.bind(this), undefined];\n      chain.unshift.apply(chain, requestInterceptorChain);\n      chain.push.apply(chain, responseInterceptorChain);\n      len = chain.length;\n\n      promise = Promise.resolve(config);\n\n      while (i < len) {\n        promise = promise.then(chain[i++], chain[i++]);\n      }\n\n      return promise;\n    }\n\n    len = requestInterceptorChain.length;\n\n    let newConfig = config;\n\n    i = 0;\n\n    while (i < len) {\n      const onFulfilled = requestInterceptorChain[i++];\n      const onRejected = requestInterceptorChain[i++];\n      try {\n        newConfig = onFulfilled(newConfig);\n      } catch (error) {\n        onRejected.call(this, error);\n        break;\n      }\n    }\n\n    try {\n      promise = dispatchRequest.call(this, newConfig);\n    } catch (error) {\n      return Promise.reject(error);\n    }\n\n    i = 0;\n    len = responseInterceptorChain.length;\n\n    while (i < len) {\n      promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);\n    }\n\n    return promise;\n  }\n\n  getUri(config) {\n    config = mergeConfig(this.defaults, config);\n    const fullPath = buildFullPath(config.baseURL, config.url);\n    return buildURL(fullPath, config.params, config.paramsSerializer);\n  }\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,\n      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,\n        headers: isForm ? {\n          'Content-Type': 'multipart/form-data'\n        } : {},\n        url,\n        data\n      }));\n    };\n  }\n\n  Axios.prototype[method] = generateHTTPMethod();\n\n  Axios.prototype[method + 'Form'] = generateHTTPMethod(true);\n});\n\nexport default Axios;\n","'use strict';\n\nimport CanceledError from './CanceledError.js';\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @param {Function} executor The executor function.\n *\n * @returns {CancelToken}\n */\nclass CancelToken {\n  constructor(executor) {\n    if (typeof executor !== 'function') {\n      throw new TypeError('executor must be a function.');\n    }\n\n    let resolvePromise;\n\n    this.promise = new Promise(function promiseExecutor(resolve) {\n      resolvePromise = resolve;\n    });\n\n    const token = this;\n\n    // eslint-disable-next-line func-names\n    this.promise.then(cancel => {\n      if (!token._listeners) return;\n\n      let 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 = onfulfilled => {\n      let _resolve;\n      // eslint-disable-next-line func-names\n      const promise = new Promise(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   */\n  throwIfRequested() {\n    if (this.reason) {\n      throw this.reason;\n    }\n  }\n\n  /**\n   * Subscribe to the cancel signal\n   */\n\n  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\n  unsubscribe(listener) {\n    if (!this._listeners) {\n      return;\n    }\n    const index = this._listeners.indexOf(listener);\n    if (index !== -1) {\n      this._listeners.splice(index, 1);\n    }\n  }\n\n  toAbortSignal() {\n    const controller = new AbortController();\n\n    const abort = (err) => {\n      controller.abort(err);\n    };\n\n    this.subscribe(abort);\n\n    controller.signal.unsubscribe = () => this.unsubscribe(abort);\n\n    return controller.signal;\n  }\n\n  /**\n   * Returns an object that contains a new `CancelToken` and a function that, when called,\n   * cancels the `CancelToken`.\n   */\n  static source() {\n    let cancel;\n    const token = new CancelToken(function executor(c) {\n      cancel = c;\n    });\n    return {\n      token,\n      cancel\n    };\n  }\n}\n\nexport default CancelToken;\n","const HttpStatusCode = {\n  Continue: 100,\n  SwitchingProtocols: 101,\n  Processing: 102,\n  EarlyHints: 103,\n  Ok: 200,\n  Created: 201,\n  Accepted: 202,\n  NonAuthoritativeInformation: 203,\n  NoContent: 204,\n  ResetContent: 205,\n  PartialContent: 206,\n  MultiStatus: 207,\n  AlreadyReported: 208,\n  ImUsed: 226,\n  MultipleChoices: 300,\n  MovedPermanently: 301,\n  Found: 302,\n  SeeOther: 303,\n  NotModified: 304,\n  UseProxy: 305,\n  Unused: 306,\n  TemporaryRedirect: 307,\n  PermanentRedirect: 308,\n  BadRequest: 400,\n  Unauthorized: 401,\n  PaymentRequired: 402,\n  Forbidden: 403,\n  NotFound: 404,\n  MethodNotAllowed: 405,\n  NotAcceptable: 406,\n  ProxyAuthenticationRequired: 407,\n  RequestTimeout: 408,\n  Conflict: 409,\n  Gone: 410,\n  LengthRequired: 411,\n  PreconditionFailed: 412,\n  PayloadTooLarge: 413,\n  UriTooLong: 414,\n  UnsupportedMediaType: 415,\n  RangeNotSatisfiable: 416,\n  ExpectationFailed: 417,\n  ImATeapot: 418,\n  MisdirectedRequest: 421,\n  UnprocessableEntity: 422,\n  Locked: 423,\n  FailedDependency: 424,\n  TooEarly: 425,\n  UpgradeRequired: 426,\n  PreconditionRequired: 428,\n  TooManyRequests: 429,\n  RequestHeaderFieldsTooLarge: 431,\n  UnavailableForLegalReasons: 451,\n  InternalServerError: 500,\n  NotImplemented: 501,\n  BadGateway: 502,\n  ServiceUnavailable: 503,\n  GatewayTimeout: 504,\n  HttpVersionNotSupported: 505,\n  VariantAlsoNegotiates: 506,\n  InsufficientStorage: 507,\n  LoopDetected: 508,\n  NotExtended: 510,\n  NetworkAuthenticationRequired: 511,\n};\n\nObject.entries(HttpStatusCode).forEach(([key, value]) => {\n  HttpStatusCode[value] = key;\n});\n\nexport default HttpStatusCode;\n","'use strict';\n\nimport utils from './utils.js';\nimport bind from './helpers/bind.js';\nimport Axios from './core/Axios.js';\nimport mergeConfig from './core/mergeConfig.js';\nimport defaults from './defaults/index.js';\nimport formDataToJSON from './helpers/formDataToJSON.js';\nimport CanceledError from './cancel/CanceledError.js';\nimport CancelToken from './cancel/CancelToken.js';\nimport isCancel from './cancel/isCancel.js';\nimport {VERSION} from './env/data.js';\nimport toFormData from './helpers/toFormData.js';\nimport AxiosError from './core/AxiosError.js';\nimport spread from './helpers/spread.js';\nimport isAxiosError from './helpers/isAxiosError.js';\nimport AxiosHeaders from \"./core/AxiosHeaders.js\";\nimport adapters from './adapters/adapters.js';\nimport HttpStatusCode from './helpers/HttpStatusCode.js';\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n *\n * @returns {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n  const context = new Axios(defaultConfig);\n  const instance = bind(Axios.prototype.request, context);\n\n  // Copy axios.prototype to instance\n  utils.extend(instance, Axios.prototype, context, {allOwnKeys: true});\n\n  // Copy context to instance\n  utils.extend(instance, context, null, {allOwnKeys: true});\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\nconst axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Expose Cancel & CancelToken\naxios.CanceledError = CanceledError;\naxios.CancelToken = CancelToken;\naxios.isCancel = isCancel;\naxios.VERSION = VERSION;\naxios.toFormData = toFormData;\n\n// Expose AxiosError class\naxios.AxiosError = 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};\n\naxios.spread = spread;\n\n// Expose isAxiosError\naxios.isAxiosError = isAxiosError;\n\n// Expose mergeConfig\naxios.mergeConfig = mergeConfig;\n\naxios.AxiosHeaders = AxiosHeaders;\n\naxios.formToJSON = thing => formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);\n\naxios.getAdapter = adapters.getAdapter;\n\naxios.HttpStatusCode = HttpStatusCode;\n\naxios.default = axios;\n\n// this module should only have a default export\nexport default axios\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 *\n * @returns {Function}\n */\nexport default function spread(callback) {\n  return function wrap(arr) {\n    return callback.apply(null, arr);\n  };\n}\n","'use strict';\n\nimport utils from './../utils.js';\n\n/**\n * Determines whether the payload is an error thrown by Axios\n *\n * @param {*} payload The value to test\n *\n * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false\n */\nexport default function isAxiosError(payload) {\n  return utils.isObject(payload) && (payload.isAxiosError === true);\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","changes","change","operation","ret","added","removed","escapeHTML","oldArr","newArr","callback","arrayDiff","diff","_base","Diff","tokenize","removeEmpty","buildValues","components","newString","oldString","useLongestToken","componentPos","componentLen","newPos","oldPos","component","tmp","oldValue","lastComponent","equals","clonePath","prototype","self","castInput","newLen","oldLen","editLength","maxEditLength","bestPath","extractCommon","execEditLength","diagonalPath","basePath","addPath","removePath","canAdd","canRemove","pushComponent","exec","last","commonCount","left","right","comparator","ignoreCase","array","chars","oldStr","newStr","characterDiff","cssDiff","oldObj","newObj","jsonDiff","_line","objectPrototypeToString","canonicalize","obj","stack","replacementStack","replacer","canonicalizedObj","toJSON","_typeof","sortedKeys","lineDiff","undefinedReplacement","stringifyReplacer","generateOptions","ignoreWhitespace","_params","retLines","linesAndNewlines","line","newlineIsToken","sentenceDiff","wordDiff","extendedWordChars","reWhitespace","tokens","_character","_word","_sentence","_css","_json","_array","_apply","_parse","_merge","_create","_dmp","_xml","uniDiff","parsePatch","currentIndex","processIndex","complete","loadFile","err","updatedContent","applyPatch","patched","_distanceIterator","removeEOFNL","addEOFNL","lines","delimiters","hunks","compareLine","lineNumber","patchContent","errorCount","fuzzFactor","minLine","hunkFits","hunk","toPos","j","content","maxLine","oldLines","localOffset","oldStart","iterator","distanceIterator","diffOffset","newLines","delimiter","linedelimiters","previousOperation","_k","fileName","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","apply","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","merged","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","defaults","bind","thisArg","arguments","getPrototypeOf","kindOf","cache","create","thing","str","kindOfTest","typeOfTest","isUndefined","isArrayBuffer","isString","isFunction","isNumber","isObject","isPlainObject","val","toStringTag","isDate","isFile","isBlob","isFileList","isURLSearchParams","isReadableStream","isRequest","isHeaders","allOwnKeys","l","getOwnPropertyNames","len","findKey","_key","_global","globalThis","isContextDefined","isTypedArray","TypedArray","Uint8Array","isHTMLForm","prop","isRegExp","reduceDescriptors","reducer","descriptors","getOwnPropertyDescriptors","reducedDescriptors","descriptor","defineProperties","ALPHA","DIGIT","ALPHABET","ALPHA_DIGIT","isAsyncFn","_setImmediate","setImmediateSupported","postMessageSupported","setImmediate","token","callbacks","cb","postMessage","asap","queueMicrotask","process","nextTick","isBuffer","isFormData","kind","isArrayBufferView","ArrayBuffer","isView","buffer","isBoolean","isStream","pipe","merge","caseless","assignValue","targetKey","extend","stripBOM","charCodeAt","inherits","superConstructor","defineProperty","toFlatObject","sourceObj","destObj","propFilter","searchString","position","lastIndex","toArray","arr","forEachEntry","pair","matchAll","regExp","hasOwnProp","freezeMethods","enumerable","writable","toObjectSet","arrayOrString","define","toCamelCase","p1","p2","toFiniteNumber","defaultValue","Number","isFinite","generateString","alphabet","isSpecCompliantForm","toJSONObject","visit","reducedValue","isThenable","AxiosError","captureStackTrace","utils","description","number","columnNumber","customProps","axiosError","cause","isVisitable","removeBrackets","renderKey","dots","predicates","TypeError","metaTokens","indexes","option","visitor","defaultVisitor","useBlob","Blob","convertValue","toISOString","Buffer","isFlatArray","exposedHelpers","build","encode","charMap","encodeURIComponent","AxiosURLSearchParams","_pairs","toFormData","encoder","_encode","buildURL","serializeFn","serialize","serializedParams","hashmarkIndex","handlers","use","fulfilled","rejected","synchronous","runWhen","eject","h","silentJSONParsing","forcedJSONParsing","clarifyTimeoutError","classes","protocols","hasBrowserEnv","_navigator","hasStandardBrowserEnv","hasStandardBrowserWebWorkerEnv","WorkerGlobalScope","importScripts","platform","buildPath","isNumericKey","isLast","arrayToObject","parsePropPath","transitional","transitionalDefaults","adapter","transformRequest","getContentType","hasJSONContentType","isObjectPayload","formDataToJSON","setContentType","helpers","isNode","toURLEncodedForm","formSerializer","_FormData","env","rawValue","parser","stringifySafely","transformResponse","JSONRequested","responseType","strictJSONParsing","timeout","xsrfCookieName","xsrfHeaderName","maxContentLength","maxBodyLength","validateStatus","common","ignoreDuplicateOf","$internals","normalizeHeader","normalizeValue","matchHeaderValue","isHeaderNameFilter","AxiosHeaders","valueOrRewrite","rewrite","setHeader","_value","_header","_rewrite","lHeader","setHeaders","rawHeaders","parsed","substring","parseHeaders","tokensRE","parseTokens","deleted","deleteHeader","normalize","format","normalized","w","formatHeader","targets","asStrings","computed","accessors","defineAccessor","accessorName","methodName","arg1","arg2","arg3","configurable","buildAccessors","accessor","mapped","headerValue","transformData","fns","isCancel","__CANCEL__","CanceledError","settle","floor","samplesCount","bytes","timestamps","firstSampleTS","head","tail","chunkLength","startedAt","bytesCount","passed","round","freq","lastArgs","timer","timestamp","threshold","invoke","progressEventReducer","isDownloadStream","bytesNotified","_speedometer","speedometer","throttle","loaded","total","lengthComputable","progressBytes","rate","progress","estimated","progressEventDecorator","throttled","asyncDecorator","msie","userAgent","urlParsingNode","originURL","resolveURL","host","hostname","port","requestURL","write","expires","domain","secure","cookie","toGMTString","read","buildFullPath","baseURL","requestedURL","relativeURL","combineURLs","headersToObject","mergeConfig","config1","config2","getMergedValue","mergeDeepProperties","valueFromConfig2","defaultToConfig2","mergeDirectKeys","mergeMap","paramsSerializer","timeoutMessage","withCredentials","withXSRFToken","onUploadProgress","onDownloadProgress","decompress","beforeRedirect","transport","httpAgent","httpsAgent","cancelToken","socketPath","responseEncoding","configValue","newConfig","auth","btoa","username","password","unescape","isURLSameOrigin","xsrfValue","cookies","XMLHttpRequest","_config","resolveConfig","requestData","requestHeaders","onCanceled","uploadThrottled","downloadThrottled","flushUpload","flushDownload","unsubscribe","onloadend","responseHeaders","getAllResponseHeaders","responseText","open","onreadystatechange","readyState","responseURL","onabort","onerror","ontimeout","timeoutErrorMessage","setRequestHeader","upload","parseProtocol","send","reason","streamChunk","chunk","chunkSize","byteLength","pos","readStream","stream","asyncIterator","reader","getReader","trackStream","onProgress","onFinish","iterable","readBytes","_onFinish","ReadableStream","close","loadedBytes","enqueue","return","highWaterMark","isFetchSupported","Response","isReadableStreamSupported","encodeText","TextEncoder","arrayBuffer","supportsRequestStream","duplexAccessed","hasContentType","duplex","supportsResponseStream","resolvers","res","resolveBodyLength","getContentLength","_request","getBodyLength","knownAdapters","http","xhr","xhrAdapter","fetchOptions","composedSignal","composeSignals","toAbortSignal","requestContentLength","contentTypeHeader","flush","isCredentialsSupported","credentials","isStreamResponse","responseContentLength","responseData","renderReason","isResolvedHandle","adapters","nameOrAdapter","rejectedReasons","reasons","throwIfCancellationRequested","throwIfRequested","dispatchRequest","VERSION","validators","deprecatedWarnings","validator","version","formatMessage","opt","desc","assertOptions","schema","allowUnknown","Axios","instanceConfig","interceptors","InterceptorManager","configOrUrl","dummy","boolean","function","contextHeaders","requestInterceptorChain","synchronousRequestInterceptors","interceptor","unshift","responseInterceptorChain","promise","chain","onFulfilled","onRejected","getUri","generateHTTPMethod","isForm","CancelToken","executor","resolvePromise","_listeners","onfulfilled","_resolve","c","HttpStatusCode","Continue","SwitchingProtocols","Processing","EarlyHints","Ok","Created","Accepted","NonAuthoritativeInformation","NoContent","ResetContent","PartialContent","MultiStatus","AlreadyReported","ImUsed","MultipleChoices","MovedPermanently","Found","SeeOther","NotModified","UseProxy","Unused","TemporaryRedirect","PermanentRedirect","BadRequest","Unauthorized","PaymentRequired","Forbidden","NotFound","MethodNotAllowed","NotAcceptable","ProxyAuthenticationRequired","RequestTimeout","Conflict","Gone","LengthRequired","PreconditionFailed","PayloadTooLarge","UriTooLong","UnsupportedMediaType","RangeNotSatisfiable","ExpectationFailed","ImATeapot","MisdirectedRequest","UnprocessableEntity","Locked","FailedDependency","TooEarly","UpgradeRequired","PreconditionRequired","TooManyRequests","RequestHeaderFieldsTooLarge","UnavailableForLegalReasons","InternalServerError","NotImplemented","BadGateway","ServiceUnavailable","GatewayTimeout","HttpVersionNotSupported","VariantAlsoNegotiates","InsufficientStorage","LoopDetected","NotExtended","NetworkAuthenticationRequired","axios","createInstance","defaultConfig","instance","Cancel","promises","spread","isAxiosError","payload","formToJSON","getAdapter","default"],"sourceRoot":""}