{"version":3,"file":"7778.b514a67c.js","mappings":"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","sources":["webpack://@finviz/website/../node_modules/@remix-run/router/dist/router.js","webpack://@finviz/website/../node_modules/lodash.throttle/index.js","webpack://@finviz/website/../node_modules/path-to-regexp/dist/index.js","webpack://@finviz/website/../node_modules/react-router-dom/dist/index.js","webpack://@finviz/website/../node_modules/react-router/dist/index.js","webpack://@finviz/website/../node_modules/classnames/index.js","webpack://@finviz/website/../node_modules/core-js/internals/error-stack-clear.js","webpack://@finviz/website/../node_modules/core-js/internals/error-stack-install.js","webpack://@finviz/website/../node_modules/core-js/internals/error-stack-installable.js","webpack://@finviz/website/../node_modules/core-js/internals/install-error-cause.js","webpack://@finviz/website/../node_modules/core-js/internals/normalize-string-argument.js","webpack://@finviz/website/../node_modules/core-js/internals/wrap-error-constructor-with-cause.js","webpack://@finviz/website/../node_modules/core-js/modules/es.error.cause.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/__chunks/3YLGPPWQ.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/__chunks/7PRQYBBV.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/__chunks/AJZ4BYF3.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/__chunks/BCALMBPZ.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/__chunks/CYQWQL4J.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/__chunks/DTR5TSDJ.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/__chunks/FZZ2AVHF.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/__chunks/JTLIIJ4U.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/__chunks/ME2CUF3F.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/__chunks/PBFD2E7P.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/__chunks/QAGXQEUG.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/__chunks/RCQ5P4YE.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/utils/events.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/utils/focus.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/3YLGPPWQ.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/C3IKGW5T.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/4CMBR7SL.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/5VQZOHHZ.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/ABQUS43J.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/BM6PGYQY.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/BYC7LY2E.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/EM5CXX6A.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/F4IYJ42G.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/3XAVFTCA.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/combobox/combobox-store.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/FEOFMWBY.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/FTXTWCCT.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/HUWAI7RB.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/ITI7HKP4.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/63XF7ACK.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/K2ZF5NU7.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/AOUGVQZ3.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/2PGBN2Y4.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/63FEHJZV.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/ESSM74HH.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/677M2CI3.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/KZAQFFOU.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/BGQ3KQ5M.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/YKJECYU7.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/TOU75OXH.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/WBDYNH73.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/HLTQOHKZ.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/ZWYATQFU.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/CZ4GFWYL.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/5M6RIVE2.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/JC64G2H7.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/6GXEOXGT.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/IGR4SXG2.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/X7QOZUD3.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/KQKDTOT4.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/KUU7WJ55.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/LMDWO4NN.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/LVA2YJMS.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/MTZPJQMC.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/O2PQ2652.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/XX67R432.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/W3VI7GFU.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/AOQQTIBO.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/O37CNYMR.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/OMU7RWRV.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/P2CTZE2T.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/P7GR5CS5.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/RS7LB2H4.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/RZ4GPYOB.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/S6EF7IVO.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/SK3NAZA3.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/SWN3JYXT.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/T6C2RYFI.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/UQQRIHDV.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/VDHZ5F7K.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/VEVQD5MH.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/VGCJ63VH.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/WYCIER3C.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/XL7CSKGW.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/tooltip/tooltip-store.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/YTDK2NGG.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/YV4JVR4I.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/ZTDSJLD6.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/combobox/combobox-popover.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/combobox/combobox.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/tooltip/tooltip-anchor.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/QFL5V2DO.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/IS6J7QCK.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/tooltip/tooltip-arrow.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/tooltip/tooltip-provider.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/tooltip/tooltip.js","webpack://@finviz/website/../node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs","webpack://@finviz/website/../node_modules/@floating-ui/core/dist/floating-ui.core.mjs","webpack://@finviz/website/../node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs","webpack://@finviz/website/../node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs"],"sourcesContent":["/**\n * @remix-run/router v1.19.0\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Actions represent the type of change to a location value.\n */\nvar Action;\n(function (Action) {\n  /**\n   * A POP indicates a change to an arbitrary index in the history stack, such\n   * as a back or forward navigation. It does not describe the direction of the\n   * navigation, only that the current index changed.\n   *\n   * Note: This is the default action for newly created history objects.\n   */\n  Action[\"Pop\"] = \"POP\";\n  /**\n   * A PUSH indicates a new entry being added to the history stack, such as when\n   * a link is clicked and a new page loads. When this happens, all subsequent\n   * entries in the stack are lost.\n   */\n  Action[\"Push\"] = \"PUSH\";\n  /**\n   * A REPLACE indicates the entry at the current index in the history stack\n   * being replaced by a new one.\n   */\n  Action[\"Replace\"] = \"REPLACE\";\n})(Action || (Action = {}));\nconst PopStateEventType = \"popstate\";\n/**\n * Memory history stores the current location in memory. It is designed for use\n * in stateful non-browser environments like tests and React Native.\n */\nfunction createMemoryHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  let {\n    initialEntries = [\"/\"],\n    initialIndex,\n    v5Compat = false\n  } = options;\n  let entries; // Declare so we can access from createMemoryLocation\n  entries = initialEntries.map((entry, index) => createMemoryLocation(entry, typeof entry === \"string\" ? null : entry.state, index === 0 ? \"default\" : undefined));\n  let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);\n  let action = Action.Pop;\n  let listener = null;\n  function clampIndex(n) {\n    return Math.min(Math.max(n, 0), entries.length - 1);\n  }\n  function getCurrentLocation() {\n    return entries[index];\n  }\n  function createMemoryLocation(to, state, key) {\n    if (state === void 0) {\n      state = null;\n    }\n    let location = createLocation(entries ? getCurrentLocation().pathname : \"/\", to, state, key);\n    warning(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in memory history: \" + JSON.stringify(to));\n    return location;\n  }\n  function createHref(to) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n  let history = {\n    get index() {\n      return index;\n    },\n    get action() {\n      return action;\n    },\n    get location() {\n      return getCurrentLocation();\n    },\n    createHref,\n    createURL(to) {\n      return new URL(createHref(to), \"http://localhost\");\n    },\n    encodeLocation(to) {\n      let path = typeof to === \"string\" ? parsePath(to) : to;\n      return {\n        pathname: path.pathname || \"\",\n        search: path.search || \"\",\n        hash: path.hash || \"\"\n      };\n    },\n    push(to, state) {\n      action = Action.Push;\n      let nextLocation = createMemoryLocation(to, state);\n      index += 1;\n      entries.splice(index, entries.length, nextLocation);\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta: 1\n        });\n      }\n    },\n    replace(to, state) {\n      action = Action.Replace;\n      let nextLocation = createMemoryLocation(to, state);\n      entries[index] = nextLocation;\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta: 0\n        });\n      }\n    },\n    go(delta) {\n      action = Action.Pop;\n      let nextIndex = clampIndex(index + delta);\n      let nextLocation = entries[nextIndex];\n      index = nextIndex;\n      if (listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta\n        });\n      }\n    },\n    listen(fn) {\n      listener = fn;\n      return () => {\n        listener = null;\n      };\n    }\n  };\n  return history;\n}\n/**\n * Browser history stores the location in regular URLs. This is the standard for\n * most web apps, but it requires some configuration on the server to ensure you\n * serve the same app at multiple URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\n */\nfunction createBrowserHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  function createBrowserLocation(window, globalHistory) {\n    let {\n      pathname,\n      search,\n      hash\n    } = window.location;\n    return createLocation(\"\", {\n      pathname,\n      search,\n      hash\n    },\n    // state defaults to `null` because `window.history.state` does\n    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n  }\n  function createBrowserHref(window, to) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n  return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);\n}\n/**\n * Hash history stores the location in window.location.hash. This makes it ideal\n * for situations where you don't want to send the location to the server for\n * some reason, either because you do cannot configure it or the URL space is\n * reserved for something else.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\n */\nfunction createHashHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  function createHashLocation(window, globalHistory) {\n    let {\n      pathname = \"/\",\n      search = \"\",\n      hash = \"\"\n    } = parsePath(window.location.hash.substr(1));\n    // Hash URL should always have a leading / just like window.location.pathname\n    // does, so if an app ends up at a route like /#something then we add a\n    // leading slash so all of our path-matching behaves the same as if it would\n    // in a browser router.  This is particularly important when there exists a\n    // root splat route (<Route path=\"*\">) since that matches internally against\n    // \"/*\" and we'd expect /#something to 404 in a hash router app.\n    if (!pathname.startsWith(\"/\") && !pathname.startsWith(\".\")) {\n      pathname = \"/\" + pathname;\n    }\n    return createLocation(\"\", {\n      pathname,\n      search,\n      hash\n    },\n    // state defaults to `null` because `window.history.state` does\n    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n  }\n  function createHashHref(window, to) {\n    let base = window.document.querySelector(\"base\");\n    let href = \"\";\n    if (base && base.getAttribute(\"href\")) {\n      let url = window.location.href;\n      let hashIndex = url.indexOf(\"#\");\n      href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n    }\n    return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n  }\n  function validateHashLocation(location, to) {\n    warning(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in hash history.push(\" + JSON.stringify(to) + \")\");\n  }\n  return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);\n}\nfunction invariant(value, message) {\n  if (value === false || value === null || typeof value === \"undefined\") {\n    throw new Error(message);\n  }\n}\nfunction warning(cond, message) {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== \"undefined\") console.warn(message);\n    try {\n      // Welcome to debugging history!\n      //\n      // This error is thrown as a convenience, so you can more easily\n      // find the source for a warning that appears in the console by\n      // enabling \"pause on exceptions\" in your JavaScript debugger.\n      throw new Error(message);\n      // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\nfunction createKey() {\n  return Math.random().toString(36).substr(2, 8);\n}\n/**\n * For browser-based histories, we combine the state and key into an object\n */\nfunction getHistoryState(location, index) {\n  return {\n    usr: location.state,\n    key: location.key,\n    idx: index\n  };\n}\n/**\n * Creates a Location object with a unique key from the given Path\n */\nfunction createLocation(current, to, state, key) {\n  if (state === void 0) {\n    state = null;\n  }\n  let location = _extends({\n    pathname: typeof current === \"string\" ? current : current.pathname,\n    search: \"\",\n    hash: \"\"\n  }, typeof to === \"string\" ? parsePath(to) : to, {\n    state,\n    // TODO: This could be cleaned up.  push/replace should probably just take\n    // full Locations now and avoid the need to run through this flow at all\n    // But that's a pretty big refactor to the current test suite so going to\n    // keep as is for the time being and just let any incoming keys take precedence\n    key: to && to.key || key || createKey()\n  });\n  return location;\n}\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\nfunction createPath(_ref) {\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\"\n  } = _ref;\n  if (search && search !== \"?\") pathname += search.charAt(0) === \"?\" ? search : \"?\" + search;\n  if (hash && hash !== \"#\") pathname += hash.charAt(0) === \"#\" ? hash : \"#\" + hash;\n  return pathname;\n}\n/**\n * Parses a string URL path into its separate pathname, search, and hash components.\n */\nfunction parsePath(path) {\n  let parsedPath = {};\n  if (path) {\n    let hashIndex = path.indexOf(\"#\");\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n    let searchIndex = path.indexOf(\"?\");\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n  return parsedPath;\n}\nfunction getUrlBasedHistory(getLocation, createHref, validateLocation, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  let {\n    window = document.defaultView,\n    v5Compat = false\n  } = options;\n  let globalHistory = window.history;\n  let action = Action.Pop;\n  let listener = null;\n  let index = getIndex();\n  // Index should only be null when we initialize. If not, it's because the\n  // user called history.pushState or history.replaceState directly, in which\n  // case we should log a warning as it will result in bugs.\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState(_extends({}, globalHistory.state, {\n      idx: index\n    }), \"\");\n  }\n  function getIndex() {\n    let state = globalHistory.state || {\n      idx: null\n    };\n    return state.idx;\n  }\n  function handlePop() {\n    action = Action.Pop;\n    let nextIndex = getIndex();\n    let delta = nextIndex == null ? null : nextIndex - index;\n    index = nextIndex;\n    if (listener) {\n      listener({\n        action,\n        location: history.location,\n        delta\n      });\n    }\n  }\n  function push(to, state) {\n    action = Action.Push;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n    index = getIndex() + 1;\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    // try...catch because iOS limits us to 100 pushState calls :/\n    try {\n      globalHistory.pushState(historyState, \"\", url);\n    } catch (error) {\n      // If the exception is because `state` can't be serialized, let that throw\n      // outwards just like a replace call would so the dev knows the cause\n      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps\n      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal\n      if (error instanceof DOMException && error.name === \"DataCloneError\") {\n        throw error;\n      }\n      // They are going to lose state here, but there is no real\n      // way to warn them about it since the page will refresh...\n      window.location.assign(url);\n    }\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location,\n        delta: 1\n      });\n    }\n  }\n  function replace(to, state) {\n    action = Action.Replace;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n    index = getIndex();\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    globalHistory.replaceState(historyState, \"\", url);\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location,\n        delta: 0\n      });\n    }\n  }\n  function createURL(to) {\n    // window.location.origin is \"null\" (the literal string value) in Firefox\n    // under certain conditions, notably when serving from a local HTML file\n    // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n    let base = window.location.origin !== \"null\" ? window.location.origin : window.location.href;\n    let href = typeof to === \"string\" ? to : createPath(to);\n    // Treating this as a full URL will strip any trailing spaces so we need to\n    // pre-encode them since they might be part of a matching splat param from\n    // an ancestor route\n    href = href.replace(/ $/, \"%20\");\n    invariant(base, \"No window.location.(origin|href) available to create URL for href: \" + href);\n    return new URL(href, base);\n  }\n  let history = {\n    get action() {\n      return action;\n    },\n    get location() {\n      return getLocation(window, globalHistory);\n    },\n    listen(fn) {\n      if (listener) {\n        throw new Error(\"A history only accepts one active listener\");\n      }\n      window.addEventListener(PopStateEventType, handlePop);\n      listener = fn;\n      return () => {\n        window.removeEventListener(PopStateEventType, handlePop);\n        listener = null;\n      };\n    },\n    createHref(to) {\n      return createHref(window, to);\n    },\n    createURL,\n    encodeLocation(to) {\n      // Encode a Location the same way window.location would\n      let url = createURL(to);\n      return {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash\n      };\n    },\n    push,\n    replace,\n    go(n) {\n      return globalHistory.go(n);\n    }\n  };\n  return history;\n}\n//#endregion\n\nvar ResultType;\n(function (ResultType) {\n  ResultType[\"data\"] = \"data\";\n  ResultType[\"deferred\"] = \"deferred\";\n  ResultType[\"redirect\"] = \"redirect\";\n  ResultType[\"error\"] = \"error\";\n})(ResultType || (ResultType = {}));\nconst immutableRouteKeys = new Set([\"lazy\", \"caseSensitive\", \"path\", \"id\", \"index\", \"children\"]);\nfunction isIndexRoute(route) {\n  return route.index === true;\n}\n// Walk the route tree generating unique IDs where necessary, so we are working\n// solely with AgnosticDataRouteObject's within the Router\nfunction convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath, manifest) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\n  if (manifest === void 0) {\n    manifest = {};\n  }\n  return routes.map((route, index) => {\n    let treePath = [...parentPath, String(index)];\n    let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n    invariant(route.index !== true || !route.children, \"Cannot specify children on an index route\");\n    invariant(!manifest[id], \"Found a route id collision on id \\\"\" + id + \"\\\".  Route \" + \"id's must be globally unique within Data Router usages\");\n    if (isIndexRoute(route)) {\n      let indexRoute = _extends({}, route, mapRouteProperties(route), {\n        id\n      });\n      manifest[id] = indexRoute;\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute = _extends({}, route, mapRouteProperties(route), {\n        id,\n        children: undefined\n      });\n      manifest[id] = pathOrLayoutRoute;\n      if (route.children) {\n        pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties, treePath, manifest);\n      }\n      return pathOrLayoutRoute;\n    }\n  });\n}\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/utils/match-routes\n */\nfunction matchRoutes(routes, locationArg, basename) {\n  if (basename === void 0) {\n    basename = \"/\";\n  }\n  return matchRoutesImpl(routes, locationArg, basename, false);\n}\nfunction matchRoutesImpl(routes, locationArg, basename, allowPartial) {\n  let location = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n  let pathname = stripBasename(location.pathname || \"/\", basename);\n  if (pathname == null) {\n    return null;\n  }\n  let branches = flattenRoutes(routes);\n  rankRouteBranches(branches);\n  let matches = null;\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    // Incoming pathnames are generally encoded from either window.location\n    // or from router.navigate, but we want to match against the unencoded\n    // paths in the route definitions.  Memory router locations won't be\n    // encoded here but there also shouldn't be anything to decode so this\n    // should be a safe operation.  This avoids needing matchRoutes to be\n    // history-aware.\n    let decoded = decodePath(pathname);\n    matches = matchRouteBranch(branches[i], decoded, allowPartial);\n  }\n  return matches;\n}\nfunction convertRouteMatchToUiMatch(match, loaderData) {\n  let {\n    route,\n    pathname,\n    params\n  } = match;\n  return {\n    id: route.id,\n    pathname,\n    params,\n    data: loaderData[route.id],\n    handle: route.handle\n  };\n}\nfunction flattenRoutes(routes, branches, parentsMeta, parentPath) {\n  if (branches === void 0) {\n    branches = [];\n  }\n  if (parentsMeta === void 0) {\n    parentsMeta = [];\n  }\n  if (parentPath === void 0) {\n    parentPath = \"\";\n  }\n  let flattenRoute = (route, index, relativePath) => {\n    let meta = {\n      relativePath: relativePath === undefined ? route.path || \"\" : relativePath,\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route\n    };\n    if (meta.relativePath.startsWith(\"/\")) {\n      invariant(meta.relativePath.startsWith(parentPath), \"Absolute route path \\\"\" + meta.relativePath + \"\\\" nested under path \" + (\"\\\"\" + parentPath + \"\\\" is not valid. An absolute child route path \") + \"must start with the combined path of all its parent routes.\");\n      meta.relativePath = meta.relativePath.slice(parentPath.length);\n    }\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta);\n    // Add the children before adding this route to the array, so we traverse the\n    // route tree depth-first and child routes appear before their parents in\n    // the \"flattened\" version.\n    if (route.children && route.children.length > 0) {\n      invariant(\n      // Our types know better, but runtime JS may not!\n      // @ts-expect-error\n      route.index !== true, \"Index routes must not have child routes. Please remove \" + (\"all child routes from route path \\\"\" + path + \"\\\".\"));\n      flattenRoutes(route.children, branches, routesMeta, path);\n    }\n    // Routes without a path shouldn't ever match by themselves unless they are\n    // index routes, so don't add them to the list of possible branches.\n    if (route.path == null && !route.index) {\n      return;\n    }\n    branches.push({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta\n    });\n  };\n  routes.forEach((route, index) => {\n    var _route$path;\n    // coarse-grain check for optional params\n    if (route.path === \"\" || !((_route$path = route.path) != null && _route$path.includes(\"?\"))) {\n      flattenRoute(route, index);\n    } else {\n      for (let exploded of explodeOptionalSegments(route.path)) {\n        flattenRoute(route, index, exploded);\n      }\n    }\n  });\n  return branches;\n}\n/**\n * Computes all combinations of optional path segments for a given path,\n * excluding combinations that are ambiguous and of lower priority.\n *\n * For example, `/one/:two?/three/:four?/:five?` explodes to:\n * - `/one/three`\n * - `/one/:two/three`\n * - `/one/three/:four`\n * - `/one/three/:five`\n * - `/one/:two/three/:four`\n * - `/one/:two/three/:five`\n * - `/one/three/:four/:five`\n * - `/one/:two/three/:four/:five`\n */\nfunction explodeOptionalSegments(path) {\n  let segments = path.split(\"/\");\n  if (segments.length === 0) return [];\n  let [first, ...rest] = segments;\n  // Optional path segments are denoted by a trailing `?`\n  let isOptional = first.endsWith(\"?\");\n  // Compute the corresponding required segment: `foo?` -> `foo`\n  let required = first.replace(/\\?$/, \"\");\n  if (rest.length === 0) {\n    // Intepret empty string as omitting an optional segment\n    // `[\"one\", \"\", \"three\"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`\n    return isOptional ? [required, \"\"] : [required];\n  }\n  let restExploded = explodeOptionalSegments(rest.join(\"/\"));\n  let result = [];\n  // All child paths with the prefix.  Do this for all children before the\n  // optional version for all children, so we get consistent ordering where the\n  // parent optional aspect is preferred as required.  Otherwise, we can get\n  // child sections interspersed where deeper optional segments are higher than\n  // parent optional segments, where for example, /:two would explode _earlier_\n  // then /:one.  By always including the parent as required _for all children_\n  // first, we avoid this issue\n  result.push(...restExploded.map(subpath => subpath === \"\" ? required : [required, subpath].join(\"/\")));\n  // Then, if this is an optional value, add all child versions without\n  if (isOptional) {\n    result.push(...restExploded);\n  }\n  // for absolute paths, ensure `/` instead of empty segment\n  return result.map(exploded => path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded);\n}\nfunction rankRouteBranches(branches) {\n  branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first\n  : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));\n}\nconst paramRe = /^:[\\w-]+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = s => s === \"*\";\nfunction computeScore(path, index) {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n  return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === \"\" ? emptySegmentValue : staticSegmentValue), initialScore);\n}\nfunction compareIndexes(a, b) {\n  let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n  return siblings ?\n  // If two routes are siblings, we should try to match the earlier sibling\n  // first. This allows people to have fine-grained control over the matching\n  // behavior by simply putting routes with identical paths in the order they\n  // want them tried.\n  a[a.length - 1] - b[b.length - 1] :\n  // Otherwise, it doesn't really make sense to rank non-siblings by index,\n  // so they sort equally.\n  0;\n}\nfunction matchRouteBranch(branch, pathname, allowPartial) {\n  if (allowPartial === void 0) {\n    allowPartial = false;\n  }\n  let {\n    routesMeta\n  } = branch;\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches = [];\n  for (let i = 0; i < routesMeta.length; ++i) {\n    let meta = routesMeta[i];\n    let end = i === routesMeta.length - 1;\n    let remainingPathname = matchedPathname === \"/\" ? pathname : pathname.slice(matchedPathname.length) || \"/\";\n    let match = matchPath({\n      path: meta.relativePath,\n      caseSensitive: meta.caseSensitive,\n      end\n    }, remainingPathname);\n    let route = meta.route;\n    if (!match && end && allowPartial && !routesMeta[routesMeta.length - 1].route.index) {\n      match = matchPath({\n        path: meta.relativePath,\n        caseSensitive: meta.caseSensitive,\n        end: false\n      }, remainingPathname);\n    }\n    if (!match) {\n      return null;\n    }\n    Object.assign(matchedParams, match.params);\n    matches.push({\n      // TODO: Can this as be avoided?\n      params: matchedParams,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),\n      route\n    });\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n  return matches;\n}\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/utils/generate-path\n */\nfunction generatePath(originalPath, params) {\n  if (params === void 0) {\n    params = {};\n  }\n  let path = originalPath;\n  if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n    warning(false, \"Route path \\\"\" + path + \"\\\" will be treated as if it were \" + (\"\\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\" because the `*` character must \") + \"always follow a `/` in the pattern. To get rid of this warning, \" + (\"please change the route path to \\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\".\"));\n    path = path.replace(/\\*$/, \"/*\");\n  }\n  // ensure `/` is added at the beginning if the path is absolute\n  const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n  const stringify = p => p == null ? \"\" : typeof p === \"string\" ? p : String(p);\n  const segments = path.split(/\\/+/).map((segment, index, array) => {\n    const isLastSegment = index === array.length - 1;\n    // only apply the splat if it's the last segment\n    if (isLastSegment && segment === \"*\") {\n      const star = \"*\";\n      // Apply the splat\n      return stringify(params[star]);\n    }\n    const keyMatch = segment.match(/^:([\\w-]+)(\\??)$/);\n    if (keyMatch) {\n      const [, key, optional] = keyMatch;\n      let param = params[key];\n      invariant(optional === \"?\" || param != null, \"Missing \\\":\" + key + \"\\\" param\");\n      return stringify(param);\n    }\n    // Remove any optional markers from optional static segments\n    return segment.replace(/\\?$/g, \"\");\n  })\n  // Remove empty segments\n  .filter(segment => !!segment);\n  return prefix + segments.join(\"/\");\n}\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/utils/match-path\n */\nfunction matchPath(pattern, pathname) {\n  if (typeof pattern === \"string\") {\n    pattern = {\n      path: pattern,\n      caseSensitive: false,\n      end: true\n    };\n  }\n  let [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);\n  let match = pathname.match(matcher);\n  if (!match) return null;\n  let matchedPathname = match[0];\n  let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n  let captureGroups = match.slice(1);\n  let params = compiledParams.reduce((memo, _ref, index) => {\n    let {\n      paramName,\n      isOptional\n    } = _ref;\n    // We need to compute the pathnameBase here using the raw splat value\n    // instead of using params[\"*\"] later because it will be decoded then\n    if (paramName === \"*\") {\n      let splatValue = captureGroups[index] || \"\";\n      pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\\/+$/, \"$1\");\n    }\n    const value = captureGroups[index];\n    if (isOptional && !value) {\n      memo[paramName] = undefined;\n    } else {\n      memo[paramName] = (value || \"\").replace(/%2F/g, \"/\");\n    }\n    return memo;\n  }, {});\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern\n  };\n}\nfunction compilePath(path, caseSensitive, end) {\n  if (caseSensitive === void 0) {\n    caseSensitive = false;\n  }\n  if (end === void 0) {\n    end = true;\n  }\n  warning(path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"), \"Route path \\\"\" + path + \"\\\" will be treated as if it were \" + (\"\\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\" because the `*` character must \") + \"always follow a `/` in the pattern. To get rid of this warning, \" + (\"please change the route path to \\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\".\"));\n  let params = [];\n  let regexpSource = \"^\" + path.replace(/\\/*\\*?$/, \"\") // Ignore trailing / and /*, we'll handle it below\n  .replace(/^\\/*/, \"/\") // Make sure it has a leading /\n  .replace(/[\\\\.*+^${}|()[\\]]/g, \"\\\\$&\") // Escape special regex chars\n  .replace(/\\/:([\\w-]+)(\\?)?/g, (_, paramName, isOptional) => {\n    params.push({\n      paramName,\n      isOptional: isOptional != null\n    });\n    return isOptional ? \"/?([^\\\\/]+)?\" : \"/([^\\\\/]+)\";\n  });\n  if (path.endsWith(\"*\")) {\n    params.push({\n      paramName: \"*\"\n    });\n    regexpSource += path === \"*\" || path === \"/*\" ? \"(.*)$\" // Already matched the initial /, just match the rest\n    : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else if (end) {\n    // When matching to the end, ignore trailing slashes\n    regexpSource += \"\\\\/*$\";\n  } else if (path !== \"\" && path !== \"/\") {\n    // If our path is non-empty and contains anything beyond an initial slash,\n    // then we have _some_ form of path in our regex, so we should expect to\n    // match only if we find the end of this path segment.  Look for an optional\n    // non-captured trailing slash (to match a portion of the URL) or the end\n    // of the path (if we've matched to the end).  We used to do this with a\n    // word boundary but that gives false positives on routes like\n    // /user-preferences since `-` counts as a word boundary.\n    regexpSource += \"(?:(?=\\\\/|$))\";\n  } else ;\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n  return [matcher, params];\n}\nfunction decodePath(value) {\n  try {\n    return value.split(\"/\").map(v => decodeURIComponent(v).replace(/\\//g, \"%2F\")).join(\"/\");\n  } catch (error) {\n    warning(false, \"The URL path \\\"\" + value + \"\\\" could not be decoded because it is is a \" + \"malformed URL segment. This is probably due to a bad percent \" + (\"encoding (\" + error + \").\"));\n    return value;\n  }\n}\n/**\n * @private\n */\nfunction stripBasename(pathname, basename) {\n  if (basename === \"/\") return pathname;\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n  // We want to leave trailing slash behavior in the user's control, so if they\n  // specify a basename with a trailing slash, we should support it\n  let startIndex = basename.endsWith(\"/\") ? basename.length - 1 : basename.length;\n  let nextChar = pathname.charAt(startIndex);\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n  return pathname.slice(startIndex) || \"/\";\n}\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/utils/resolve-path\n */\nfunction resolvePath(to, fromPathname) {\n  if (fromPathname === void 0) {\n    fromPathname = \"/\";\n  }\n  let {\n    pathname: toPathname,\n    search = \"\",\n    hash = \"\"\n  } = typeof to === \"string\" ? parsePath(to) : to;\n  let pathname = toPathname ? toPathname.startsWith(\"/\") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;\n  return {\n    pathname,\n    search: normalizeSearch(search),\n    hash: normalizeHash(hash)\n  };\n}\nfunction resolvePathname(relativePath, fromPathname) {\n  let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n  let relativeSegments = relativePath.split(\"/\");\n  relativeSegments.forEach(segment => {\n    if (segment === \"..\") {\n      // Keep the root \"\" segment so the pathname starts at /\n      if (segments.length > 1) segments.pop();\n    } else if (segment !== \".\") {\n      segments.push(segment);\n    }\n  });\n  return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\nfunction getInvalidPathError(char, field, dest, path) {\n  return \"Cannot include a '\" + char + \"' character in a manually specified \" + (\"`to.\" + field + \"` field [\" + JSON.stringify(path) + \"].  Please separate it out to the \") + (\"`to.\" + dest + \"` field. Alternatively you may provide the full path as \") + \"a string in <Link to=\\\"...\\\"> and the router will parse it for you.\";\n}\n/**\n * @private\n *\n * When processing relative navigation we want to ignore ancestor routes that\n * do not contribute to the path, such that index/pathless layout routes don't\n * interfere.\n *\n * For example, when moving a route element into an index route and/or a\n * pathless layout route, relative link behavior contained within should stay\n * the same.  Both of the following examples should link back to the root:\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\" element={<Link to=\"..\"}>\n *   </Route>\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\">\n *       <Route element={<AccountsLayout />}>       // <-- Does not contribute\n *         <Route index element={<Link to=\"..\"} />  // <-- Does not contribute\n *       </Route\n *     </Route>\n *   </Route>\n */\nfunction getPathContributingMatches(matches) {\n  return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);\n}\n// Return the array of pathnames for the current route matches - used to\n// generate the routePathnames input for resolveTo()\nfunction getResolveToMatches(matches, v7_relativeSplatPath) {\n  let pathMatches = getPathContributingMatches(matches);\n  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf\n  // match so we include splat values for \".\" links.  See:\n  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329\n  if (v7_relativeSplatPath) {\n    return pathMatches.map((match, idx) => idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase);\n  }\n  return pathMatches.map(match => match.pathnameBase);\n}\n/**\n * @private\n */\nfunction resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {\n  if (isPathRelative === void 0) {\n    isPathRelative = false;\n  }\n  let to;\n  if (typeof toArg === \"string\") {\n    to = parsePath(toArg);\n  } else {\n    to = _extends({}, toArg);\n    invariant(!to.pathname || !to.pathname.includes(\"?\"), getInvalidPathError(\"?\", \"pathname\", \"search\", to));\n    invariant(!to.pathname || !to.pathname.includes(\"#\"), getInvalidPathError(\"#\", \"pathname\", \"hash\", to));\n    invariant(!to.search || !to.search.includes(\"#\"), getInvalidPathError(\"#\", \"search\", \"hash\", to));\n  }\n  let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n  let toPathname = isEmptyPath ? \"/\" : to.pathname;\n  let from;\n  // Routing is relative to the current pathname if explicitly requested.\n  //\n  // If a pathname is explicitly provided in `to`, it should be relative to the\n  // route context. This is explained in `Note on `<Link to>` values` in our\n  // migration guide from v5 as a means of disambiguation between `to` values\n  // that begin with `/` and those that do not. However, this is problematic for\n  // `to` values that do not provide a pathname. `to` can simply be a search or\n  // hash string, in which case we should assume that the navigation is relative\n  // to the current location's pathname and *not* the route pathname.\n  if (toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n    // With relative=\"route\" (the default), each leading .. segment means\n    // \"go up one route\" instead of \"go up one URL segment\".  This is a key\n    // difference from how <a href> works and a major reason we call this a\n    // \"to\" value instead of a \"href\".\n    if (!isPathRelative && toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n      to.pathname = toSegments.join(\"/\");\n    }\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n  let path = resolvePath(to, from);\n  // Ensure the pathname has a trailing slash if the original \"to\" had one\n  let hasExplicitTrailingSlash = toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\");\n  // Or if this was a link to the current path which has a trailing slash\n  let hasCurrentTrailingSlash = (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n  if (!path.pathname.endsWith(\"/\") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {\n    path.pathname += \"/\";\n  }\n  return path;\n}\n/**\n * @private\n */\nfunction getToPathname(to) {\n  // Empty strings should be treated the same as / paths\n  return to === \"\" || to.pathname === \"\" ? \"/\" : typeof to === \"string\" ? parsePath(to).pathname : to.pathname;\n}\n/**\n * @private\n */\nconst joinPaths = paths => paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n/**\n * @private\n */\nconst normalizePathname = pathname => pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n/**\n * @private\n */\nconst normalizeSearch = search => !search || search === \"?\" ? \"\" : search.startsWith(\"?\") ? search : \"?\" + search;\n/**\n * @private\n */\nconst normalizeHash = hash => !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n */\nconst json = function json(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  let headers = new Headers(responseInit.headers);\n  if (!headers.has(\"Content-Type\")) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n  }\n  return new Response(JSON.stringify(data), _extends({}, responseInit, {\n    headers\n  }));\n};\nclass DataWithResponseInit {\n  constructor(data, init) {\n    this.type = \"DataWithResponseInit\";\n    this.data = data;\n    this.init = init || null;\n  }\n}\n/**\n * Create \"responses\" that contain `status`/`headers` without forcing\n * serialization into an actual `Response` - used by Remix single fetch\n */\nfunction data(data, init) {\n  return new DataWithResponseInit(data, typeof init === \"number\" ? {\n    status: init\n  } : init);\n}\nclass AbortedDeferredError extends Error {}\nclass DeferredData {\n  constructor(data, responseInit) {\n    this.pendingKeysSet = new Set();\n    this.subscribers = new Set();\n    this.deferredKeys = [];\n    invariant(data && typeof data === \"object\" && !Array.isArray(data), \"defer() only accepts plain objects\");\n    // Set up an AbortController + Promise we can race against to exit early\n    // cancellation\n    let reject;\n    this.abortPromise = new Promise((_, r) => reject = r);\n    this.controller = new AbortController();\n    let onAbort = () => reject(new AbortedDeferredError(\"Deferred data aborted\"));\n    this.unlistenAbortSignal = () => this.controller.signal.removeEventListener(\"abort\", onAbort);\n    this.controller.signal.addEventListener(\"abort\", onAbort);\n    this.data = Object.entries(data).reduce((acc, _ref2) => {\n      let [key, value] = _ref2;\n      return Object.assign(acc, {\n        [key]: this.trackPromise(key, value)\n      });\n    }, {});\n    if (this.done) {\n      // All incoming values were resolved\n      this.unlistenAbortSignal();\n    }\n    this.init = responseInit;\n  }\n  trackPromise(key, value) {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n    this.deferredKeys.push(key);\n    this.pendingKeysSet.add(key);\n    // We store a little wrapper promise that will be extended with\n    // _data/_error props upon resolve/reject\n    let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, undefined, data), error => this.onSettle(promise, key, error));\n    // Register rejection listeners to avoid uncaught promise rejections on\n    // errors or aborted deferred values\n    promise.catch(() => {});\n    Object.defineProperty(promise, \"_tracked\", {\n      get: () => true\n    });\n    return promise;\n  }\n  onSettle(promise, key, error, data) {\n    if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {\n      this.unlistenAbortSignal();\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      return Promise.reject(error);\n    }\n    this.pendingKeysSet.delete(key);\n    if (this.done) {\n      // Nothing left to abort!\n      this.unlistenAbortSignal();\n    }\n    // If the promise was resolved/rejected with undefined, we'll throw an error as you\n    // should always resolve with a value or null\n    if (error === undefined && data === undefined) {\n      let undefinedError = new Error(\"Deferred data for key \\\"\" + key + \"\\\" resolved/rejected with `undefined`, \" + \"you must resolve/reject with a value or `null`.\");\n      Object.defineProperty(promise, \"_error\", {\n        get: () => undefinedError\n      });\n      this.emit(false, key);\n      return Promise.reject(undefinedError);\n    }\n    if (data === undefined) {\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      this.emit(false, key);\n      return Promise.reject(error);\n    }\n    Object.defineProperty(promise, \"_data\", {\n      get: () => data\n    });\n    this.emit(false, key);\n    return data;\n  }\n  emit(aborted, settledKey) {\n    this.subscribers.forEach(subscriber => subscriber(aborted, settledKey));\n  }\n  subscribe(fn) {\n    this.subscribers.add(fn);\n    return () => this.subscribers.delete(fn);\n  }\n  cancel() {\n    this.controller.abort();\n    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));\n    this.emit(true);\n  }\n  async resolveData(signal) {\n    let aborted = false;\n    if (!this.done) {\n      let onAbort = () => this.cancel();\n      signal.addEventListener(\"abort\", onAbort);\n      aborted = await new Promise(resolve => {\n        this.subscribe(aborted => {\n          signal.removeEventListener(\"abort\", onAbort);\n          if (aborted || this.done) {\n            resolve(aborted);\n          }\n        });\n      });\n    }\n    return aborted;\n  }\n  get done() {\n    return this.pendingKeysSet.size === 0;\n  }\n  get unwrappedData() {\n    invariant(this.data !== null && this.done, \"Can only unwrap data on initialized and settled deferreds\");\n    return Object.entries(this.data).reduce((acc, _ref3) => {\n      let [key, value] = _ref3;\n      return Object.assign(acc, {\n        [key]: unwrapTrackedPromise(value)\n      });\n    }, {});\n  }\n  get pendingKeys() {\n    return Array.from(this.pendingKeysSet);\n  }\n}\nfunction isTrackedPromise(value) {\n  return value instanceof Promise && value._tracked === true;\n}\nfunction unwrapTrackedPromise(value) {\n  if (!isTrackedPromise(value)) {\n    return value;\n  }\n  if (value._error) {\n    throw value._error;\n  }\n  return value._data;\n}\nconst defer = function defer(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  return new DeferredData(data, responseInit);\n};\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst redirect = function redirect(url, init) {\n  if (init === void 0) {\n    init = 302;\n  }\n  let responseInit = init;\n  if (typeof responseInit === \"number\") {\n    responseInit = {\n      status: responseInit\n    };\n  } else if (typeof responseInit.status === \"undefined\") {\n    responseInit.status = 302;\n  }\n  let headers = new Headers(responseInit.headers);\n  headers.set(\"Location\", url);\n  return new Response(null, _extends({}, responseInit, {\n    headers\n  }));\n};\n/**\n * A redirect response that will force a document reload to the new location.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst redirectDocument = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Reload-Document\", \"true\");\n  return response;\n};\n/**\n * A redirect response that will perform a `history.replaceState` instead of a\n * `history.pushState` for client-side navigation redirects.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst replace = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Replace\", \"true\");\n  return response;\n};\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n *\n * We don't export the class for public use since it's an implementation\n * detail, but we export the interface above so folks can build their own\n * abstractions around instances via isRouteErrorResponse()\n */\nclass ErrorResponseImpl {\n  constructor(status, statusText, data, internal) {\n    if (internal === void 0) {\n      internal = false;\n    }\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.internal = internal;\n    if (data instanceof Error) {\n      this.data = data.toString();\n      this.error = data;\n    } else {\n      this.data = data;\n    }\n  }\n}\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\nfunction isRouteErrorResponse(error) {\n  return error != null && typeof error.status === \"number\" && typeof error.statusText === \"string\" && typeof error.internal === \"boolean\" && \"data\" in error;\n}\n\nconst validMutationMethodsArr = [\"post\", \"put\", \"patch\", \"delete\"];\nconst validMutationMethods = new Set(validMutationMethodsArr);\nconst validRequestMethodsArr = [\"get\", ...validMutationMethodsArr];\nconst validRequestMethods = new Set(validRequestMethodsArr);\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\nconst IDLE_NAVIGATION = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined\n};\nconst IDLE_FETCHER = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined\n};\nconst IDLE_BLOCKER = {\n  state: \"unblocked\",\n  proceed: undefined,\n  reset: undefined,\n  location: undefined\n};\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\nconst defaultMapRouteProperties = route => ({\n  hasErrorBoundary: Boolean(route.hasErrorBoundary)\n});\nconst TRANSITIONS_STORAGE_KEY = \"remix-router-transitions\";\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Create a router and listen to history POP navigations\n */\nfunction createRouter(init) {\n  const routerWindow = init.window ? init.window : typeof window !== \"undefined\" ? window : undefined;\n  const isBrowser = typeof routerWindow !== \"undefined\" && typeof routerWindow.document !== \"undefined\" && typeof routerWindow.document.createElement !== \"undefined\";\n  const isServer = !isBrowser;\n  invariant(init.routes.length > 0, \"You must provide a non-empty routes array to createRouter\");\n  let mapRouteProperties;\n  if (init.mapRouteProperties) {\n    mapRouteProperties = init.mapRouteProperties;\n  } else if (init.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = init.detectErrorBoundary;\n    mapRouteProperties = route => ({\n      hasErrorBoundary: detectErrorBoundary(route)\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Routes keyed by ID\n  let manifest = {};\n  // Routes in tree format for matching\n  let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties, undefined, manifest);\n  let inFlightDataRoutes;\n  let basename = init.basename || \"/\";\n  let dataStrategyImpl = init.unstable_dataStrategy || defaultDataStrategy;\n  let patchRoutesOnMissImpl = init.unstable_patchRoutesOnMiss;\n  // Config driven behavior flags\n  let future = _extends({\n    v7_fetcherPersist: false,\n    v7_normalizeFormMethod: false,\n    v7_partialHydration: false,\n    v7_prependBasename: false,\n    v7_relativeSplatPath: false,\n    v7_skipActionErrorRevalidation: false\n  }, init.future);\n  // Cleanup function for history\n  let unlistenHistory = null;\n  // Externally-provided functions to call on all state changes\n  let subscribers = new Set();\n  // Externally-provided object to hold scroll restoration locations during routing\n  let savedScrollPositions = null;\n  // Externally-provided function to get scroll restoration keys\n  let getScrollRestorationKey = null;\n  // Externally-provided function to get current scroll position\n  let getScrollPosition = null;\n  // One-time flag to control the initial hydration scroll restoration.  Because\n  // we don't get the saved positions from <ScrollRestoration /> until _after_\n  // the initial render, we need to manually trigger a separate updateState to\n  // send along the restoreScrollPosition\n  // Set to true if we have `hydrationData` since we assume we were SSR'd and that\n  // SSR did the initial scroll restoration.\n  let initialScrollRestored = init.hydrationData != null;\n  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);\n  let initialErrors = null;\n  if (initialMatches == null && !patchRoutesOnMissImpl) {\n    // If we do not match a user-provided-route, fall back to the root\n    // to allow the error boundary to take over\n    let error = getInternalRouterError(404, {\n      pathname: init.history.location.pathname\n    });\n    let {\n      matches,\n      route\n    } = getShortCircuitMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = {\n      [route.id]: error\n    };\n  }\n  // In SPA apps, if the user provided a patchRoutesOnMiss implementation and\n  // our initial match is a splat route, clear them out so we run through lazy\n  // discovery on hydration in case there's a more accurate lazy route match.\n  // In SSR apps (with `hydrationData`), we expect that the server will send\n  // up the proper matched routes so we don't want to run lazy discovery on\n  // initial hydration and want to hydrate into the splat route.\n  if (initialMatches && !init.hydrationData) {\n    let fogOfWar = checkFogOfWar(initialMatches, dataRoutes, init.history.location.pathname);\n    if (fogOfWar.active) {\n      initialMatches = null;\n    }\n  }\n  let initialized;\n  if (!initialMatches) {\n    initialized = false;\n    initialMatches = [];\n    // If partial hydration and fog of war is enabled, we will be running\n    // `patchRoutesOnMiss` during hydration so include any partial matches as\n    // the initial matches so we can properly render `HydrateFallback`'s\n    if (future.v7_partialHydration) {\n      let fogOfWar = checkFogOfWar(null, dataRoutes, init.history.location.pathname);\n      if (fogOfWar.active && fogOfWar.matches) {\n        initialMatches = fogOfWar.matches;\n      }\n    }\n  } else if (initialMatches.some(m => m.route.lazy)) {\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 (!initialMatches.some(m => m.route.loader)) {\n    // If we've got no loaders to run, then we're good to go\n    initialized = true;\n  } else if (future.v7_partialHydration) {\n    // If partial hydration is enabled, we're initialized so long as we were\n    // provided with hydrationData for every route with a loader, and no loaders\n    // were marked for explicit hydration\n    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;\n    let errors = init.hydrationData ? init.hydrationData.errors : null;\n    let isRouteInitialized = m => {\n      // No loader, nothing to initialize\n      if (!m.route.loader) {\n        return true;\n      }\n      // Explicitly opting-in to running on hydration\n      if (typeof m.route.loader === \"function\" && m.route.loader.hydrate === true) {\n        return false;\n      }\n      // Otherwise, initialized if hydrated with data or an error\n      return loaderData && loaderData[m.route.id] !== undefined || errors && errors[m.route.id] !== undefined;\n    };\n    // If errors exist, don't consider routes below the boundary\n    if (errors) {\n      let idx = initialMatches.findIndex(m => errors[m.route.id] !== undefined);\n      initialized = initialMatches.slice(0, idx + 1).every(isRouteInitialized);\n    } else {\n      initialized = initialMatches.every(isRouteInitialized);\n    }\n  } else {\n    // Without partial hydration - we're initialized if we were provided any\n    // hydrationData - which is expected to be complete\n    initialized = init.hydrationData != null;\n  }\n  let router;\n  let state = {\n    historyAction: init.history.action,\n    location: init.history.location,\n    matches: initialMatches,\n    initialized,\n    navigation: IDLE_NAVIGATION,\n    // Don't restore on initial updateState() if we were SSR'd\n    restoreScrollPosition: init.hydrationData != null ? false : null,\n    preventScrollReset: false,\n    revalidation: \"idle\",\n    loaderData: init.hydrationData && init.hydrationData.loaderData || {},\n    actionData: init.hydrationData && init.hydrationData.actionData || null,\n    errors: init.hydrationData && init.hydrationData.errors || initialErrors,\n    fetchers: new Map(),\n    blockers: new Map()\n  };\n  // -- Stateful internal variables to manage navigations --\n  // Current navigation in progress (to be committed in completeNavigation)\n  let pendingAction = Action.Pop;\n  // Should the current navigation prevent the scroll reset if scroll cannot\n  // be restored?\n  let pendingPreventScrollReset = false;\n  // AbortController for the active navigation\n  let pendingNavigationController;\n  // Should the current navigation enable document.startViewTransition?\n  let pendingViewTransitionEnabled = false;\n  // Store applied view transitions so we can apply them on POP\n  let appliedViewTransitions = new Map();\n  // Cleanup function for persisting applied transitions to sessionStorage\n  let removePageHideEventListener = null;\n  // We use this to avoid touching history in completeNavigation if a\n  // revalidation is entirely uninterrupted\n  let isUninterruptedRevalidation = false;\n  // Use this internal flag to force revalidation of all loaders:\n  //  - submissions (completed or interrupted)\n  //  - useRevalidator()\n  //  - X-Remix-Revalidate (from redirect)\n  let isRevalidationRequired = false;\n  // Use this internal array to capture routes that require revalidation due\n  // to a cancelled deferred on action submission\n  let cancelledDeferredRoutes = [];\n  // Use this internal array to capture fetcher loads that were cancelled by an\n  // action navigation and require revalidation\n  let cancelledFetcherLoads = new Set();\n  // AbortControllers for any in-flight fetchers\n  let fetchControllers = new Map();\n  // Track loads based on the order in which they started\n  let incrementingLoadId = 0;\n  // Track the outstanding pending navigation data load to be compared against\n  // the globally incrementing load when a fetcher load lands after a completed\n  // navigation\n  let pendingNavigationLoadId = -1;\n  // Fetchers that triggered data reloads as a result of their actions\n  let fetchReloadIds = new Map();\n  // Fetchers that triggered redirect navigations\n  let fetchRedirectIds = new Set();\n  // Most recent href/match for fetcher.load calls for fetchers\n  let fetchLoadMatches = new Map();\n  // Ref-count mounted fetchers so we know when it's ok to clean them up\n  let activeFetchers = new Map();\n  // Fetchers that have requested a delete when using v7_fetcherPersist,\n  // they'll be officially removed after they return to idle\n  let deletedFetchers = new Set();\n  // Store DeferredData instances for active route matches.  When a\n  // route loader returns defer() we stick one in here.  Then, when a nested\n  // promise resolves we update loaderData.  If a new navigation starts we\n  // cancel active deferreds for eliminated routes.\n  let activeDeferreds = new Map();\n  // Store blocker functions in a separate Map outside of router state since\n  // we don't need to update UI state if they change\n  let blockerFunctions = new Map();\n  // Map of pending patchRoutesOnMiss() promises (keyed by path/matches) so\n  // that we only kick them off once for a given combo\n  let pendingPatchRoutes = new Map();\n  // Flag to ignore the next history update, so we can revert the URL change on\n  // a POP navigation that was blocked by the user without touching router state\n  let ignoreNextHistoryUpdate = false;\n  // Initialize the router, all side effects should be kicked off from here.\n  // Implemented as a Fluent API for ease of:\n  //   let router = createRouter(init).initialize();\n  function initialize() {\n    // If history informs us of a POP navigation, start the navigation but do not update\n    // state.  We'll update our own state once the navigation completes\n    unlistenHistory = init.history.listen(_ref => {\n      let {\n        action: historyAction,\n        location,\n        delta\n      } = _ref;\n      // Ignore this event if it was just us resetting the URL from a\n      // blocked POP navigation\n      if (ignoreNextHistoryUpdate) {\n        ignoreNextHistoryUpdate = false;\n        return;\n      }\n      warning(blockerFunctions.size === 0 || delta != null, \"You are trying to use a blocker on a POP navigation to a location \" + \"that was not created by @remix-run/router. This will fail silently in \" + \"production. This can happen if you are navigating outside the router \" + \"via `window.history.pushState`/`window.location.hash` instead of using \" + \"router navigation APIs.  This can also happen if you are using \" + \"createHashRouter and the user manually changes the URL.\");\n      let blockerKey = shouldBlockNavigation({\n        currentLocation: state.location,\n        nextLocation: location,\n        historyAction\n      });\n      if (blockerKey && delta != null) {\n        // Restore the URL to match the current UI, but don't update router state\n        ignoreNextHistoryUpdate = true;\n        init.history.go(delta * -1);\n        // Put the blocker into a blocked state\n        updateBlocker(blockerKey, {\n          state: \"blocked\",\n          location,\n          proceed() {\n            updateBlocker(blockerKey, {\n              state: \"proceeding\",\n              proceed: undefined,\n              reset: undefined,\n              location\n            });\n            // Re-do the same POP navigation we just blocked\n            init.history.go(delta);\n          },\n          reset() {\n            let blockers = new Map(state.blockers);\n            blockers.set(blockerKey, IDLE_BLOCKER);\n            updateState({\n              blockers\n            });\n          }\n        });\n        return;\n      }\n      return startNavigation(historyAction, location);\n    });\n    if (isBrowser) {\n      // FIXME: This feels gross.  How can we cleanup the lines between\n      // scrollRestoration/appliedTransitions persistance?\n      restoreAppliedTransitions(routerWindow, appliedViewTransitions);\n      let _saveAppliedTransitions = () => persistAppliedTransitions(routerWindow, appliedViewTransitions);\n      routerWindow.addEventListener(\"pagehide\", _saveAppliedTransitions);\n      removePageHideEventListener = () => routerWindow.removeEventListener(\"pagehide\", _saveAppliedTransitions);\n    }\n    // Kick off initial data load if needed.  Use Pop to avoid modifying history\n    // Note we don't do any handling of lazy here.  For SPA's it'll get handled\n    // in the normal navigation flow.  For SSR it's expected that lazy modules are\n    // resolved prior to router creation since we can't go into a fallbackElement\n    // UI for SSR'd apps\n    if (!state.initialized) {\n      startNavigation(Action.Pop, state.location, {\n        initialHydration: true\n      });\n    }\n    return router;\n  }\n  // Clean up a router and it's side effects\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\n    }\n    if (removePageHideEventListener) {\n      removePageHideEventListener();\n    }\n    subscribers.clear();\n    pendingNavigationController && pendingNavigationController.abort();\n    state.fetchers.forEach((_, key) => deleteFetcher(key));\n    state.blockers.forEach((_, key) => deleteBlocker(key));\n  }\n  // Subscribe to state updates for the router\n  function subscribe(fn) {\n    subscribers.add(fn);\n    return () => subscribers.delete(fn);\n  }\n  // Update our state and notify the calling context of the change\n  function updateState(newState, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    state = _extends({}, state, newState);\n    // Prep fetcher cleanup so we can tell the UI which fetcher data entries\n    // can be removed\n    let completedFetchers = [];\n    let deletedFetchersKeys = [];\n    if (future.v7_fetcherPersist) {\n      state.fetchers.forEach((fetcher, key) => {\n        if (fetcher.state === \"idle\") {\n          if (deletedFetchers.has(key)) {\n            // Unmounted from the UI and can be totally removed\n            deletedFetchersKeys.push(key);\n          } else {\n            // Returned to idle but still mounted in the UI, so semi-remains for\n            // revalidations and such\n            completedFetchers.push(key);\n          }\n        }\n      });\n    }\n    // Iterate over a local copy so that if flushSync is used and we end up\n    // removing and adding a new subscriber due to the useCallback dependencies,\n    // we don't get ourselves into a loop calling the new subscriber immediately\n    [...subscribers].forEach(subscriber => subscriber(state, {\n      deletedFetchers: deletedFetchersKeys,\n      unstable_viewTransitionOpts: opts.viewTransitionOpts,\n      unstable_flushSync: opts.flushSync === true\n    }));\n    // Remove idle fetchers from state since we only care about in-flight fetchers.\n    if (future.v7_fetcherPersist) {\n      completedFetchers.forEach(key => state.fetchers.delete(key));\n      deletedFetchersKeys.forEach(key => deleteFetcher(key));\n    }\n  }\n  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION\n  // and setting state.[historyAction/location/matches] to the new route.\n  // - Location is a required param\n  // - Navigation will always be set to IDLE_NAVIGATION\n  // - Can pass any other state in newState\n  function completeNavigation(location, newState, _temp) {\n    var _location$state, _location$state2;\n    let {\n      flushSync\n    } = _temp === void 0 ? {} : _temp;\n    // Deduce if we're in a loading/actionReload state:\n    // - We have committed actionData in the store\n    // - The current navigation was a mutation submission\n    // - We're past the submitting state and into the loading state\n    // - The location being loaded is not the result of a redirect\n    let isActionReload = state.actionData != null && state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && state.navigation.state === \"loading\" && ((_location$state = location.state) == null ? void 0 : _location$state._isRedirect) !== true;\n    let actionData;\n    if (newState.actionData) {\n      if (Object.keys(newState.actionData).length > 0) {\n        actionData = newState.actionData;\n      } else {\n        // Empty actionData -> clear prior actionData due to an action error\n        actionData = null;\n      }\n    } else if (isActionReload) {\n      // Keep the current data if we're wrapping up the action reload\n      actionData = state.actionData;\n    } else {\n      // Clear actionData on any other completed navigations\n      actionData = null;\n    }\n    // Always preserve any existing loaderData from re-used routes\n    let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;\n    // On a successful navigation we can assume we got through all blockers\n    // so we can start fresh\n    let blockers = state.blockers;\n    if (blockers.size > 0) {\n      blockers = new Map(blockers);\n      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));\n    }\n    // Always respect the user flag.  Otherwise don't reset on mutation\n    // submission navigations unless they redirect\n    let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;\n    // Commit any in-flight routes at the end of the HMR revalidation \"navigation\"\n    if (inFlightDataRoutes) {\n      dataRoutes = inFlightDataRoutes;\n      inFlightDataRoutes = undefined;\n    }\n    if (isUninterruptedRevalidation) ; else if (pendingAction === Action.Pop) ; else if (pendingAction === Action.Push) {\n      init.history.push(location, location.state);\n    } else if (pendingAction === Action.Replace) {\n      init.history.replace(location, location.state);\n    }\n    let viewTransitionOpts;\n    // On POP, enable transitions if they were enabled on the original navigation\n    if (pendingAction === Action.Pop) {\n      // Forward takes precedence so they behave like the original navigation\n      let priorPaths = appliedViewTransitions.get(state.location.pathname);\n      if (priorPaths && priorPaths.has(location.pathname)) {\n        viewTransitionOpts = {\n          currentLocation: state.location,\n          nextLocation: location\n        };\n      } else if (appliedViewTransitions.has(location.pathname)) {\n        // If we don't have a previous forward nav, assume we're popping back to\n        // the new location and enable if that location previously enabled\n        viewTransitionOpts = {\n          currentLocation: location,\n          nextLocation: state.location\n        };\n      }\n    } else if (pendingViewTransitionEnabled) {\n      // Store the applied transition on PUSH/REPLACE\n      let toPaths = appliedViewTransitions.get(state.location.pathname);\n      if (toPaths) {\n        toPaths.add(location.pathname);\n      } else {\n        toPaths = new Set([location.pathname]);\n        appliedViewTransitions.set(state.location.pathname, toPaths);\n      }\n      viewTransitionOpts = {\n        currentLocation: state.location,\n        nextLocation: location\n      };\n    }\n    updateState(_extends({}, newState, {\n      actionData,\n      loaderData,\n      historyAction: pendingAction,\n      location,\n      initialized: true,\n      navigation: IDLE_NAVIGATION,\n      revalidation: \"idle\",\n      restoreScrollPosition: getSavedScrollPosition(location, newState.matches || state.matches),\n      preventScrollReset,\n      blockers\n    }), {\n      viewTransitionOpts,\n      flushSync: flushSync === true\n    });\n    // Reset stateful navigation vars\n    pendingAction = Action.Pop;\n    pendingPreventScrollReset = false;\n    pendingViewTransitionEnabled = false;\n    isUninterruptedRevalidation = false;\n    isRevalidationRequired = false;\n    cancelledDeferredRoutes = [];\n  }\n  // Trigger a navigation event, which can either be a numerical POP or a PUSH\n  // replace with an optional submission\n  async function navigate(to, opts) {\n    if (typeof to === \"number\") {\n      init.history.go(to);\n      return;\n    }\n    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, to, future.v7_relativeSplatPath, opts == null ? void 0 : opts.fromRouteId, opts == null ? void 0 : opts.relative);\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, false, normalizedPath, opts);\n    let currentLocation = state.location;\n    let nextLocation = createLocation(state.location, path, opts && opts.state);\n    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded\n    // URL from window.location, so we need to encode it here so the behavior\n    // remains the same as POP and non-data-router usages.  new URL() does all\n    // the same encoding we'd get from a history.pushState/window.location read\n    // without having to touch history\n    nextLocation = _extends({}, nextLocation, init.history.encodeLocation(nextLocation));\n    let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n    let historyAction = Action.Push;\n    if (userReplace === true) {\n      historyAction = Action.Replace;\n    } else if (userReplace === false) ; else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) {\n      // By default on submissions to the current location we REPLACE so that\n      // users don't have to double-click the back button to get to the prior\n      // location.  If the user redirects to a different location from the\n      // action/loader this will be ignored and the redirect will be a PUSH\n      historyAction = Action.Replace;\n    }\n    let preventScrollReset = opts && \"preventScrollReset\" in opts ? opts.preventScrollReset === true : undefined;\n    let flushSync = (opts && opts.unstable_flushSync) === true;\n    let blockerKey = shouldBlockNavigation({\n      currentLocation,\n      nextLocation,\n      historyAction\n    });\n    if (blockerKey) {\n      // Put the blocker into a blocked state\n      updateBlocker(blockerKey, {\n        state: \"blocked\",\n        location: nextLocation,\n        proceed() {\n          updateBlocker(blockerKey, {\n            state: \"proceeding\",\n            proceed: undefined,\n            reset: undefined,\n            location: nextLocation\n          });\n          // Send the same navigation through\n          navigate(to, opts);\n        },\n        reset() {\n          let blockers = new Map(state.blockers);\n          blockers.set(blockerKey, IDLE_BLOCKER);\n          updateState({\n            blockers\n          });\n        }\n      });\n      return;\n    }\n    return await startNavigation(historyAction, nextLocation, {\n      submission,\n      // Send through the formData serialization error if we have one so we can\n      // render at the right error boundary after we match routes\n      pendingError: error,\n      preventScrollReset,\n      replace: opts && opts.replace,\n      enableViewTransition: opts && opts.unstable_viewTransition,\n      flushSync\n    });\n  }\n  // Revalidate all current loaders.  If a navigation is in progress or if this\n  // is interrupted by a navigation, allow this to \"succeed\" by calling all\n  // loaders during the next loader round\n  function revalidate() {\n    interruptActiveLoads();\n    updateState({\n      revalidation: \"loading\"\n    });\n    // If we're currently submitting an action, we don't need to start a new\n    // navigation, we'll just let the follow up loader execution call all loaders\n    if (state.navigation.state === \"submitting\") {\n      return;\n    }\n    // If we're currently in an idle state, start a new navigation for the current\n    // action/location and mark it as uninterrupted, which will skip the history\n    // update in completeNavigation\n    if (state.navigation.state === \"idle\") {\n      startNavigation(state.historyAction, state.location, {\n        startUninterruptedRevalidation: true\n      });\n      return;\n    }\n    // Otherwise, if we're currently in a loading state, just start a new\n    // navigation to the navigation.location but do not trigger an uninterrupted\n    // revalidation so that history correctly updates once the navigation completes\n    startNavigation(pendingAction || state.historyAction, state.navigation.location, {\n      overrideNavigation: state.navigation\n    });\n  }\n  // Start a navigation to the given action/location.  Can optionally provide a\n  // overrideNavigation which will override the normalLoad in the case of a redirect\n  // navigation\n  async function startNavigation(historyAction, location, opts) {\n    // Abort any in-progress navigations and start a new one. Unset any ongoing\n    // uninterrupted revalidations unless told otherwise, since we want this\n    // new navigation to update history normally\n    pendingNavigationController && pendingNavigationController.abort();\n    pendingNavigationController = null;\n    pendingAction = historyAction;\n    isUninterruptedRevalidation = (opts && opts.startUninterruptedRevalidation) === true;\n    // Save the current scroll position every time we start a new navigation,\n    // and track whether we should reset scroll on completion\n    saveScrollPosition(state.location, state.matches);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches = matchRoutes(routesToUse, location, basename);\n    let flushSync = (opts && opts.flushSync) === true;\n    let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n    // Short circuit with a 404 on the root error boundary if we match nothing\n    if (!matches) {\n      let {\n        error,\n        notFoundMatches,\n        route\n      } = handleNavigational404(location.pathname);\n      completeNavigation(location, {\n        matches: notFoundMatches,\n        loaderData: {},\n        errors: {\n          [route.id]: error\n        }\n      }, {\n        flushSync\n      });\n      return;\n    }\n    // Short circuit if it's only a hash change and not a revalidation or\n    // mutation submission.\n    //\n    // Ignore on initial page loads because since the initial load will always\n    // be \"same hash\".  For example, on /page#hash and submit a <Form method=\"post\">\n    // which will default to a navigation to /page\n    if (state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {\n      completeNavigation(location, {\n        matches\n      }, {\n        flushSync\n      });\n      return;\n    }\n    // Create a controller/Request for this navigation\n    pendingNavigationController = new AbortController();\n    let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);\n    let pendingActionResult;\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 = [findNearestBoundary(matches).route.id, {\n        type: ResultType.error,\n        error: opts.pendingError\n      }];\n    } else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {\n      // Call action if we received an action submission\n      let actionResult = await handleAction(request, location, opts.submission, matches, fogOfWar.active, {\n        replace: opts.replace,\n        flushSync\n      });\n      if (actionResult.shortCircuited) {\n        return;\n      }\n      // If we received a 404 from handleAction, it's because we couldn't lazily\n      // discover the destination route so we don't want to call loaders\n      if (actionResult.pendingActionResult) {\n        let [routeId, result] = actionResult.pendingActionResult;\n        if (isErrorResult(result) && isRouteErrorResponse(result.error) && result.error.status === 404) {\n          pendingNavigationController = null;\n          completeNavigation(location, {\n            matches: actionResult.matches,\n            loaderData: {},\n            errors: {\n              [routeId]: result.error\n            }\n          });\n          return;\n        }\n      }\n      matches = actionResult.matches || matches;\n      pendingActionResult = actionResult.pendingActionResult;\n      loadingNavigation = getLoadingNavigation(location, opts.submission);\n      flushSync = false;\n      // No need to do fog of war matching again on loader execution\n      fogOfWar.active = false;\n      // Create a GET request for the loaders\n      request = createClientSideRequest(init.history, request.url, request.signal);\n    }\n    // Call loaders\n    let {\n      shortCircuited,\n      matches: updatedMatches,\n      loaderData,\n      errors\n    } = await handleLoaders(request, location, matches, fogOfWar.active, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult);\n    if (shortCircuited) {\n      return;\n    }\n    // Clean up now that the action/loaders have completed.  Don't clean up if\n    // we short circuited because pendingNavigationController will have already\n    // been assigned to a new controller for the next navigation\n    pendingNavigationController = null;\n    completeNavigation(location, _extends({\n      matches: updatedMatches || matches\n    }, getActionDataForCommit(pendingActionResult), {\n      loaderData,\n      errors\n    }));\n  }\n  // Call the action matched by the leaf route for this navigation and handle\n  // redirects/errors\n  async function handleAction(request, location, submission, matches, isFogOfWar, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    interruptActiveLoads();\n    // Put us in a submitting state\n    let navigation = getSubmittingNavigation(location, submission);\n    updateState({\n      navigation\n    }, {\n      flushSync: opts.flushSync === true\n    });\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);\n      if (discoverResult.type === \"aborted\") {\n        return {\n          shortCircuited: true\n        };\n      } else if (discoverResult.type === \"error\") {\n        let {\n          boundaryId,\n          error\n        } = handleDiscoverRouteError(location.pathname, discoverResult);\n        return {\n          matches: discoverResult.partialMatches,\n          pendingActionResult: [boundaryId, {\n            type: ResultType.error,\n            error\n          }]\n        };\n      } else if (!discoverResult.matches) {\n        let {\n          notFoundMatches,\n          error,\n          route\n        } = handleNavigational404(location.pathname);\n        return {\n          matches: notFoundMatches,\n          pendingActionResult: [route.id, {\n            type: ResultType.error,\n            error\n          }]\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n    // Call our action and get the result\n    let result;\n    let actionMatch = getTargetMatch(matches, location);\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      result = {\n        type: ResultType.error,\n        error: getInternalRouterError(405, {\n          method: request.method,\n          pathname: location.pathname,\n          routeId: actionMatch.route.id\n        })\n      };\n    } else {\n      let results = await callDataStrategy(\"action\", request, [actionMatch], matches);\n      result = results[0];\n      if (request.signal.aborted) {\n        return {\n          shortCircuited: true\n        };\n      }\n    }\n    if (isRedirectResult(result)) {\n      let replace;\n      if (opts && opts.replace != null) {\n        replace = opts.replace;\n      } else {\n        // If the user didn't explicity indicate replace behavior, replace if\n        // we redirected to the exact same location we're currently at to avoid\n        // double back-buttons\n        let location = normalizeRedirectLocation(result.response.headers.get(\"Location\"), new URL(request.url), basename);\n        replace = location === state.location.pathname + state.location.search;\n      }\n      await startRedirectNavigation(request, result, {\n        submission,\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    if (isDeferredResult(result)) {\n      throw getInternalRouterError(400, {\n        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      // By default, all submissions to the current location are REPLACE\n      // navigations, but if the action threw an error that'll be rendered in\n      // an errorElement, we fall back to PUSH so that the user can use the\n      // back button to get back to the pre-submission form location to try\n      // again\n      if ((opts && opts.replace) !== true) {\n        pendingAction = Action.Push;\n      }\n      return {\n        matches,\n        pendingActionResult: [boundaryMatch.route.id, result]\n      };\n    }\n    return {\n      matches,\n      pendingActionResult: [actionMatch.route.id, result]\n    };\n  }\n  // Call all applicable loaders for the given matches, handling redirects,\n  // errors, etc.\n  async function handleLoaders(request, location, matches, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult) {\n    // Figure out the right navigation we want to use for data loading\n    let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);\n    // If this was a redirect from an action we don't have a \"submission\" but\n    // we have it on the loading navigation so use that if available\n    let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);\n    // 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    let shouldUpdateNavigationState = !isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration);\n    // When fog of war is enabled, we enter our `loading` state earlier so we\n    // can discover new routes during the `loading` state.  We skip this if\n    // we've already run actions since we would have done our matching already.\n    // If the children() function threw then, we want to proceed with the\n    // partial matches it discovered.\n    if (isFogOfWar) {\n      if (shouldUpdateNavigationState) {\n        let actionData = getUpdatedActionData(pendingActionResult);\n        updateState(_extends({\n          navigation: loadingNavigation\n        }, actionData !== undefined ? {\n          actionData\n        } : {}), {\n          flushSync\n        });\n      }\n      let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);\n      if (discoverResult.type === \"aborted\") {\n        return {\n          shortCircuited: true\n        };\n      } else if (discoverResult.type === \"error\") {\n        let {\n          boundaryId,\n          error\n        } = handleDiscoverRouteError(location.pathname, discoverResult);\n        return {\n          matches: discoverResult.partialMatches,\n          loaderData: {},\n          errors: {\n            [boundaryId]: error\n          }\n        };\n      } else if (!discoverResult.matches) {\n        let {\n          error,\n          notFoundMatches,\n          route\n        } = handleNavigational404(location.pathname);\n        return {\n          matches: notFoundMatches,\n          loaderData: {},\n          errors: {\n            [route.id]: error\n          }\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult);\n    // Cancel pending deferreds for no-longer-matched routes or routes we're\n    // about to reload.  Note that if this is an action reload we would have\n    // already cancelled all pending deferreds so this would be a no-op\n    cancelActiveDeferreds(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId));\n    pendingNavigationLoadId = ++incrementingLoadId;\n    // Short circuit if we have no loaders to run\n    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n      let updatedFetchers = markFetchRedirectsDone();\n      completeNavigation(location, _extends({\n        matches,\n        loaderData: {},\n        // Commit pending error if we're short circuiting\n        errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {\n          [pendingActionResult[0]]: pendingActionResult[1].error\n        } : null\n      }, getActionDataForCommit(pendingActionResult), updatedFetchers ? {\n        fetchers: new Map(state.fetchers)\n      } : {}), {\n        flushSync\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    if (shouldUpdateNavigationState) {\n      let updates = {};\n      if (!isFogOfWar) {\n        // Only update navigation/actionNData if we didn't already do it above\n        updates.navigation = loadingNavigation;\n        let actionData = getUpdatedActionData(pendingActionResult);\n        if (actionData !== undefined) {\n          updates.actionData = actionData;\n        }\n      }\n      if (revalidatingFetchers.length > 0) {\n        updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);\n      }\n      updateState(updates, {\n        flushSync\n      });\n    }\n    revalidatingFetchers.forEach(rf => {\n      if (fetchControllers.has(rf.key)) {\n        abortFetcher(rf.key);\n      }\n      if (rf.controller) {\n        // Fetchers use an independent AbortController so that aborting a fetcher\n        // (via deleteFetcher) does not abort the triggering navigation that\n        // triggered the revalidation\n        fetchControllers.set(rf.key, rf.controller);\n      }\n    });\n    // Proxy navigation abort through to revalidation fetchers\n    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(f => abortFetcher(f.key));\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.addEventListener(\"abort\", abortPendingFetchRevalidations);\n    }\n    let {\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, request);\n    if (request.signal.aborted) {\n      return {\n        shortCircuited: true\n      };\n    }\n    // Clean up _after_ loaders have completed.  Don't clean up if we short\n    // circuited because fetchControllers would have been aborted and\n    // reassigned to new controllers for the next navigation\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.removeEventListener(\"abort\", abortPendingFetchRevalidations);\n    }\n    revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key));\n    // If any loaders returned a redirect Response, start a new REPLACE navigation\n    let redirect = findRedirect([...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 = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n        fetchRedirectIds.add(fetcherKey);\n      }\n      await startRedirectNavigation(request, redirect.result, {\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    // Process and commit output from loaders\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, matches, matchesToLoad, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds);\n    // Wire up subscribers to update loaderData as promises settle\n    activeDeferreds.forEach((deferredData, routeId) => {\n      deferredData.subscribe(aborted => {\n        // Note: No need to updateState here since the TrackedPromise on\n        // loaderData is stable across resolve/reject\n        // Remove this instance if we were aborted or if promises have settled\n        if (aborted || deferredData.done) {\n          activeDeferreds.delete(routeId);\n        }\n      });\n    });\n    // During partial hydration, preserve SSR errors for routes that don't re-run\n    if (future.v7_partialHydration && initialHydration && state.errors) {\n      Object.entries(state.errors).filter(_ref2 => {\n        let [id] = _ref2;\n        return !matchesToLoad.some(m => m.route.id === id);\n      }).forEach(_ref3 => {\n        let [routeId, error] = _ref3;\n        errors = Object.assign(errors || {}, {\n          [routeId]: error\n        });\n      });\n    }\n    let updatedFetchers = markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n    return _extends({\n      matches,\n      loaderData,\n      errors\n    }, shouldUpdateFetchers ? {\n      fetchers: new Map(state.fetchers)\n    } : {});\n  }\n  function getUpdatedActionData(pendingActionResult) {\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      return {\n        [pendingActionResult[0]]: pendingActionResult[1].data\n      };\n    } else if (state.actionData) {\n      if (Object.keys(state.actionData).length === 0) {\n        return null;\n      } else {\n        return state.actionData;\n      }\n    }\n  }\n  function getUpdatedRevalidatingFetchers(revalidatingFetchers) {\n    revalidatingFetchers.forEach(rf => {\n      let fetcher = state.fetchers.get(rf.key);\n      let revalidatingFetcher = getLoadingFetcher(undefined, fetcher ? fetcher.data : undefined);\n      state.fetchers.set(rf.key, revalidatingFetcher);\n    });\n    return new Map(state.fetchers);\n  }\n  // Trigger a fetcher load/submit for the given fetcher key\n  function fetch(key, routeId, href, opts) {\n    if (isServer) {\n      throw new Error(\"router.fetch() was called during the server render, but it shouldn't be. \" + \"You are likely calling a useFetcher() method in the body of your component. \" + \"Try moving it to a useEffect or a callback.\");\n    }\n    if (fetchControllers.has(key)) abortFetcher(key);\n    let flushSync = (opts && opts.unstable_flushSync) === true;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, future.v7_relativeSplatPath, routeId, opts == null ? void 0 : opts.relative);\n    let matches = matchRoutes(routesToUse, normalizedPath, basename);\n    let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n    if (!matches) {\n      setFetcherError(key, routeId, getInternalRouterError(404, {\n        pathname: normalizedPath\n      }), {\n        flushSync\n      });\n      return;\n    }\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, true, normalizedPath, opts);\n    if (error) {\n      setFetcherError(key, routeId, error, {\n        flushSync\n      });\n      return;\n    }\n    let match = getTargetMatch(matches, path);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n    if (submission && isMutationMethod(submission.formMethod)) {\n      handleFetcherAction(key, routeId, path, match, matches, fogOfWar.active, flushSync, submission);\n      return;\n    }\n    // Store off the match so we can call it's shouldRevalidate on subsequent\n    // revalidations\n    fetchLoadMatches.set(key, {\n      routeId,\n      path\n    });\n    handleFetcherLoader(key, routeId, path, match, matches, fogOfWar.active, flushSync, submission);\n  }\n  // Call the action for the matched fetcher.submit(), and then handle redirects,\n  // errors, and revalidation\n  async function handleFetcherAction(key, routeId, path, match, requestMatches, isFogOfWar, flushSync, submission) {\n    interruptActiveLoads();\n    fetchLoadMatches.delete(key);\n    function detectAndHandle405Error(m) {\n      if (!m.route.action && !m.route.lazy) {\n        let error = getInternalRouterError(405, {\n          method: submission.formMethod,\n          pathname: path,\n          routeId: routeId\n        });\n        setFetcherError(key, routeId, error, {\n          flushSync\n        });\n        return true;\n      }\n      return false;\n    }\n    if (!isFogOfWar && detectAndHandle405Error(match)) {\n      return;\n    }\n    // Put this fetcher into it's submitting state\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {\n      flushSync\n    });\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(requestMatches, path, fetchRequest.signal);\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        let {\n          error\n        } = handleDiscoverRouteError(path, discoverResult);\n        setFetcherError(key, routeId, error, {\n          flushSync\n        });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(key, routeId, getInternalRouterError(404, {\n          pathname: path\n        }), {\n          flushSync\n        });\n        return;\n      } else {\n        requestMatches = discoverResult.matches;\n        match = getTargetMatch(requestMatches, path);\n        if (detectAndHandle405Error(match)) {\n          return;\n        }\n      }\n    }\n    // Call the action for the fetcher\n    fetchControllers.set(key, abortController);\n    let originatingLoadId = incrementingLoadId;\n    let actionResults = await callDataStrategy(\"action\", fetchRequest, [match], requestMatches);\n    let actionResult = actionResults[0];\n    if (fetchRequest.signal.aborted) {\n      // We can delete this so long as we weren't aborted by our own fetcher\n      // re-submit which would have put _new_ controller is in fetchControllers\n      if (fetchControllers.get(key) === abortController) {\n        fetchControllers.delete(key);\n      }\n      return;\n    }\n    // When using v7_fetcherPersist, we don't want errors bubbling up to the UI\n    // or redirects processed for unmounted fetchers so we just revert them to\n    // idle\n    if (future.v7_fetcherPersist && deletedFetchers.has(key)) {\n      if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      }\n      // Let SuccessResult's fall through for revalidation\n    } else {\n      if (isRedirectResult(actionResult)) {\n        fetchControllers.delete(key);\n        if (pendingNavigationLoadId > originatingLoadId) {\n          // A new navigation was kicked off after our action started, so that\n          // should take precedence over this redirect navigation.  We already\n          // set isRevalidationRequired so all loaders for the new route should\n          // fire unless opted out via shouldRevalidate\n          updateFetcherState(key, getDoneFetcher(undefined));\n          return;\n        } else {\n          fetchRedirectIds.add(key);\n          updateFetcherState(key, getLoadingFetcher(submission));\n          return startRedirectNavigation(fetchRequest, actionResult, {\n            fetcherSubmission: submission\n          });\n        }\n      }\n      // Process any non-redirect errors thrown\n      if (isErrorResult(actionResult)) {\n        setFetcherError(key, routeId, actionResult.error);\n        return;\n      }\n    }\n    if (isDeferredResult(actionResult)) {\n      throw getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n    }\n    // Start the data load for current matches, or the next location if we're\n    // in the middle of a navigation\n    let nextLocation = state.navigation.location || state.location;\n    let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let matches = state.navigation.state !== \"idle\" ? matchRoutes(routesToUse, state.navigation.location, basename) : state.matches;\n    invariant(matches, \"Didn't find any matches after fetcher action\");\n    let loadId = ++incrementingLoadId;\n    fetchReloadIds.set(key, loadId);\n    let loadFetcher = getLoadingFetcher(submission, actionResult.data);\n    state.fetchers.set(key, loadFetcher);\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, false, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, [match.route.id, actionResult]);\n    // Put all revalidating fetchers into the loading state, except for the\n    // current fetcher which we want to keep in it's current loading state which\n    // contains it's action submission info + action data\n    revalidatingFetchers.filter(rf => rf.key !== key).forEach(rf => {\n      let staleKey = rf.key;\n      let existingFetcher = state.fetchers.get(staleKey);\n      let revalidatingFetcher = getLoadingFetcher(undefined, existingFetcher ? existingFetcher.data : undefined);\n      state.fetchers.set(staleKey, revalidatingFetcher);\n      if (fetchControllers.has(staleKey)) {\n        abortFetcher(staleKey);\n      }\n      if (rf.controller) {\n        fetchControllers.set(staleKey, rf.controller);\n      }\n    });\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(rf => abortFetcher(rf.key));\n    abortController.signal.addEventListener(\"abort\", abortPendingFetchRevalidations);\n    let {\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);\n    if (abortController.signal.aborted) {\n      return;\n    }\n    abortController.signal.removeEventListener(\"abort\", abortPendingFetchRevalidations);\n    fetchReloadIds.delete(key);\n    fetchControllers.delete(key);\n    revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));\n    let redirect = findRedirect([...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 = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n        fetchRedirectIds.add(fetcherKey);\n      }\n      return startRedirectNavigation(revalidationRequest, redirect.result);\n    }\n    // Process and commit output from loaders\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, state.matches, matchesToLoad, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);\n    // Since we let revalidations complete even if the submitting fetcher was\n    // deleted, only put it back to idle if it hasn't been deleted\n    if (state.fetchers.has(key)) {\n      let doneFetcher = getDoneFetcher(actionResult.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n    abortStaleFetchLoads(loadId);\n    // If we are currently in a navigation loading state and this fetcher is\n    // more recent than the navigation, we want the newer data so abort the\n    // navigation and complete it with the fetcher data\n    if (state.navigation.state === \"loading\" && loadId > pendingNavigationLoadId) {\n      invariant(pendingAction, \"Expected pending action\");\n      pendingNavigationController && pendingNavigationController.abort();\n      completeNavigation(state.navigation.location, {\n        matches,\n        loaderData,\n        errors,\n        fetchers: new Map(state.fetchers)\n      });\n    } else {\n      // otherwise just update with the fetcher data, preserving any existing\n      // loaderData for loaders that did not need to reload.  We have to\n      // manually merge here since we aren't going through completeNavigation\n      updateState({\n        errors,\n        loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors),\n        fetchers: new Map(state.fetchers)\n      });\n      isRevalidationRequired = false;\n    }\n  }\n  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n  async function handleFetcherLoader(key, routeId, path, match, matches, isFogOfWar, flushSync, submission) {\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : undefined), {\n      flushSync\n    });\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(matches, path, fetchRequest.signal);\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        let {\n          error\n        } = handleDiscoverRouteError(path, discoverResult);\n        setFetcherError(key, routeId, error, {\n          flushSync\n        });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(key, routeId, getInternalRouterError(404, {\n          pathname: path\n        }), {\n          flushSync\n        });\n        return;\n      } else {\n        matches = discoverResult.matches;\n        match = getTargetMatch(matches, path);\n      }\n    }\n    // Call the loader for this fetcher route match\n    fetchControllers.set(key, abortController);\n    let originatingLoadId = incrementingLoadId;\n    let results = await callDataStrategy(\"loader\", fetchRequest, [match], matches);\n    let result = results[0];\n    // Deferred isn't supported for fetcher loads, await everything and treat it\n    // as a normal load.  resolveDeferredData will return undefined if this\n    // fetcher gets aborted, so we just leave result untouched and short circuit\n    // below if that happens\n    if (isDeferredResult(result)) {\n      result = (await resolveDeferredData(result, fetchRequest.signal, true)) || result;\n    }\n    // We can delete this so long as we weren't aborted by our our own fetcher\n    // re-load which would have put _new_ controller is in fetchControllers\n    if (fetchControllers.get(key) === abortController) {\n      fetchControllers.delete(key);\n    }\n    if (fetchRequest.signal.aborted) {\n      return;\n    }\n    // We don't want errors bubbling up or redirects followed for unmounted\n    // fetchers, so short circuit here if it was removed from the UI\n    if (deletedFetchers.has(key)) {\n      updateFetcherState(key, getDoneFetcher(undefined));\n      return;\n    }\n    // If the loader threw a redirect Response, start a new REPLACE navigation\n    if (isRedirectResult(result)) {\n      if (pendingNavigationLoadId > originatingLoadId) {\n        // A new navigation was kicked off after our loader started, so that\n        // should take precedence over this redirect navigation\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      } else {\n        fetchRedirectIds.add(key);\n        await startRedirectNavigation(fetchRequest, result);\n        return;\n      }\n    }\n    // Process any non-redirect errors thrown\n    if (isErrorResult(result)) {\n      setFetcherError(key, routeId, result.error);\n      return;\n    }\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n    // Put the fetcher back into an idle state\n    updateFetcherState(key, getDoneFetcher(result.data));\n  }\n  /**\n   * Utility function to handle redirects returned from an action or loader.\n   * Normally, a redirect \"replaces\" the navigation that triggered it.  So, for\n   * example:\n   *\n   *  - user is on /a\n   *  - user clicks a link to /b\n   *  - loader for /b redirects to /c\n   *\n   * In a non-JS app the browser would track the in-flight navigation to /b and\n   * then replace it with /c when it encountered the redirect response.  In\n   * the end it would only ever update the URL bar with /c.\n   *\n   * In client-side routing using pushState/replaceState, we aim to emulate\n   * this behavior and we also do not update history until the end of the\n   * navigation (including processed redirects).  This means that we never\n   * actually touch history until we've processed redirects, so we just use\n   * the history action from the original navigation (PUSH or REPLACE).\n   */\n  async function startRedirectNavigation(request, redirect, _temp2) {\n    let {\n      submission,\n      fetcherSubmission,\n      replace\n    } = _temp2 === void 0 ? {} : _temp2;\n    if (redirect.response.headers.has(\"X-Remix-Revalidate\")) {\n      isRevalidationRequired = true;\n    }\n    let location = redirect.response.headers.get(\"Location\");\n    invariant(location, \"Expected a Location header on the redirect Response\");\n    location = normalizeRedirectLocation(location, new URL(request.url), basename);\n    let redirectLocation = createLocation(state.location, location, {\n      _isRedirect: true\n    });\n    if (isBrowser) {\n      let isDocumentReload = false;\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      if (isDocumentReload) {\n        if (replace) {\n          routerWindow.location.replace(location);\n        } else {\n          routerWindow.location.assign(location);\n        }\n        return;\n      }\n    }\n    // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n    pendingNavigationController = null;\n    let redirectHistoryAction = replace === true || redirect.response.headers.has(\"X-Remix-Replace\") ? Action.Replace : Action.Push;\n    // Use the incoming submission if provided, fallback on the active one in\n    // state.navigation\n    let {\n      formMethod,\n      formAction,\n      formEncType\n    } = state.navigation;\n    if (!submission && !fetcherSubmission && formMethod && formAction && formEncType) {\n      submission = getSubmissionFromNavigation(state.navigation);\n    }\n    // If this was a 307/308 submission we want to preserve the HTTP method and\n    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the\n    // redirected location\n    let activeSubmission = submission || fetcherSubmission;\n    if (redirectPreserveMethodStatusCodes.has(redirect.response.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        submission: _extends({}, 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(redirectLocation, submission);\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        overrideNavigation,\n        // Send fetcher submissions through for shouldRevalidate\n        fetcherSubmission,\n        // Preserve this flag across redirects\n        preventScrollReset: pendingPreventScrollReset\n      });\n    }\n  }\n  // Utility wrapper for calling dataStrategy client-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(type, request, matchesToLoad, matches) {\n    try {\n      let results = await callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, manifest, mapRouteProperties);\n      return await Promise.all(results.map((result, i) => {\n        if (isRedirectHandlerResult(result)) {\n          let response = result.result;\n          return {\n            type: ResultType.redirect,\n            response: normalizeRelativeRoutingRedirectResponse(response, request, matchesToLoad[i].route.id, matches, basename, future.v7_relativeSplatPath)\n          };\n        }\n        return convertHandlerResultToDataResult(result);\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  async function callLoadersAndMaybeResolveData(currentMatches, matches, matchesToLoad, fetchersToLoad, request) {\n    let [loaderResults, ...fetcherResults] = await Promise.all([matchesToLoad.length ? callDataStrategy(\"loader\", request, matchesToLoad, matches) : [], ...fetchersToLoad.map(f => {\n      if (f.matches && f.match && f.controller) {\n        let fetcherRequest = createClientSideRequest(init.history, f.path, f.controller.signal);\n        return callDataStrategy(\"loader\", fetcherRequest, [f.match], f.matches).then(r => r[0]);\n      } else {\n        return Promise.resolve({\n          type: ResultType.error,\n          error: getInternalRouterError(404, {\n            pathname: f.path\n          })\n        });\n      }\n    })]);\n    await Promise.all([resolveDeferredResults(currentMatches, matchesToLoad, loaderResults, loaderResults.map(() => request.signal), false, state.loaderData), resolveDeferredResults(currentMatches, fetchersToLoad.map(f => f.match), fetcherResults, fetchersToLoad.map(f => f.controller ? f.controller.signal : null), true)]);\n    return {\n      loaderResults,\n      fetcherResults\n    };\n  }\n  function interruptActiveLoads() {\n    // Every interruption triggers a revalidation\n    isRevalidationRequired = true;\n    // Cancel pending route-level deferreds and mark cancelled routes for\n    // revalidation\n    cancelledDeferredRoutes.push(...cancelActiveDeferreds());\n    // Abort in-flight fetcher loads\n    fetchLoadMatches.forEach((_, key) => {\n      if (fetchControllers.has(key)) {\n        cancelledFetcherLoads.add(key);\n        abortFetcher(key);\n      }\n    });\n  }\n  function updateFetcherState(key, fetcher, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    state.fetchers.set(key, fetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    }, {\n      flushSync: (opts && opts.flushSync) === true\n    });\n  }\n  function setFetcherError(key, routeId, error, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    let boundaryMatch = findNearestBoundary(state.matches, routeId);\n    deleteFetcher(key);\n    updateState({\n      errors: {\n        [boundaryMatch.route.id]: error\n      },\n      fetchers: new Map(state.fetchers)\n    }, {\n      flushSync: (opts && opts.flushSync) === true\n    });\n  }\n  function getFetcher(key) {\n    if (future.v7_fetcherPersist) {\n      activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);\n      // If this fetcher was previously marked for deletion, unmark it since we\n      // have a new instance\n      if (deletedFetchers.has(key)) {\n        deletedFetchers.delete(key);\n      }\n    }\n    return state.fetchers.get(key) || IDLE_FETCHER;\n  }\n  function deleteFetcher(key) {\n    let fetcher = state.fetchers.get(key);\n    // Don't abort the controller if this is a deletion of a fetcher.submit()\n    // in it's loading phase since - we don't want to abort the corresponding\n    // revalidation and want them to complete and land\n    if (fetchControllers.has(key) && !(fetcher && fetcher.state === \"loading\" && fetchReloadIds.has(key))) {\n      abortFetcher(key);\n    }\n    fetchLoadMatches.delete(key);\n    fetchReloadIds.delete(key);\n    fetchRedirectIds.delete(key);\n    deletedFetchers.delete(key);\n    cancelledFetcherLoads.delete(key);\n    state.fetchers.delete(key);\n  }\n  function deleteFetcherAndUpdateState(key) {\n    if (future.v7_fetcherPersist) {\n      let count = (activeFetchers.get(key) || 0) - 1;\n      if (count <= 0) {\n        activeFetchers.delete(key);\n        deletedFetchers.add(key);\n      } else {\n        activeFetchers.set(key, count);\n      }\n    } else {\n      deleteFetcher(key);\n    }\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n  }\n  function abortFetcher(key) {\n    let controller = fetchControllers.get(key);\n    invariant(controller, \"Expected fetch controller: \" + key);\n    controller.abort();\n    fetchControllers.delete(key);\n  }\n  function markFetchersDone(keys) {\n    for (let key of keys) {\n      let fetcher = getFetcher(key);\n      let doneFetcher = getDoneFetcher(fetcher.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n  function markFetchRedirectsDone() {\n    let doneKeys = [];\n    let updatedFetchers = false;\n    for (let key of fetchRedirectIds) {\n      let fetcher = state.fetchers.get(key);\n      invariant(fetcher, \"Expected fetcher: \" + key);\n      if (fetcher.state === \"loading\") {\n        fetchRedirectIds.delete(key);\n        doneKeys.push(key);\n        updatedFetchers = true;\n      }\n    }\n    markFetchersDone(doneKeys);\n    return updatedFetchers;\n  }\n  function abortStaleFetchLoads(landedId) {\n    let yeetedKeys = [];\n    for (let [key, id] of fetchReloadIds) {\n      if (id < landedId) {\n        let fetcher = state.fetchers.get(key);\n        invariant(fetcher, \"Expected fetcher: \" + key);\n        if (fetcher.state === \"loading\") {\n          abortFetcher(key);\n          fetchReloadIds.delete(key);\n          yeetedKeys.push(key);\n        }\n      }\n    }\n    markFetchersDone(yeetedKeys);\n    return yeetedKeys.length > 0;\n  }\n  function getBlocker(key, fn) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n    if (blockerFunctions.get(key) !== fn) {\n      blockerFunctions.set(key, fn);\n    }\n    return blocker;\n  }\n  function deleteBlocker(key) {\n    state.blockers.delete(key);\n    blockerFunctions.delete(key);\n  }\n  // Utility function to update blockers, ensuring valid state transitions\n  function updateBlocker(key, newBlocker) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n    // Poor mans state machine :)\n    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n    invariant(blocker.state === \"unblocked\" && newBlocker.state === \"blocked\" || blocker.state === \"blocked\" && newBlocker.state === \"blocked\" || blocker.state === \"blocked\" && newBlocker.state === \"proceeding\" || blocker.state === \"blocked\" && newBlocker.state === \"unblocked\" || blocker.state === \"proceeding\" && newBlocker.state === \"unblocked\", \"Invalid blocker state transition: \" + blocker.state + \" -> \" + newBlocker.state);\n    let blockers = new Map(state.blockers);\n    blockers.set(key, newBlocker);\n    updateState({\n      blockers\n    });\n  }\n  function shouldBlockNavigation(_ref4) {\n    let {\n      currentLocation,\n      nextLocation,\n      historyAction\n    } = _ref4;\n    if (blockerFunctions.size === 0) {\n      return;\n    }\n    // We ony support a single active blocker at the moment since we don't have\n    // any compelling use cases for multi-blocker yet\n    if (blockerFunctions.size > 1) {\n      warning(false, \"A router only supports one blocker at a time\");\n    }\n    let entries = Array.from(blockerFunctions.entries());\n    let [blockerKey, blockerFunction] = entries[entries.length - 1];\n    let blocker = state.blockers.get(blockerKey);\n    if (blocker && blocker.state === \"proceeding\") {\n      // If the blocker is currently proceeding, we don't need to re-check\n      // it and can let this navigation continue\n      return;\n    }\n    // At this point, we know we're unblocked/blocked so we need to check the\n    // user-provided blocker function\n    if (blockerFunction({\n      currentLocation,\n      nextLocation,\n      historyAction\n    })) {\n      return blockerKey;\n    }\n  }\n  function handleNavigational404(pathname) {\n    let error = getInternalRouterError(404, {\n      pathname\n    });\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let {\n      matches,\n      route\n    } = getShortCircuitMatches(routesToUse);\n    // Cancel all pending deferred on 404s since we don't keep any routes\n    cancelActiveDeferreds();\n    return {\n      notFoundMatches: matches,\n      route,\n      error\n    };\n  }\n  function handleDiscoverRouteError(pathname, discoverResult) {\n    return {\n      boundaryId: findNearestBoundary(discoverResult.partialMatches).route.id,\n      error: getInternalRouterError(400, {\n        type: \"route-discovery\",\n        pathname,\n        message: discoverResult.error != null && \"message\" in discoverResult.error ? discoverResult.error : String(discoverResult.error)\n      })\n    };\n  }\n  function cancelActiveDeferreds(predicate) {\n    let cancelledRouteIds = [];\n    activeDeferreds.forEach((dfd, routeId) => {\n      if (!predicate || predicate(routeId)) {\n        // Cancel the deferred - but do not remove from activeDeferreds here -\n        // we rely on the subscribers to do that so our tests can assert proper\n        // cleanup via _internalActiveDeferreds\n        dfd.cancel();\n        cancelledRouteIds.push(routeId);\n        activeDeferreds.delete(routeId);\n      }\n    });\n    return cancelledRouteIds;\n  }\n  // Opt in to capturing and reporting scroll positions during navigations,\n  // used by the <ScrollRestoration> component\n  function enableScrollRestoration(positions, getPosition, getKey) {\n    savedScrollPositions = positions;\n    getScrollPosition = getPosition;\n    getScrollRestorationKey = getKey || null;\n    // Perform initial hydration scroll restoration, since we miss the boat on\n    // the initial updateState() because we've not yet rendered <ScrollRestoration/>\n    // and therefore have no savedScrollPositions available\n    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n      initialScrollRestored = true;\n      let y = getSavedScrollPosition(state.location, state.matches);\n      if (y != null) {\n        updateState({\n          restoreScrollPosition: y\n        });\n      }\n    }\n    return () => {\n      savedScrollPositions = null;\n      getScrollPosition = null;\n      getScrollRestorationKey = null;\n    };\n  }\n  function getScrollKey(location, matches) {\n    if (getScrollRestorationKey) {\n      let key = getScrollRestorationKey(location, matches.map(m => convertRouteMatchToUiMatch(m, state.loaderData)));\n      return key || location.key;\n    }\n    return location.key;\n  }\n  function saveScrollPosition(location, matches) {\n    if (savedScrollPositions && getScrollPosition) {\n      let key = getScrollKey(location, matches);\n      savedScrollPositions[key] = getScrollPosition();\n    }\n  }\n  function getSavedScrollPosition(location, matches) {\n    if (savedScrollPositions) {\n      let key = getScrollKey(location, matches);\n      let y = savedScrollPositions[key];\n      if (typeof y === \"number\") {\n        return y;\n      }\n    }\n    return null;\n  }\n  function checkFogOfWar(matches, routesToUse, pathname) {\n    if (patchRoutesOnMissImpl) {\n      if (!matches) {\n        let fogMatches = matchRoutesImpl(routesToUse, pathname, basename, true);\n        return {\n          active: true,\n          matches: fogMatches || []\n        };\n      } else {\n        let leafRoute = matches[matches.length - 1].route;\n        if (leafRoute.path && (leafRoute.path === \"*\" || leafRoute.path.endsWith(\"/*\"))) {\n          // If we matched a splat, it might only be because we haven't yet fetched\n          // the children that would match with a higher score, so let's fetch\n          // around and find out\n          let partialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);\n          return {\n            active: true,\n            matches: partialMatches\n          };\n        }\n      }\n    }\n    return {\n      active: false,\n      matches: null\n    };\n  }\n  async function discoverRoutes(matches, pathname, signal) {\n    let partialMatches = matches;\n    let route = partialMatches.length > 0 ? partialMatches[partialMatches.length - 1].route : null;\n    while (true) {\n      let isNonHMR = inFlightDataRoutes == null;\n      let routesToUse = inFlightDataRoutes || dataRoutes;\n      try {\n        await loadLazyRouteChildren(patchRoutesOnMissImpl, pathname, partialMatches, routesToUse, manifest, mapRouteProperties, pendingPatchRoutes, signal);\n      } catch (e) {\n        return {\n          type: \"error\",\n          error: e,\n          partialMatches\n        };\n      } finally {\n        // If we are not in the middle of an HMR revalidation and we changed the\n        // routes, provide a new identity so when we `updateState` at the end of\n        // this navigation/fetch `router.routes` will be a new identity and\n        // trigger a re-run of memoized `router.routes` dependencies.\n        // HMR will already update the identity and reflow when it lands\n        // `inFlightDataRoutes` in `completeNavigation`\n        if (isNonHMR) {\n          dataRoutes = [...dataRoutes];\n        }\n      }\n      if (signal.aborted) {\n        return {\n          type: \"aborted\"\n        };\n      }\n      let newMatches = matchRoutes(routesToUse, pathname, basename);\n      let matchedSplat = false;\n      if (newMatches) {\n        let leafRoute = newMatches[newMatches.length - 1].route;\n        if (leafRoute.index) {\n          // If we found an index route, we can stop\n          return {\n            type: \"success\",\n            matches: newMatches\n          };\n        }\n        if (leafRoute.path && leafRoute.path.length > 0) {\n          if (leafRoute.path === \"*\") {\n            // If we found a splat route, we can't be sure there's not a\n            // higher-scoring route down some partial matches trail so we need\n            // to check that out\n            matchedSplat = true;\n          } else {\n            // If we found a non-splat route, we can stop\n            return {\n              type: \"success\",\n              matches: newMatches\n            };\n          }\n        }\n      }\n      let newPartialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);\n      // If we are no longer partially matching anything, this was either a\n      // legit splat match above, or it's a 404.  Also avoid loops if the\n      // second pass results in the same partial matches\n      if (!newPartialMatches || partialMatches.map(m => m.route.id).join(\"-\") === newPartialMatches.map(m => m.route.id).join(\"-\")) {\n        return {\n          type: \"success\",\n          matches: matchedSplat ? newMatches : null\n        };\n      }\n      partialMatches = newPartialMatches;\n      route = partialMatches[partialMatches.length - 1].route;\n      if (route.path === \"*\") {\n        // The splat is still our most accurate partial, so run with it\n        return {\n          type: \"success\",\n          matches: partialMatches\n        };\n      }\n    }\n  }\n  function _internalSetRoutes(newRoutes) {\n    manifest = {};\n    inFlightDataRoutes = convertRoutesToDataRoutes(newRoutes, mapRouteProperties, undefined, manifest);\n  }\n  function patchRoutes(routeId, children) {\n    let isNonHMR = inFlightDataRoutes == null;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties);\n    // If we are not in the middle of an HMR revalidation and we changed the\n    // routes, provide a new identity and trigger a reflow via `updateState`\n    // to re-run memoized `router.routes` dependencies.\n    // HMR will already update the identity and reflow when it lands\n    // `inFlightDataRoutes` in `completeNavigation`\n    if (isNonHMR) {\n      dataRoutes = [...dataRoutes];\n      updateState({});\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 => init.history.createHref(to),\n    encodeLocation: to => init.history.encodeLocation(to),\n    getFetcher,\n    deleteFetcher: deleteFetcherAndUpdateState,\n    dispose,\n    getBlocker,\n    deleteBlocker,\n    patchRoutes,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds,\n    // TODO: Remove setRoutes, it's temporary to avoid dealing with\n    // updating the tree while validating the update algorithm.\n    _internalSetRoutes\n  };\n  return router;\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\nconst UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\nfunction createStaticHandler(routes, opts) {\n  invariant(routes.length > 0, \"You must provide a non-empty routes array to createStaticHandler\");\n  let manifest = {};\n  let basename = (opts ? opts.basename : null) || \"/\";\n  let mapRouteProperties;\n  if (opts != null && opts.mapRouteProperties) {\n    mapRouteProperties = opts.mapRouteProperties;\n  } else if (opts != null && opts.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = opts.detectErrorBoundary;\n    mapRouteProperties = route => ({\n      hasErrorBoundary: detectErrorBoundary(route)\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Config driven behavior flags\n  let future = _extends({\n    v7_relativeSplatPath: false,\n    v7_throwAbortReason: false\n  }, opts ? opts.future : null);\n  let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, undefined, manifest);\n  /**\n   * The query() method is intended for document requests, in which we want to\n   * call an optional action and potentially multiple loaders for all nested\n   * routes.  It returns a StaticHandlerContext object, which is very similar\n   * to the router state (location, loaderData, actionData, errors, etc.) and\n   * also adds SSR-specific information such as the statusCode and headers\n   * from action/loaders Responses.\n   *\n   * It _should_ never throw and should report all errors through the\n   * returned context.errors object, properly associating errors to their error\n   * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be\n   * used to emulate React error boundaries during SSr by performing a second\n   * pass only down to the boundaryId.\n   *\n   * The one exception where we do not return a StaticHandlerContext is when a\n   * redirect response is returned or thrown from any action/loader.  We\n   * propagate that out and return the raw Response so the HTTP server can\n   * return it directly.\n   *\n   * - `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(request, _temp3) {\n    let {\n      requestContext,\n      skipLoaderErrorBubbling,\n      unstable_dataStrategy\n    } = _temp3 === void 0 ? {} : _temp3;\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\") {\n      let error = getInternalRouterError(405, {\n        method\n      });\n      let {\n        matches: methodNotAllowedMatches,\n        route\n      } = getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: methodNotAllowedMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    } else if (!matches) {\n      let error = getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n      let {\n        matches: notFoundMatches,\n        route\n      } = getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: notFoundMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    let result = await queryImpl(request, location, matches, requestContext, unstable_dataStrategy || null, skipLoaderErrorBubbling === true, null);\n    if (isResponse(result)) {\n      return result;\n    }\n    // When returning StaticHandlerContext, we patch back in the location here\n    // since we need it for React Context.  But this helps keep our submit and\n    // loadRouteData operating on a Request instead of a Location\n    return _extends({\n      location,\n      basename\n    }, result);\n  }\n  /**\n   * The queryRoute() method is intended for targeted route requests, either\n   * for fetch ?_data requests or resource route requests.  In this case, we\n   * are only ever calling a single action or loader, and we are returning the\n   * returned value directly.  In most cases, this will be a Response returned\n   * from the action/loader, but it may be a primitive or other value as well -\n   * and in such cases the calling context should handle that accordingly.\n   *\n   * We do respect the throw/return differentiation, so if an action/loader\n   * throws, then this method will throw the value.  This is important so we\n   * can do proper boundary identification in Remix where a thrown Response\n   * must go to the Catch Boundary but a returned Response is happy-path.\n   *\n   * One thing to note is that any Router-initiated Errors that make sense\n   * to associate with a status code will be thrown as an ErrorResponse\n   * instance which include the raw Error, such that the calling context can\n   * serialize the error as they see fit while including the proper response\n   * code.  Examples here are 404 and 405 errors that occur prior to reaching\n   * any user-defined loaders.\n   *\n   * - `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(request, _temp4) {\n    let {\n      routeId,\n      requestContext,\n      unstable_dataStrategy\n    } = _temp4 === void 0 ? {} : _temp4;\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\" && method !== \"OPTIONS\") {\n      throw getInternalRouterError(405, {\n        method\n      });\n    } else if (!matches) {\n      throw getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n    }\n    let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);\n    if (routeId && !match) {\n      throw getInternalRouterError(403, {\n        pathname: location.pathname,\n        routeId\n      });\n    } else if (!match) {\n      // This should never hit I don't think?\n      throw getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n    }\n    let result = await queryImpl(request, location, matches, requestContext, unstable_dataStrategy || null, false, match);\n    if (isResponse(result)) {\n      return result;\n    }\n    let error = result.errors ? Object.values(result.errors)[0] : undefined;\n    if (error !== undefined) {\n      // If we got back result.errors, that means the loader/action threw\n      // _something_ that wasn't a Response, but it's not guaranteed/required\n      // to be an `instanceof Error` either, so we have to use throw here to\n      // preserve the \"error\" state outside of queryImpl.\n      throw error;\n    }\n    // Pick off the right state value to return\n    if (result.actionData) {\n      return Object.values(result.actionData)[0];\n    }\n    if (result.loaderData) {\n      var _result$activeDeferre;\n      let data = Object.values(result.loaderData)[0];\n      if ((_result$activeDeferre = result.activeDeferreds) != null && _result$activeDeferre[match.route.id]) {\n        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];\n      }\n      return data;\n    }\n    return undefined;\n  }\n  async function queryImpl(request, location, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch) {\n    invariant(request.signal, \"query()/queryRoute() requests must contain an AbortController signal\");\n    try {\n      if (isMutationMethod(request.method.toLowerCase())) {\n        let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch != null);\n        return result;\n      }\n      let result = await loadRouteData(request, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch);\n      return isResponse(result) ? result : _extends({}, result, {\n        actionData: null,\n        actionHeaders: {}\n      });\n    } catch (e) {\n      // If the user threw/returned a Response in callLoaderOrAction 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  async function submit(request, matches, actionMatch, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, isRouteRequest) {\n    let result;\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: actionMatch.route.id\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error\n      };\n    } else {\n      let results = await callDataStrategy(\"action\", request, [actionMatch], matches, isRouteRequest, requestContext, unstable_dataStrategy);\n      result = results[0];\n      if (request.signal.aborted) {\n        throwStaticHandlerAbortedError(request, isRouteRequest, future);\n      }\n    }\n    if (isRedirectResult(result)) {\n      // Uhhhh - this should never happen, we should always throw these from\n      // callLoaderOrAction, but the type narrowing here keeps TS happy and we\n      // can get back on the \"throw all redirect responses\" train here should\n      // this ever happen :/\n      throw new Response(null, {\n        status: result.response.status,\n        headers: {\n          Location: result.response.headers.get(\"Location\")\n        }\n      });\n    }\n    if (isDeferredResult(result)) {\n      let error = getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error\n      };\n    }\n    if (isRouteRequest) {\n      // Note: This should only be non-Response values if we get here, since\n      // isRouteRequest should throw any Response received in callLoaderOrAction\n      if (isErrorResult(result)) {\n        throw result.error;\n      }\n      return {\n        matches: [actionMatch],\n        loaderData: {},\n        actionData: {\n          [actionMatch.route.id]: result.data\n        },\n        errors: null,\n        // Note: statusCode + headers are unused here since queryRoute will\n        // return the raw Response or value\n        statusCode: 200,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    // 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    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 ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);\n      let context = await loadRouteData(loaderRequest, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, null, [boundaryMatch.route.id, result]);\n      // action status codes take precedence over loader status codes\n      return _extends({}, context, {\n        statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,\n        actionData: null,\n        actionHeaders: _extends({}, result.headers ? {\n          [actionMatch.route.id]: result.headers\n        } : {})\n      });\n    }\n    let context = await loadRouteData(loaderRequest, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, null);\n    return _extends({}, context, {\n      actionData: {\n        [actionMatch.route.id]: result.data\n      }\n    }, result.statusCode ? {\n      statusCode: result.statusCode\n    } : {}, {\n      actionHeaders: result.headers ? {\n        [actionMatch.route.id]: result.headers\n      } : {}\n    });\n  }\n  async function loadRouteData(request, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch, pendingActionResult) {\n    let isRouteRequest = routeMatch != null;\n    // Short circuit if we have no loaders to run (queryRoute())\n    if (isRouteRequest && !(routeMatch != null && routeMatch.route.loader) && !(routeMatch != null && routeMatch.route.lazy)) {\n      throw getInternalRouterError(400, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: routeMatch == null ? void 0 : routeMatch.route.id\n      });\n    }\n    let requestMatches = routeMatch ? [routeMatch] : pendingActionResult && isErrorResult(pendingActionResult[1]) ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]) : matches;\n    let matchesToLoad = requestMatches.filter(m => m.route.loader || m.route.lazy);\n    // Short circuit if we have no loaders to run (query())\n    if (matchesToLoad.length === 0) {\n      return {\n        matches,\n        // Add a null for all matched routes for proper revalidation on the client\n        loaderData: matches.reduce((acc, m) => Object.assign(acc, {\n          [m.route.id]: null\n        }), {}),\n        errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {\n          [pendingActionResult[0]]: pendingActionResult[1].error\n        } : null,\n        statusCode: 200,\n        loaderHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    let results = await callDataStrategy(\"loader\", request, matchesToLoad, matches, isRouteRequest, requestContext, unstable_dataStrategy);\n    if (request.signal.aborted) {\n      throwStaticHandlerAbortedError(request, isRouteRequest, future);\n    }\n    // Process and commit output from loaders\n    let activeDeferreds = new Map();\n    let context = processRouteLoaderData(matches, matchesToLoad, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling);\n    // Add a null for any non-loader matches for proper revalidation on the client\n    let executedLoaders = new Set(matchesToLoad.map(match => match.route.id));\n    matches.forEach(match => {\n      if (!executedLoaders.has(match.route.id)) {\n        context.loaderData[match.route.id] = null;\n      }\n    });\n    return _extends({}, context, {\n      matches,\n      activeDeferreds: activeDeferreds.size > 0 ? Object.fromEntries(activeDeferreds.entries()) : null\n    });\n  }\n  // Utility wrapper for calling dataStrategy server-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(type, request, matchesToLoad, matches, isRouteRequest, requestContext, unstable_dataStrategy) {\n    let results = await callDataStrategyImpl(unstable_dataStrategy || defaultDataStrategy, type, request, matchesToLoad, matches, manifest, mapRouteProperties, requestContext);\n    return await Promise.all(results.map((result, i) => {\n      if (isRedirectHandlerResult(result)) {\n        let response = result.result;\n        // Throw redirects and let the server handle them with an HTTP redirect\n        throw normalizeRelativeRoutingRedirectResponse(response, request, matchesToLoad[i].route.id, matches, basename, future.v7_relativeSplatPath);\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      return convertHandlerResultToDataResult(result);\n    }));\n  }\n  return {\n    dataRoutes,\n    query,\n    queryRoute\n  };\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Helpers\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Given an existing StaticHandlerContext and an error thrown at render time,\n * provide an updated StaticHandlerContext suitable for a second SSR render\n */\nfunction getStaticContextFromError(routes, context, error) {\n  let newContext = _extends({}, context, {\n    statusCode: isRouteErrorResponse(error) ? error.status : 500,\n    errors: {\n      [context._deepestRenderedBoundaryId || routes[0].id]: error\n    }\n  });\n  return newContext;\n}\nfunction throwStaticHandlerAbortedError(request, isRouteRequest, future) {\n  if (future.v7_throwAbortReason && request.signal.reason !== undefined) {\n    throw request.signal.reason;\n  }\n  let method = isRouteRequest ? \"queryRoute\" : \"query\";\n  throw new Error(method + \"() call aborted: \" + request.method + \" \" + request.url);\n}\nfunction isSubmissionNavigation(opts) {\n  return opts != null && (\"formData\" in opts && opts.formData != null || \"body\" in opts && opts.body !== undefined);\n}\nfunction normalizeTo(location, matches, basename, prependBasename, to, v7_relativeSplatPath, fromRouteId, relative) {\n  let contextualMatches;\n  let activeRouteMatch;\n  if (fromRouteId) {\n    // Grab matches up to the calling route so our route-relative logic is\n    // relative to the correct source route\n    contextualMatches = [];\n    for (let match of matches) {\n      contextualMatches.push(match);\n      if (match.route.id === fromRouteId) {\n        activeRouteMatch = match;\n        break;\n      }\n    }\n  } else {\n    contextualMatches = matches;\n    activeRouteMatch = matches[matches.length - 1];\n  }\n  // Resolve the relative path\n  let path = resolveTo(to ? to : \".\", getResolveToMatches(contextualMatches, v7_relativeSplatPath), stripBasename(location.pathname, basename) || location.pathname, relative === \"path\");\n  // When `to` is not specified we inherit search/hash from the current\n  // location, unlike when to=\".\" and we just inherit the path.\n  // See https://github.com/remix-run/remix/issues/927\n  if (to == null) {\n    path.search = location.search;\n    path.hash = location.hash;\n  }\n  // Add an ?index param for matched index routes if we don't already have one\n  if ((to == null || to === \"\" || to === \".\") && activeRouteMatch && activeRouteMatch.route.index && !hasNakedIndexQuery(path.search)) {\n    path.search = path.search ? path.search.replace(/^\\?/, \"?index&\") : \"?index\";\n  }\n  // If we're operating within a basename, prepend it to the pathname.  If\n  // this is a root navigation, then just use the raw basename which allows\n  // the basename to have full control over the presence of a trailing slash\n  // on root actions\n  if (prependBasename && basename !== \"/\") {\n    path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n  return createPath(path);\n}\n// Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\nfunction normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {\n  // Return location verbatim on non-submission navigations\n  if (!opts || !isSubmissionNavigation(opts)) {\n    return {\n      path\n    };\n  }\n  if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n    return {\n      path,\n      error: getInternalRouterError(405, {\n        method: opts.formMethod\n      })\n    };\n  }\n  let getInvalidBodyError = () => ({\n    path,\n    error: getInternalRouterError(400, {\n      type: \"invalid-body\"\n    })\n  });\n  // Create a Submission on non-GET navigations\n  let rawFormMethod = opts.formMethod || \"get\";\n  let formMethod = normalizeFormMethod ? rawFormMethod.toUpperCase() : rawFormMethod.toLowerCase();\n  let formAction = stripHashFromPath(path);\n  if (opts.body !== undefined) {\n    if (opts.formEncType === \"text/plain\") {\n      // text only support POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n      let text = typeof opts.body === \"string\" ? opts.body : opts.body instanceof FormData || opts.body instanceof URLSearchParams ?\n      // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data\n      Array.from(opts.body.entries()).reduce((acc, _ref5) => {\n        let [name, value] = _ref5;\n        return \"\" + acc + name + \"=\" + value + \"\\n\";\n      }, \"\") : String(opts.body);\n      return {\n        path,\n        submission: {\n          formMethod,\n          formAction,\n          formEncType: opts.formEncType,\n          formData: undefined,\n          json: undefined,\n          text\n        }\n      };\n    } else if (opts.formEncType === \"application/json\") {\n      // json only supports POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n      try {\n        let json = typeof opts.body === \"string\" ? JSON.parse(opts.body) : opts.body;\n        return {\n          path,\n          submission: {\n            formMethod,\n            formAction,\n            formEncType: opts.formEncType,\n            formData: undefined,\n            json,\n            text: undefined\n          }\n        };\n      } catch (e) {\n        return getInvalidBodyError();\n      }\n    }\n  }\n  invariant(typeof FormData === \"function\", \"FormData is not available in this environment\");\n  let searchParams;\n  let formData;\n  if (opts.formData) {\n    searchParams = convertFormDataToSearchParams(opts.formData);\n    formData = opts.formData;\n  } else if (opts.body instanceof FormData) {\n    searchParams = convertFormDataToSearchParams(opts.body);\n    formData = opts.body;\n  } else if (opts.body instanceof URLSearchParams) {\n    searchParams = opts.body;\n    formData = convertSearchParamsToFormData(searchParams);\n  } else if (opts.body == null) {\n    searchParams = new URLSearchParams();\n    formData = new FormData();\n  } else {\n    try {\n      searchParams = new URLSearchParams(opts.body);\n      formData = convertSearchParamsToFormData(searchParams);\n    } catch (e) {\n      return getInvalidBodyError();\n    }\n  }\n  let submission = {\n    formMethod,\n    formAction,\n    formEncType: opts && opts.formEncType || \"application/x-www-form-urlencoded\",\n    formData,\n    json: undefined,\n    text: undefined\n  };\n  if (isMutationMethod(submission.formMethod)) {\n    return {\n      path,\n      submission\n    };\n  }\n  // Flatten submission onto URLSearchParams for GET submissions\n  let parsedPath = parsePath(path);\n  // On GET navigation submissions we can drop the ?index param from the\n  // resulting location since all loaders will run.  But fetcher GET submissions\n  // only run a single loader so we need to preserve any incoming ?index params\n  if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n    searchParams.append(\"index\", \"\");\n  }\n  parsedPath.search = \"?\" + searchParams;\n  return {\n    path: createPath(parsedPath),\n    submission\n  };\n}\n// Filter out all routes below any caught error as they aren't going to\n// render so we don't need to load them\nfunction getLoaderMatchesUntilBoundary(matches, boundaryId) {\n  let boundaryMatches = matches;\n  if (boundaryId) {\n    let index = matches.findIndex(m => m.route.id === boundaryId);\n    if (index >= 0) {\n      boundaryMatches = matches.slice(0, index);\n    }\n  }\n  return boundaryMatches;\n}\nfunction getMatchesToLoad(history, state, matches, submission, location, isInitialLoad, skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {\n  let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : undefined;\n  let currentUrl = history.createURL(state.location);\n  let nextUrl = history.createURL(location);\n  // Pick navigation matches that are net-new or qualify for revalidation\n  let boundaryId = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[0] : undefined;\n  let boundaryMatches = boundaryId ? getLoaderMatchesUntilBoundary(matches, boundaryId) : matches;\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 ? pendingActionResult[1].statusCode : undefined;\n  let shouldSkipRevalidation = skipActionErrorRevalidation && actionStatus && actionStatus >= 400;\n  let navigationMatches = boundaryMatches.filter((match, index) => {\n    let {\n      route\n    } = match;\n    if (route.lazy) {\n      // We haven't loaded this route yet so we don't know if it's got a loader!\n      return true;\n    }\n    if (route.loader == null) {\n      return false;\n    }\n    if (isInitialLoad) {\n      if (typeof route.loader !== \"function\" || route.loader.hydrate) {\n        return true;\n      }\n      return state.loaderData[route.id] === undefined && (\n      // Don't re-run if the loader ran and threw an error\n      !state.errors || state.errors[route.id] === undefined);\n    }\n    // Always call the loader on new route instances and pending defer cancellations\n    if (isNewLoader(state.loaderData, state.matches[index], match) || cancelledDeferredRoutes.some(id => id === match.route.id)) {\n      return true;\n    }\n    // This is the default implementation for when we revalidate.  If the route\n    // provides it's own implementation, then we give them full control but\n    // provide this value so they can leverage it if needed after they check\n    // their own specific use cases\n    let currentRouteMatch = state.matches[index];\n    let nextRouteMatch = match;\n    return shouldRevalidateLoader(match, _extends({\n      currentUrl,\n      currentParams: currentRouteMatch.params,\n      nextUrl,\n      nextParams: nextRouteMatch.params\n    }, submission, {\n      actionResult,\n      actionStatus,\n      defaultShouldRevalidate: shouldSkipRevalidation ? false :\n      // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate\n      isRevalidationRequired || currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search ||\n      // Search params affect all loaders\n      currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)\n    }));\n  });\n  // Pick fetcher.loads that need to be revalidated\n  let revalidatingFetchers = [];\n  fetchLoadMatches.forEach((f, key) => {\n    // Don't revalidate:\n    //  - on initial load (shouldn't be any fetchers then anyway)\n    //  - if fetcher won't be present in the subsequent render\n    //    - no longer matches the URL (v7_fetcherPersist=false)\n    //    - was unmounted but persisted due to v7_fetcherPersist=true\n    if (isInitialLoad || !matches.some(m => m.route.id === f.routeId) || deletedFetchers.has(key)) {\n      return;\n    }\n    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);\n    // If the fetcher path no longer matches, push it in with null matches so\n    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is\n    // currently only a use-case for Remix HMR where the route tree can change\n    // at runtime and remove a route previously loaded via a fetcher\n    if (!fetcherMatches) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: null,\n        match: null,\n        controller: null\n      });\n      return;\n    }\n    // Revalidating fetchers are decoupled from the route matches since they\n    // load from a static href.  They revalidate based on explicit revalidation\n    // (submission, useRevalidator, or X-Remix-Revalidate)\n    let fetcher = state.fetchers.get(key);\n    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);\n    let shouldRevalidate = false;\n    if (fetchRedirectIds.has(key)) {\n      // Never trigger a revalidation of an actively redirecting fetcher\n      shouldRevalidate = false;\n    } else if (cancelledFetcherLoads.has(key)) {\n      // Always mark for revalidation if the fetcher was cancelled\n      cancelledFetcherLoads.delete(key);\n      shouldRevalidate = true;\n    } else if (fetcher && fetcher.state !== \"idle\" && fetcher.data === undefined) {\n      // If the fetcher hasn't ever completed loading yet, then this isn't a\n      // revalidation, it would just be a brand new load if an explicit\n      // revalidation is required\n      shouldRevalidate = isRevalidationRequired;\n    } else {\n      // Otherwise fall back on any user-defined shouldRevalidate, defaulting\n      // to explicit revalidations only\n      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({\n        currentUrl,\n        currentParams: state.matches[state.matches.length - 1].params,\n        nextUrl,\n        nextParams: matches[matches.length - 1].params\n      }, submission, {\n        actionResult,\n        actionStatus,\n        defaultShouldRevalidate: shouldSkipRevalidation ? false : isRevalidationRequired\n      }));\n    }\n    if (shouldRevalidate) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: fetcherMatches,\n        match: fetcherMatch,\n        controller: new AbortController()\n      });\n    }\n  });\n  return [navigationMatches, revalidatingFetchers];\n}\nfunction isNewLoader(currentLoaderData, currentMatch, match) {\n  let isNew =\n  // [a] -> [a, b]\n  !currentMatch ||\n  // [a, b] -> [a, c]\n  match.route.id !== currentMatch.route.id;\n  // Handle the case that we don't have data for a re-used route, potentially\n  // from a prior error or from a cancelled pending deferred\n  let isMissingData = currentLoaderData[match.route.id] === undefined;\n  // Always load if this is a net-new route or we don't yet have data\n  return isNew || isMissingData;\n}\nfunction isNewRouteInstance(currentMatch, match) {\n  let currentPath = currentMatch.route.path;\n  return (\n    // param change for this match, /users/123 -> /users/456\n    currentMatch.pathname !== match.pathname ||\n    // splat param changed, which is not present in match.path\n    // e.g. /files/images/avatar.jpg -> files/finances.xls\n    currentPath != null && currentPath.endsWith(\"*\") && currentMatch.params[\"*\"] !== match.params[\"*\"]\n  );\n}\nfunction shouldRevalidateLoader(loaderMatch, arg) {\n  if (loaderMatch.route.shouldRevalidate) {\n    let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n  return arg.defaultShouldRevalidate;\n}\n/**\n * Idempotent utility to execute patchRoutesOnMiss() to lazily load route\n * definitions and update the routes/routeManifest\n */\nasync function loadLazyRouteChildren(patchRoutesOnMissImpl, path, matches, routes, manifest, mapRouteProperties, pendingRouteChildren, signal) {\n  let key = [path, ...matches.map(m => m.route.id)].join(\"-\");\n  try {\n    let pending = pendingRouteChildren.get(key);\n    if (!pending) {\n      pending = patchRoutesOnMissImpl({\n        path,\n        matches,\n        patch: (routeId, children) => {\n          if (!signal.aborted) {\n            patchRoutesImpl(routeId, children, routes, manifest, mapRouteProperties);\n          }\n        }\n      });\n      pendingRouteChildren.set(key, pending);\n    }\n    if (pending && isPromise(pending)) {\n      await pending;\n    }\n  } finally {\n    pendingRouteChildren.delete(key);\n  }\n}\nfunction patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties) {\n  if (routeId) {\n    var _route$children;\n    let route = manifest[routeId];\n    invariant(route, \"No route found to patch children into: routeId = \" + routeId);\n    let dataChildren = convertRoutesToDataRoutes(children, mapRouteProperties, [routeId, \"patch\", String(((_route$children = route.children) == null ? void 0 : _route$children.length) || \"0\")], manifest);\n    if (route.children) {\n      route.children.push(...dataChildren);\n    } else {\n      route.children = dataChildren;\n    }\n  } else {\n    let dataChildren = convertRoutesToDataRoutes(children, mapRouteProperties, [\"patch\", String(routesToUse.length || \"0\")], manifest);\n    routesToUse.push(...dataChildren);\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(route, mapRouteProperties, manifest) {\n  if (!route.lazy) {\n    return;\n  }\n  let lazyRoute = await route.lazy();\n  // If the lazy route function was executed and removed by another parallel\n  // call then we can return - first lazy() to finish wins because the return\n  // value of lazy is expected to be static\n  if (!route.lazy) {\n    return;\n  }\n  let routeToUpdate = manifest[route.id];\n  invariant(routeToUpdate, \"No route found in manifest\");\n  // Update the route in place.  This should be safe because there's no way\n  // we could yet be sitting on this route as we can't get there without\n  // resolving lazy() first.\n  //\n  // This is different than the HMR \"update\" use-case where we may actively be\n  // on the route being updated.  The main concern boils down to \"does this\n  // mutation affect any ongoing navigations or any current state.matches\n  // values?\".  If not, it should be safe to update in place.\n  let routeUpdates = {};\n  for (let lazyRouteProperty in lazyRoute) {\n    let staticRouteValue = routeToUpdate[lazyRouteProperty];\n    let isPropertyStaticallyDefined = staticRouteValue !== undefined &&\n    // This property isn't static since it should always be updated based\n    // on the route updates\n    lazyRouteProperty !== \"hasErrorBoundary\";\n    warning(!isPropertyStaticallyDefined, \"Route \\\"\" + routeToUpdate.id + \"\\\" has a static property \\\"\" + lazyRouteProperty + \"\\\" \" + \"defined but its lazy function is also returning a value for this property. \" + (\"The lazy route property \\\"\" + lazyRouteProperty + \"\\\" will be ignored.\"));\n    if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {\n      routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];\n    }\n  }\n  // Mutate the route with the provided updates.  Do this first so we pass\n  // the updated version to mapRouteProperties\n  Object.assign(routeToUpdate, routeUpdates);\n  // Mutate the `hasErrorBoundary` property on the route based on the route\n  // updates and remove the `lazy` function so we don't resolve the lazy\n  // route again.\n  Object.assign(routeToUpdate, _extends({}, mapRouteProperties(routeToUpdate), {\n    lazy: undefined\n  }));\n}\n// Default implementation of `dataStrategy` which fetches all loaders in parallel\nfunction defaultDataStrategy(opts) {\n  return Promise.all(opts.matches.map(m => m.resolve()));\n}\nasync function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, manifest, mapRouteProperties, requestContext) {\n  let routeIdsToLoad = matchesToLoad.reduce((acc, m) => acc.add(m.route.id), new Set());\n  let loadedMatches = new Set();\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 = handlerOverride => {\n        loadedMatches.add(match.route.id);\n        return shouldLoad ? callLoaderOrAction(type, request, match, manifest, mapRouteProperties, handlerOverride, requestContext) : Promise.resolve({\n          type: ResultType.data,\n          result: undefined\n        });\n      };\n      return _extends({}, match, {\n        shouldLoad,\n        resolve\n      });\n    }),\n    request,\n    params: matches[0].params,\n    context: requestContext\n  });\n  // Throw if any loadRoute implementations not called since they are what\n  // ensures a route is fully loaded\n  matches.forEach(m => invariant(loadedMatches.has(m.route.id), \"`match.resolve()` was not called for route id \\\"\" + m.route.id + \"\\\". \" + \"You must call `match.resolve()` on every match passed to \" + \"`dataStrategy` to ensure all routes are properly loaded.\"));\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// Default logic for calling a loader/action is the user has no specified a dataStrategy\nasync function callLoaderOrAction(type, request, match, manifest, mapRouteProperties, handlerOverride, staticContext) {\n  let result;\n  let onReject;\n  let runHandler = handler => {\n    // Setup a promise we can race against so that abort signals short circuit\n    let reject;\n    // This will never resolve so safe to type it as Promise<HandlerResult> to\n    // satisfy the function return value\n    let abortPromise = new Promise((_, r) => reject = r);\n    onReject = () => reject();\n    request.signal.addEventListener(\"abort\", onReject);\n    let actualHandler = ctx => {\n      if (typeof handler !== \"function\") {\n        return Promise.reject(new Error(\"You cannot call the handler for a route which defines a boolean \" + (\"\\\"\" + type + \"\\\" [routeId: \" + match.route.id + \"]\")));\n      }\n      return handler({\n        request,\n        params: match.params,\n        context: staticContext\n      }, ...(ctx !== undefined ? [ctx] : []));\n    };\n    let handlerPromise;\n    if (handlerOverride) {\n      handlerPromise = handlerOverride(ctx => actualHandler(ctx));\n    } else {\n      handlerPromise = (async () => {\n        try {\n          let val = await actualHandler();\n          return {\n            type: \"data\",\n            result: val\n          };\n        } catch (e) {\n          return {\n            type: \"error\",\n            result: e\n          };\n        }\n      })();\n    }\n    return Promise.race([handlerPromise, abortPromise]);\n  };\n  try {\n    let handler = match.route[type];\n    if (match.route.lazy) {\n      if (handler) {\n        // Run statically defined handler in parallel with lazy()\n        let handlerError;\n        let [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        }), loadLazyRouteModule(match.route, mapRouteProperties, manifest)]);\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        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 {\n            type: ResultType.data,\n            result: undefined\n          };\n        }\n      }\n    } else if (!handler) {\n      let url = new URL(request.url);\n      let pathname = url.pathname + url.search;\n      throw getInternalRouterError(404, {\n        pathname\n      });\n    } else {\n      result = await runHandler(handler);\n    }\n    invariant(result.result !== undefined, \"You defined \" + (type === \"action\" ? \"an action\" : \"a loader\") + \" for route \" + (\"\\\"\" + match.route.id + \"\\\" but didn't return anything from your `\" + type + \"` \") + \"function. Please return a value or `null`.\");\n  } catch (e) {\n    // 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 {\n      type: ResultType.error,\n      result: e\n    };\n  } finally {\n    if (onReject) {\n      request.signal.removeEventListener(\"abort\", onReject);\n    }\n  }\n  return result;\n}\nasync function convertHandlerResultToDataResult(handlerResult) {\n  let {\n    result,\n    type\n  } = handlerResult;\n  if (isResponse(result)) {\n    let data;\n    try {\n      let contentType = result.headers.get(\"Content-Type\");\n      // Check between word boundaries instead of startsWith() due to the last\n      // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type\n      if (contentType && /\\bapplication\\/json\\b/.test(contentType)) {\n        if (result.body == null) {\n          data = null;\n        } else {\n          data = await result.json();\n        }\n      } else {\n        data = await result.text();\n      }\n    } catch (e) {\n      return {\n        type: ResultType.error,\n        error: e\n      };\n    }\n    if (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    return {\n      type: ResultType.data,\n      data,\n      statusCode: result.status,\n      headers: result.headers\n    };\n  }\n  if (type === ResultType.error) {\n    if (isDataWithResponseInit(result)) {\n      var _result$init2;\n      if (result.data instanceof Error) {\n        var _result$init;\n        return {\n          type: ResultType.error,\n          error: result.data,\n          statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status\n        };\n      }\n      // Convert thrown unstable_data() to ErrorResponse instances\n      result = new ErrorResponseImpl(((_result$init2 = result.init) == null ? void 0 : _result$init2.status) || 500, undefined, result.data);\n    }\n    return {\n      type: ResultType.error,\n      error: result,\n      statusCode: isRouteErrorResponse(result) ? result.status : undefined\n    };\n  }\n  if (isDeferredData(result)) {\n    var _result$init3, _result$init4;\n    return {\n      type: ResultType.deferred,\n      deferredData: result,\n      statusCode: (_result$init3 = result.init) == null ? void 0 : _result$init3.status,\n      headers: ((_result$init4 = result.init) == null ? void 0 : _result$init4.headers) && new Headers(result.init.headers)\n    };\n  }\n  if (isDataWithResponseInit(result)) {\n    var _result$init5, _result$init6;\n    return {\n      type: ResultType.data,\n      data: result.data,\n      statusCode: (_result$init5 = result.init) == null ? void 0 : _result$init5.status,\n      headers: (_result$init6 = result.init) != null && _result$init6.headers ? new Headers(result.init.headers) : undefined\n    };\n  }\n  return {\n    type: ResultType.data,\n    data: result\n  };\n}\n// Support relative routing in internal redirects\nfunction normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, v7_relativeSplatPath) {\n  let location = response.headers.get(\"Location\");\n  invariant(location, \"Redirects returned/thrown from loaders/actions must have a Location header\");\n  if (!ABSOLUTE_URL_REGEX.test(location)) {\n    let trimmedMatches = matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1);\n    location = normalizeTo(new URL(request.url), trimmedMatches, basename, true, location, v7_relativeSplatPath);\n    response.headers.set(\"Location\", location);\n  }\n  return response;\n}\nfunction normalizeRedirectLocation(location, currentUrl, basename) {\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(\"//\") ? new URL(currentUrl.protocol + normalizedLocation) : 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// Utility method for creating the Request instances for loaders/actions during\n// client-side navigations and fetches.  During SSR we will always have a\n// Request instance from the static handler (query/queryRoute)\nfunction createClientSideRequest(history, location, signal, submission) {\n  let url = history.createURL(stripHashFromPath(location)).toString();\n  let init = {\n    signal\n  };\n  if (submission && isMutationMethod(submission.formMethod)) {\n    let {\n      formMethod,\n      formEncType\n    } = submission;\n    // Didn't think we needed this but it turns out unlike other methods, patch\n    // won't be properly normalized to uppercase and results in a 405 error.\n    // See: https://fetch.spec.whatwg.org/#concept-method\n    init.method = formMethod.toUpperCase();\n    if (formEncType === \"application/json\") {\n      init.headers = new Headers({\n        \"Content-Type\": formEncType\n      });\n      init.body = JSON.stringify(submission.json);\n    } else if (formEncType === \"text/plain\") {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.text;\n    } else if (formEncType === \"application/x-www-form-urlencoded\" && submission.formData) {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = convertFormDataToSearchParams(submission.formData);\n    } else {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.formData;\n    }\n  }\n  return new Request(url, init);\n}\nfunction convertFormDataToSearchParams(formData) {\n  let searchParams = new URLSearchParams();\n  for (let [key, value] of formData.entries()) {\n    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs\n    searchParams.append(key, typeof value === \"string\" ? value : value.name);\n  }\n  return searchParams;\n}\nfunction convertSearchParamsToFormData(searchParams) {\n  let formData = new FormData();\n  for (let [key, value] of searchParams.entries()) {\n    formData.append(key, value);\n  }\n  return formData;\n}\nfunction processRouteLoaderData(matches, matchesToLoad, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling) {\n  // Fill in loaderData/errors from our loaders\n  let loaderData = {};\n  let errors = null;\n  let statusCode;\n  let foundError = false;\n  let loaderHeaders = {};\n  let pendingError = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : undefined;\n  // Process loader results into state.loaderData/state.errors\n  results.forEach((result, index) => {\n    let id = matchesToLoad[index].route.id;\n    invariant(!isRedirectResult(result), \"Cannot handle redirect results in processLoaderData\");\n    if (isErrorResult(result)) {\n      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      errors = errors || {};\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      // Clear our any prior loaderData for the throwing route\n      loaderData[id] = undefined;\n      // Once we find our first (highest) error, we set the status code and\n      // prevent deeper status codes from overriding\n      if (!foundError) {\n        foundError = true;\n        statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;\n      }\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    } else {\n      if (isDeferredResult(result)) {\n        activeDeferreds.set(id, result.deferredData);\n        loaderData[id] = result.deferredData.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (result.statusCode != null && result.statusCode !== 200 && !foundError) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      } 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  // 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 = {\n      [pendingActionResult[0]]: pendingError\n    };\n    loaderData[pendingActionResult[0]] = undefined;\n  }\n  return {\n    loaderData,\n    errors,\n    statusCode: statusCode || 200,\n    loaderHeaders\n  };\n}\nfunction processLoaderData(state, matches, matchesToLoad, results, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds) {\n  let {\n    loaderData,\n    errors\n  } = processRouteLoaderData(matches, matchesToLoad, results, pendingActionResult, activeDeferreds, false // This method is only called client side so we always want to bubble\n  );\n  // Process results from our revalidating fetchers\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let {\n      key,\n      match,\n      controller\n    } = revalidatingFetchers[index];\n    invariant(fetcherResults !== undefined && fetcherResults[index] !== undefined, \"Did not find corresponding fetcher result\");\n    let result = fetcherResults[index];\n    // Process fetcher non-redirect errors\n    if (controller && controller.signal.aborted) {\n      // Nothing to do for aborted fetchers\n      continue;\n    } else if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);\n      if (!(errors && errors[boundaryMatch.route.id])) {\n        errors = _extends({}, errors, {\n          [boundaryMatch.route.id]: result.error\n        });\n      }\n      state.fetchers.delete(key);\n    } else if (isRedirectResult(result)) {\n      // Should never get here, redirects should get processed above, but we\n      // keep this to type narrow to a success result in the else\n      invariant(false, \"Unhandled fetcher revalidation redirect\");\n    } else if (isDeferredResult(result)) {\n      // Should never get here, deferred data should be awaited for fetchers\n      // in resolveDeferredResults\n      invariant(false, \"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = getDoneFetcher(result.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n  return {\n    loaderData,\n    errors\n  };\n}\nfunction mergeLoaderData(loaderData, newLoaderData, matches, errors) {\n  let mergedLoaderData = _extends({}, newLoaderData);\n  for (let match of matches) {\n    let id = match.route.id;\n    if (newLoaderData.hasOwnProperty(id)) {\n      if (newLoaderData[id] !== undefined) {\n        mergedLoaderData[id] = newLoaderData[id];\n      }\n    } else if (loaderData[id] !== undefined && match.route.loader) {\n      // Preserve existing keys not included in newLoaderData and where a loader\n      // wasn't removed by HMR\n      mergedLoaderData[id] = loaderData[id];\n    }\n    if (errors && errors.hasOwnProperty(id)) {\n      // Don't keep any loader data below the boundary\n      break;\n    }\n  }\n  return mergedLoaderData;\n}\nfunction getActionDataForCommit(pendingActionResult) {\n  if (!pendingActionResult) {\n    return {};\n  }\n  return isErrorResult(pendingActionResult[1]) ? {\n    // Clear out prior actionData on errors\n    actionData: {}\n  } : {\n    actionData: {\n      [pendingActionResult[0]]: pendingActionResult[1].data\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(matches, routeId) {\n  let eligibleMatches = routeId ? matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1) : [...matches];\n  return eligibleMatches.reverse().find(m => m.route.hasErrorBoundary === true) || matches[0];\n}\nfunction getShortCircuitMatches(routes) {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route = routes.length === 1 ? routes[0] : routes.find(r => r.index || !r.path || r.path === \"/\") || {\n    id: \"__shim-error-route__\"\n  };\n  return {\n    matches: [{\n      params: {},\n      pathname: \"\",\n      pathnameBase: \"\",\n      route\n    }],\n    route\n  };\n}\nfunction getInternalRouterError(status, _temp5) {\n  let {\n    pathname,\n    routeId,\n    method,\n    type,\n    message\n  } = _temp5 === void 0 ? {} : _temp5;\n  let statusText = \"Unknown Server Error\";\n  let errorMessage = \"Unknown @remix-run/router error\";\n  if (status === 400) {\n    statusText = \"Bad Request\";\n    if (type === \"route-discovery\") {\n      errorMessage = \"Unable to match URL \\\"\" + pathname + \"\\\" - the `unstable_patchRoutesOnMiss()` \" + (\"function threw the following error:\\n\" + message);\n    } else if (method && pathname && routeId) {\n      errorMessage = \"You made a \" + method + \" request to \\\"\" + pathname + \"\\\" but \" + (\"did not provide a `loader` for route \\\"\" + routeId + \"\\\", \") + \"so there is no way to handle the request.\";\n    } else if (type === \"defer-action\") {\n      errorMessage = \"defer() is not supported in actions\";\n    } else if (type === \"invalid-body\") {\n      errorMessage = \"Unable to encode submission body\";\n    }\n  } else if (status === 403) {\n    statusText = \"Forbidden\";\n    errorMessage = \"Route \\\"\" + routeId + \"\\\" does not match URL \\\"\" + pathname + \"\\\"\";\n  } else if (status === 404) {\n    statusText = \"Not Found\";\n    errorMessage = \"No route matches URL \\\"\" + pathname + \"\\\"\";\n  } else if (status === 405) {\n    statusText = \"Method Not Allowed\";\n    if (method && pathname && routeId) {\n      errorMessage = \"You made a \" + method.toUpperCase() + \" request to \\\"\" + pathname + \"\\\" but \" + (\"did not provide an `action` for route \\\"\" + routeId + \"\\\", \") + \"so there is no way to handle the request.\";\n    } else if (method) {\n      errorMessage = \"Invalid request method \\\"\" + method.toUpperCase() + \"\\\"\";\n    }\n  }\n  return new ErrorResponseImpl(status || 500, statusText, new Error(errorMessage), true);\n}\n// Find any returned redirect errors, starting from the lowest match\nfunction findRedirect(results) {\n  for (let i = results.length - 1; i >= 0; i--) {\n    let result = results[i];\n    if (isRedirectResult(result)) {\n      return {\n        result,\n        idx: i\n      };\n    }\n  }\n}\nfunction stripHashFromPath(path) {\n  let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n  return createPath(_extends({}, parsedPath, {\n    hash: \"\"\n  }));\n}\nfunction isHashChangeOnly(a, b) {\n  if (a.pathname !== b.pathname || a.search !== b.search) {\n    return false;\n  }\n  if (a.hash === \"\") {\n    // /page -> /page#hash\n    return b.hash !== \"\";\n  } else if (a.hash === b.hash) {\n    // /page#hash -> /page#hash\n    return true;\n  } else if (b.hash !== \"\") {\n    // /page#hash -> /page#other\n    return true;\n  }\n  // If the hash is removed the browser will re-perform a request to the server\n  // /page#hash -> /page\n  return false;\n}\nfunction isPromise(val) {\n  return typeof val === \"object\" && val != null && \"then\" in val;\n}\nfunction isHandlerResult(result) {\n  return result != null && typeof result === \"object\" && \"type\" in result && \"result\" in result && (result.type === ResultType.data || result.type === ResultType.error);\n}\nfunction isRedirectHandlerResult(result) {\n  return isResponse(result.result) && redirectStatusCodes.has(result.result.status);\n}\nfunction isDeferredResult(result) {\n  return result.type === ResultType.deferred;\n}\nfunction isErrorResult(result) {\n  return result.type === ResultType.error;\n}\nfunction isRedirectResult(result) {\n  return (result && result.type) === ResultType.redirect;\n}\nfunction isDataWithResponseInit(value) {\n  return typeof value === \"object\" && value != null && \"type\" in value && \"data\" in value && \"init\" in value && value.type === \"DataWithResponseInit\";\n}\nfunction isDeferredData(value) {\n  let deferred = value;\n  return deferred && typeof deferred === \"object\" && typeof deferred.data === \"object\" && typeof deferred.subscribe === \"function\" && typeof deferred.cancel === \"function\" && typeof deferred.resolveData === \"function\";\n}\nfunction isResponse(value) {\n  return value != null && typeof value.status === \"number\" && typeof value.statusText === \"string\" && typeof value.headers === \"object\" && typeof value.body !== \"undefined\";\n}\nfunction isRedirectResponse(result) {\n  if (!isResponse(result)) {\n    return false;\n  }\n  let status = result.status;\n  let location = result.headers.get(\"Location\");\n  return status >= 300 && status <= 399 && location != null;\n}\nfunction isValidMethod(method) {\n  return validRequestMethods.has(method.toLowerCase());\n}\nfunction isMutationMethod(method) {\n  return validMutationMethods.has(method.toLowerCase());\n}\nasync function resolveDeferredResults(currentMatches, matchesToLoad, results, signals, isFetcher, currentLoaderData) {\n  for (let index = 0; index < results.length; index++) {\n    let result = results[index];\n    let match = matchesToLoad[index];\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n    let currentMatch = currentMatches.find(m => m.route.id === match.route.id);\n    let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\n    if (isDeferredResult(result) && (isFetcher || isRevalidatingLoader)) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      let signal = signals[index];\n      invariant(signal, \"Expected an AbortSignal for revalidating fetcher deferred result\");\n      await resolveDeferredData(result, signal, isFetcher).then(result => {\n        if (result) {\n          results[index] = result || results[index];\n        }\n      });\n    }\n  }\n}\nasync function resolveDeferredData(result, signal, unwrap) {\n  if (unwrap === void 0) {\n    unwrap = false;\n  }\n  let aborted = await result.deferredData.resolveData(signal);\n  if (aborted) {\n    return;\n  }\n  if (unwrap) {\n    try {\n      return {\n        type: ResultType.data,\n        data: result.deferredData.unwrappedData\n      };\n    } catch (e) {\n      // Handle any TrackedPromise._error values encountered while unwrapping\n      return {\n        type: ResultType.error,\n        error: e\n      };\n    }\n  }\n  return {\n    type: ResultType.data,\n    data: result.deferredData.data\n  };\n}\nfunction hasNakedIndexQuery(search) {\n  return new URLSearchParams(search).getAll(\"index\").some(v => v === \"\");\n}\nfunction getTargetMatch(matches, location) {\n  let search = typeof location === \"string\" ? parsePath(location).search : location.search;\n  if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || \"\")) {\n    // Return the leaf index route when index is present\n    return matches[matches.length - 1];\n  }\n  // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n  // pathless layout routes)\n  let pathMatches = getPathContributingMatches(matches);\n  return pathMatches[pathMatches.length - 1];\n}\nfunction getSubmissionFromNavigation(navigation) {\n  let {\n    formMethod,\n    formAction,\n    formEncType,\n    text,\n    formData,\n    json\n  } = navigation;\n  if (!formMethod || !formAction || !formEncType) {\n    return;\n  }\n  if (text != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json: undefined,\n      text\n    };\n  } else if (formData != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData,\n      json: undefined,\n      text: undefined\n    };\n  } else if (json !== undefined) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json,\n      text: undefined\n    };\n  }\n}\nfunction getLoadingNavigation(location, submission) {\n  if (submission) {\n    let navigation = {\n      state: \"loading\",\n      location,\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text\n    };\n    return navigation;\n  } else {\n    let navigation = {\n      state: \"loading\",\n      location,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined\n    };\n    return navigation;\n  }\n}\nfunction getSubmittingNavigation(location, submission) {\n  let navigation = {\n    state: \"submitting\",\n    location,\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text\n  };\n  return navigation;\n}\nfunction getLoadingFetcher(submission, data) {\n  if (submission) {\n    let fetcher = {\n      state: \"loading\",\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n      data\n    };\n    return fetcher;\n  } else {\n    let fetcher = {\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n      data\n    };\n    return fetcher;\n  }\n}\nfunction getSubmittingFetcher(submission, existingFetcher) {\n  let fetcher = {\n    state: \"submitting\",\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n    data: existingFetcher ? existingFetcher.data : undefined\n  };\n  return fetcher;\n}\nfunction getDoneFetcher(data) {\n  let fetcher = {\n    state: \"idle\",\n    formMethod: undefined,\n    formAction: undefined,\n    formEncType: undefined,\n    formData: undefined,\n    json: undefined,\n    text: undefined,\n    data\n  };\n  return fetcher;\n}\nfunction restoreAppliedTransitions(_window, transitions) {\n  try {\n    let sessionPositions = _window.sessionStorage.getItem(TRANSITIONS_STORAGE_KEY);\n    if (sessionPositions) {\n      let json = JSON.parse(sessionPositions);\n      for (let [k, v] of Object.entries(json || {})) {\n        if (v && Array.isArray(v)) {\n          transitions.set(k, new Set(v || []));\n        }\n      }\n    }\n  } catch (e) {\n    // no-op, use default empty object\n  }\n}\nfunction persistAppliedTransitions(_window, transitions) {\n  if (transitions.size > 0) {\n    let json = {};\n    for (let [k, v] of transitions) {\n      json[k] = [...v];\n    }\n    try {\n      _window.sessionStorage.setItem(TRANSITIONS_STORAGE_KEY, JSON.stringify(json));\n    } catch (error) {\n      warning(false, \"Failed to save applied view transitions in sessionStorage (\" + error + \").\");\n    }\n  }\n}\n//#endregion\n\nexport { AbortedDeferredError, Action, IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, UNSAFE_DEFERRED_SYMBOL, DeferredData as UNSAFE_DeferredData, ErrorResponseImpl as UNSAFE_ErrorResponseImpl, convertRouteMatchToUiMatch as UNSAFE_convertRouteMatchToUiMatch, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, decodePath as UNSAFE_decodePath, getResolveToMatches as UNSAFE_getResolveToMatches, invariant as UNSAFE_invariant, warning as UNSAFE_warning, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, createRouter, createStaticHandler, defer, generatePath, getStaticContextFromError, getToPathname, isDataWithResponseInit, isDeferredData, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, parsePath, redirect, redirectDocument, replace, resolvePath, resolveTo, stripBasename, data as unstable_data };\n//# sourceMappingURL=router.js.map\n","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\n/**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n *  Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\nfunction throttle(func, wait, options) {\n  var leading = true,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  if (isObject(options)) {\n    leading = 'leading' in options ? !!options.leading : leading;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n  return debounce(func, wait, {\n    'leading': leading,\n    'maxWait': wait,\n    'trailing': trailing\n  });\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = throttle;\n","\"use strict\";\nvar __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _Iter_peek;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.TokenData = void 0;\nexports.parse = parse;\nexports.compile = compile;\nexports.match = match;\nexports.pathToRegexp = pathToRegexp;\nexports.stringify = stringify;\nconst DEFAULT_DELIMITER = \"/\";\nconst NOOP_VALUE = (value) => value;\nconst ID_START = /^[$_\\p{ID_Start}]$/u;\nconst ID_CONTINUE = /^[$\\u200c\\u200d\\p{ID_Continue}]$/u;\nconst DEBUG_URL = \"https://git.new/pathToRegexpError\";\nconst SIMPLE_TOKENS = {\n    // Groups.\n    \"{\": \"{\",\n    \"}\": \"}\",\n    // Reserved.\n    \"(\": \"(\",\n    \")\": \")\",\n    \"[\": \"[\",\n    \"]\": \"]\",\n    \"+\": \"+\",\n    \"?\": \"?\",\n    \"!\": \"!\",\n};\n/**\n * Escape text for stringify to path.\n */\nfunction escapeText(str) {\n    return str.replace(/[{}()\\[\\]+?!:*]/g, \"\\\\$&\");\n}\n/**\n * Escape a regular expression string.\n */\nfunction escape(str) {\n    return str.replace(/[.+*?^${}()[\\]|/\\\\]/g, \"\\\\$&\");\n}\n/**\n * Tokenize input string.\n */\nfunction* lexer(str) {\n    const chars = [...str];\n    let i = 0;\n    function name() {\n        let value = \"\";\n        if (ID_START.test(chars[++i])) {\n            value += chars[i];\n            while (ID_CONTINUE.test(chars[++i])) {\n                value += chars[i];\n            }\n        }\n        else if (chars[i] === '\"') {\n            let pos = i;\n            while (i < chars.length) {\n                if (chars[++i] === '\"') {\n                    i++;\n                    pos = 0;\n                    break;\n                }\n                if (chars[i] === \"\\\\\") {\n                    value += chars[++i];\n                }\n                else {\n                    value += chars[i];\n                }\n            }\n            if (pos) {\n                throw new TypeError(`Unterminated quote at ${pos}: ${DEBUG_URL}`);\n            }\n        }\n        if (!value) {\n            throw new TypeError(`Missing parameter name at ${i}: ${DEBUG_URL}`);\n        }\n        return value;\n    }\n    while (i < chars.length) {\n        const value = chars[i];\n        const type = SIMPLE_TOKENS[value];\n        if (type) {\n            yield { type, index: i++, value };\n        }\n        else if (value === \"\\\\\") {\n            yield { type: \"ESCAPED\", index: i++, value: chars[i++] };\n        }\n        else if (value === \":\") {\n            const value = name();\n            yield { type: \"PARAM\", index: i, value };\n        }\n        else if (value === \"*\") {\n            const value = name();\n            yield { type: \"WILDCARD\", index: i, value };\n        }\n        else {\n            yield { type: \"CHAR\", index: i, value: chars[i++] };\n        }\n    }\n    return { type: \"END\", index: i, value: \"\" };\n}\nclass Iter {\n    constructor(tokens) {\n        this.tokens = tokens;\n        _Iter_peek.set(this, void 0);\n    }\n    peek() {\n        if (!__classPrivateFieldGet(this, _Iter_peek, \"f\")) {\n            const next = this.tokens.next();\n            __classPrivateFieldSet(this, _Iter_peek, next.value, \"f\");\n        }\n        return __classPrivateFieldGet(this, _Iter_peek, \"f\");\n    }\n    tryConsume(type) {\n        const token = this.peek();\n        if (token.type !== type)\n            return;\n        __classPrivateFieldSet(this, _Iter_peek, undefined, \"f\"); // Reset after consumed.\n        return token.value;\n    }\n    consume(type) {\n        const value = this.tryConsume(type);\n        if (value !== undefined)\n            return value;\n        const { type: nextType, index } = this.peek();\n        throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}: ${DEBUG_URL}`);\n    }\n    text() {\n        let result = \"\";\n        let value;\n        while ((value = this.tryConsume(\"CHAR\") || this.tryConsume(\"ESCAPED\"))) {\n            result += value;\n        }\n        return result;\n    }\n}\n_Iter_peek = new WeakMap();\n/**\n * Tokenized path instance.\n */\nclass TokenData {\n    constructor(tokens) {\n        this.tokens = tokens;\n    }\n}\nexports.TokenData = TokenData;\n/**\n * Parse a string for the raw tokens.\n */\nfunction parse(str, options = {}) {\n    const { encodePath = NOOP_VALUE } = options;\n    const it = new Iter(lexer(str));\n    function consume(endType) {\n        const tokens = [];\n        while (true) {\n            const path = it.text();\n            if (path)\n                tokens.push({ type: \"text\", value: encodePath(path) });\n            const param = it.tryConsume(\"PARAM\");\n            if (param) {\n                tokens.push({\n                    type: \"param\",\n                    name: param,\n                });\n                continue;\n            }\n            const wildcard = it.tryConsume(\"WILDCARD\");\n            if (wildcard) {\n                tokens.push({\n                    type: \"wildcard\",\n                    name: wildcard,\n                });\n                continue;\n            }\n            const open = it.tryConsume(\"{\");\n            if (open) {\n                tokens.push({\n                    type: \"group\",\n                    tokens: consume(\"}\"),\n                });\n                continue;\n            }\n            it.consume(endType);\n            return tokens;\n        }\n    }\n    const tokens = consume(\"END\");\n    return new TokenData(tokens);\n}\n/**\n * Compile a string to a template function for the path.\n */\nfunction compile(path, options = {}) {\n    const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;\n    const data = path instanceof TokenData ? path : parse(path, options);\n    const fn = tokensToFunction(data.tokens, delimiter, encode);\n    return function path(data = {}) {\n        const [path, ...missing] = fn(data);\n        if (missing.length) {\n            throw new TypeError(`Missing parameters: ${missing.join(\", \")}`);\n        }\n        return path;\n    };\n}\nfunction tokensToFunction(tokens, delimiter, encode) {\n    const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode));\n    return (data) => {\n        const result = [\"\"];\n        for (const encoder of encoders) {\n            const [value, ...extras] = encoder(data);\n            result[0] += value;\n            result.push(...extras);\n        }\n        return result;\n    };\n}\n/**\n * Convert a single token into a path building function.\n */\nfunction tokenToFunction(token, delimiter, encode) {\n    if (token.type === \"text\")\n        return () => [token.value];\n    if (token.type === \"group\") {\n        const fn = tokensToFunction(token.tokens, delimiter, encode);\n        return (data) => {\n            const [value, ...missing] = fn(data);\n            if (!missing.length)\n                return [value];\n            return [\"\"];\n        };\n    }\n    const encodeValue = encode || NOOP_VALUE;\n    if (token.type === \"wildcard\" && encode !== false) {\n        return (data) => {\n            const value = data[token.name];\n            if (value == null)\n                return [\"\", token.name];\n            if (!Array.isArray(value) || value.length === 0) {\n                throw new TypeError(`Expected \"${token.name}\" to be a non-empty array`);\n            }\n            return [\n                value\n                    .map((value, index) => {\n                    if (typeof value !== \"string\") {\n                        throw new TypeError(`Expected \"${token.name}/${index}\" to be a string`);\n                    }\n                    return encodeValue(value);\n                })\n                    .join(delimiter),\n            ];\n        };\n    }\n    return (data) => {\n        const value = data[token.name];\n        if (value == null)\n            return [\"\", token.name];\n        if (typeof value !== \"string\") {\n            throw new TypeError(`Expected \"${token.name}\" to be a string`);\n        }\n        return [encodeValue(value)];\n    };\n}\n/**\n * Transform a path into a match function.\n */\nfunction match(path, options = {}) {\n    const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;\n    const { regexp, keys } = pathToRegexp(path, options);\n    const decoders = keys.map((key) => {\n        if (decode === false)\n            return NOOP_VALUE;\n        if (key.type === \"param\")\n            return decode;\n        return (value) => value.split(delimiter).map(decode);\n    });\n    return function match(input) {\n        const m = regexp.exec(input);\n        if (!m)\n            return false;\n        const path = m[0];\n        const params = Object.create(null);\n        for (let i = 1; i < m.length; i++) {\n            if (m[i] === undefined)\n                continue;\n            const key = keys[i - 1];\n            const decoder = decoders[i - 1];\n            params[key.name] = decoder(m[i]);\n        }\n        return { path, params };\n    };\n}\nfunction pathToRegexp(path, options = {}) {\n    const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true, } = options;\n    const keys = [];\n    const sources = [];\n    const flags = sensitive ? \"s\" : \"is\";\n    const paths = Array.isArray(path) ? path : [path];\n    const items = paths.map((path) => path instanceof TokenData ? path : parse(path, options));\n    for (const { tokens } of items) {\n        for (const seq of flatten(tokens, 0, [])) {\n            const regexp = sequenceToRegExp(seq, delimiter, keys);\n            sources.push(regexp);\n        }\n    }\n    let pattern = `^(?:${sources.join(\"|\")})`;\n    if (trailing)\n        pattern += `(?:${escape(delimiter)}$)?`;\n    pattern += end ? \"$\" : `(?=${escape(delimiter)}|$)`;\n    const regexp = new RegExp(pattern, flags);\n    return { regexp, keys };\n}\n/**\n * Generate a flat list of sequence tokens from the given tokens.\n */\nfunction* flatten(tokens, index, init) {\n    if (index === tokens.length) {\n        return yield init;\n    }\n    const token = tokens[index];\n    if (token.type === \"group\") {\n        const fork = init.slice();\n        for (const seq of flatten(token.tokens, 0, fork)) {\n            yield* flatten(tokens, index + 1, seq);\n        }\n    }\n    else {\n        init.push(token);\n    }\n    yield* flatten(tokens, index + 1, init);\n}\n/**\n * Transform a flat sequence of tokens into a regular expression.\n */\nfunction sequenceToRegExp(tokens, delimiter, keys) {\n    let result = \"\";\n    let backtrack = \"\";\n    let isSafeSegmentParam = true;\n    for (let i = 0; i < tokens.length; i++) {\n        const token = tokens[i];\n        if (token.type === \"text\") {\n            result += escape(token.value);\n            backtrack = token.value;\n            isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter));\n            continue;\n        }\n        if (token.type === \"param\" || token.type === \"wildcard\") {\n            if (!isSafeSegmentParam && !backtrack) {\n                throw new TypeError(`Missing text after \"${token.name}\": ${DEBUG_URL}`);\n            }\n            if (token.type === \"param\") {\n                result += `(${negate(delimiter, isSafeSegmentParam ? \"\" : backtrack)}+)`;\n            }\n            else {\n                result += `(.+)`;\n            }\n            keys.push(token);\n            backtrack = \"\";\n            isSafeSegmentParam = false;\n            continue;\n        }\n    }\n    return result;\n}\nfunction negate(delimiter, backtrack) {\n    const values = [delimiter, backtrack].filter(Boolean);\n    const isSimple = values.every((value) => value.length === 1);\n    if (isSimple)\n        return `[^${escape(values.join(\"\"))}]`;\n    return `(?:(?!${values.map(escape).join(\"|\")}).)`;\n}\n/**\n * Stringify token data into a path string.\n */\nfunction stringify(data) {\n    return data.tokens\n        .map(function stringifyToken(token, index, tokens) {\n        if (token.type === \"text\")\n            return escapeText(token.value);\n        if (token.type === \"group\") {\n            return `{${token.tokens.map(stringifyToken).join(\"\")}}`;\n        }\n        const isSafe = isNameSafe(token.name) && isNextNameSafe(tokens[index + 1]);\n        const key = isSafe ? token.name : JSON.stringify(token.name);\n        if (token.type === \"param\")\n            return `:${key}`;\n        if (token.type === \"wildcard\")\n            return `*${key}`;\n        throw new TypeError(`Unexpected token: ${token}`);\n    })\n        .join(\"\");\n}\nfunction isNameSafe(name) {\n    const [first, ...rest] = name;\n    if (!ID_START.test(first))\n        return false;\n    return rest.every((char) => ID_CONTINUE.test(char));\n}\nfunction isNextNameSafe(token) {\n    if (token?.type !== \"text\")\n        return true;\n    return !ID_CONTINUE.test(token.value[0]);\n}\n//# sourceMappingURL=index.js.map","/**\n * React Router DOM v6.26.0\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { UNSAFE_mapRouteProperties, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, Router, UNSAFE_useRoutesImpl, UNSAFE_NavigationContext, useHref, useResolvedPath, useLocation, useNavigate, createPath, UNSAFE_useRouteId, UNSAFE_RouteContext, useMatches, useNavigation, useBlocker } from 'react-router';\nexport { AbortedDeferredError, Await, MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, Routes, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RouteContext, UNSAFE_useRouteId, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromElements, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, replace, resolvePath, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes } from 'react-router';\nimport { stripBasename, UNSAFE_warning, createRouter, createBrowserHistory, createHashHistory, UNSAFE_ErrorResponseImpl, UNSAFE_invariant, joinPaths, IDLE_FETCHER, matchPath } from '@remix-run/router';\nexport { UNSAFE_ErrorResponseImpl } from '@remix-run/router';\n\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}\n\nconst defaultMethod = \"get\";\nconst defaultEncType = \"application/x-www-form-urlencoded\";\nfunction isHtmlElement(object) {\n  return object != null && typeof object.tagName === \"string\";\n}\nfunction isButtonElement(object) {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"button\";\n}\nfunction isFormElement(object) {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"form\";\n}\nfunction isInputElement(object) {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"input\";\n}\nfunction isModifiedEvent(event) {\n  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\nfunction shouldProcessLinkClick(event, target) {\n  return event.button === 0 && (\n  // Ignore everything but left clicks\n  !target || target === \"_self\") &&\n  // Let browser handle \"target=_blank\" etc.\n  !isModifiedEvent(event) // Ignore clicks with modifier keys\n  ;\n}\n/**\n * Creates a URLSearchParams object using the given initializer.\n *\n * This is identical to `new URLSearchParams(init)` except it also\n * supports arrays as values in the object form of the initializer\n * instead of just strings. This is convenient when you need multiple\n * values for a given key, but don't want to use an array initializer.\n *\n * For example, instead of:\n *\n *   let searchParams = new URLSearchParams([\n *     ['sort', 'name'],\n *     ['sort', 'price']\n *   ]);\n *\n * you can do:\n *\n *   let searchParams = createSearchParams({\n *     sort: ['name', 'price']\n *   });\n */\nfunction createSearchParams(init) {\n  if (init === void 0) {\n    init = \"\";\n  }\n  return new URLSearchParams(typeof init === \"string\" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => {\n    let value = init[key];\n    return memo.concat(Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]);\n  }, []));\n}\nfunction getSearchParamsForLocation(locationSearch, defaultSearchParams) {\n  let searchParams = createSearchParams(locationSearch);\n  if (defaultSearchParams) {\n    // Use `defaultSearchParams.forEach(...)` here instead of iterating of\n    // `defaultSearchParams.keys()` to work-around a bug in Firefox related to\n    // web extensions. Relevant Bugzilla tickets:\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1414602\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1023984\n    defaultSearchParams.forEach((_, key) => {\n      if (!searchParams.has(key)) {\n        defaultSearchParams.getAll(key).forEach(value => {\n          searchParams.append(key, value);\n        });\n      }\n    });\n  }\n  return searchParams;\n}\n// One-time check for submitter support\nlet _formDataSupportsSubmitter = null;\nfunction isFormDataSubmitterSupported() {\n  if (_formDataSupportsSubmitter === null) {\n    try {\n      new FormData(document.createElement(\"form\"),\n      // @ts-expect-error if FormData supports the submitter parameter, this will throw\n      0);\n      _formDataSupportsSubmitter = false;\n    } catch (e) {\n      _formDataSupportsSubmitter = true;\n    }\n  }\n  return _formDataSupportsSubmitter;\n}\nconst supportedFormEncTypes = new Set([\"application/x-www-form-urlencoded\", \"multipart/form-data\", \"text/plain\"]);\nfunction getFormEncType(encType) {\n  if (encType != null && !supportedFormEncTypes.has(encType)) {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"\\\"\" + encType + \"\\\" is not a valid `encType` for `<Form>`/`<fetcher.Form>` \" + (\"and will default to \\\"\" + defaultEncType + \"\\\"\")) : void 0;\n    return null;\n  }\n  return encType;\n}\nfunction getFormSubmissionInfo(target, basename) {\n  let method;\n  let action;\n  let encType;\n  let formData;\n  let body;\n  if (isFormElement(target)) {\n    // When grabbing the action from the element, it will have had the basename\n    // prefixed to ensure non-JS scenarios work, so strip it since we'll\n    // re-prefix in the router\n    let attr = target.getAttribute(\"action\");\n    action = attr ? stripBasename(attr, basename) : null;\n    method = target.getAttribute(\"method\") || defaultMethod;\n    encType = getFormEncType(target.getAttribute(\"enctype\")) || defaultEncType;\n    formData = new FormData(target);\n  } else if (isButtonElement(target) || isInputElement(target) && (target.type === \"submit\" || target.type === \"image\")) {\n    let form = target.form;\n    if (form == null) {\n      throw new Error(\"Cannot submit a <button> or <input type=\\\"submit\\\"> without a <form>\");\n    }\n    // <button>/<input type=\"submit\"> may override attributes of <form>\n    // When grabbing the action from the element, it will have had the basename\n    // prefixed to ensure non-JS scenarios work, so strip it since we'll\n    // re-prefix in the router\n    let attr = target.getAttribute(\"formaction\") || form.getAttribute(\"action\");\n    action = attr ? stripBasename(attr, basename) : null;\n    method = target.getAttribute(\"formmethod\") || form.getAttribute(\"method\") || defaultMethod;\n    encType = getFormEncType(target.getAttribute(\"formenctype\")) || getFormEncType(form.getAttribute(\"enctype\")) || defaultEncType;\n    // Build a FormData object populated from a form and submitter\n    formData = new FormData(form, target);\n    // If this browser doesn't support the `FormData(el, submitter)` format,\n    // then tack on the submitter value at the end.  This is a lightweight\n    // solution that is not 100% spec compliant.  For complete support in older\n    // browsers, consider using the `formdata-submitter-polyfill` package\n    if (!isFormDataSubmitterSupported()) {\n      let {\n        name,\n        type,\n        value\n      } = target;\n      if (type === \"image\") {\n        let prefix = name ? name + \".\" : \"\";\n        formData.append(prefix + \"x\", \"0\");\n        formData.append(prefix + \"y\", \"0\");\n      } else if (name) {\n        formData.append(name, value);\n      }\n    }\n  } else if (isHtmlElement(target)) {\n    throw new Error(\"Cannot submit element that is not <form>, <button>, or \" + \"<input type=\\\"submit|image\\\">\");\n  } else {\n    method = defaultMethod;\n    action = null;\n    encType = defaultEncType;\n    body = target;\n  }\n  // Send body for <Form encType=\"text/plain\" so we encode it into text\n  if (formData && encType === \"text/plain\") {\n    body = formData;\n    formData = undefined;\n  }\n  return {\n    action,\n    method: method.toLowerCase(),\n    encType,\n    formData,\n    body\n  };\n}\n\nconst _excluded = [\"onClick\", \"relative\", \"reloadDocument\", \"replace\", \"state\", \"target\", \"to\", \"preventScrollReset\", \"unstable_viewTransition\"],\n  _excluded2 = [\"aria-current\", \"caseSensitive\", \"className\", \"end\", \"style\", \"to\", \"unstable_viewTransition\", \"children\"],\n  _excluded3 = [\"fetcherKey\", \"navigate\", \"reloadDocument\", \"replace\", \"state\", \"method\", \"action\", \"onSubmit\", \"relative\", \"preventScrollReset\", \"unstable_viewTransition\"];\n// HEY YOU! DON'T TOUCH THIS VARIABLE!\n//\n// It is replaced with the proper version at build time via a babel plugin in\n// the rollup config.\n//\n// Export a global property onto the window for React Router detection by the\n// Core Web Vitals Technology Report.  This way they can configure the `wappalyzer`\n// to detect and properly classify live websites as being built with React Router:\n// https://github.com/HTTPArchive/wappalyzer/blob/main/src/technologies/r.json\nconst REACT_ROUTER_VERSION = \"6\";\ntry {\n  window.__reactRouterVersion = REACT_ROUTER_VERSION;\n} catch (e) {\n  // no-op\n}\nfunction createBrowserRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    future: _extends({}, opts == null ? void 0 : opts.future, {\n      v7_prependBasename: true\n    }),\n    history: createBrowserHistory({\n      window: opts == null ? void 0 : opts.window\n    }),\n    hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(),\n    routes,\n    mapRouteProperties: UNSAFE_mapRouteProperties,\n    unstable_dataStrategy: opts == null ? void 0 : opts.unstable_dataStrategy,\n    unstable_patchRoutesOnMiss: opts == null ? void 0 : opts.unstable_patchRoutesOnMiss,\n    window: opts == null ? void 0 : opts.window\n  }).initialize();\n}\nfunction createHashRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    future: _extends({}, opts == null ? void 0 : opts.future, {\n      v7_prependBasename: true\n    }),\n    history: createHashHistory({\n      window: opts == null ? void 0 : opts.window\n    }),\n    hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(),\n    routes,\n    mapRouteProperties: UNSAFE_mapRouteProperties,\n    unstable_dataStrategy: opts == null ? void 0 : opts.unstable_dataStrategy,\n    unstable_patchRoutesOnMiss: opts == null ? void 0 : opts.unstable_patchRoutesOnMiss,\n    window: opts == null ? void 0 : opts.window\n  }).initialize();\n}\nfunction parseHydrationData() {\n  var _window;\n  let state = (_window = window) == null ? void 0 : _window.__staticRouterHydrationData;\n  if (state && state.errors) {\n    state = _extends({}, state, {\n      errors: deserializeErrors(state.errors)\n    });\n  }\n  return state;\n}\nfunction deserializeErrors(errors) {\n  if (!errors) return null;\n  let entries = Object.entries(errors);\n  let serialized = {};\n  for (let [key, val] of entries) {\n    // Hey you!  If you change this, please change the corresponding logic in\n    // serializeErrors in react-router-dom/server.tsx :)\n    if (val && val.__type === \"RouteErrorResponse\") {\n      serialized[key] = new UNSAFE_ErrorResponseImpl(val.status, val.statusText, val.data, val.internal === true);\n    } else if (val && val.__type === \"Error\") {\n      // Attempt to reconstruct the right type of Error (i.e., ReferenceError)\n      if (val.__subType) {\n        let ErrorConstructor = window[val.__subType];\n        if (typeof ErrorConstructor === \"function\") {\n          try {\n            // @ts-expect-error\n            let error = new ErrorConstructor(val.message);\n            // Wipe away the client-side stack trace.  Nothing to fill it in with\n            // because we don't serialize SSR stack traces for security reasons\n            error.stack = \"\";\n            serialized[key] = error;\n          } catch (e) {\n            // no-op - fall through and create a normal Error\n          }\n        }\n      }\n      if (serialized[key] == null) {\n        let error = new Error(val.message);\n        // Wipe away the client-side stack trace.  Nothing to fill it in with\n        // because we don't serialize SSR stack traces for security reasons\n        error.stack = \"\";\n        serialized[key] = error;\n      }\n    } else {\n      serialized[key] = val;\n    }\n  }\n  return serialized;\n}\nconst ViewTransitionContext = /*#__PURE__*/React.createContext({\n  isTransitioning: false\n});\nif (process.env.NODE_ENV !== \"production\") {\n  ViewTransitionContext.displayName = \"ViewTransition\";\n}\nconst FetchersContext = /*#__PURE__*/React.createContext(new Map());\nif (process.env.NODE_ENV !== \"production\") {\n  FetchersContext.displayName = \"Fetchers\";\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Components\n////////////////////////////////////////////////////////////////////////////////\n/**\n  Webpack + React 17 fails to compile on any of the following because webpack\n  complains that `startTransition` doesn't exist in `React`:\n  * import { startTransition } from \"react\"\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n  Moving it to a constant such as the following solves the Webpack/React 17 issue:\n  * import * as React from from \"react\";\n    const START_TRANSITION = \"startTransition\";\n    START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n  However, that introduces webpack/terser minification issues in production builds\n  in React 18 where minification/obfuscation ends up removing the call of\n  React.startTransition entirely from the first half of the ternary.  Grabbing\n  this exported reference once up front resolves that issue.\n\n  See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\nconst FLUSH_SYNC = \"flushSync\";\nconst flushSyncImpl = ReactDOM[FLUSH_SYNC];\nconst USE_ID = \"useId\";\nconst useIdImpl = React[USE_ID];\nfunction startTransitionSafe(cb) {\n  if (startTransitionImpl) {\n    startTransitionImpl(cb);\n  } else {\n    cb();\n  }\n}\nfunction flushSyncSafe(cb) {\n  if (flushSyncImpl) {\n    flushSyncImpl(cb);\n  } else {\n    cb();\n  }\n}\nclass Deferred {\n  constructor() {\n    this.status = \"pending\";\n    this.promise = new Promise((resolve, reject) => {\n      this.resolve = value => {\n        if (this.status === \"pending\") {\n          this.status = \"resolved\";\n          resolve(value);\n        }\n      };\n      this.reject = reason => {\n        if (this.status === \"pending\") {\n          this.status = \"rejected\";\n          reject(reason);\n        }\n      };\n    });\n  }\n}\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nfunction RouterProvider(_ref) {\n  let {\n    fallbackElement,\n    router,\n    future\n  } = _ref;\n  let [state, setStateImpl] = React.useState(router.state);\n  let [pendingState, setPendingState] = React.useState();\n  let [vtContext, setVtContext] = React.useState({\n    isTransitioning: false\n  });\n  let [renderDfd, setRenderDfd] = React.useState();\n  let [transition, setTransition] = React.useState();\n  let [interruption, setInterruption] = React.useState();\n  let fetcherData = React.useRef(new Map());\n  let {\n    v7_startTransition\n  } = future || {};\n  let optInStartTransition = React.useCallback(cb => {\n    if (v7_startTransition) {\n      startTransitionSafe(cb);\n    } else {\n      cb();\n    }\n  }, [v7_startTransition]);\n  let setState = React.useCallback((newState, _ref2) => {\n    let {\n      deletedFetchers,\n      unstable_flushSync: flushSync,\n      unstable_viewTransitionOpts: viewTransitionOpts\n    } = _ref2;\n    deletedFetchers.forEach(key => fetcherData.current.delete(key));\n    newState.fetchers.forEach((fetcher, key) => {\n      if (fetcher.data !== undefined) {\n        fetcherData.current.set(key, fetcher.data);\n      }\n    });\n    let isViewTransitionUnavailable = router.window == null || router.window.document == null || typeof router.window.document.startViewTransition !== \"function\";\n    // If this isn't a view transition or it's not available in this browser,\n    // just update and be done with it\n    if (!viewTransitionOpts || isViewTransitionUnavailable) {\n      if (flushSync) {\n        flushSyncSafe(() => setStateImpl(newState));\n      } else {\n        optInStartTransition(() => setStateImpl(newState));\n      }\n      return;\n    }\n    // flushSync + startViewTransition\n    if (flushSync) {\n      // Flush through the context to mark DOM elements as transition=ing\n      flushSyncSafe(() => {\n        // Cancel any pending transitions\n        if (transition) {\n          renderDfd && renderDfd.resolve();\n          transition.skipTransition();\n        }\n        setVtContext({\n          isTransitioning: true,\n          flushSync: true,\n          currentLocation: viewTransitionOpts.currentLocation,\n          nextLocation: viewTransitionOpts.nextLocation\n        });\n      });\n      // Update the DOM\n      let t = router.window.document.startViewTransition(() => {\n        flushSyncSafe(() => setStateImpl(newState));\n      });\n      // Clean up after the animation completes\n      t.finished.finally(() => {\n        flushSyncSafe(() => {\n          setRenderDfd(undefined);\n          setTransition(undefined);\n          setPendingState(undefined);\n          setVtContext({\n            isTransitioning: false\n          });\n        });\n      });\n      flushSyncSafe(() => setTransition(t));\n      return;\n    }\n    // startTransition + startViewTransition\n    if (transition) {\n      // Interrupting an in-progress transition, cancel and let everything flush\n      // out, and then kick off a new transition from the interruption state\n      renderDfd && renderDfd.resolve();\n      transition.skipTransition();\n      setInterruption({\n        state: newState,\n        currentLocation: viewTransitionOpts.currentLocation,\n        nextLocation: viewTransitionOpts.nextLocation\n      });\n    } else {\n      // Completed navigation update with opted-in view transitions, let 'er rip\n      setPendingState(newState);\n      setVtContext({\n        isTransitioning: true,\n        flushSync: false,\n        currentLocation: viewTransitionOpts.currentLocation,\n        nextLocation: viewTransitionOpts.nextLocation\n      });\n    }\n  }, [router.window, transition, renderDfd, fetcherData, optInStartTransition]);\n  // Need to use a layout effect here so we are subscribed early enough to\n  // pick up on any render-driven redirects/navigations (useEffect/<Navigate>)\n  React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);\n  // When we start a view transition, create a Deferred we can use for the\n  // eventual \"completed\" render\n  React.useEffect(() => {\n    if (vtContext.isTransitioning && !vtContext.flushSync) {\n      setRenderDfd(new Deferred());\n    }\n  }, [vtContext]);\n  // Once the deferred is created, kick off startViewTransition() to update the\n  // DOM and then wait on the Deferred to resolve (indicating the DOM update has\n  // happened)\n  React.useEffect(() => {\n    if (renderDfd && pendingState && router.window) {\n      let newState = pendingState;\n      let renderPromise = renderDfd.promise;\n      let transition = router.window.document.startViewTransition(async () => {\n        optInStartTransition(() => setStateImpl(newState));\n        await renderPromise;\n      });\n      transition.finished.finally(() => {\n        setRenderDfd(undefined);\n        setTransition(undefined);\n        setPendingState(undefined);\n        setVtContext({\n          isTransitioning: false\n        });\n      });\n      setTransition(transition);\n    }\n  }, [optInStartTransition, pendingState, renderDfd, router.window]);\n  // When the new location finally renders and is committed to the DOM, this\n  // effect will run to resolve the transition\n  React.useEffect(() => {\n    if (renderDfd && pendingState && state.location.key === pendingState.location.key) {\n      renderDfd.resolve();\n    }\n  }, [renderDfd, transition, state.location, pendingState]);\n  // If we get interrupted with a new navigation during a transition, we skip\n  // the active transition, let it cleanup, then kick it off again here\n  React.useEffect(() => {\n    if (!vtContext.isTransitioning && interruption) {\n      setPendingState(interruption.state);\n      setVtContext({\n        isTransitioning: true,\n        flushSync: false,\n        currentLocation: interruption.currentLocation,\n        nextLocation: interruption.nextLocation\n      });\n      setInterruption(undefined);\n    }\n  }, [vtContext.isTransitioning, interruption]);\n  React.useEffect(() => {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(fallbackElement == null || !router.future.v7_partialHydration, \"`<RouterProvider fallbackElement>` is deprecated when using \" + \"`v7_partialHydration`, use a `HydrateFallback` component instead\") : void 0;\n    // Only log this once on initial mount\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n  let navigator = React.useMemo(() => {\n    return {\n      createHref: router.createHref,\n      encodeLocation: router.encodeLocation,\n      go: n => router.navigate(n),\n      push: (to, state, opts) => router.navigate(to, {\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      }),\n      replace: (to, state, opts) => router.navigate(to, {\n        replace: true,\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      })\n    };\n  }, [router]);\n  let basename = router.basename || \"/\";\n  let dataRouterContext = React.useMemo(() => ({\n    router,\n    navigator,\n    static: false,\n    basename\n  }), [router, navigator, basename]);\n  let routerFuture = React.useMemo(() => ({\n    v7_relativeSplatPath: router.future.v7_relativeSplatPath\n  }), [router.future.v7_relativeSplatPath]);\n  // The fragment and {null} here are important!  We need them to keep React 18's\n  // useId happy when we are server-rendering since we may have a <script> here\n  // containing the hydrated server-side staticContext (from StaticRouterProvider).\n  // useId relies on the component tree structure to generate deterministic id's\n  // so we need to ensure it remains the same on the client even though\n  // we don't need the <script> tag\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(UNSAFE_DataRouterContext.Provider, {\n    value: dataRouterContext\n  }, /*#__PURE__*/React.createElement(UNSAFE_DataRouterStateContext.Provider, {\n    value: state\n  }, /*#__PURE__*/React.createElement(FetchersContext.Provider, {\n    value: fetcherData.current\n  }, /*#__PURE__*/React.createElement(ViewTransitionContext.Provider, {\n    value: vtContext\n  }, /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    location: state.location,\n    navigationType: state.historyAction,\n    navigator: navigator,\n    future: routerFuture\n  }, state.initialized || router.future.v7_partialHydration ? /*#__PURE__*/React.createElement(MemoizedDataRoutes, {\n    routes: router.routes,\n    future: router.future,\n    state: state\n  }) : fallbackElement))))), null);\n}\n// Memoize to avoid re-renders when updating `ViewTransitionContext`\nconst MemoizedDataRoutes = /*#__PURE__*/React.memo(DataRoutes);\nfunction DataRoutes(_ref3) {\n  let {\n    routes,\n    future,\n    state\n  } = _ref3;\n  return UNSAFE_useRoutesImpl(routes, undefined, state, future);\n}\n/**\n * A `<Router>` for use in web browsers. Provides the cleanest URLs.\n */\nfunction BrowserRouter(_ref4) {\n  let {\n    basename,\n    children,\n    future,\n    window\n  } = _ref4;\n  let historyRef = React.useRef();\n  if (historyRef.current == null) {\n    historyRef.current = createBrowserHistory({\n      window,\n      v5Compat: true\n    });\n  }\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history,\n    future: future\n  });\n}\n/**\n * A `<Router>` for use in web browsers. Stores the location in the hash\n * portion of the URL so it is not sent to the server.\n */\nfunction HashRouter(_ref5) {\n  let {\n    basename,\n    children,\n    future,\n    window\n  } = _ref5;\n  let historyRef = React.useRef();\n  if (historyRef.current == null) {\n    historyRef.current = createHashHistory({\n      window,\n      v5Compat: true\n    });\n  }\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history,\n    future: future\n  });\n}\n/**\n * A `<Router>` that accepts a pre-instantiated history object. It's important\n * to note that using your own history object is highly discouraged and may add\n * two versions of the history library to your bundles unless you use the same\n * version of the history library that React Router uses internally.\n */\nfunction HistoryRouter(_ref6) {\n  let {\n    basename,\n    children,\n    future,\n    history\n  } = _ref6;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history,\n    future: future\n  });\n}\nif (process.env.NODE_ENV !== \"production\") {\n  HistoryRouter.displayName = \"unstable_HistoryRouter\";\n}\nconst isBrowser = typeof window !== \"undefined\" && typeof window.document !== \"undefined\" && typeof window.document.createElement !== \"undefined\";\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n/**\n * The public API for rendering a history-aware `<a>`.\n */\nconst Link = /*#__PURE__*/React.forwardRef(function LinkWithRef(_ref7, ref) {\n  let {\n      onClick,\n      relative,\n      reloadDocument,\n      replace,\n      state,\n      target,\n      to,\n      preventScrollReset,\n      unstable_viewTransition\n    } = _ref7,\n    rest = _objectWithoutPropertiesLoose(_ref7, _excluded);\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  // Rendered into <a href> for absolute URLs\n  let absoluteHref;\n  let isExternal = false;\n  if (typeof to === \"string\" && ABSOLUTE_URL_REGEX.test(to)) {\n    // Render the absolute href server- and client-side\n    absoluteHref = to;\n    // Only check for external origins client-side\n    if (isBrowser) {\n      try {\n        let currentUrl = new URL(window.location.href);\n        let targetUrl = to.startsWith(\"//\") ? new URL(currentUrl.protocol + to) : new URL(to);\n        let path = stripBasename(targetUrl.pathname, basename);\n        if (targetUrl.origin === currentUrl.origin && path != null) {\n          // Strip the protocol/origin/basename for same-origin absolute URLs\n          to = path + targetUrl.search + targetUrl.hash;\n        } else {\n          isExternal = true;\n        }\n      } catch (e) {\n        // We can't do external URL detection without a valid URL\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"<Link to=\\\"\" + to + \"\\\"> contains an invalid URL which will probably break \" + \"when clicked - please update to a valid URL path.\") : void 0;\n      }\n    }\n  }\n  // Rendered into <a href> for relative URLs\n  let href = useHref(to, {\n    relative\n  });\n  let internalOnClick = useLinkClickHandler(to, {\n    replace,\n    state,\n    target,\n    preventScrollReset,\n    relative,\n    unstable_viewTransition\n  });\n  function handleClick(event) {\n    if (onClick) onClick(event);\n    if (!event.defaultPrevented) {\n      internalOnClick(event);\n    }\n  }\n  return (\n    /*#__PURE__*/\n    // eslint-disable-next-line jsx-a11y/anchor-has-content\n    React.createElement(\"a\", _extends({}, rest, {\n      href: absoluteHref || href,\n      onClick: isExternal || reloadDocument ? onClick : handleClick,\n      ref: ref,\n      target: target\n    }))\n  );\n});\nif (process.env.NODE_ENV !== \"production\") {\n  Link.displayName = \"Link\";\n}\n/**\n * A `<Link>` wrapper that knows if it's \"active\" or not.\n */\nconst NavLink = /*#__PURE__*/React.forwardRef(function NavLinkWithRef(_ref8, ref) {\n  let {\n      \"aria-current\": ariaCurrentProp = \"page\",\n      caseSensitive = false,\n      className: classNameProp = \"\",\n      end = false,\n      style: styleProp,\n      to,\n      unstable_viewTransition,\n      children\n    } = _ref8,\n    rest = _objectWithoutPropertiesLoose(_ref8, _excluded2);\n  let path = useResolvedPath(to, {\n    relative: rest.relative\n  });\n  let location = useLocation();\n  let routerState = React.useContext(UNSAFE_DataRouterStateContext);\n  let {\n    navigator,\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  let isTransitioning = routerState != null &&\n  // Conditional usage is OK here because the usage of a data router is static\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  useViewTransitionState(path) && unstable_viewTransition === true;\n  let toPathname = navigator.encodeLocation ? navigator.encodeLocation(path).pathname : path.pathname;\n  let locationPathname = location.pathname;\n  let nextLocationPathname = routerState && routerState.navigation && routerState.navigation.location ? routerState.navigation.location.pathname : null;\n  if (!caseSensitive) {\n    locationPathname = locationPathname.toLowerCase();\n    nextLocationPathname = nextLocationPathname ? nextLocationPathname.toLowerCase() : null;\n    toPathname = toPathname.toLowerCase();\n  }\n  if (nextLocationPathname && basename) {\n    nextLocationPathname = stripBasename(nextLocationPathname, basename) || nextLocationPathname;\n  }\n  // If the `to` has a trailing slash, look at that exact spot.  Otherwise,\n  // we're looking for a slash _after_ what's in `to`.  For example:\n  //\n  // <NavLink to=\"/users\"> and <NavLink to=\"/users/\">\n  // both want to look for a / at index 6 to match URL `/users/matt`\n  const endSlashPosition = toPathname !== \"/\" && toPathname.endsWith(\"/\") ? toPathname.length - 1 : toPathname.length;\n  let isActive = locationPathname === toPathname || !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(endSlashPosition) === \"/\";\n  let isPending = nextLocationPathname != null && (nextLocationPathname === toPathname || !end && nextLocationPathname.startsWith(toPathname) && nextLocationPathname.charAt(toPathname.length) === \"/\");\n  let renderProps = {\n    isActive,\n    isPending,\n    isTransitioning\n  };\n  let ariaCurrent = isActive ? ariaCurrentProp : undefined;\n  let className;\n  if (typeof classNameProp === \"function\") {\n    className = classNameProp(renderProps);\n  } else {\n    // If the className prop is not a function, we use a default `active`\n    // class for <NavLink />s that are active. In v5 `active` was the default\n    // value for `activeClassName`, but we are removing that API and can still\n    // use the old default behavior for a cleaner upgrade path and keep the\n    // simple styling rules working as they currently do.\n    className = [classNameProp, isActive ? \"active\" : null, isPending ? \"pending\" : null, isTransitioning ? \"transitioning\" : null].filter(Boolean).join(\" \");\n  }\n  let style = typeof styleProp === \"function\" ? styleProp(renderProps) : styleProp;\n  return /*#__PURE__*/React.createElement(Link, _extends({}, rest, {\n    \"aria-current\": ariaCurrent,\n    className: className,\n    ref: ref,\n    style: style,\n    to: to,\n    unstable_viewTransition: unstable_viewTransition\n  }), typeof children === \"function\" ? children(renderProps) : children);\n});\nif (process.env.NODE_ENV !== \"production\") {\n  NavLink.displayName = \"NavLink\";\n}\n/**\n * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except\n * that the interaction with the server is with `fetch` instead of new document\n * requests, allowing components to add nicer UX to the page as the form is\n * submitted and returns with data.\n */\nconst Form = /*#__PURE__*/React.forwardRef((_ref9, forwardedRef) => {\n  let {\n      fetcherKey,\n      navigate,\n      reloadDocument,\n      replace,\n      state,\n      method = defaultMethod,\n      action,\n      onSubmit,\n      relative,\n      preventScrollReset,\n      unstable_viewTransition\n    } = _ref9,\n    props = _objectWithoutPropertiesLoose(_ref9, _excluded3);\n  let submit = useSubmit();\n  let formAction = useFormAction(action, {\n    relative\n  });\n  let formMethod = method.toLowerCase() === \"get\" ? \"get\" : \"post\";\n  let submitHandler = event => {\n    onSubmit && onSubmit(event);\n    if (event.defaultPrevented) return;\n    event.preventDefault();\n    let submitter = event.nativeEvent.submitter;\n    let submitMethod = (submitter == null ? void 0 : submitter.getAttribute(\"formmethod\")) || method;\n    submit(submitter || event.currentTarget, {\n      fetcherKey,\n      method: submitMethod,\n      navigate,\n      replace,\n      state,\n      relative,\n      preventScrollReset,\n      unstable_viewTransition\n    });\n  };\n  return /*#__PURE__*/React.createElement(\"form\", _extends({\n    ref: forwardedRef,\n    method: formMethod,\n    action: formAction,\n    onSubmit: reloadDocument ? onSubmit : submitHandler\n  }, props));\n});\nif (process.env.NODE_ENV !== \"production\") {\n  Form.displayName = \"Form\";\n}\n/**\n * This component will emulate the browser's scroll restoration on location\n * changes.\n */\nfunction ScrollRestoration(_ref10) {\n  let {\n    getKey,\n    storageKey\n  } = _ref10;\n  useScrollRestoration({\n    getKey,\n    storageKey\n  });\n  return null;\n}\nif (process.env.NODE_ENV !== \"production\") {\n  ScrollRestoration.displayName = \"ScrollRestoration\";\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Hooks\n////////////////////////////////////////////////////////////////////////////////\nvar DataRouterHook;\n(function (DataRouterHook) {\n  DataRouterHook[\"UseScrollRestoration\"] = \"useScrollRestoration\";\n  DataRouterHook[\"UseSubmit\"] = \"useSubmit\";\n  DataRouterHook[\"UseSubmitFetcher\"] = \"useSubmitFetcher\";\n  DataRouterHook[\"UseFetcher\"] = \"useFetcher\";\n  DataRouterHook[\"useViewTransitionState\"] = \"useViewTransitionState\";\n})(DataRouterHook || (DataRouterHook = {}));\nvar DataRouterStateHook;\n(function (DataRouterStateHook) {\n  DataRouterStateHook[\"UseFetcher\"] = \"useFetcher\";\n  DataRouterStateHook[\"UseFetchers\"] = \"useFetchers\";\n  DataRouterStateHook[\"UseScrollRestoration\"] = \"useScrollRestoration\";\n})(DataRouterStateHook || (DataRouterStateHook = {}));\n// Internal hooks\nfunction getDataRouterConsoleError(hookName) {\n  return hookName + \" must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.\";\n}\nfunction useDataRouterContext(hookName) {\n  let ctx = React.useContext(UNSAFE_DataRouterContext);\n  !ctx ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return ctx;\n}\nfunction useDataRouterState(hookName) {\n  let state = React.useContext(UNSAFE_DataRouterStateContext);\n  !state ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return state;\n}\n// External hooks\n/**\n * Handles the click behavior for router `<Link>` components. This is useful if\n * you need to create custom `<Link>` components with the same click behavior we\n * use in our exported `<Link>`.\n */\nfunction useLinkClickHandler(to, _temp) {\n  let {\n    target,\n    replace: replaceProp,\n    state,\n    preventScrollReset,\n    relative,\n    unstable_viewTransition\n  } = _temp === void 0 ? {} : _temp;\n  let navigate = useNavigate();\n  let location = useLocation();\n  let path = useResolvedPath(to, {\n    relative\n  });\n  return React.useCallback(event => {\n    if (shouldProcessLinkClick(event, target)) {\n      event.preventDefault();\n      // If the URL hasn't changed, a regular <a> will do a replace instead of\n      // a push, so do the same here unless the replace prop is explicitly set\n      let replace = replaceProp !== undefined ? replaceProp : createPath(location) === createPath(path);\n      navigate(to, {\n        replace,\n        state,\n        preventScrollReset,\n        relative,\n        unstable_viewTransition\n      });\n    }\n  }, [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative, unstable_viewTransition]);\n}\n/**\n * A convenient wrapper for reading and writing search parameters via the\n * URLSearchParams interface.\n */\nfunction useSearchParams(defaultInit) {\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(typeof URLSearchParams !== \"undefined\", \"You cannot use the `useSearchParams` hook in a browser that does not \" + \"support the URLSearchParams API. If you need to support Internet \" + \"Explorer 11, we recommend you load a polyfill such as \" + \"https://github.com/ungap/url-search-params.\") : void 0;\n  let defaultSearchParamsRef = React.useRef(createSearchParams(defaultInit));\n  let hasSetSearchParamsRef = React.useRef(false);\n  let location = useLocation();\n  let searchParams = React.useMemo(() =>\n  // Only merge in the defaults if we haven't yet called setSearchParams.\n  // Once we call that we want those to take precedence, otherwise you can't\n  // remove a param with setSearchParams({}) if it has an initial value\n  getSearchParamsForLocation(location.search, hasSetSearchParamsRef.current ? null : defaultSearchParamsRef.current), [location.search]);\n  let navigate = useNavigate();\n  let setSearchParams = React.useCallback((nextInit, navigateOptions) => {\n    const newSearchParams = createSearchParams(typeof nextInit === \"function\" ? nextInit(searchParams) : nextInit);\n    hasSetSearchParamsRef.current = true;\n    navigate(\"?\" + newSearchParams, navigateOptions);\n  }, [navigate, searchParams]);\n  return [searchParams, setSearchParams];\n}\nfunction validateClientSideSubmission() {\n  if (typeof document === \"undefined\") {\n    throw new Error(\"You are calling submit during the server render. \" + \"Try calling submit within a `useEffect` or callback instead.\");\n  }\n}\nlet fetcherId = 0;\nlet getUniqueFetcherId = () => \"__\" + String(++fetcherId) + \"__\";\n/**\n * Returns a function that may be used to programmatically submit a form (or\n * some arbitrary data) to the server.\n */\nfunction useSubmit() {\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseSubmit);\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  let currentRouteId = UNSAFE_useRouteId();\n  return React.useCallback(function (target, options) {\n    if (options === void 0) {\n      options = {};\n    }\n    validateClientSideSubmission();\n    let {\n      action,\n      method,\n      encType,\n      formData,\n      body\n    } = getFormSubmissionInfo(target, basename);\n    if (options.navigate === false) {\n      let key = options.fetcherKey || getUniqueFetcherId();\n      router.fetch(key, currentRouteId, options.action || action, {\n        preventScrollReset: options.preventScrollReset,\n        formData,\n        body,\n        formMethod: options.method || method,\n        formEncType: options.encType || encType,\n        unstable_flushSync: options.unstable_flushSync\n      });\n    } else {\n      router.navigate(options.action || action, {\n        preventScrollReset: options.preventScrollReset,\n        formData,\n        body,\n        formMethod: options.method || method,\n        formEncType: options.encType || encType,\n        replace: options.replace,\n        state: options.state,\n        fromRouteId: currentRouteId,\n        unstable_flushSync: options.unstable_flushSync,\n        unstable_viewTransition: options.unstable_viewTransition\n      });\n    }\n  }, [router, basename, currentRouteId]);\n}\n// v7: Eventually we should deprecate this entirely in favor of using the\n// router method directly?\nfunction useFormAction(action, _temp2) {\n  let {\n    relative\n  } = _temp2 === void 0 ? {} : _temp2;\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  let routeContext = React.useContext(UNSAFE_RouteContext);\n  !routeContext ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFormAction must be used inside a RouteContext\") : UNSAFE_invariant(false) : void 0;\n  let [match] = routeContext.matches.slice(-1);\n  // Shallow clone path so we can modify it below, otherwise we modify the\n  // object referenced by useMemo inside useResolvedPath\n  let path = _extends({}, useResolvedPath(action ? action : \".\", {\n    relative\n  }));\n  // If no action was specified, browsers will persist current search params\n  // when determining the path, so match that behavior\n  // https://github.com/remix-run/remix/issues/927\n  let location = useLocation();\n  if (action == null) {\n    // Safe to write to this directly here since if action was undefined, we\n    // would have called useResolvedPath(\".\") which will never include a search\n    path.search = location.search;\n    // When grabbing search params from the URL, remove any included ?index param\n    // since it might not apply to our contextual route.  We add it back based\n    // on match.route.index below\n    let params = new URLSearchParams(path.search);\n    if (params.has(\"index\") && params.get(\"index\") === \"\") {\n      params.delete(\"index\");\n      path.search = params.toString() ? \"?\" + params.toString() : \"\";\n    }\n  }\n  if ((!action || action === \".\") && match.route.index) {\n    path.search = path.search ? path.search.replace(/^\\?/, \"?index&\") : \"?index\";\n  }\n  // If we're operating within a basename, prepend it to the pathname prior\n  // to creating the form action.  If this is a root navigation, then just use\n  // the raw basename which allows the basename to have full control over the\n  // presence of a trailing slash on root actions\n  if (basename !== \"/\") {\n    path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n  return createPath(path);\n}\n// TODO: (v7) Change the useFetcher generic default from `any` to `unknown`\n/**\n * Interacts with route loaders and actions without causing a navigation. Great\n * for any interaction that stays on the same page.\n */\nfunction useFetcher(_temp3) {\n  var _route$matches;\n  let {\n    key\n  } = _temp3 === void 0 ? {} : _temp3;\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseFetcher);\n  let state = useDataRouterState(DataRouterStateHook.UseFetcher);\n  let fetcherData = React.useContext(FetchersContext);\n  let route = React.useContext(UNSAFE_RouteContext);\n  let routeId = (_route$matches = route.matches[route.matches.length - 1]) == null ? void 0 : _route$matches.route.id;\n  !fetcherData ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher must be used inside a FetchersContext\") : UNSAFE_invariant(false) : void 0;\n  !route ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher must be used inside a RouteContext\") : UNSAFE_invariant(false) : void 0;\n  !(routeId != null) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher can only be used on routes that contain a unique \\\"id\\\"\") : UNSAFE_invariant(false) : void 0;\n  // Fetcher key handling\n  // OK to call conditionally to feature detect `useId`\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  let defaultKey = useIdImpl ? useIdImpl() : \"\";\n  let [fetcherKey, setFetcherKey] = React.useState(key || defaultKey);\n  if (key && key !== fetcherKey) {\n    setFetcherKey(key);\n  } else if (!fetcherKey) {\n    // We will only fall through here when `useId` is not available\n    setFetcherKey(getUniqueFetcherId());\n  }\n  // Registration/cleanup\n  React.useEffect(() => {\n    router.getFetcher(fetcherKey);\n    return () => {\n      // Tell the router we've unmounted - if v7_fetcherPersist is enabled this\n      // will not delete immediately but instead queue up a delete after the\n      // fetcher returns to an `idle` state\n      router.deleteFetcher(fetcherKey);\n    };\n  }, [router, fetcherKey]);\n  // Fetcher additions\n  let load = React.useCallback((href, opts) => {\n    !routeId ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"No routeId available for fetcher.load()\") : UNSAFE_invariant(false) : void 0;\n    router.fetch(fetcherKey, routeId, href, opts);\n  }, [fetcherKey, routeId, router]);\n  let submitImpl = useSubmit();\n  let submit = React.useCallback((target, opts) => {\n    submitImpl(target, _extends({}, opts, {\n      navigate: false,\n      fetcherKey\n    }));\n  }, [fetcherKey, submitImpl]);\n  let FetcherForm = React.useMemo(() => {\n    let FetcherForm = /*#__PURE__*/React.forwardRef((props, ref) => {\n      return /*#__PURE__*/React.createElement(Form, _extends({}, props, {\n        navigate: false,\n        fetcherKey: fetcherKey,\n        ref: ref\n      }));\n    });\n    if (process.env.NODE_ENV !== \"production\") {\n      FetcherForm.displayName = \"fetcher.Form\";\n    }\n    return FetcherForm;\n  }, [fetcherKey]);\n  // Exposed FetcherWithComponents\n  let fetcher = state.fetchers.get(fetcherKey) || IDLE_FETCHER;\n  let data = fetcherData.get(fetcherKey);\n  let fetcherWithComponents = React.useMemo(() => _extends({\n    Form: FetcherForm,\n    submit,\n    load\n  }, fetcher, {\n    data\n  }), [FetcherForm, submit, load, fetcher, data]);\n  return fetcherWithComponents;\n}\n/**\n * Provides all fetchers currently on the page. Useful for layouts and parent\n * routes that need to provide pending/optimistic UI regarding the fetch.\n */\nfunction useFetchers() {\n  let state = useDataRouterState(DataRouterStateHook.UseFetchers);\n  return Array.from(state.fetchers.entries()).map(_ref11 => {\n    let [key, fetcher] = _ref11;\n    return _extends({}, fetcher, {\n      key\n    });\n  });\n}\nconst SCROLL_RESTORATION_STORAGE_KEY = \"react-router-scroll-positions\";\nlet savedScrollPositions = {};\n/**\n * When rendered inside a RouterProvider, will restore scroll positions on navigations\n */\nfunction useScrollRestoration(_temp4) {\n  let {\n    getKey,\n    storageKey\n  } = _temp4 === void 0 ? {} : _temp4;\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseScrollRestoration);\n  let {\n    restoreScrollPosition,\n    preventScrollReset\n  } = useDataRouterState(DataRouterStateHook.UseScrollRestoration);\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  let location = useLocation();\n  let matches = useMatches();\n  let navigation = useNavigation();\n  // Trigger manual scroll restoration while we're active\n  React.useEffect(() => {\n    window.history.scrollRestoration = \"manual\";\n    return () => {\n      window.history.scrollRestoration = \"auto\";\n    };\n  }, []);\n  // Save positions on pagehide\n  usePageHide(React.useCallback(() => {\n    if (navigation.state === \"idle\") {\n      let key = (getKey ? getKey(location, matches) : null) || location.key;\n      savedScrollPositions[key] = window.scrollY;\n    }\n    try {\n      sessionStorage.setItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY, JSON.stringify(savedScrollPositions));\n    } catch (error) {\n      process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"Failed to save scroll positions in sessionStorage, <ScrollRestoration /> will not work properly (\" + error + \").\") : void 0;\n    }\n    window.history.scrollRestoration = \"auto\";\n  }, [storageKey, getKey, navigation.state, location, matches]));\n  // Read in any saved scroll locations\n  if (typeof document !== \"undefined\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      try {\n        let sessionPositions = sessionStorage.getItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY);\n        if (sessionPositions) {\n          savedScrollPositions = JSON.parse(sessionPositions);\n        }\n      } catch (e) {\n        // no-op, use default empty object\n      }\n    }, [storageKey]);\n    // Enable scroll restoration in the router\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      let getKeyWithoutBasename = getKey && basename !== \"/\" ? (location, matches) => getKey( // Strip the basename to match useLocation()\n      _extends({}, location, {\n        pathname: stripBasename(location.pathname, basename) || location.pathname\n      }), matches) : getKey;\n      let disableScrollRestoration = router == null ? void 0 : router.enableScrollRestoration(savedScrollPositions, () => window.scrollY, getKeyWithoutBasename);\n      return () => disableScrollRestoration && disableScrollRestoration();\n    }, [router, basename, getKey]);\n    // Restore scrolling when state.restoreScrollPosition changes\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      // Explicit false means don't do anything (used for submissions)\n      if (restoreScrollPosition === false) {\n        return;\n      }\n      // been here before, scroll to it\n      if (typeof restoreScrollPosition === \"number\") {\n        window.scrollTo(0, restoreScrollPosition);\n        return;\n      }\n      // try to scroll to the hash\n      if (location.hash) {\n        let el = document.getElementById(decodeURIComponent(location.hash.slice(1)));\n        if (el) {\n          el.scrollIntoView();\n          return;\n        }\n      }\n      // Don't reset if this navigation opted out\n      if (preventScrollReset === true) {\n        return;\n      }\n      // otherwise go to the top on new locations\n      window.scrollTo(0, 0);\n    }, [location, restoreScrollPosition, preventScrollReset]);\n  }\n}\n/**\n * Setup a callback to be fired on the window's `beforeunload` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\nfunction useBeforeUnload(callback, options) {\n  let {\n    capture\n  } = options || {};\n  React.useEffect(() => {\n    let opts = capture != null ? {\n      capture\n    } : undefined;\n    window.addEventListener(\"beforeunload\", callback, opts);\n    return () => {\n      window.removeEventListener(\"beforeunload\", callback, opts);\n    };\n  }, [callback, capture]);\n}\n/**\n * Setup a callback to be fired on the window's `pagehide` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.  This event is better supported than beforeunload across browsers.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\nfunction usePageHide(callback, options) {\n  let {\n    capture\n  } = options || {};\n  React.useEffect(() => {\n    let opts = capture != null ? {\n      capture\n    } : undefined;\n    window.addEventListener(\"pagehide\", callback, opts);\n    return () => {\n      window.removeEventListener(\"pagehide\", callback, opts);\n    };\n  }, [callback, capture]);\n}\n/**\n * Wrapper around useBlocker to show a window.confirm prompt to users instead\n * of building a custom UI with useBlocker.\n *\n * Warning: This has *a lot of rough edges* and behaves very differently (and\n * very incorrectly in some cases) across browsers if user click addition\n * back/forward navigations while the confirm is open.  Use at your own risk.\n */\nfunction usePrompt(_ref12) {\n  let {\n    when,\n    message\n  } = _ref12;\n  let blocker = useBlocker(when);\n  React.useEffect(() => {\n    if (blocker.state === \"blocked\") {\n      let proceed = window.confirm(message);\n      if (proceed) {\n        // This timeout is needed to avoid a weird \"race\" on POP navigations\n        // between the `window.history` revert navigation and the result of\n        // `window.confirm`\n        setTimeout(blocker.proceed, 0);\n      } else {\n        blocker.reset();\n      }\n    }\n  }, [blocker, message]);\n  React.useEffect(() => {\n    if (blocker.state === \"blocked\" && !when) {\n      blocker.reset();\n    }\n  }, [blocker, when]);\n}\n/**\n * Return a boolean indicating if there is an active view transition to the\n * given href.  You can use this value to render CSS classes or viewTransitionName\n * styles onto your elements\n *\n * @param href The destination href\n * @param [opts.relative] Relative routing type (\"route\" | \"path\")\n */\nfunction useViewTransitionState(to, opts) {\n  if (opts === void 0) {\n    opts = {};\n  }\n  let vtContext = React.useContext(ViewTransitionContext);\n  !(vtContext != null) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"`unstable_useViewTransitionState` must be used within `react-router-dom`'s `RouterProvider`.  \" + \"Did you accidentally import `RouterProvider` from `react-router`?\") : UNSAFE_invariant(false) : void 0;\n  let {\n    basename\n  } = useDataRouterContext(DataRouterHook.useViewTransitionState);\n  let path = useResolvedPath(to, {\n    relative: opts.relative\n  });\n  if (!vtContext.isTransitioning) {\n    return false;\n  }\n  let currentPath = stripBasename(vtContext.currentLocation.pathname, basename) || vtContext.currentLocation.pathname;\n  let nextPath = stripBasename(vtContext.nextLocation.pathname, basename) || vtContext.nextLocation.pathname;\n  // Transition is active if we're going to or coming from the indicated\n  // destination.  This ensures that other PUSH navigations that reverse\n  // an indicated transition apply.  I.e., on the list view you have:\n  //\n  //   <NavLink to=\"/details/1\" unstable_viewTransition>\n  //\n  // If you click the breadcrumb back to the list view:\n  //\n  //   <NavLink to=\"/list\" unstable_viewTransition>\n  //\n  // We should apply the transition because it's indicated as active going\n  // from /list -> /details/1 and therefore should be active on the reverse\n  // (even though this isn't strictly a POP reverse)\n  return matchPath(path.pathname, nextPath) != null || matchPath(path.pathname, currentPath) != null;\n}\n//#endregion\n\nexport { BrowserRouter, Form, HashRouter, Link, NavLink, RouterProvider, ScrollRestoration, FetchersContext as UNSAFE_FetchersContext, ViewTransitionContext as UNSAFE_ViewTransitionContext, useScrollRestoration as UNSAFE_useScrollRestoration, createBrowserRouter, createHashRouter, createSearchParams, HistoryRouter as unstable_HistoryRouter, usePrompt as unstable_usePrompt, useViewTransitionState as unstable_useViewTransitionState, useBeforeUnload, useFetcher, useFetchers, useFormAction, useLinkClickHandler, useSearchParams, useSubmit };\n//# sourceMappingURL=index.js.map\n","/**\n * React Router v6.26.0\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nimport * as React from 'react';\nimport { UNSAFE_invariant, joinPaths, matchPath, UNSAFE_decodePath, UNSAFE_getResolveToMatches, UNSAFE_warning, resolveTo, parsePath, matchRoutes, Action, UNSAFE_convertRouteMatchToUiMatch, stripBasename, IDLE_BLOCKER, isRouteErrorResponse, createMemoryHistory, AbortedDeferredError, createRouter } from '@remix-run/router';\nexport { AbortedDeferredError, Action as NavigationType, createPath, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, replace, resolvePath } from '@remix-run/router';\n\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\n// Create react-specific types from the agnostic types in @remix-run/router to\n// export from react-router\nconst DataRouterContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  DataRouterContext.displayName = \"DataRouter\";\n}\nconst DataRouterStateContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  DataRouterStateContext.displayName = \"DataRouterState\";\n}\nconst AwaitContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  AwaitContext.displayName = \"Await\";\n}\n\n/**\n * A Navigator is a \"location changer\"; it's how you get to different locations.\n *\n * Every history instance conforms to the Navigator interface, but the\n * distinction is useful primarily when it comes to the low-level `<Router>` API\n * where both the location and a navigator must be provided separately in order\n * to avoid \"tearing\" that may occur in a suspense-enabled app if the action\n * and/or location were to be read directly from the history instance.\n */\n\nconst NavigationContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  NavigationContext.displayName = \"Navigation\";\n}\nconst LocationContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  LocationContext.displayName = \"Location\";\n}\nconst RouteContext = /*#__PURE__*/React.createContext({\n  outlet: null,\n  matches: [],\n  isDataRoute: false\n});\nif (process.env.NODE_ENV !== \"production\") {\n  RouteContext.displayName = \"Route\";\n}\nconst RouteErrorContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  RouteErrorContext.displayName = \"RouteError\";\n}\n\n/**\n * Returns the full href for the given \"to\" value. This is useful for building\n * custom links that are also accessible and preserve right-click behavior.\n *\n * @see https://reactrouter.com/hooks/use-href\n */\nfunction useHref(to, _temp) {\n  let {\n    relative\n  } = _temp === void 0 ? {} : _temp;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useHref() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    basename,\n    navigator\n  } = React.useContext(NavigationContext);\n  let {\n    hash,\n    pathname,\n    search\n  } = useResolvedPath(to, {\n    relative\n  });\n  let joinedPathname = pathname;\n\n  // If we're operating within a basename, prepend it to the pathname prior\n  // to creating the href.  If this is a root navigation, then just use the raw\n  // basename which allows the basename to have full control over the presence\n  // of a trailing slash on root links\n  if (basename !== \"/\") {\n    joinedPathname = pathname === \"/\" ? basename : joinPaths([basename, pathname]);\n  }\n  return navigator.createHref({\n    pathname: joinedPathname,\n    search,\n    hash\n  });\n}\n\n/**\n * Returns true if this component is a descendant of a `<Router>`.\n *\n * @see https://reactrouter.com/hooks/use-in-router-context\n */\nfunction useInRouterContext() {\n  return React.useContext(LocationContext) != null;\n}\n\n/**\n * Returns the current location object, which represents the current URL in web\n * browsers.\n *\n * Note: If you're using this it may mean you're doing some of your own\n * \"routing\" in your app, and we'd like to know what your use case is. We may\n * be able to provide something higher-level to better suit your needs.\n *\n * @see https://reactrouter.com/hooks/use-location\n */\nfunction useLocation() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useLocation() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  return React.useContext(LocationContext).location;\n}\n\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/hooks/use-navigation-type\n */\nfunction useNavigationType() {\n  return React.useContext(LocationContext).navigationType;\n}\n\n/**\n * Returns a PathMatch object if the given pattern matches the current URL.\n * This is useful for components that need to know \"active\" state, e.g.\n * `<NavLink>`.\n *\n * @see https://reactrouter.com/hooks/use-match\n */\nfunction useMatch(pattern) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useMatch() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    pathname\n  } = useLocation();\n  return React.useMemo(() => matchPath(pattern, UNSAFE_decodePath(pathname)), [pathname, pattern]);\n}\n\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\n\nconst navigateEffectWarning = \"You should call navigate() in a React.useEffect(), not when \" + \"your component is first rendered.\";\n\n// Mute warnings for calls to useNavigate in SSR environments\nfunction useIsomorphicLayoutEffect(cb) {\n  let isStatic = React.useContext(NavigationContext).static;\n  if (!isStatic) {\n    // We should be able to get rid of this once react 18.3 is released\n    // See: https://github.com/facebook/react/pull/26395\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(cb);\n  }\n}\n\n/**\n * Returns an imperative method for changing the location. Used by `<Link>`s, but\n * may also be used by other elements to change the location.\n *\n * @see https://reactrouter.com/hooks/use-navigate\n */\nfunction useNavigate() {\n  let {\n    isDataRoute\n  } = React.useContext(RouteContext);\n  // Conditional usage is OK here because the usage of a data router is static\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return isDataRoute ? useNavigateStable() : useNavigateUnstable();\n}\nfunction useNavigateUnstable() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useNavigate() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let dataRouterContext = React.useContext(DataRouterContext);\n  let {\n    basename,\n    future,\n    navigator\n  } = React.useContext(NavigationContext);\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let routePathnamesJson = JSON.stringify(UNSAFE_getResolveToMatches(matches, future.v7_relativeSplatPath));\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n  let navigate = React.useCallback(function (to, options) {\n    if (options === void 0) {\n      options = {};\n    }\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(activeRef.current, navigateEffectWarning) : void 0;\n\n    // Short circuit here since if this happens on first render the navigate\n    // is useless because we haven't wired up our history listener yet\n    if (!activeRef.current) return;\n    if (typeof to === \"number\") {\n      navigator.go(to);\n      return;\n    }\n    let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, options.relative === \"path\");\n\n    // If we're operating within a basename, prepend it to the pathname prior\n    // to handing off to history (but only if we're not in a data router,\n    // otherwise it'll prepend the basename inside of the router).\n    // If this is a root navigation, then we navigate to the raw basename\n    // which allows the basename to have full control over the presence of a\n    // trailing slash on root links\n    if (dataRouterContext == null && basename !== \"/\") {\n      path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n    }\n    (!!options.replace ? navigator.replace : navigator.push)(path, options.state, options);\n  }, [basename, navigator, routePathnamesJson, locationPathname, dataRouterContext]);\n  return navigate;\n}\nconst OutletContext = /*#__PURE__*/React.createContext(null);\n\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/hooks/use-outlet-context\n */\nfunction useOutletContext() {\n  return React.useContext(OutletContext);\n}\n\n/**\n * Returns the element for the child route at this level of the route\n * hierarchy. Used internally by `<Outlet>` to render child routes.\n *\n * @see https://reactrouter.com/hooks/use-outlet\n */\nfunction useOutlet(context) {\n  let outlet = React.useContext(RouteContext).outlet;\n  if (outlet) {\n    return /*#__PURE__*/React.createElement(OutletContext.Provider, {\n      value: context\n    }, outlet);\n  }\n  return outlet;\n}\n\n/**\n * Returns an object of key/value pairs of the dynamic params from the current\n * URL that were matched by the route path.\n *\n * @see https://reactrouter.com/hooks/use-params\n */\nfunction useParams() {\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let routeMatch = matches[matches.length - 1];\n  return routeMatch ? routeMatch.params : {};\n}\n\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/hooks/use-resolved-path\n */\nfunction useResolvedPath(to, _temp2) {\n  let {\n    relative\n  } = _temp2 === void 0 ? {} : _temp2;\n  let {\n    future\n  } = React.useContext(NavigationContext);\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let routePathnamesJson = JSON.stringify(UNSAFE_getResolveToMatches(matches, future.v7_relativeSplatPath));\n  return React.useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, relative === \"path\"), [to, routePathnamesJson, locationPathname, relative]);\n}\n\n/**\n * Returns the element of the route that matched the current location, prepared\n * with the correct context to render the remainder of the route tree. Route\n * elements in the tree must render an `<Outlet>` to render their child route's\n * element.\n *\n * @see https://reactrouter.com/hooks/use-routes\n */\nfunction useRoutes(routes, locationArg) {\n  return useRoutesImpl(routes, locationArg);\n}\n\n// Internal implementation with accept optional param for RouterProvider usage\nfunction useRoutesImpl(routes, locationArg, dataRouterState, future) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useRoutes() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    navigator\n  } = React.useContext(NavigationContext);\n  let {\n    matches: parentMatches\n  } = React.useContext(RouteContext);\n  let routeMatch = parentMatches[parentMatches.length - 1];\n  let parentParams = routeMatch ? routeMatch.params : {};\n  let parentPathname = routeMatch ? routeMatch.pathname : \"/\";\n  let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : \"/\";\n  let parentRoute = routeMatch && routeMatch.route;\n  if (process.env.NODE_ENV !== \"production\") {\n    // You won't get a warning about 2 different <Routes> under a <Route>\n    // without a trailing *, but this is a best-effort warning anyway since we\n    // cannot even give the warning unless they land at the parent route.\n    //\n    // Example:\n    //\n    // <Routes>\n    //   {/* This route path MUST end with /* because otherwise\n    //       it will never match /blog/post/123 */}\n    //   <Route path=\"blog\" element={<Blog />} />\n    //   <Route path=\"blog/feed\" element={<BlogFeed />} />\n    // </Routes>\n    //\n    // function Blog() {\n    //   return (\n    //     <Routes>\n    //       <Route path=\"post/:id\" element={<Post />} />\n    //     </Routes>\n    //   );\n    // }\n    let parentPath = parentRoute && parentRoute.path || \"\";\n    warningOnce(parentPathname, !parentRoute || parentPath.endsWith(\"*\"), \"You rendered descendant <Routes> (or called `useRoutes()`) at \" + (\"\\\"\" + parentPathname + \"\\\" (under <Route path=\\\"\" + parentPath + \"\\\">) but the \") + \"parent route path has no trailing \\\"*\\\". This means if you navigate \" + \"deeper, the parent won't match anymore and therefore the child \" + \"routes will never render.\\n\\n\" + (\"Please change the parent <Route path=\\\"\" + parentPath + \"\\\"> to <Route \") + (\"path=\\\"\" + (parentPath === \"/\" ? \"*\" : parentPath + \"/*\") + \"\\\">.\"));\n  }\n  let locationFromContext = useLocation();\n  let location;\n  if (locationArg) {\n    var _parsedLocationArg$pa;\n    let parsedLocationArg = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n    !(parentPathnameBase === \"/\" || ((_parsedLocationArg$pa = parsedLocationArg.pathname) == null ? void 0 : _parsedLocationArg$pa.startsWith(parentPathnameBase))) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"When overriding the location using `<Routes location>` or `useRoutes(routes, location)`, \" + \"the location pathname must begin with the portion of the URL pathname that was \" + (\"matched by all parent routes. The current pathname base is \\\"\" + parentPathnameBase + \"\\\" \") + (\"but pathname \\\"\" + parsedLocationArg.pathname + \"\\\" was given in the `location` prop.\")) : UNSAFE_invariant(false) : void 0;\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\n  let pathname = location.pathname || \"/\";\n  let remainingPathname = pathname;\n  if (parentPathnameBase !== \"/\") {\n    // Determine the remaining pathname by removing the # of URL segments the\n    // parentPathnameBase has, instead of removing based on character count.\n    // This is because we can't guarantee that incoming/outgoing encodings/\n    // decodings will match exactly.\n    // We decode paths before matching on a per-segment basis with\n    // decodeURIComponent(), but we re-encode pathnames via `new URL()` so they\n    // match what `window.location.pathname` would reflect.  Those don't 100%\n    // align when it comes to encoded URI characters such as % and &.\n    //\n    // So we may end up with:\n    //   pathname:           \"/descendant/a%25b/match\"\n    //   parentPathnameBase: \"/descendant/a%b\"\n    //\n    // And the direct substring removal approach won't work :/\n    let parentSegments = parentPathnameBase.replace(/^\\//, \"\").split(\"/\");\n    let segments = pathname.replace(/^\\//, \"\").split(\"/\");\n    remainingPathname = \"/\" + segments.slice(parentSegments.length).join(\"/\");\n  }\n  let matches = matchRoutes(routes, {\n    pathname: remainingPathname\n  });\n  if (process.env.NODE_ENV !== \"production\") {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(parentRoute || matches != null, \"No routes matched location \\\"\" + location.pathname + location.search + location.hash + \"\\\" \") : void 0;\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(matches == null || matches[matches.length - 1].route.element !== undefined || matches[matches.length - 1].route.Component !== undefined || matches[matches.length - 1].route.lazy !== undefined, \"Matched leaf route at location \\\"\" + location.pathname + location.search + location.hash + \"\\\" \" + \"does not have an element or Component. This means it will render an <Outlet /> with a \" + \"null value by default resulting in an \\\"empty\\\" page.\") : void 0;\n  }\n  let renderedMatches = _renderMatches(matches && matches.map(match => Object.assign({}, match, {\n    params: Object.assign({}, parentParams, match.params),\n    pathname: joinPaths([parentPathnameBase,\n    // Re-encode pathnames that were decoded inside matchRoutes\n    navigator.encodeLocation ? navigator.encodeLocation(match.pathname).pathname : match.pathname]),\n    pathnameBase: match.pathnameBase === \"/\" ? parentPathnameBase : joinPaths([parentPathnameBase,\n    // Re-encode pathnames that were decoded inside matchRoutes\n    navigator.encodeLocation ? navigator.encodeLocation(match.pathnameBase).pathname : match.pathnameBase])\n  })), parentMatches, dataRouterState, future);\n\n  // When a user passes in a `locationArg`, the associated routes need to\n  // be wrapped in a new `LocationContext.Provider` in order for `useLocation`\n  // to use the scoped location instead of the global location.\n  if (locationArg && renderedMatches) {\n    return /*#__PURE__*/React.createElement(LocationContext.Provider, {\n      value: {\n        location: _extends({\n          pathname: \"/\",\n          search: \"\",\n          hash: \"\",\n          state: null,\n          key: \"default\"\n        }, location),\n        navigationType: Action.Pop\n      }\n    }, renderedMatches);\n  }\n  return renderedMatches;\n}\nfunction DefaultErrorComponent() {\n  let error = useRouteError();\n  let message = isRouteErrorResponse(error) ? error.status + \" \" + error.statusText : error instanceof Error ? error.message : JSON.stringify(error);\n  let stack = error instanceof Error ? error.stack : null;\n  let lightgrey = \"rgba(200,200,200, 0.5)\";\n  let preStyles = {\n    padding: \"0.5rem\",\n    backgroundColor: lightgrey\n  };\n  let codeStyles = {\n    padding: \"2px 4px\",\n    backgroundColor: lightgrey\n  };\n  let devInfo = null;\n  if (process.env.NODE_ENV !== \"production\") {\n    console.error(\"Error handled by React Router default ErrorBoundary:\", error);\n    devInfo = /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"p\", null, \"\\uD83D\\uDCBF Hey developer \\uD83D\\uDC4B\"), /*#__PURE__*/React.createElement(\"p\", null, \"You can provide a way better UX than this when your app throws errors by providing your own \", /*#__PURE__*/React.createElement(\"code\", {\n      style: codeStyles\n    }, \"ErrorBoundary\"), \" or\", \" \", /*#__PURE__*/React.createElement(\"code\", {\n      style: codeStyles\n    }, \"errorElement\"), \" prop on your route.\"));\n  }\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"h2\", null, \"Unexpected Application Error!\"), /*#__PURE__*/React.createElement(\"h3\", {\n    style: {\n      fontStyle: \"italic\"\n    }\n  }, message), stack ? /*#__PURE__*/React.createElement(\"pre\", {\n    style: preStyles\n  }, stack) : null, devInfo);\n}\nconst defaultErrorElement = /*#__PURE__*/React.createElement(DefaultErrorComponent, null);\nclass RenderErrorBoundary extends React.Component {\n  constructor(props) {\n    super(props);\n    this.state = {\n      location: props.location,\n      revalidation: props.revalidation,\n      error: props.error\n    };\n  }\n  static getDerivedStateFromError(error) {\n    return {\n      error: error\n    };\n  }\n  static getDerivedStateFromProps(props, state) {\n    // When we get into an error state, the user will likely click \"back\" to the\n    // previous page that didn't have an error. Because this wraps the entire\n    // application, that will have no effect--the error page continues to display.\n    // This gives us a mechanism to recover from the error when the location changes.\n    //\n    // Whether we're in an error state or not, we update the location in state\n    // so that when we are in an error state, it gets reset when a new location\n    // comes in and the user recovers from the error.\n    if (state.location !== props.location || state.revalidation !== \"idle\" && props.revalidation === \"idle\") {\n      return {\n        error: props.error,\n        location: props.location,\n        revalidation: props.revalidation\n      };\n    }\n\n    // If we're not changing locations, preserve the location but still surface\n    // any new errors that may come through. We retain the existing error, we do\n    // this because the error provided from the app state may be cleared without\n    // the location changing.\n    return {\n      error: props.error !== undefined ? props.error : state.error,\n      location: state.location,\n      revalidation: props.revalidation || state.revalidation\n    };\n  }\n  componentDidCatch(error, errorInfo) {\n    console.error(\"React Router caught the following error during render\", error, errorInfo);\n  }\n  render() {\n    return this.state.error !== undefined ? /*#__PURE__*/React.createElement(RouteContext.Provider, {\n      value: this.props.routeContext\n    }, /*#__PURE__*/React.createElement(RouteErrorContext.Provider, {\n      value: this.state.error,\n      children: this.props.component\n    })) : this.props.children;\n  }\n}\nfunction RenderedRoute(_ref) {\n  let {\n    routeContext,\n    match,\n    children\n  } = _ref;\n  let dataRouterContext = React.useContext(DataRouterContext);\n\n  // Track how deep we got in our render pass to emulate SSR componentDidCatch\n  // in a DataStaticRouter\n  if (dataRouterContext && dataRouterContext.static && dataRouterContext.staticContext && (match.route.errorElement || match.route.ErrorBoundary)) {\n    dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;\n  }\n  return /*#__PURE__*/React.createElement(RouteContext.Provider, {\n    value: routeContext\n  }, children);\n}\nfunction _renderMatches(matches, parentMatches, dataRouterState, future) {\n  var _dataRouterState;\n  if (parentMatches === void 0) {\n    parentMatches = [];\n  }\n  if (dataRouterState === void 0) {\n    dataRouterState = null;\n  }\n  if (future === void 0) {\n    future = null;\n  }\n  if (matches == null) {\n    var _future;\n    if (!dataRouterState) {\n      return null;\n    }\n    if (dataRouterState.errors) {\n      // Don't bail if we have data router errors so we can render them in the\n      // boundary.  Use the pre-matched (or shimmed) matches\n      matches = dataRouterState.matches;\n    } else if ((_future = future) != null && _future.v7_partialHydration && parentMatches.length === 0 && !dataRouterState.initialized && dataRouterState.matches.length > 0) {\n      // Don't bail if we're initializing with partial hydration and we have\n      // router matches.  That means we're actively running `patchRoutesOnMiss`\n      // so we should render down the partial matches to the appropriate\n      // `HydrateFallback`.  We only do this if `parentMatches` is empty so it\n      // only impacts the root matches for `RouterProvider` and no descendant\n      // `<Routes>`\n      matches = dataRouterState.matches;\n    } else {\n      return null;\n    }\n  }\n  let renderedMatches = matches;\n\n  // If we have data errors, trim matches to the highest error boundary\n  let errors = (_dataRouterState = dataRouterState) == null ? void 0 : _dataRouterState.errors;\n  if (errors != null) {\n    let errorIndex = renderedMatches.findIndex(m => m.route.id && (errors == null ? void 0 : errors[m.route.id]) !== undefined);\n    !(errorIndex >= 0) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"Could not find a matching route for errors on route IDs: \" + Object.keys(errors).join(\",\")) : UNSAFE_invariant(false) : void 0;\n    renderedMatches = renderedMatches.slice(0, Math.min(renderedMatches.length, errorIndex + 1));\n  }\n\n  // If we're in a partial hydration mode, detect if we need to render down to\n  // a given HydrateFallback while we load the rest of the hydration data\n  let renderFallback = false;\n  let fallbackIndex = -1;\n  if (dataRouterState && future && future.v7_partialHydration) {\n    for (let i = 0; i < renderedMatches.length; i++) {\n      let match = renderedMatches[i];\n      // Track the deepest fallback up until the first route without data\n      if (match.route.HydrateFallback || match.route.hydrateFallbackElement) {\n        fallbackIndex = i;\n      }\n      if (match.route.id) {\n        let {\n          loaderData,\n          errors\n        } = dataRouterState;\n        let needsToRunLoader = match.route.loader && loaderData[match.route.id] === undefined && (!errors || errors[match.route.id] === undefined);\n        if (match.route.lazy || needsToRunLoader) {\n          // We found the first route that's not ready to render (waiting on\n          // lazy, or has a loader that hasn't run yet).  Flag that we need to\n          // render a fallback and render up until the appropriate fallback\n          renderFallback = true;\n          if (fallbackIndex >= 0) {\n            renderedMatches = renderedMatches.slice(0, fallbackIndex + 1);\n          } else {\n            renderedMatches = [renderedMatches[0]];\n          }\n          break;\n        }\n      }\n    }\n  }\n  return renderedMatches.reduceRight((outlet, match, index) => {\n    // Only data routers handle errors/fallbacks\n    let error;\n    let shouldRenderHydrateFallback = false;\n    let errorElement = null;\n    let hydrateFallbackElement = null;\n    if (dataRouterState) {\n      error = errors && match.route.id ? errors[match.route.id] : undefined;\n      errorElement = match.route.errorElement || defaultErrorElement;\n      if (renderFallback) {\n        if (fallbackIndex < 0 && index === 0) {\n          warningOnce(\"route-fallback\", false, \"No `HydrateFallback` element provided to render during initial hydration\");\n          shouldRenderHydrateFallback = true;\n          hydrateFallbackElement = null;\n        } else if (fallbackIndex === index) {\n          shouldRenderHydrateFallback = true;\n          hydrateFallbackElement = match.route.hydrateFallbackElement || null;\n        }\n      }\n    }\n    let matches = parentMatches.concat(renderedMatches.slice(0, index + 1));\n    let getChildren = () => {\n      let children;\n      if (error) {\n        children = errorElement;\n      } else if (shouldRenderHydrateFallback) {\n        children = hydrateFallbackElement;\n      } else if (match.route.Component) {\n        // Note: This is a de-optimized path since React won't re-use the\n        // ReactElement since it's identity changes with each new\n        // React.createElement call.  We keep this so folks can use\n        // `<Route Component={...}>` in `<Routes>` but generally `Component`\n        // usage is only advised in `RouterProvider` when we can convert it to\n        // `element` ahead of time.\n        children = /*#__PURE__*/React.createElement(match.route.Component, null);\n      } else if (match.route.element) {\n        children = match.route.element;\n      } else {\n        children = outlet;\n      }\n      return /*#__PURE__*/React.createElement(RenderedRoute, {\n        match: match,\n        routeContext: {\n          outlet,\n          matches,\n          isDataRoute: dataRouterState != null\n        },\n        children: children\n      });\n    };\n    // Only wrap in an error boundary within data router usages when we have an\n    // ErrorBoundary/errorElement on this route.  Otherwise let it bubble up to\n    // an ancestor ErrorBoundary/errorElement\n    return dataRouterState && (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? /*#__PURE__*/React.createElement(RenderErrorBoundary, {\n      location: dataRouterState.location,\n      revalidation: dataRouterState.revalidation,\n      component: errorElement,\n      error: error,\n      children: getChildren(),\n      routeContext: {\n        outlet: null,\n        matches,\n        isDataRoute: true\n      }\n    }) : getChildren();\n  }, null);\n}\nvar DataRouterHook = /*#__PURE__*/function (DataRouterHook) {\n  DataRouterHook[\"UseBlocker\"] = \"useBlocker\";\n  DataRouterHook[\"UseRevalidator\"] = \"useRevalidator\";\n  DataRouterHook[\"UseNavigateStable\"] = \"useNavigate\";\n  return DataRouterHook;\n}(DataRouterHook || {});\nvar DataRouterStateHook = /*#__PURE__*/function (DataRouterStateHook) {\n  DataRouterStateHook[\"UseBlocker\"] = \"useBlocker\";\n  DataRouterStateHook[\"UseLoaderData\"] = \"useLoaderData\";\n  DataRouterStateHook[\"UseActionData\"] = \"useActionData\";\n  DataRouterStateHook[\"UseRouteError\"] = \"useRouteError\";\n  DataRouterStateHook[\"UseNavigation\"] = \"useNavigation\";\n  DataRouterStateHook[\"UseRouteLoaderData\"] = \"useRouteLoaderData\";\n  DataRouterStateHook[\"UseMatches\"] = \"useMatches\";\n  DataRouterStateHook[\"UseRevalidator\"] = \"useRevalidator\";\n  DataRouterStateHook[\"UseNavigateStable\"] = \"useNavigate\";\n  DataRouterStateHook[\"UseRouteId\"] = \"useRouteId\";\n  return DataRouterStateHook;\n}(DataRouterStateHook || {});\nfunction getDataRouterConsoleError(hookName) {\n  return hookName + \" must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.\";\n}\nfunction useDataRouterContext(hookName) {\n  let ctx = React.useContext(DataRouterContext);\n  !ctx ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return ctx;\n}\nfunction useDataRouterState(hookName) {\n  let state = React.useContext(DataRouterStateContext);\n  !state ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return state;\n}\nfunction useRouteContext(hookName) {\n  let route = React.useContext(RouteContext);\n  !route ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return route;\n}\n\n// Internal version with hookName-aware debugging\nfunction useCurrentRouteId(hookName) {\n  let route = useRouteContext(hookName);\n  let thisRoute = route.matches[route.matches.length - 1];\n  !thisRoute.route.id ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, hookName + \" can only be used on routes that contain a unique \\\"id\\\"\") : UNSAFE_invariant(false) : void 0;\n  return thisRoute.route.id;\n}\n\n/**\n * Returns the ID for the nearest contextual route\n */\nfunction useRouteId() {\n  return useCurrentRouteId(DataRouterStateHook.UseRouteId);\n}\n\n/**\n * Returns the current navigation, defaulting to an \"idle\" navigation when\n * no navigation is in progress\n */\nfunction useNavigation() {\n  let state = useDataRouterState(DataRouterStateHook.UseNavigation);\n  return state.navigation;\n}\n\n/**\n * Returns a revalidate function for manually triggering revalidation, as well\n * as the current state of any manual revalidations\n */\nfunction useRevalidator() {\n  let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);\n  let state = useDataRouterState(DataRouterStateHook.UseRevalidator);\n  return React.useMemo(() => ({\n    revalidate: dataRouterContext.router.revalidate,\n    state: state.revalidation\n  }), [dataRouterContext.router.revalidate, state.revalidation]);\n}\n\n/**\n * Returns the active route matches, useful for accessing loaderData for\n * parent/child routes or the route \"handle\" property\n */\nfunction useMatches() {\n  let {\n    matches,\n    loaderData\n  } = useDataRouterState(DataRouterStateHook.UseMatches);\n  return React.useMemo(() => matches.map(m => UNSAFE_convertRouteMatchToUiMatch(m, loaderData)), [matches, loaderData]);\n}\n\n/**\n * Returns the loader data for the nearest ancestor Route loader\n */\nfunction useLoaderData() {\n  let state = useDataRouterState(DataRouterStateHook.UseLoaderData);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n  if (state.errors && state.errors[routeId] != null) {\n    console.error(\"You cannot `useLoaderData` in an errorElement (routeId: \" + routeId + \")\");\n    return undefined;\n  }\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the loaderData for the given routeId\n */\nfunction useRouteLoaderData(routeId) {\n  let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the action data for the nearest ancestor Route action\n */\nfunction useActionData() {\n  let state = useDataRouterState(DataRouterStateHook.UseActionData);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n  return state.actionData ? state.actionData[routeId] : undefined;\n}\n\n/**\n * Returns the nearest ancestor Route error, which could be a loader/action\n * error or a render error.  This is intended to be called from your\n * ErrorBoundary/errorElement to display a proper error message.\n */\nfunction useRouteError() {\n  var _state$errors;\n  let error = React.useContext(RouteErrorContext);\n  let state = useDataRouterState(DataRouterStateHook.UseRouteError);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseRouteError);\n\n  // If this was a render error, we put it in a RouteError context inside\n  // of RenderErrorBoundary\n  if (error !== undefined) {\n    return error;\n  }\n\n  // Otherwise look for errors from our data router state\n  return (_state$errors = state.errors) == null ? void 0 : _state$errors[routeId];\n}\n\n/**\n * Returns the happy-path data from the nearest ancestor `<Await />` value\n */\nfunction useAsyncValue() {\n  let value = React.useContext(AwaitContext);\n  return value == null ? void 0 : value._data;\n}\n\n/**\n * Returns the error from the nearest ancestor `<Await />` value\n */\nfunction useAsyncError() {\n  let value = React.useContext(AwaitContext);\n  return value == null ? void 0 : value._error;\n}\nlet blockerId = 0;\n\n/**\n * Allow the application to block navigations within the SPA and present the\n * user a confirmation dialog to confirm the navigation.  Mostly used to avoid\n * using half-filled form data.  This does not handle hard-reloads or\n * cross-origin navigations.\n */\nfunction useBlocker(shouldBlock) {\n  let {\n    router,\n    basename\n  } = useDataRouterContext(DataRouterHook.UseBlocker);\n  let state = useDataRouterState(DataRouterStateHook.UseBlocker);\n  let [blockerKey, setBlockerKey] = React.useState(\"\");\n  let blockerFunction = React.useCallback(arg => {\n    if (typeof shouldBlock !== \"function\") {\n      return !!shouldBlock;\n    }\n    if (basename === \"/\") {\n      return shouldBlock(arg);\n    }\n\n    // If they provided us a function and we've got an active basename, strip\n    // it from the locations we expose to the user to match the behavior of\n    // useLocation\n    let {\n      currentLocation,\n      nextLocation,\n      historyAction\n    } = arg;\n    return shouldBlock({\n      currentLocation: _extends({}, currentLocation, {\n        pathname: stripBasename(currentLocation.pathname, basename) || currentLocation.pathname\n      }),\n      nextLocation: _extends({}, nextLocation, {\n        pathname: stripBasename(nextLocation.pathname, basename) || nextLocation.pathname\n      }),\n      historyAction\n    });\n  }, [basename, shouldBlock]);\n\n  // This effect is in charge of blocker key assignment and deletion (which is\n  // tightly coupled to the key)\n  React.useEffect(() => {\n    let key = String(++blockerId);\n    setBlockerKey(key);\n    return () => router.deleteBlocker(key);\n  }, [router]);\n\n  // This effect handles assigning the blockerFunction.  This is to handle\n  // unstable blocker function identities, and happens only after the prior\n  // effect so we don't get an orphaned blockerFunction in the router with a\n  // key of \"\".  Until then we just have the IDLE_BLOCKER.\n  React.useEffect(() => {\n    if (blockerKey !== \"\") {\n      router.getBlocker(blockerKey, blockerFunction);\n    }\n  }, [router, blockerKey, blockerFunction]);\n\n  // Prefer the blocker from `state` not `router.state` since DataRouterContext\n  // is memoized so this ensures we update on blocker state updates\n  return blockerKey && state.blockers.has(blockerKey) ? state.blockers.get(blockerKey) : IDLE_BLOCKER;\n}\n\n/**\n * Stable version of useNavigate that is used when we are in the context of\n * a RouterProvider.\n */\nfunction useNavigateStable() {\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseNavigateStable);\n  let id = useCurrentRouteId(DataRouterStateHook.UseNavigateStable);\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n  let navigate = React.useCallback(function (to, options) {\n    if (options === void 0) {\n      options = {};\n    }\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(activeRef.current, navigateEffectWarning) : void 0;\n\n    // Short circuit here since if this happens on first render the navigate\n    // is useless because we haven't wired up our router subscriber yet\n    if (!activeRef.current) return;\n    if (typeof to === \"number\") {\n      router.navigate(to);\n    } else {\n      router.navigate(to, _extends({\n        fromRouteId: id\n      }, options));\n    }\n  }, [router, id]);\n  return navigate;\n}\nconst alreadyWarned = {};\nfunction warningOnce(key, cond, message) {\n  if (!cond && !alreadyWarned[key]) {\n    alreadyWarned[key] = true;\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, message) : void 0;\n  }\n}\n\n/**\n  Webpack + React 17 fails to compile on any of the following because webpack\n  complains that `startTransition` doesn't exist in `React`:\n  * import { startTransition } from \"react\"\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n  Moving it to a constant such as the following solves the Webpack/React 17 issue:\n  * import * as React from from \"react\";\n    const START_TRANSITION = \"startTransition\";\n    START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n  However, that introduces webpack/terser minification issues in production builds\n  in React 18 where minification/obfuscation ends up removing the call of\n  React.startTransition entirely from the first half of the ternary.  Grabbing\n  this exported reference once up front resolves that issue.\n\n  See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\n\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nfunction RouterProvider(_ref) {\n  let {\n    fallbackElement,\n    router,\n    future\n  } = _ref;\n  let [state, setStateImpl] = React.useState(router.state);\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    if (v7_startTransition && startTransitionImpl) {\n      startTransitionImpl(() => setStateImpl(newState));\n    } else {\n      setStateImpl(newState);\n    }\n  }, [setStateImpl, v7_startTransition]);\n\n  // Need to use a layout effect here so we are subscribed early enough to\n  // pick up on any render-driven redirects/navigations (useEffect/<Navigate>)\n  React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);\n  React.useEffect(() => {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(fallbackElement == null || !router.future.v7_partialHydration, \"`<RouterProvider fallbackElement>` is deprecated when using \" + \"`v7_partialHydration`, use a `HydrateFallback` component instead\") : void 0;\n    // Only log this once on initial mount\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n  let navigator = React.useMemo(() => {\n    return {\n      createHref: router.createHref,\n      encodeLocation: router.encodeLocation,\n      go: n => router.navigate(n),\n      push: (to, state, opts) => router.navigate(to, {\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      }),\n      replace: (to, state, opts) => router.navigate(to, {\n        replace: true,\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      })\n    };\n  }, [router]);\n  let basename = router.basename || \"/\";\n  let dataRouterContext = React.useMemo(() => ({\n    router,\n    navigator,\n    static: false,\n    basename\n  }), [router, navigator, basename]);\n\n  // The fragment and {null} here are important!  We need them to keep React 18's\n  // useId happy when we are server-rendering since we may have a <script> here\n  // containing the hydrated server-side staticContext (from StaticRouterProvider).\n  // useId relies on the component tree structure to generate deterministic id's\n  // so we need to ensure it remains the same on the client even though\n  // we don't need the <script> tag\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(DataRouterContext.Provider, {\n    value: dataRouterContext\n  }, /*#__PURE__*/React.createElement(DataRouterStateContext.Provider, {\n    value: state\n  }, /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    location: state.location,\n    navigationType: state.historyAction,\n    navigator: navigator,\n    future: {\n      v7_relativeSplatPath: router.future.v7_relativeSplatPath\n    }\n  }, state.initialized || router.future.v7_partialHydration ? /*#__PURE__*/React.createElement(DataRoutes, {\n    routes: router.routes,\n    future: router.future,\n    state: state\n  }) : fallbackElement))), null);\n}\nfunction DataRoutes(_ref2) {\n  let {\n    routes,\n    future,\n    state\n  } = _ref2;\n  return useRoutesImpl(routes, undefined, state, future);\n}\n/**\n * A `<Router>` that stores all entries in memory.\n *\n * @see https://reactrouter.com/router-components/memory-router\n */\nfunction MemoryRouter(_ref3) {\n  let {\n    basename,\n    children,\n    initialEntries,\n    initialIndex,\n    future\n  } = _ref3;\n  let historyRef = React.useRef();\n  if (historyRef.current == null) {\n    historyRef.current = createMemoryHistory({\n      initialEntries,\n      initialIndex,\n      v5Compat: true\n    });\n  }\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history,\n    future: future\n  });\n}\n/**\n * Changes the current location.\n *\n * Note: This API is mostly useful in React.Component subclasses that are not\n * able to use hooks. In functional components, we recommend you use the\n * `useNavigate` hook instead.\n *\n * @see https://reactrouter.com/components/navigate\n */\nfunction Navigate(_ref4) {\n  let {\n    to,\n    replace,\n    state,\n    relative\n  } = _ref4;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of\n  // the router loaded. We can help them understand how to avoid that.\n  \"<Navigate> may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    future,\n    static: isStatic\n  } = React.useContext(NavigationContext);\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(!isStatic, \"<Navigate> must not be used on the initial render in a <StaticRouter>. \" + \"This is a no-op, but you should modify your code so the <Navigate> is \" + \"only ever rendered in response to some user interaction or state change.\") : void 0;\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let navigate = useNavigate();\n\n  // Resolve the path outside of the effect so that when effects run twice in\n  // StrictMode they navigate to the same place\n  let path = resolveTo(to, UNSAFE_getResolveToMatches(matches, future.v7_relativeSplatPath), locationPathname, relative === \"path\");\n  let jsonPath = JSON.stringify(path);\n  React.useEffect(() => navigate(JSON.parse(jsonPath), {\n    replace,\n    state,\n    relative\n  }), [navigate, jsonPath, relative, replace, state]);\n  return null;\n}\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/components/outlet\n */\nfunction Outlet(props) {\n  return useOutlet(props.context);\n}\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/components/route\n */\nfunction Route(_props) {\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"A <Route> is only ever to be used as the child of <Routes> element, \" + \"never rendered directly. Please wrap your <Route> in a <Routes>.\") : UNSAFE_invariant(false) ;\n}\n/**\n * Provides location context for the rest of the app.\n *\n * Note: You usually won't render a `<Router>` directly. Instead, you'll render a\n * router that is more specific to your environment such as a `<BrowserRouter>`\n * in web browsers or a `<StaticRouter>` for server rendering.\n *\n * @see https://reactrouter.com/router-components/router\n */\nfunction Router(_ref5) {\n  let {\n    basename: basenameProp = \"/\",\n    children = null,\n    location: locationProp,\n    navigationType = Action.Pop,\n    navigator,\n    static: staticProp = false,\n    future\n  } = _ref5;\n  !!useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"You cannot render a <Router> inside another <Router>.\" + \" You should never have more than one in your app.\") : UNSAFE_invariant(false) : void 0;\n\n  // Preserve trailing slashes on basename, so we can let the user control\n  // the enforcement of trailing slashes throughout the app\n  let basename = basenameProp.replace(/^\\/*/, \"/\");\n  let navigationContext = React.useMemo(() => ({\n    basename,\n    navigator,\n    static: staticProp,\n    future: _extends({\n      v7_relativeSplatPath: false\n    }, future)\n  }), [basename, future, navigator, staticProp]);\n  if (typeof locationProp === \"string\") {\n    locationProp = parsePath(locationProp);\n  }\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\",\n    state = null,\n    key = \"default\"\n  } = locationProp;\n  let locationContext = React.useMemo(() => {\n    let trailingPathname = stripBasename(pathname, basename);\n    if (trailingPathname == null) {\n      return null;\n    }\n    return {\n      location: {\n        pathname: trailingPathname,\n        search,\n        hash,\n        state,\n        key\n      },\n      navigationType\n    };\n  }, [basename, pathname, search, hash, state, key, navigationType]);\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(locationContext != null, \"<Router basename=\\\"\" + basename + \"\\\"> is not able to match the URL \" + (\"\\\"\" + pathname + search + hash + \"\\\" because it does not start with the \") + \"basename, so the <Router> won't render anything.\") : void 0;\n  if (locationContext == null) {\n    return null;\n  }\n  return /*#__PURE__*/React.createElement(NavigationContext.Provider, {\n    value: navigationContext\n  }, /*#__PURE__*/React.createElement(LocationContext.Provider, {\n    children: children,\n    value: locationContext\n  }));\n}\n/**\n * A container for a nested tree of `<Route>` elements that renders the branch\n * that best matches the current location.\n *\n * @see https://reactrouter.com/components/routes\n */\nfunction Routes(_ref6) {\n  let {\n    children,\n    location\n  } = _ref6;\n  return useRoutes(createRoutesFromChildren(children), location);\n}\n/**\n * Component to use for rendering lazily loaded data from returning defer()\n * in a loader function\n */\nfunction Await(_ref7) {\n  let {\n    children,\n    errorElement,\n    resolve\n  } = _ref7;\n  return /*#__PURE__*/React.createElement(AwaitErrorBoundary, {\n    resolve: resolve,\n    errorElement: errorElement\n  }, /*#__PURE__*/React.createElement(ResolveAwait, null, children));\n}\nvar AwaitRenderStatus = /*#__PURE__*/function (AwaitRenderStatus) {\n  AwaitRenderStatus[AwaitRenderStatus[\"pending\"] = 0] = \"pending\";\n  AwaitRenderStatus[AwaitRenderStatus[\"success\"] = 1] = \"success\";\n  AwaitRenderStatus[AwaitRenderStatus[\"error\"] = 2] = \"error\";\n  return AwaitRenderStatus;\n}(AwaitRenderStatus || {});\nconst neverSettledPromise = new Promise(() => {});\nclass AwaitErrorBoundary extends React.Component {\n  constructor(props) {\n    super(props);\n    this.state = {\n      error: null\n    };\n  }\n  static getDerivedStateFromError(error) {\n    return {\n      error\n    };\n  }\n  componentDidCatch(error, errorInfo) {\n    console.error(\"<Await> caught the following error during render\", error, errorInfo);\n  }\n  render() {\n    let {\n      children,\n      errorElement,\n      resolve\n    } = this.props;\n    let promise = null;\n    let status = AwaitRenderStatus.pending;\n    if (!(resolve instanceof Promise)) {\n      // Didn't get a promise - provide as a resolved promise\n      status = AwaitRenderStatus.success;\n      promise = Promise.resolve();\n      Object.defineProperty(promise, \"_tracked\", {\n        get: () => true\n      });\n      Object.defineProperty(promise, \"_data\", {\n        get: () => resolve\n      });\n    } else if (this.state.error) {\n      // Caught a render error, provide it as a rejected promise\n      status = AwaitRenderStatus.error;\n      let renderError = this.state.error;\n      promise = Promise.reject().catch(() => {}); // Avoid unhandled rejection warnings\n      Object.defineProperty(promise, \"_tracked\", {\n        get: () => true\n      });\n      Object.defineProperty(promise, \"_error\", {\n        get: () => renderError\n      });\n    } else if (resolve._tracked) {\n      // Already tracked promise - check contents\n      promise = resolve;\n      status = \"_error\" in promise ? AwaitRenderStatus.error : \"_data\" in promise ? AwaitRenderStatus.success : AwaitRenderStatus.pending;\n    } else {\n      // Raw (untracked) promise - track it\n      status = AwaitRenderStatus.pending;\n      Object.defineProperty(resolve, \"_tracked\", {\n        get: () => true\n      });\n      promise = resolve.then(data => Object.defineProperty(resolve, \"_data\", {\n        get: () => data\n      }), error => Object.defineProperty(resolve, \"_error\", {\n        get: () => error\n      }));\n    }\n    if (status === AwaitRenderStatus.error && promise._error instanceof AbortedDeferredError) {\n      // Freeze the UI by throwing a never resolved promise\n      throw neverSettledPromise;\n    }\n    if (status === AwaitRenderStatus.error && !errorElement) {\n      // No errorElement, throw to the nearest route-level error boundary\n      throw promise._error;\n    }\n    if (status === AwaitRenderStatus.error) {\n      // Render via our errorElement\n      return /*#__PURE__*/React.createElement(AwaitContext.Provider, {\n        value: promise,\n        children: errorElement\n      });\n    }\n    if (status === AwaitRenderStatus.success) {\n      // Render children with resolved value\n      return /*#__PURE__*/React.createElement(AwaitContext.Provider, {\n        value: promise,\n        children: children\n      });\n    }\n\n    // Throw to the suspense boundary\n    throw promise;\n  }\n}\n\n/**\n * @private\n * Indirection to leverage useAsyncValue for a render-prop API on `<Await>`\n */\nfunction ResolveAwait(_ref8) {\n  let {\n    children\n  } = _ref8;\n  let data = useAsyncValue();\n  let toRender = typeof children === \"function\" ? children(data) : children;\n  return /*#__PURE__*/React.createElement(React.Fragment, null, toRender);\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// UTILS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Creates a route config from a React \"children\" object, which is usually\n * either a `<Route>` element or an array of them. Used internally by\n * `<Routes>` to create a route config from its children.\n *\n * @see https://reactrouter.com/utils/create-routes-from-children\n */\nfunction createRoutesFromChildren(children, parentPath) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\n  let routes = [];\n  React.Children.forEach(children, (element, index) => {\n    if (! /*#__PURE__*/React.isValidElement(element)) {\n      // Ignore non-elements. This allows people to more easily inline\n      // conditionals in their route config.\n      return;\n    }\n    let treePath = [...parentPath, index];\n    if (element.type === React.Fragment) {\n      // Transparently support React.Fragment and its children.\n      routes.push.apply(routes, createRoutesFromChildren(element.props.children, treePath));\n      return;\n    }\n    !(element.type === Route) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"[\" + (typeof element.type === \"string\" ? element.type : element.type.name) + \"] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>\") : UNSAFE_invariant(false) : void 0;\n    !(!element.props.index || !element.props.children) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"An index route cannot have child routes.\") : UNSAFE_invariant(false) : void 0;\n    let route = {\n      id: element.props.id || treePath.join(\"-\"),\n      caseSensitive: element.props.caseSensitive,\n      element: element.props.element,\n      Component: element.props.Component,\n      index: element.props.index,\n      path: element.props.path,\n      loader: element.props.loader,\n      action: element.props.action,\n      errorElement: element.props.errorElement,\n      ErrorBoundary: element.props.ErrorBoundary,\n      hasErrorBoundary: element.props.ErrorBoundary != null || element.props.errorElement != null,\n      shouldRevalidate: element.props.shouldRevalidate,\n      handle: element.props.handle,\n      lazy: element.props.lazy\n    };\n    if (element.props.children) {\n      route.children = createRoutesFromChildren(element.props.children, treePath);\n    }\n    routes.push(route);\n  });\n  return routes;\n}\n\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\nfunction renderMatches(matches) {\n  return _renderMatches(matches);\n}\n\nfunction mapRouteProperties(route) {\n  let updates = {\n    // Note: this check also occurs in createRoutesFromChildren so update\n    // there if you change this -- please and thank you!\n    hasErrorBoundary: route.ErrorBoundary != null || route.errorElement != null\n  };\n  if (route.Component) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (route.element) {\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `Component` and `element` on your route - \" + \"`Component` will be used.\") : void 0;\n      }\n    }\n    Object.assign(updates, {\n      element: /*#__PURE__*/React.createElement(route.Component),\n      Component: undefined\n    });\n  }\n  if (route.HydrateFallback) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (route.hydrateFallbackElement) {\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `HydrateFallback` and `hydrateFallbackElement` on your route - \" + \"`HydrateFallback` will be used.\") : void 0;\n      }\n    }\n    Object.assign(updates, {\n      hydrateFallbackElement: /*#__PURE__*/React.createElement(route.HydrateFallback),\n      HydrateFallback: undefined\n    });\n  }\n  if (route.ErrorBoundary) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (route.errorElement) {\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `ErrorBoundary` and `errorElement` on your route - \" + \"`ErrorBoundary` will be used.\") : void 0;\n      }\n    }\n    Object.assign(updates, {\n      errorElement: /*#__PURE__*/React.createElement(route.ErrorBoundary),\n      ErrorBoundary: undefined\n    });\n  }\n  return updates;\n}\nfunction createMemoryRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    future: _extends({}, opts == null ? void 0 : opts.future, {\n      v7_prependBasename: true\n    }),\n    history: createMemoryHistory({\n      initialEntries: opts == null ? void 0 : opts.initialEntries,\n      initialIndex: opts == null ? void 0 : opts.initialIndex\n    }),\n    hydrationData: opts == null ? void 0 : opts.hydrationData,\n    routes,\n    mapRouteProperties,\n    unstable_dataStrategy: opts == null ? void 0 : opts.unstable_dataStrategy,\n    unstable_patchRoutesOnMiss: opts == null ? void 0 : opts.unstable_patchRoutesOnMiss\n  }).initialize();\n}\n\nexport { Await, MemoryRouter, Navigate, Outlet, Route, Router, RouterProvider, Routes, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RouteContext as UNSAFE_RouteContext, mapRouteProperties as UNSAFE_mapRouteProperties, useRouteId as UNSAFE_useRouteId, useRoutesImpl as UNSAFE_useRoutesImpl, createMemoryRouter, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, renderMatches, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };\n//# sourceMappingURL=index.js.map\n","/*!\n\tCopyright (c) 2018 Jed Watson.\n\tLicensed under the MIT License (MIT), see\n\thttp://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = '';\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (arg) {\n\t\t\t\tclasses = appendClass(classes, parseValue(arg));\n\t\t\t}\n\t\t}\n\n\t\treturn classes;\n\t}\n\n\tfunction parseValue (arg) {\n\t\tif (typeof arg === 'string' || typeof arg === 'number') {\n\t\t\treturn arg;\n\t\t}\n\n\t\tif (typeof arg !== 'object') {\n\t\t\treturn '';\n\t\t}\n\n\t\tif (Array.isArray(arg)) {\n\t\t\treturn classNames.apply(null, arg);\n\t\t}\n\n\t\tif (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {\n\t\t\treturn arg.toString();\n\t\t}\n\n\t\tvar classes = '';\n\n\t\tfor (var key in arg) {\n\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\tclasses = appendClass(classes, key);\n\t\t\t}\n\t\t}\n\n\t\treturn classes;\n\t}\n\n\tfunction appendClass (value, newClass) {\n\t\tif (!newClass) {\n\t\t\treturn value;\n\t\t}\n\t\n\t\tif (value) {\n\t\t\treturn value + ' ' + newClass;\n\t\t}\n\t\n\t\treturn value + newClass;\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar $Error = Error;\nvar replace = uncurryThis(''.replace);\n\nvar TEST = (function (arg) { return String(new $Error(arg).stack); })('zxcasd');\n// eslint-disable-next-line redos/no-vulnerable -- safe\nvar V8_OR_CHAKRA_STACK_ENTRY = /\\n\\s*at [^:]*:[^\\n]*/;\nvar IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);\n\nmodule.exports = function (stack, dropEntries) {\n  if (IS_V8_OR_CHAKRA_STACK && typeof stack == 'string' && !$Error.prepareStackTrace) {\n    while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, '');\n  } return stack;\n};\n","'use strict';\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar clearErrorStack = require('../internals/error-stack-clear');\nvar ERROR_STACK_INSTALLABLE = require('../internals/error-stack-installable');\n\n// non-standard V8\nvar captureStackTrace = Error.captureStackTrace;\n\nmodule.exports = function (error, C, stack, dropEntries) {\n  if (ERROR_STACK_INSTALLABLE) {\n    if (captureStackTrace) captureStackTrace(error, C);\n    else createNonEnumerableProperty(error, 'stack', clearErrorStack(stack, dropEntries));\n  }\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = !fails(function () {\n  var error = new Error('a');\n  if (!('stack' in error)) return true;\n  // eslint-disable-next-line es/no-object-defineproperty -- safe\n  Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7));\n  return error.stack !== 7;\n});\n","'use strict';\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\n// `InstallErrorCause` abstract operation\n// https://tc39.es/proposal-error-cause/#sec-errorobjects-install-error-cause\nmodule.exports = function (O, options) {\n  if (isObject(options) && 'cause' in options) {\n    createNonEnumerableProperty(O, 'cause', options.cause);\n  }\n};\n","'use strict';\nvar toString = require('../internals/to-string');\n\nmodule.exports = function (argument, $default) {\n  return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument);\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar hasOwn = require('../internals/has-own-property');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar proxyAccessor = require('../internals/proxy-accessor');\nvar inheritIfRequired = require('../internals/inherit-if-required');\nvar normalizeStringArgument = require('../internals/normalize-string-argument');\nvar installErrorCause = require('../internals/install-error-cause');\nvar installErrorStack = require('../internals/error-stack-install');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IS_PURE = require('../internals/is-pure');\n\nmodule.exports = function (FULL_NAME, wrapper, FORCED, IS_AGGREGATE_ERROR) {\n  var STACK_TRACE_LIMIT = 'stackTraceLimit';\n  var OPTIONS_POSITION = IS_AGGREGATE_ERROR ? 2 : 1;\n  var path = FULL_NAME.split('.');\n  var ERROR_NAME = path[path.length - 1];\n  var OriginalError = getBuiltIn.apply(null, path);\n\n  if (!OriginalError) return;\n\n  var OriginalErrorPrototype = OriginalError.prototype;\n\n  // V8 9.3- bug https://bugs.chromium.org/p/v8/issues/detail?id=12006\n  if (!IS_PURE && hasOwn(OriginalErrorPrototype, 'cause')) delete OriginalErrorPrototype.cause;\n\n  if (!FORCED) return OriginalError;\n\n  var BaseError = getBuiltIn('Error');\n\n  var WrappedError = wrapper(function (a, b) {\n    var message = normalizeStringArgument(IS_AGGREGATE_ERROR ? b : a, undefined);\n    var result = IS_AGGREGATE_ERROR ? new OriginalError(a) : new OriginalError();\n    if (message !== undefined) createNonEnumerableProperty(result, 'message', message);\n    installErrorStack(result, WrappedError, result.stack, 2);\n    if (this && isPrototypeOf(OriginalErrorPrototype, this)) inheritIfRequired(result, this, WrappedError);\n    if (arguments.length > OPTIONS_POSITION) installErrorCause(result, arguments[OPTIONS_POSITION]);\n    return result;\n  });\n\n  WrappedError.prototype = OriginalErrorPrototype;\n\n  if (ERROR_NAME !== 'Error') {\n    if (setPrototypeOf) setPrototypeOf(WrappedError, BaseError);\n    else copyConstructorProperties(WrappedError, BaseError, { name: true });\n  } else if (DESCRIPTORS && STACK_TRACE_LIMIT in OriginalError) {\n    proxyAccessor(WrappedError, OriginalError, STACK_TRACE_LIMIT);\n    proxyAccessor(WrappedError, OriginalError, 'prepareStackTrace');\n  }\n\n  copyConstructorProperties(WrappedError, OriginalError);\n\n  if (!IS_PURE) try {\n    // Safari 13- bug: WebAssembly errors does not have a proper `.name`\n    if (OriginalErrorPrototype.name !== ERROR_NAME) {\n      createNonEnumerableProperty(OriginalErrorPrototype, 'name', ERROR_NAME);\n    }\n    OriginalErrorPrototype.constructor = WrappedError;\n  } catch (error) { /* empty */ }\n\n  return WrappedError;\n};\n","'use strict';\n/* eslint-disable no-unused-vars -- required for functions `.length` */\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar wrapErrorConstructorWithCause = require('../internals/wrap-error-constructor-with-cause');\n\nvar WEB_ASSEMBLY = 'WebAssembly';\nvar WebAssembly = global[WEB_ASSEMBLY];\n\n// eslint-disable-next-line es/no-error-cause -- feature detection\nvar FORCED = new Error('e', { cause: 7 }).cause !== 7;\n\nvar exportGlobalErrorCauseWrapper = function (ERROR_NAME, wrapper) {\n  var O = {};\n  O[ERROR_NAME] = wrapErrorConstructorWithCause(ERROR_NAME, wrapper, FORCED);\n  $({ global: true, constructor: true, arity: 1, forced: FORCED }, O);\n};\n\nvar exportWebAssemblyErrorCauseWrapper = function (ERROR_NAME, wrapper) {\n  if (WebAssembly && WebAssembly[ERROR_NAME]) {\n    var O = {};\n    O[ERROR_NAME] = wrapErrorConstructorWithCause(WEB_ASSEMBLY + '.' + ERROR_NAME, wrapper, FORCED);\n    $({ target: WEB_ASSEMBLY, stat: true, constructor: true, arity: 1, forced: FORCED }, O);\n  }\n};\n\n// https://tc39.es/ecma262/#sec-nativeerror\nexportGlobalErrorCauseWrapper('Error', function (init) {\n  return function Error(message) { return apply(init, this, arguments); };\n});\nexportGlobalErrorCauseWrapper('EvalError', function (init) {\n  return function EvalError(message) { return apply(init, this, arguments); };\n});\nexportGlobalErrorCauseWrapper('RangeError', function (init) {\n  return function RangeError(message) { return apply(init, this, arguments); };\n});\nexportGlobalErrorCauseWrapper('ReferenceError', function (init) {\n  return function ReferenceError(message) { return apply(init, this, arguments); };\n});\nexportGlobalErrorCauseWrapper('SyntaxError', function (init) {\n  return function SyntaxError(message) { return apply(init, this, arguments); };\n});\nexportGlobalErrorCauseWrapper('TypeError', function (init) {\n  return function TypeError(message) { return apply(init, this, arguments); };\n});\nexportGlobalErrorCauseWrapper('URIError', function (init) {\n  return function URIError(message) { return apply(init, this, arguments); };\n});\nexportWebAssemblyErrorCauseWrapper('CompileError', function (init) {\n  return function CompileError(message) { return apply(init, this, arguments); };\n});\nexportWebAssemblyErrorCauseWrapper('LinkError', function (init) {\n  return function LinkError(message) { return apply(init, this, arguments); };\n});\nexportWebAssemblyErrorCauseWrapper('RuntimeError', function (init) {\n  return function RuntimeError(message) { return apply(init, this, arguments); };\n});\n","\"use client\";\nvar __defProp = Object.defineProperty;\nvar __defProps = Object.defineProperties;\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));\nvar __objRest = (source, exclude) => {\n  var target = {};\n  for (var prop in source)\n    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)\n      target[prop] = source[prop];\n  if (source != null && __getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(source)) {\n      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))\n        target[prop] = source[prop];\n    }\n  return target;\n};\n\nexport {\n  __spreadValues,\n  __spreadProps,\n  __objRest\n};\n","\"use client\";\n\n// src/utils/array.ts\nfunction toArray(arg) {\n  if (Array.isArray(arg)) {\n    return arg;\n  }\n  return typeof arg !== \"undefined\" ? [arg] : [];\n}\nfunction addItemToArray(array, item, index = -1) {\n  if (!(index in array)) {\n    return [...array, item];\n  }\n  return [...array.slice(0, index), item, ...array.slice(index)];\n}\nfunction flatten2DArray(array) {\n  const flattened = [];\n  for (const row of array) {\n    flattened.push(...row);\n  }\n  return flattened;\n}\nfunction reverseArray(array) {\n  return array.slice().reverse();\n}\n\nexport {\n  toArray,\n  addItemToArray,\n  flatten2DArray,\n  reverseArray\n};\n","\"use client\";\nimport {\n  createCollectionStore\n} from \"./CYQWQL4J.js\";\nimport {\n  flatten2DArray,\n  reverseArray\n} from \"./7PRQYBBV.js\";\nimport {\n  createStore,\n  setup,\n  sync\n} from \"./BCALMBPZ.js\";\nimport {\n  defaultValue\n} from \"./PBFD2E7P.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/composite/composite-store.ts\nvar NULL_ITEM = { id: null };\nfunction findFirstEnabledItem(items, excludeId) {\n  return items.find((item) => {\n    if (excludeId) {\n      return !item.disabled && item.id !== excludeId;\n    }\n    return !item.disabled;\n  });\n}\nfunction getEnabledItems(items, excludeId) {\n  return items.filter((item) => {\n    if (excludeId) {\n      return !item.disabled && item.id !== excludeId;\n    }\n    return !item.disabled;\n  });\n}\nfunction getItemsInRow(items, rowId) {\n  return items.filter((item) => item.rowId === rowId);\n}\nfunction flipItems(items, activeId, shouldInsertNullItem = false) {\n  const index = items.findIndex((item) => item.id === activeId);\n  return [\n    ...items.slice(index + 1),\n    ...shouldInsertNullItem ? [NULL_ITEM] : [],\n    ...items.slice(0, index)\n  ];\n}\nfunction groupItemsByRows(items) {\n  const rows = [];\n  for (const item of items) {\n    const row = rows.find((currentRow) => {\n      var _a;\n      return ((_a = currentRow[0]) == null ? void 0 : _a.rowId) === item.rowId;\n    });\n    if (row) {\n      row.push(item);\n    } else {\n      rows.push([item]);\n    }\n  }\n  return rows;\n}\nfunction getMaxRowLength(array) {\n  let maxLength = 0;\n  for (const { length } of array) {\n    if (length > maxLength) {\n      maxLength = length;\n    }\n  }\n  return maxLength;\n}\nfunction createEmptyItem(rowId) {\n  return {\n    id: \"__EMPTY_ITEM__\",\n    disabled: true,\n    rowId\n  };\n}\nfunction normalizeRows(rows, activeId, focusShift) {\n  const maxLength = getMaxRowLength(rows);\n  for (const row of rows) {\n    for (let i = 0; i < maxLength; i += 1) {\n      const item = row[i];\n      if (!item || focusShift && item.disabled) {\n        const isFirst = i === 0;\n        const previousItem = isFirst && focusShift ? findFirstEnabledItem(row) : row[i - 1];\n        row[i] = previousItem && activeId !== previousItem.id && focusShift ? previousItem : createEmptyItem(previousItem == null ? void 0 : previousItem.rowId);\n      }\n    }\n  }\n  return rows;\n}\nfunction verticalizeItems(items) {\n  const rows = groupItemsByRows(items);\n  const maxLength = getMaxRowLength(rows);\n  const verticalized = [];\n  for (let i = 0; i < maxLength; i += 1) {\n    for (const row of rows) {\n      const item = row[i];\n      if (item) {\n        verticalized.push(__spreadProps(__spreadValues({}, item), {\n          // If there's no rowId, it means that it's not a grid composite, but\n          // a single row instead. So, instead of verticalizing it, that is,\n          // assigning a different rowId based on the column index, we keep it\n          // undefined so they will be part of the same row. This is useful\n          // when using up/down on one-dimensional composites.\n          rowId: item.rowId ? `${i}` : void 0\n        }));\n      }\n    }\n  }\n  return verticalized;\n}\nfunction createCompositeStore(props = {}) {\n  var _a;\n  const syncState = (_a = props.store) == null ? void 0 : _a.getState();\n  const collection = createCollectionStore(props);\n  const activeId = defaultValue(\n    props.activeId,\n    syncState == null ? void 0 : syncState.activeId,\n    props.defaultActiveId\n  );\n  const initialState = __spreadProps(__spreadValues({}, collection.getState()), {\n    id: defaultValue(\n      props.id,\n      syncState == null ? void 0 : syncState.id,\n      `id-${Math.random().toString(36).slice(2, 8)}`\n    ),\n    activeId,\n    baseElement: defaultValue(syncState == null ? void 0 : syncState.baseElement, null),\n    includesBaseElement: defaultValue(\n      props.includesBaseElement,\n      syncState == null ? void 0 : syncState.includesBaseElement,\n      activeId === null\n    ),\n    moves: defaultValue(syncState == null ? void 0 : syncState.moves, 0),\n    orientation: defaultValue(\n      props.orientation,\n      syncState == null ? void 0 : syncState.orientation,\n      \"both\"\n    ),\n    rtl: defaultValue(props.rtl, syncState == null ? void 0 : syncState.rtl, false),\n    virtualFocus: defaultValue(\n      props.virtualFocus,\n      syncState == null ? void 0 : syncState.virtualFocus,\n      false\n    ),\n    focusLoop: defaultValue(props.focusLoop, syncState == null ? void 0 : syncState.focusLoop, false),\n    focusWrap: defaultValue(props.focusWrap, syncState == null ? void 0 : syncState.focusWrap, false),\n    focusShift: defaultValue(props.focusShift, syncState == null ? void 0 : syncState.focusShift, false)\n  });\n  const composite = createStore(initialState, collection, props.store);\n  setup(\n    composite,\n    () => sync(composite, [\"renderedItems\", \"activeId\"], (state) => {\n      composite.setState(\"activeId\", (activeId2) => {\n        var _a2;\n        if (activeId2 !== void 0) return activeId2;\n        return (_a2 = findFirstEnabledItem(state.renderedItems)) == null ? void 0 : _a2.id;\n      });\n    })\n  );\n  const getNextId = (direction = \"next\", options = {}) => {\n    var _a2, _b;\n    const defaultState = composite.getState();\n    const {\n      skip = 0,\n      activeId: activeId2 = defaultState.activeId,\n      focusShift = defaultState.focusShift,\n      focusLoop = defaultState.focusLoop,\n      focusWrap = defaultState.focusWrap,\n      includesBaseElement = defaultState.includesBaseElement,\n      renderedItems = defaultState.renderedItems,\n      rtl = defaultState.rtl\n    } = options;\n    const isVerticalDirection = direction === \"up\" || direction === \"down\";\n    const isNextDirection = direction === \"next\" || direction === \"down\";\n    const canReverse = isNextDirection ? rtl && !isVerticalDirection : !rtl || isVerticalDirection;\n    const canShift = focusShift && !skip;\n    let items = !isVerticalDirection ? renderedItems : flatten2DArray(\n      normalizeRows(groupItemsByRows(renderedItems), activeId2, canShift)\n    );\n    items = canReverse ? reverseArray(items) : items;\n    items = isVerticalDirection ? verticalizeItems(items) : items;\n    if (activeId2 == null) {\n      return (_a2 = findFirstEnabledItem(items)) == null ? void 0 : _a2.id;\n    }\n    const activeItem = items.find((item) => item.id === activeId2);\n    if (!activeItem) {\n      return (_b = findFirstEnabledItem(items)) == null ? void 0 : _b.id;\n    }\n    const isGrid = items.some((item) => item.rowId);\n    const activeIndex = items.indexOf(activeItem);\n    const nextItems = items.slice(activeIndex + 1);\n    const nextItemsInRow = getItemsInRow(nextItems, activeItem.rowId);\n    if (skip) {\n      const nextEnabledItemsInRow = getEnabledItems(nextItemsInRow, activeId2);\n      const nextItem2 = nextEnabledItemsInRow.slice(skip)[0] || // If we can't find an item, just return the last one.\n      nextEnabledItemsInRow[nextEnabledItemsInRow.length - 1];\n      return nextItem2 == null ? void 0 : nextItem2.id;\n    }\n    const canLoop = focusLoop && (isVerticalDirection ? focusLoop !== \"horizontal\" : focusLoop !== \"vertical\");\n    const canWrap = isGrid && focusWrap && (isVerticalDirection ? focusWrap !== \"horizontal\" : focusWrap !== \"vertical\");\n    const hasNullItem = isNextDirection ? (!isGrid || isVerticalDirection) && canLoop && includesBaseElement : isVerticalDirection ? includesBaseElement : false;\n    if (canLoop) {\n      const loopItems = canWrap && !hasNullItem ? items : getItemsInRow(items, activeItem.rowId);\n      const sortedItems = flipItems(loopItems, activeId2, hasNullItem);\n      const nextItem2 = findFirstEnabledItem(sortedItems, activeId2);\n      return nextItem2 == null ? void 0 : nextItem2.id;\n    }\n    if (canWrap) {\n      const nextItem2 = findFirstEnabledItem(\n        // We can use nextItems, which contains all the next items, including\n        // items from other rows, to wrap between rows. However, if there is a\n        // null item (the composite container), we'll only use the next items in\n        // the row. So moving next from the last item will focus on the\n        // composite container. On grid composites, horizontal navigation never\n        // focuses on the composite container, only vertical.\n        hasNullItem ? nextItemsInRow : nextItems,\n        activeId2\n      );\n      const nextId = hasNullItem ? (nextItem2 == null ? void 0 : nextItem2.id) || null : nextItem2 == null ? void 0 : nextItem2.id;\n      return nextId;\n    }\n    const nextItem = findFirstEnabledItem(nextItemsInRow, activeId2);\n    if (!nextItem && hasNullItem) {\n      return null;\n    }\n    return nextItem == null ? void 0 : nextItem.id;\n  };\n  return __spreadProps(__spreadValues(__spreadValues({}, collection), composite), {\n    setBaseElement: (element) => composite.setState(\"baseElement\", element),\n    setActiveId: (id) => composite.setState(\"activeId\", id),\n    move: (id) => {\n      if (id === void 0) return;\n      composite.setState(\"activeId\", id);\n      composite.setState(\"moves\", (moves) => moves + 1);\n    },\n    first: () => {\n      var _a2;\n      return (_a2 = findFirstEnabledItem(composite.getState().renderedItems)) == null ? void 0 : _a2.id;\n    },\n    last: () => {\n      var _a2;\n      return (_a2 = findFirstEnabledItem(reverseArray(composite.getState().renderedItems))) == null ? void 0 : _a2.id;\n    },\n    next: (options) => {\n      if (options !== void 0 && typeof options === \"number\") {\n        options = { skip: options };\n      }\n      return getNextId(\"next\", options);\n    },\n    previous: (options) => {\n      if (options !== void 0 && typeof options === \"number\") {\n        options = { skip: options };\n      }\n      return getNextId(\"previous\", options);\n    },\n    down: (options) => {\n      if (options !== void 0 && typeof options === \"number\") {\n        options = { skip: options };\n      }\n      return getNextId(\"down\", options);\n    },\n    up: (options) => {\n      if (options !== void 0 && typeof options === \"number\") {\n        options = { skip: options };\n      }\n      return getNextId(\"up\", options);\n    }\n  });\n}\n\nexport {\n  createCompositeStore\n};\n","\"use client\";\nimport {\n  applyState,\n  chain,\n  getKeys,\n  hasOwnProperty,\n  invariant,\n  noop,\n  omit,\n  pick\n} from \"./PBFD2E7P.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/utils/store.ts\nfunction getInternal(store, key) {\n  const internals = store.__unstableInternals;\n  invariant(internals, \"Invalid store\");\n  return internals[key];\n}\nfunction createStore(initialState, ...stores) {\n  let state = initialState;\n  let prevStateBatch = state;\n  let lastUpdate = Symbol();\n  let destroy = noop;\n  const instances = /* @__PURE__ */ new Set();\n  const updatedKeys = /* @__PURE__ */ new Set();\n  const setups = /* @__PURE__ */ new Set();\n  const listeners = /* @__PURE__ */ new Set();\n  const batchListeners = /* @__PURE__ */ new Set();\n  const disposables = /* @__PURE__ */ new WeakMap();\n  const listenerKeys = /* @__PURE__ */ new WeakMap();\n  const storeSetup = (callback) => {\n    setups.add(callback);\n    return () => setups.delete(callback);\n  };\n  const storeInit = () => {\n    const initialized = instances.size;\n    const instance = Symbol();\n    instances.add(instance);\n    const maybeDestroy = () => {\n      instances.delete(instance);\n      if (instances.size) return;\n      destroy();\n    };\n    if (initialized) return maybeDestroy;\n    const desyncs = getKeys(state).map(\n      (key) => chain(\n        ...stores.map((store) => {\n          var _a;\n          const storeState = (_a = store == null ? void 0 : store.getState) == null ? void 0 : _a.call(store);\n          if (!storeState) return;\n          if (!hasOwnProperty(storeState, key)) return;\n          return sync(store, [key], (state2) => {\n            setState(\n              key,\n              state2[key],\n              // @ts-expect-error - Not public API. This is just to prevent\n              // infinite loops.\n              true\n            );\n          });\n        })\n      )\n    );\n    const teardowns = [];\n    for (const setup2 of setups) {\n      teardowns.push(setup2());\n    }\n    const cleanups = stores.map(init);\n    destroy = chain(...desyncs, ...teardowns, ...cleanups);\n    return maybeDestroy;\n  };\n  const sub = (keys, listener, set = listeners) => {\n    set.add(listener);\n    listenerKeys.set(listener, keys);\n    return () => {\n      var _a;\n      (_a = disposables.get(listener)) == null ? void 0 : _a();\n      disposables.delete(listener);\n      listenerKeys.delete(listener);\n      set.delete(listener);\n    };\n  };\n  const storeSubscribe = (keys, listener) => sub(keys, listener);\n  const storeSync = (keys, listener) => {\n    disposables.set(listener, listener(state, state));\n    return sub(keys, listener);\n  };\n  const storeBatch = (keys, listener) => {\n    disposables.set(listener, listener(state, prevStateBatch));\n    return sub(keys, listener, batchListeners);\n  };\n  const storePick = (keys) => createStore(pick(state, keys), finalStore);\n  const storeOmit = (keys) => createStore(omit(state, keys), finalStore);\n  const getState = () => state;\n  const setState = (key, value, fromStores = false) => {\n    var _a;\n    if (!hasOwnProperty(state, key)) return;\n    const nextValue = applyState(value, state[key]);\n    if (nextValue === state[key]) return;\n    if (!fromStores) {\n      for (const store of stores) {\n        (_a = store == null ? void 0 : store.setState) == null ? void 0 : _a.call(store, key, nextValue);\n      }\n    }\n    const prevState = state;\n    state = __spreadProps(__spreadValues({}, state), { [key]: nextValue });\n    const thisUpdate = Symbol();\n    lastUpdate = thisUpdate;\n    updatedKeys.add(key);\n    const run = (listener, prev, uKeys) => {\n      var _a2;\n      const keys = listenerKeys.get(listener);\n      const updated = (k) => uKeys ? uKeys.has(k) : k === key;\n      if (!keys || keys.some(updated)) {\n        (_a2 = disposables.get(listener)) == null ? void 0 : _a2();\n        disposables.set(listener, listener(state, prev));\n      }\n    };\n    for (const listener of listeners) {\n      run(listener, prevState);\n    }\n    queueMicrotask(() => {\n      if (lastUpdate !== thisUpdate) return;\n      const snapshot = state;\n      for (const listener of batchListeners) {\n        run(listener, prevStateBatch, updatedKeys);\n      }\n      prevStateBatch = snapshot;\n      updatedKeys.clear();\n    });\n  };\n  const finalStore = {\n    getState,\n    setState,\n    __unstableInternals: {\n      setup: storeSetup,\n      init: storeInit,\n      subscribe: storeSubscribe,\n      sync: storeSync,\n      batch: storeBatch,\n      pick: storePick,\n      omit: storeOmit\n    }\n  };\n  return finalStore;\n}\nfunction setup(store, ...args) {\n  if (!store) return;\n  return getInternal(store, \"setup\")(...args);\n}\nfunction init(store, ...args) {\n  if (!store) return;\n  return getInternal(store, \"init\")(...args);\n}\nfunction subscribe(store, ...args) {\n  if (!store) return;\n  return getInternal(store, \"subscribe\")(...args);\n}\nfunction sync(store, ...args) {\n  if (!store) return;\n  return getInternal(store, \"sync\")(...args);\n}\nfunction batch(store, ...args) {\n  if (!store) return;\n  return getInternal(store, \"batch\")(...args);\n}\nfunction omit2(store, ...args) {\n  if (!store) return;\n  return getInternal(store, \"omit\")(...args);\n}\nfunction pick2(store, ...args) {\n  if (!store) return;\n  return getInternal(store, \"pick\")(...args);\n}\nfunction mergeStore(...stores) {\n  const initialState = stores.reduce((state, store2) => {\n    var _a;\n    const nextState = (_a = store2 == null ? void 0 : store2.getState) == null ? void 0 : _a.call(store2);\n    if (!nextState) return state;\n    return Object.assign(state, nextState);\n  }, {});\n  const store = createStore(initialState, ...stores);\n  return Object.assign({}, ...stores, store);\n}\nfunction throwOnConflictingProps(props, store) {\n  if (process.env.NODE_ENV === \"production\") return;\n  if (!store) return;\n  const defaultKeys = Object.entries(props).filter(([key, value]) => key.startsWith(\"default\") && value !== void 0).map(([key]) => {\n    var _a;\n    const stateKey = key.replace(\"default\", \"\");\n    return `${((_a = stateKey[0]) == null ? void 0 : _a.toLowerCase()) || \"\"}${stateKey.slice(1)}`;\n  });\n  if (!defaultKeys.length) return;\n  const storeState = store.getState();\n  const conflictingProps = defaultKeys.filter(\n    (key) => hasOwnProperty(storeState, key)\n  );\n  if (!conflictingProps.length) return;\n  throw new Error(\n    `Passing a store prop in conjunction with a default state is not supported.\n\nconst store = useSelectStore();\n<SelectProvider store={store} defaultValue=\"Apple\" />\n                ^             ^\n\nInstead, pass the default state to the topmost store:\n\nconst store = useSelectStore({ defaultValue: \"Apple\" });\n<SelectProvider store={store} />\n\nSee https://github.com/ariakit/ariakit/pull/2745 for more details.\n\nIf there's a particular need for this, please submit a feature request at https://github.com/ariakit/ariakit\n`\n  );\n}\n\nexport {\n  createStore,\n  setup,\n  init,\n  subscribe,\n  sync,\n  batch,\n  omit2 as omit,\n  pick2 as pick,\n  mergeStore,\n  throwOnConflictingProps\n};\n","\"use client\";\nimport {\n  batch,\n  createStore,\n  init,\n  setup,\n  throwOnConflictingProps\n} from \"./BCALMBPZ.js\";\nimport {\n  chain,\n  defaultValue\n} from \"./PBFD2E7P.js\";\nimport {\n  getDocument,\n  sortBasedOnDOMPosition\n} from \"./DTR5TSDJ.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/collection/collection-store.ts\nfunction getCommonParent(items) {\n  var _a;\n  const firstItem = items.find((item) => !!item.element);\n  const lastItem = [...items].reverse().find((item) => !!item.element);\n  let parentElement = (_a = firstItem == null ? void 0 : firstItem.element) == null ? void 0 : _a.parentElement;\n  while (parentElement && (lastItem == null ? void 0 : lastItem.element)) {\n    const parent = parentElement;\n    if (lastItem && parent.contains(lastItem.element)) {\n      return parentElement;\n    }\n    parentElement = parentElement.parentElement;\n  }\n  return getDocument(parentElement).body;\n}\nfunction getPrivateStore(store) {\n  return store == null ? void 0 : store.__unstablePrivateStore;\n}\nfunction createCollectionStore(props = {}) {\n  var _a;\n  throwOnConflictingProps(props, props.store);\n  const syncState = (_a = props.store) == null ? void 0 : _a.getState();\n  const items = defaultValue(\n    props.items,\n    syncState == null ? void 0 : syncState.items,\n    props.defaultItems,\n    []\n  );\n  const itemsMap = new Map(items.map((item) => [item.id, item]));\n  const initialState = {\n    items,\n    renderedItems: defaultValue(syncState == null ? void 0 : syncState.renderedItems, [])\n  };\n  const syncPrivateStore = getPrivateStore(props.store);\n  const privateStore = createStore(\n    { items, renderedItems: initialState.renderedItems },\n    syncPrivateStore\n  );\n  const collection = createStore(initialState, props.store);\n  const sortItems = (renderedItems) => {\n    const sortedItems = sortBasedOnDOMPosition(renderedItems, (i) => i.element);\n    privateStore.setState(\"renderedItems\", sortedItems);\n    collection.setState(\"renderedItems\", sortedItems);\n  };\n  setup(collection, () => init(privateStore));\n  setup(privateStore, () => {\n    return batch(privateStore, [\"items\"], (state) => {\n      collection.setState(\"items\", state.items);\n    });\n  });\n  setup(privateStore, () => {\n    return batch(privateStore, [\"renderedItems\"], (state) => {\n      let firstRun = true;\n      let raf = requestAnimationFrame(() => {\n        const { renderedItems } = collection.getState();\n        if (state.renderedItems === renderedItems) return;\n        sortItems(state.renderedItems);\n      });\n      if (typeof IntersectionObserver !== \"function\") {\n        return () => cancelAnimationFrame(raf);\n      }\n      const ioCallback = () => {\n        if (firstRun) {\n          firstRun = false;\n          return;\n        }\n        cancelAnimationFrame(raf);\n        raf = requestAnimationFrame(() => sortItems(state.renderedItems));\n      };\n      const root = getCommonParent(state.renderedItems);\n      const observer = new IntersectionObserver(ioCallback, { root });\n      for (const item of state.renderedItems) {\n        if (!item.element) continue;\n        observer.observe(item.element);\n      }\n      return () => {\n        cancelAnimationFrame(raf);\n        observer.disconnect();\n      };\n    });\n  });\n  const mergeItem = (item, setItems, canDeleteFromMap = false) => {\n    let prevItem;\n    setItems((items2) => {\n      const index = items2.findIndex(({ id }) => id === item.id);\n      const nextItems = items2.slice();\n      if (index !== -1) {\n        prevItem = items2[index];\n        const nextItem = __spreadValues(__spreadValues({}, prevItem), item);\n        nextItems[index] = nextItem;\n        itemsMap.set(item.id, nextItem);\n      } else {\n        nextItems.push(item);\n        itemsMap.set(item.id, item);\n      }\n      return nextItems;\n    });\n    const unmergeItem = () => {\n      setItems((items2) => {\n        if (!prevItem) {\n          if (canDeleteFromMap) {\n            itemsMap.delete(item.id);\n          }\n          return items2.filter(({ id }) => id !== item.id);\n        }\n        const index = items2.findIndex(({ id }) => id === item.id);\n        if (index === -1) return items2;\n        const nextItems = items2.slice();\n        nextItems[index] = prevItem;\n        itemsMap.set(item.id, prevItem);\n        return nextItems;\n      });\n    };\n    return unmergeItem;\n  };\n  const registerItem = (item) => mergeItem(\n    item,\n    (getItems) => privateStore.setState(\"items\", getItems),\n    true\n  );\n  return __spreadProps(__spreadValues({}, collection), {\n    registerItem,\n    renderItem: (item) => chain(\n      registerItem(item),\n      mergeItem(\n        item,\n        (getItems) => privateStore.setState(\"renderedItems\", getItems)\n      )\n    ),\n    item: (id) => {\n      if (!id) return null;\n      let item = itemsMap.get(id);\n      if (!item) {\n        const { items: items2 } = privateStore.getState();\n        item = items2.find((item2) => item2.id === id);\n        if (item) {\n          itemsMap.set(id, item);\n        }\n      }\n      return item || null;\n    },\n    // @ts-expect-error Internal\n    __unstablePrivateStore: privateStore\n  });\n}\n\nexport {\n  createCollectionStore\n};\n","\"use client\";\n\n// src/utils/dom.ts\nvar canUseDOM = checkIsBrowser();\nfunction checkIsBrowser() {\n  var _a;\n  return typeof window !== \"undefined\" && !!((_a = window.document) == null ? void 0 : _a.createElement);\n}\nfunction getDocument(node) {\n  if (!node) return document;\n  if (\"self\" in node) return node.document;\n  return node.ownerDocument || document;\n}\nfunction getWindow(node) {\n  if (!node) return self;\n  if (\"self\" in node) return node.self;\n  return getDocument(node).defaultView || window;\n}\nfunction getActiveElement(node, activeDescendant = false) {\n  const { activeElement } = getDocument(node);\n  if (!(activeElement == null ? void 0 : activeElement.nodeName)) {\n    return null;\n  }\n  if (isFrame(activeElement) && activeElement.contentDocument) {\n    return getActiveElement(\n      activeElement.contentDocument.body,\n      activeDescendant\n    );\n  }\n  if (activeDescendant) {\n    const id = activeElement.getAttribute(\"aria-activedescendant\");\n    if (id) {\n      const element = getDocument(activeElement).getElementById(id);\n      if (element) {\n        return element;\n      }\n    }\n  }\n  return activeElement;\n}\nfunction contains(parent, child) {\n  return parent === child || parent.contains(child);\n}\nfunction isFrame(element) {\n  return element.tagName === \"IFRAME\";\n}\nfunction isButton(element) {\n  const tagName = element.tagName.toLowerCase();\n  if (tagName === \"button\") return true;\n  if (tagName === \"input\" && element.type) {\n    return buttonInputTypes.indexOf(element.type) !== -1;\n  }\n  return false;\n}\nvar buttonInputTypes = [\n  \"button\",\n  \"color\",\n  \"file\",\n  \"image\",\n  \"reset\",\n  \"submit\"\n];\nfunction isVisible(element) {\n  if (typeof element.checkVisibility === \"function\") {\n    return element.checkVisibility();\n  }\n  const htmlElement = element;\n  return htmlElement.offsetWidth > 0 || htmlElement.offsetHeight > 0 || element.getClientRects().length > 0;\n}\nfunction isTextField(element) {\n  try {\n    const isTextInput = element instanceof HTMLInputElement && element.selectionStart !== null;\n    const isTextArea = element.tagName === \"TEXTAREA\";\n    return isTextInput || isTextArea || false;\n  } catch (error) {\n    return false;\n  }\n}\nfunction isTextbox(element) {\n  return element.isContentEditable || isTextField(element);\n}\nfunction getTextboxValue(element) {\n  if (isTextField(element)) {\n    return element.value;\n  }\n  if (element.isContentEditable) {\n    const range = getDocument(element).createRange();\n    range.selectNodeContents(element);\n    return range.toString();\n  }\n  return \"\";\n}\nfunction getTextboxSelection(element) {\n  let start = 0;\n  let end = 0;\n  if (isTextField(element)) {\n    start = element.selectionStart || 0;\n    end = element.selectionEnd || 0;\n  } else if (element.isContentEditable) {\n    const selection = getDocument(element).getSelection();\n    if ((selection == null ? void 0 : selection.rangeCount) && selection.anchorNode && contains(element, selection.anchorNode) && selection.focusNode && contains(element, selection.focusNode)) {\n      const range = selection.getRangeAt(0);\n      const nextRange = range.cloneRange();\n      nextRange.selectNodeContents(element);\n      nextRange.setEnd(range.startContainer, range.startOffset);\n      start = nextRange.toString().length;\n      nextRange.setEnd(range.endContainer, range.endOffset);\n      end = nextRange.toString().length;\n    }\n  }\n  return { start, end };\n}\nfunction getPopupRole(element, fallback) {\n  const allowedPopupRoles = [\"dialog\", \"menu\", \"listbox\", \"tree\", \"grid\"];\n  const role = element == null ? void 0 : element.getAttribute(\"role\");\n  if (role && allowedPopupRoles.indexOf(role) !== -1) {\n    return role;\n  }\n  return fallback;\n}\nfunction getPopupItemRole(element, fallback) {\n  var _a;\n  const itemRoleByPopupRole = {\n    menu: \"menuitem\",\n    listbox: \"option\",\n    tree: \"treeitem\"\n  };\n  const popupRole = getPopupRole(element);\n  if (!popupRole) return fallback;\n  const key = popupRole;\n  return (_a = itemRoleByPopupRole[key]) != null ? _a : fallback;\n}\nfunction scrollIntoViewIfNeeded(element, arg) {\n  if (isPartiallyHidden(element) && \"scrollIntoView\" in element) {\n    element.scrollIntoView(arg);\n  }\n}\nfunction getScrollingElement(element) {\n  if (!element) return null;\n  const isScrollableOverflow = (overflow) => {\n    if (overflow === \"auto\") return true;\n    if (overflow === \"scroll\") return true;\n    return false;\n  };\n  if (element.clientHeight && element.scrollHeight > element.clientHeight) {\n    const { overflowY } = getComputedStyle(element);\n    if (isScrollableOverflow(overflowY)) return element;\n  } else if (element.clientWidth && element.scrollWidth > element.clientWidth) {\n    const { overflowX } = getComputedStyle(element);\n    if (isScrollableOverflow(overflowX)) return element;\n  }\n  return getScrollingElement(element.parentElement) || document.scrollingElement || document.body;\n}\nfunction isPartiallyHidden(element) {\n  const elementRect = element.getBoundingClientRect();\n  const scroller = getScrollingElement(element);\n  if (!scroller) return false;\n  const scrollerRect = scroller.getBoundingClientRect();\n  const isHTML = scroller.tagName === \"HTML\";\n  const scrollerTop = isHTML ? scrollerRect.top + scroller.scrollTop : scrollerRect.top;\n  const scrollerBottom = isHTML ? scroller.clientHeight : scrollerRect.bottom;\n  const scrollerLeft = isHTML ? scrollerRect.left + scroller.scrollLeft : scrollerRect.left;\n  const scrollerRight = isHTML ? scroller.clientWidth : scrollerRect.right;\n  const top = elementRect.top < scrollerTop;\n  const left = elementRect.left < scrollerLeft;\n  const bottom = elementRect.bottom > scrollerBottom;\n  const right = elementRect.right > scrollerRight;\n  return top || left || bottom || right;\n}\nfunction setSelectionRange(element, ...args) {\n  if (/text|search|password|tel|url/i.test(element.type)) {\n    element.setSelectionRange(...args);\n  }\n}\nfunction sortBasedOnDOMPosition(items, getElement) {\n  const pairs = items.map((item, index) => [index, item]);\n  let isOrderDifferent = false;\n  pairs.sort(([indexA, a], [indexB, b]) => {\n    const elementA = getElement(a);\n    const elementB = getElement(b);\n    if (elementA === elementB) return 0;\n    if (!elementA || !elementB) return 0;\n    if (isElementPreceding(elementA, elementB)) {\n      if (indexA > indexB) {\n        isOrderDifferent = true;\n      }\n      return -1;\n    }\n    if (indexA < indexB) {\n      isOrderDifferent = true;\n    }\n    return 1;\n  });\n  if (isOrderDifferent) {\n    return pairs.map(([_, item]) => item);\n  }\n  return items;\n}\nfunction isElementPreceding(a, b) {\n  return Boolean(\n    b.compareDocumentPosition(a) & Node.DOCUMENT_POSITION_PRECEDING\n  );\n}\n\nexport {\n  canUseDOM,\n  getDocument,\n  getWindow,\n  getActiveElement,\n  contains,\n  isFrame,\n  isButton,\n  isVisible,\n  isTextField,\n  isTextbox,\n  getTextboxValue,\n  getTextboxSelection,\n  getPopupRole,\n  getPopupItemRole,\n  scrollIntoViewIfNeeded,\n  getScrollingElement,\n  isPartiallyHidden,\n  setSelectionRange,\n  sortBasedOnDOMPosition\n};\n","\"use client\";\nimport {\n  createDisclosureStore\n} from \"./RCQ5P4YE.js\";\n\n// src/dialog/dialog-store.ts\nfunction createDialogStore(props = {}) {\n  return createDisclosureStore(props);\n}\n\nexport {\n  createDialogStore\n};\n","\"use client\";\nimport {\n  createPopoverStore\n} from \"./ME2CUF3F.js\";\nimport {\n  createStore\n} from \"./BCALMBPZ.js\";\nimport {\n  defaultValue\n} from \"./PBFD2E7P.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/hovercard/hovercard-store.ts\nfunction createHovercardStore(props = {}) {\n  var _a;\n  const syncState = (_a = props.store) == null ? void 0 : _a.getState();\n  const popover = createPopoverStore(__spreadProps(__spreadValues({}, props), {\n    placement: defaultValue(\n      props.placement,\n      syncState == null ? void 0 : syncState.placement,\n      \"bottom\"\n    )\n  }));\n  const timeout = defaultValue(props.timeout, syncState == null ? void 0 : syncState.timeout, 500);\n  const initialState = __spreadProps(__spreadValues({}, popover.getState()), {\n    timeout,\n    showTimeout: defaultValue(props.showTimeout, syncState == null ? void 0 : syncState.showTimeout),\n    hideTimeout: defaultValue(props.hideTimeout, syncState == null ? void 0 : syncState.hideTimeout),\n    autoFocusOnShow: defaultValue(syncState == null ? void 0 : syncState.autoFocusOnShow, false)\n  });\n  const hovercard = createStore(initialState, popover, props.store);\n  return __spreadProps(__spreadValues(__spreadValues({}, popover), hovercard), {\n    setAutoFocusOnShow: (value) => hovercard.setState(\"autoFocusOnShow\", value)\n  });\n}\n\nexport {\n  createHovercardStore\n};\n","\"use client\";\nimport {\n  createDialogStore\n} from \"./FZZ2AVHF.js\";\nimport {\n  createStore,\n  mergeStore,\n  omit,\n  throwOnConflictingProps\n} from \"./BCALMBPZ.js\";\nimport {\n  defaultValue\n} from \"./PBFD2E7P.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/popover/popover-store.ts\nfunction createPopoverStore(_a = {}) {\n  var _b = _a, {\n    popover: otherPopover\n  } = _b, props = __objRest(_b, [\n    \"popover\"\n  ]);\n  const store = mergeStore(\n    props.store,\n    omit(otherPopover, [\n      \"arrowElement\",\n      \"anchorElement\",\n      \"contentElement\",\n      \"popoverElement\",\n      \"disclosureElement\"\n    ])\n  );\n  throwOnConflictingProps(props, store);\n  const syncState = store == null ? void 0 : store.getState();\n  const dialog = createDialogStore(__spreadProps(__spreadValues({}, props), { store }));\n  const placement = defaultValue(\n    props.placement,\n    syncState == null ? void 0 : syncState.placement,\n    \"bottom\"\n  );\n  const initialState = __spreadProps(__spreadValues({}, dialog.getState()), {\n    placement,\n    currentPlacement: placement,\n    anchorElement: defaultValue(syncState == null ? void 0 : syncState.anchorElement, null),\n    popoverElement: defaultValue(syncState == null ? void 0 : syncState.popoverElement, null),\n    arrowElement: defaultValue(syncState == null ? void 0 : syncState.arrowElement, null),\n    rendered: Symbol(\"rendered\")\n  });\n  const popover = createStore(initialState, dialog, store);\n  return __spreadProps(__spreadValues(__spreadValues({}, dialog), popover), {\n    setAnchorElement: (element) => popover.setState(\"anchorElement\", element),\n    setPopoverElement: (element) => popover.setState(\"popoverElement\", element),\n    setArrowElement: (element) => popover.setState(\"arrowElement\", element),\n    render: () => popover.setState(\"rendered\", Symbol(\"rendered\"))\n  });\n}\n\nexport {\n  createPopoverStore\n};\n","\"use client\";\nimport {\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/utils/misc.ts\nfunction noop(..._) {\n}\nfunction shallowEqual(a, b) {\n  if (a === b) return true;\n  if (!a) return false;\n  if (!b) return false;\n  if (typeof a !== \"object\") return false;\n  if (typeof b !== \"object\") return false;\n  const aKeys = Object.keys(a);\n  const bKeys = Object.keys(b);\n  const { length } = aKeys;\n  if (bKeys.length !== length) return false;\n  for (const key of aKeys) {\n    if (a[key] !== b[key]) {\n      return false;\n    }\n  }\n  return true;\n}\nfunction applyState(argument, currentValue) {\n  if (isUpdater(argument)) {\n    const value = isLazyValue(currentValue) ? currentValue() : currentValue;\n    return argument(value);\n  }\n  return argument;\n}\nfunction isUpdater(argument) {\n  return typeof argument === \"function\";\n}\nfunction isLazyValue(value) {\n  return typeof value === \"function\";\n}\nfunction isObject(arg) {\n  return typeof arg === \"object\" && arg != null;\n}\nfunction isEmpty(arg) {\n  if (Array.isArray(arg)) return !arg.length;\n  if (isObject(arg)) return !Object.keys(arg).length;\n  if (arg == null) return true;\n  if (arg === \"\") return true;\n  return false;\n}\nfunction isInteger(arg) {\n  if (typeof arg === \"number\") {\n    return Math.floor(arg) === arg;\n  }\n  return String(Math.floor(Number(arg))) === arg;\n}\nfunction hasOwnProperty(object, prop) {\n  if (typeof Object.hasOwn === \"function\") {\n    return Object.hasOwn(object, prop);\n  }\n  return Object.prototype.hasOwnProperty.call(object, prop);\n}\nfunction chain(...fns) {\n  return (...args) => {\n    for (const fn of fns) {\n      if (typeof fn === \"function\") {\n        fn(...args);\n      }\n    }\n  };\n}\nfunction cx(...args) {\n  return args.filter(Boolean).join(\" \") || void 0;\n}\nfunction normalizeString(str) {\n  return str.normalize(\"NFD\").replace(/[\\u0300-\\u036f]/g, \"\");\n}\nfunction omit(object, keys) {\n  const result = __spreadValues({}, object);\n  for (const key of keys) {\n    if (hasOwnProperty(result, key)) {\n      delete result[key];\n    }\n  }\n  return result;\n}\nfunction pick(object, paths) {\n  const result = {};\n  for (const key of paths) {\n    if (hasOwnProperty(object, key)) {\n      result[key] = object[key];\n    }\n  }\n  return result;\n}\nfunction identity(value) {\n  return value;\n}\nfunction beforePaint(cb = noop) {\n  const raf = requestAnimationFrame(cb);\n  return () => cancelAnimationFrame(raf);\n}\nfunction afterPaint(cb = noop) {\n  let raf = requestAnimationFrame(() => {\n    raf = requestAnimationFrame(cb);\n  });\n  return () => cancelAnimationFrame(raf);\n}\nfunction invariant(condition, message) {\n  if (condition) return;\n  if (typeof message !== \"string\") throw new Error(\"Invariant failed\");\n  throw new Error(message);\n}\nfunction getKeys(obj) {\n  return Object.keys(obj);\n}\nfunction isFalsyBooleanCallback(booleanOrCallback, ...args) {\n  const result = typeof booleanOrCallback === \"function\" ? booleanOrCallback(...args) : booleanOrCallback;\n  if (result == null) return false;\n  return !result;\n}\nfunction disabledFromProps(props) {\n  return props.disabled || props[\"aria-disabled\"] === true || props[\"aria-disabled\"] === \"true\";\n}\nfunction removeUndefinedValues(obj) {\n  const result = {};\n  for (const key in obj) {\n    if (obj[key] !== void 0) {\n      result[key] = obj[key];\n    }\n  }\n  return result;\n}\nfunction defaultValue(...values) {\n  for (const value of values) {\n    if (value !== void 0) return value;\n  }\n  return void 0;\n}\n\nexport {\n  noop,\n  shallowEqual,\n  applyState,\n  isObject,\n  isEmpty,\n  isInteger,\n  hasOwnProperty,\n  chain,\n  cx,\n  normalizeString,\n  omit,\n  pick,\n  identity,\n  beforePaint,\n  afterPaint,\n  invariant,\n  getKeys,\n  isFalsyBooleanCallback,\n  disabledFromProps,\n  removeUndefinedValues,\n  defaultValue\n};\n","\"use client\";\nimport {\n  canUseDOM\n} from \"./DTR5TSDJ.js\";\n\n// src/utils/platform.ts\nfunction isTouchDevice() {\n  return canUseDOM && !!navigator.maxTouchPoints;\n}\nfunction isApple() {\n  if (!canUseDOM) return false;\n  return /mac|iphone|ipad|ipod/i.test(navigator.platform);\n}\nfunction isSafari() {\n  return canUseDOM && isApple() && /apple/i.test(navigator.vendor);\n}\nfunction isFirefox() {\n  return canUseDOM && /firefox\\//i.test(navigator.userAgent);\n}\nfunction isMac() {\n  return canUseDOM && navigator.platform.startsWith(\"Mac\") && !isTouchDevice();\n}\n\nexport {\n  isTouchDevice,\n  isApple,\n  isSafari,\n  isFirefox,\n  isMac\n};\n","\"use client\";\nimport {\n  createStore,\n  mergeStore,\n  omit,\n  setup,\n  subscribe,\n  sync,\n  throwOnConflictingProps\n} from \"./BCALMBPZ.js\";\nimport {\n  defaultValue\n} from \"./PBFD2E7P.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/disclosure/disclosure-store.ts\nfunction createDisclosureStore(props = {}) {\n  const store = mergeStore(\n    props.store,\n    omit(props.disclosure, [\"contentElement\", \"disclosureElement\"])\n  );\n  throwOnConflictingProps(props, store);\n  const syncState = store == null ? void 0 : store.getState();\n  const open = defaultValue(\n    props.open,\n    syncState == null ? void 0 : syncState.open,\n    props.defaultOpen,\n    false\n  );\n  const animated = defaultValue(props.animated, syncState == null ? void 0 : syncState.animated, false);\n  const initialState = {\n    open,\n    animated,\n    animating: !!animated && open,\n    mounted: open,\n    contentElement: defaultValue(syncState == null ? void 0 : syncState.contentElement, null),\n    disclosureElement: defaultValue(syncState == null ? void 0 : syncState.disclosureElement, null)\n  };\n  const disclosure = createStore(initialState, store);\n  setup(\n    disclosure,\n    () => sync(disclosure, [\"animated\", \"animating\"], (state) => {\n      if (state.animated) return;\n      disclosure.setState(\"animating\", false);\n    })\n  );\n  setup(\n    disclosure,\n    () => subscribe(disclosure, [\"open\"], () => {\n      if (!disclosure.getState().animated) return;\n      disclosure.setState(\"animating\", true);\n    })\n  );\n  setup(\n    disclosure,\n    () => sync(disclosure, [\"open\", \"animating\"], (state) => {\n      disclosure.setState(\"mounted\", state.open || state.animating);\n    })\n  );\n  return __spreadProps(__spreadValues({}, disclosure), {\n    disclosure: props.disclosure,\n    setOpen: (value) => disclosure.setState(\"open\", value),\n    show: () => disclosure.setState(\"open\", true),\n    hide: () => disclosure.setState(\"open\", false),\n    toggle: () => disclosure.setState(\"open\", (open2) => !open2),\n    stopAnimation: () => disclosure.setState(\"animating\", false),\n    setContentElement: (value) => disclosure.setState(\"contentElement\", value),\n    setDisclosureElement: (value) => disclosure.setState(\"disclosureElement\", value)\n  });\n}\n\nexport {\n  createDisclosureStore\n};\n","\"use client\";\nimport {\n  isApple\n} from \"../__chunks/QAGXQEUG.js\";\nimport {\n  contains\n} from \"../__chunks/DTR5TSDJ.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"../__chunks/3YLGPPWQ.js\";\n\n// src/utils/events.ts\nfunction isPortalEvent(event) {\n  return Boolean(\n    event.currentTarget && !contains(event.currentTarget, event.target)\n  );\n}\nfunction isSelfTarget(event) {\n  return event.target === event.currentTarget;\n}\nfunction isOpeningInNewTab(event) {\n  const element = event.currentTarget;\n  if (!element) return false;\n  const isAppleDevice = isApple();\n  if (isAppleDevice && !event.metaKey) return false;\n  if (!isAppleDevice && !event.ctrlKey) return false;\n  const tagName = element.tagName.toLowerCase();\n  if (tagName === \"a\") return true;\n  if (tagName === \"button\" && element.type === \"submit\") return true;\n  if (tagName === \"input\" && element.type === \"submit\") return true;\n  return false;\n}\nfunction isDownloading(event) {\n  const element = event.currentTarget;\n  if (!element) return false;\n  const tagName = element.tagName.toLowerCase();\n  if (!event.altKey) return false;\n  if (tagName === \"a\") return true;\n  if (tagName === \"button\" && element.type === \"submit\") return true;\n  if (tagName === \"input\" && element.type === \"submit\") return true;\n  return false;\n}\nfunction fireEvent(element, type, eventInit) {\n  const event = new Event(type, eventInit);\n  return element.dispatchEvent(event);\n}\nfunction fireBlurEvent(element, eventInit) {\n  const event = new FocusEvent(\"blur\", eventInit);\n  const defaultAllowed = element.dispatchEvent(event);\n  const bubbleInit = __spreadProps(__spreadValues({}, eventInit), { bubbles: true });\n  element.dispatchEvent(new FocusEvent(\"focusout\", bubbleInit));\n  return defaultAllowed;\n}\nfunction fireFocusEvent(element, eventInit) {\n  const event = new FocusEvent(\"focus\", eventInit);\n  const defaultAllowed = element.dispatchEvent(event);\n  const bubbleInit = __spreadProps(__spreadValues({}, eventInit), { bubbles: true });\n  element.dispatchEvent(new FocusEvent(\"focusin\", bubbleInit));\n  return defaultAllowed;\n}\nfunction fireKeyboardEvent(element, type, eventInit) {\n  const event = new KeyboardEvent(type, eventInit);\n  return element.dispatchEvent(event);\n}\nfunction fireClickEvent(element, eventInit) {\n  const event = new MouseEvent(\"click\", eventInit);\n  return element.dispatchEvent(event);\n}\nfunction isFocusEventOutside(event, container) {\n  const containerElement = container || event.currentTarget;\n  const relatedTarget = event.relatedTarget;\n  return !relatedTarget || !contains(containerElement, relatedTarget);\n}\nfunction getInputType(event) {\n  const nativeEvent = \"nativeEvent\" in event ? event.nativeEvent : event;\n  if (!nativeEvent) return;\n  if (!(\"inputType\" in nativeEvent)) return;\n  if (typeof nativeEvent.inputType !== \"string\") return;\n  return nativeEvent.inputType;\n}\nfunction queueBeforeEvent(element, type, callback, timeout) {\n  const createTimer = (callback2) => {\n    if (timeout) {\n      const timerId2 = setTimeout(callback2, timeout);\n      return () => clearTimeout(timerId2);\n    }\n    const timerId = requestAnimationFrame(callback2);\n    return () => cancelAnimationFrame(timerId);\n  };\n  const cancelTimer = createTimer(() => {\n    element.removeEventListener(type, callSync, true);\n    callback();\n  });\n  const callSync = () => {\n    cancelTimer();\n    callback();\n  };\n  element.addEventListener(type, callSync, { once: true, capture: true });\n  return cancelTimer;\n}\nfunction addGlobalEventListener(type, listener, options, scope = window) {\n  const children = [];\n  try {\n    scope.document.addEventListener(type, listener, options);\n    for (const frame of Array.from(scope.frames)) {\n      children.push(addGlobalEventListener(type, listener, options, frame));\n    }\n  } catch (e) {\n  }\n  const removeEventListener = () => {\n    try {\n      scope.document.removeEventListener(type, listener, options);\n    } catch (e) {\n    }\n    for (const remove of children) {\n      remove();\n    }\n  };\n  return removeEventListener;\n}\nexport {\n  addGlobalEventListener,\n  fireBlurEvent,\n  fireClickEvent,\n  fireEvent,\n  fireFocusEvent,\n  fireKeyboardEvent,\n  getInputType,\n  isDownloading,\n  isFocusEventOutside,\n  isOpeningInNewTab,\n  isPortalEvent,\n  isSelfTarget,\n  queueBeforeEvent\n};\n","\"use client\";\nimport {\n  contains,\n  getActiveElement,\n  isFrame,\n  isVisible\n} from \"../__chunks/DTR5TSDJ.js\";\nimport {\n  __spreadValues\n} from \"../__chunks/3YLGPPWQ.js\";\n\n// src/utils/focus.ts\nvar selector = \"input:not([type='hidden']):not([disabled]), select:not([disabled]), textarea:not([disabled]), a[href], button:not([disabled]), [tabindex], summary, iframe, object, embed, area[href], audio[controls], video[controls], [contenteditable]:not([contenteditable='false'])\";\nfunction hasNegativeTabIndex(element) {\n  const tabIndex = Number.parseInt(element.getAttribute(\"tabindex\") || \"0\", 10);\n  return tabIndex < 0;\n}\nfunction isFocusable(element) {\n  if (!element.matches(selector)) return false;\n  if (!isVisible(element)) return false;\n  if (element.closest(\"[inert]\")) return false;\n  return true;\n}\nfunction isTabbable(element) {\n  if (!isFocusable(element)) return false;\n  if (hasNegativeTabIndex(element)) return false;\n  if (!(\"form\" in element)) return true;\n  if (!element.form) return true;\n  if (element.checked) return true;\n  if (element.type !== \"radio\") return true;\n  const radioGroup = element.form.elements.namedItem(element.name);\n  if (!radioGroup) return true;\n  if (!(\"length\" in radioGroup)) return true;\n  const activeElement = getActiveElement(element);\n  if (!activeElement) return true;\n  if (activeElement === element) return true;\n  if (!(\"form\" in activeElement)) return true;\n  if (activeElement.form !== element.form) return true;\n  if (activeElement.name !== element.name) return true;\n  return false;\n}\nfunction getAllFocusableIn(container, includeContainer) {\n  const elements = Array.from(\n    container.querySelectorAll(selector)\n  );\n  if (includeContainer) {\n    elements.unshift(container);\n  }\n  const focusableElements = elements.filter(isFocusable);\n  focusableElements.forEach((element, i) => {\n    if (isFrame(element) && element.contentDocument) {\n      const frameBody = element.contentDocument.body;\n      focusableElements.splice(i, 1, ...getAllFocusableIn(frameBody));\n    }\n  });\n  return focusableElements;\n}\nfunction getAllFocusable(includeBody) {\n  return getAllFocusableIn(document.body, includeBody);\n}\nfunction getFirstFocusableIn(container, includeContainer) {\n  const [first] = getAllFocusableIn(container, includeContainer);\n  return first || null;\n}\nfunction getFirstFocusable(includeBody) {\n  return getFirstFocusableIn(document.body, includeBody);\n}\nfunction getAllTabbableIn(container, includeContainer, fallbackToFocusable) {\n  const elements = Array.from(\n    container.querySelectorAll(selector)\n  );\n  const tabbableElements = elements.filter(isTabbable);\n  if (includeContainer && isTabbable(container)) {\n    tabbableElements.unshift(container);\n  }\n  tabbableElements.forEach((element, i) => {\n    if (isFrame(element) && element.contentDocument) {\n      const frameBody = element.contentDocument.body;\n      const allFrameTabbable = getAllTabbableIn(\n        frameBody,\n        false,\n        fallbackToFocusable\n      );\n      tabbableElements.splice(i, 1, ...allFrameTabbable);\n    }\n  });\n  if (!tabbableElements.length && fallbackToFocusable) {\n    return elements;\n  }\n  return tabbableElements;\n}\nfunction getAllTabbable(fallbackToFocusable) {\n  return getAllTabbableIn(document.body, false, fallbackToFocusable);\n}\nfunction getFirstTabbableIn(container, includeContainer, fallbackToFocusable) {\n  const [first] = getAllTabbableIn(\n    container,\n    includeContainer,\n    fallbackToFocusable\n  );\n  return first || null;\n}\nfunction getFirstTabbable(fallbackToFocusable) {\n  return getFirstTabbableIn(document.body, false, fallbackToFocusable);\n}\nfunction getLastTabbableIn(container, includeContainer, fallbackToFocusable) {\n  const allTabbable = getAllTabbableIn(\n    container,\n    includeContainer,\n    fallbackToFocusable\n  );\n  return allTabbable[allTabbable.length - 1] || null;\n}\nfunction getLastTabbable(fallbackToFocusable) {\n  return getLastTabbableIn(document.body, false, fallbackToFocusable);\n}\nfunction getNextTabbableIn(container, includeContainer, fallbackToFirst, fallbackToFocusable) {\n  const activeElement = getActiveElement(container);\n  const allFocusable = getAllFocusableIn(container, includeContainer);\n  const activeIndex = allFocusable.indexOf(activeElement);\n  const nextFocusableElements = allFocusable.slice(activeIndex + 1);\n  return nextFocusableElements.find(isTabbable) || (fallbackToFirst ? allFocusable.find(isTabbable) : null) || (fallbackToFocusable ? nextFocusableElements[0] : null) || null;\n}\nfunction getNextTabbable(fallbackToFirst, fallbackToFocusable) {\n  return getNextTabbableIn(\n    document.body,\n    false,\n    fallbackToFirst,\n    fallbackToFocusable\n  );\n}\nfunction getPreviousTabbableIn(container, includeContainer, fallbackToLast, fallbackToFocusable) {\n  const activeElement = getActiveElement(container);\n  const allFocusable = getAllFocusableIn(container, includeContainer).reverse();\n  const activeIndex = allFocusable.indexOf(activeElement);\n  const previousFocusableElements = allFocusable.slice(activeIndex + 1);\n  return previousFocusableElements.find(isTabbable) || (fallbackToLast ? allFocusable.find(isTabbable) : null) || (fallbackToFocusable ? previousFocusableElements[0] : null) || null;\n}\nfunction getPreviousTabbable(fallbackToFirst, fallbackToFocusable) {\n  return getPreviousTabbableIn(\n    document.body,\n    false,\n    fallbackToFirst,\n    fallbackToFocusable\n  );\n}\nfunction getClosestFocusable(element) {\n  while (element && !isFocusable(element)) {\n    element = element.closest(selector);\n  }\n  return element || null;\n}\nfunction hasFocus(element) {\n  const activeElement = getActiveElement(element);\n  if (!activeElement) return false;\n  if (activeElement === element) return true;\n  const activeDescendant = activeElement.getAttribute(\"aria-activedescendant\");\n  if (!activeDescendant) return false;\n  return activeDescendant === element.id;\n}\nfunction hasFocusWithin(element) {\n  const activeElement = getActiveElement(element);\n  if (!activeElement) return false;\n  if (contains(element, activeElement)) return true;\n  const activeDescendant = activeElement.getAttribute(\"aria-activedescendant\");\n  if (!activeDescendant) return false;\n  if (!(\"id\" in element)) return false;\n  if (activeDescendant === element.id) return true;\n  return !!element.querySelector(`#${CSS.escape(activeDescendant)}`);\n}\nfunction focusIfNeeded(element) {\n  if (!hasFocusWithin(element) && isFocusable(element)) {\n    element.focus();\n  }\n}\nfunction disableFocus(element) {\n  var _a;\n  const currentTabindex = (_a = element.getAttribute(\"tabindex\")) != null ? _a : \"\";\n  element.setAttribute(\"data-tabindex\", currentTabindex);\n  element.setAttribute(\"tabindex\", \"-1\");\n}\nfunction disableFocusIn(container, includeContainer) {\n  const tabbableElements = getAllTabbableIn(container, includeContainer);\n  for (const element of tabbableElements) {\n    disableFocus(element);\n  }\n}\nfunction restoreFocusIn(container) {\n  const elements = container.querySelectorAll(\"[data-tabindex]\");\n  const restoreTabIndex = (element) => {\n    const tabindex = element.getAttribute(\"data-tabindex\");\n    element.removeAttribute(\"data-tabindex\");\n    if (tabindex) {\n      element.setAttribute(\"tabindex\", tabindex);\n    } else {\n      element.removeAttribute(\"tabindex\");\n    }\n  };\n  if (container.hasAttribute(\"data-tabindex\")) {\n    restoreTabIndex(container);\n  }\n  for (const element of elements) {\n    restoreTabIndex(element);\n  }\n}\nfunction focusIntoView(element, options) {\n  if (!(\"scrollIntoView\" in element)) {\n    element.focus();\n  } else {\n    element.focus({ preventScroll: true });\n    element.scrollIntoView(__spreadValues({ block: \"nearest\", inline: \"nearest\" }, options));\n  }\n}\nexport {\n  disableFocus,\n  disableFocusIn,\n  focusIfNeeded,\n  focusIntoView,\n  getAllFocusable,\n  getAllFocusableIn,\n  getAllTabbable,\n  getAllTabbableIn,\n  getClosestFocusable,\n  getFirstFocusable,\n  getFirstFocusableIn,\n  getFirstTabbable,\n  getFirstTabbableIn,\n  getLastTabbable,\n  getLastTabbableIn,\n  getNextTabbable,\n  getNextTabbableIn,\n  getPreviousTabbable,\n  getPreviousTabbableIn,\n  hasFocus,\n  hasFocusWithin,\n  isFocusable,\n  isTabbable,\n  restoreFocusIn\n};\n","\"use client\";\nvar __defProp = Object.defineProperty;\nvar __defProps = Object.defineProperties;\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));\nvar __objRest = (source, exclude) => {\n  var target = {};\n  for (var prop in source)\n    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)\n      target[prop] = source[prop];\n  if (source != null && __getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(source)) {\n      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))\n        target[prop] = source[prop];\n    }\n  return target;\n};\n\nexport {\n  __spreadValues,\n  __spreadProps,\n  __objRest\n};\n","\"use client\";\nimport {\n  useStore,\n  useStoreProps\n} from \"./YV4JVR4I.js\";\nimport {\n  useUpdateEffect\n} from \"./ABQUS43J.js\";\n\n// src/collection/collection-store.ts\nimport * as Core from \"@ariakit/core/collection/collection-store\";\nfunction useCollectionStoreProps(store, update, props) {\n  useUpdateEffect(update, [props.store]);\n  useStoreProps(store, props, \"items\", \"setItems\");\n  return store;\n}\nfunction useCollectionStore(props = {}) {\n  const [store, update] = useStore(Core.createCollectionStore, props);\n  return useCollectionStoreProps(store, update, props);\n}\n\nexport {\n  useCollectionStoreProps,\n  useCollectionStore\n};\n","\"use client\";\nimport {\n  useCollectionStoreProps\n} from \"./C3IKGW5T.js\";\nimport {\n  useStore,\n  useStoreProps\n} from \"./YV4JVR4I.js\";\nimport {\n  useId\n} from \"./ABQUS43J.js\";\nimport {\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/composite/composite-store.ts\nimport * as Core from \"@ariakit/core/composite/composite-store\";\nfunction useCompositeStoreOptions(props) {\n  const id = useId(props.id);\n  return __spreadValues({ id }, props);\n}\nfunction useCompositeStoreProps(store, update, props) {\n  store = useCollectionStoreProps(store, update, props);\n  useStoreProps(store, props, \"activeId\", \"setActiveId\");\n  useStoreProps(store, props, \"includesBaseElement\");\n  useStoreProps(store, props, \"virtualFocus\");\n  useStoreProps(store, props, \"orientation\");\n  useStoreProps(store, props, \"rtl\");\n  useStoreProps(store, props, \"focusLoop\");\n  useStoreProps(store, props, \"focusWrap\");\n  useStoreProps(store, props, \"focusShift\");\n  return store;\n}\nfunction useCompositeStore(props = {}) {\n  props = useCompositeStoreOptions(props);\n  const [store, update] = useStore(Core.createCompositeStore, props);\n  return useCompositeStoreProps(store, update, props);\n}\n\nexport {\n  useCompositeStoreOptions,\n  useCompositeStoreProps,\n  useCompositeStore\n};\n","\"use client\";\n\n// src/composite/utils.ts\nimport { getDocument, isTextField } from \"@ariakit/core/utils/dom\";\nvar NULL_ITEM = { id: null };\nfunction flipItems(items, activeId, shouldInsertNullItem = false) {\n  const index = items.findIndex((item) => item.id === activeId);\n  return [\n    ...items.slice(index + 1),\n    ...shouldInsertNullItem ? [NULL_ITEM] : [],\n    ...items.slice(0, index)\n  ];\n}\nfunction findFirstEnabledItem(items, excludeId) {\n  return items.find((item) => {\n    if (excludeId) {\n      return !item.disabled && item.id !== excludeId;\n    }\n    return !item.disabled;\n  });\n}\nfunction getEnabledItem(store, id) {\n  if (!id) return null;\n  return store.item(id) || null;\n}\nfunction groupItemsByRows(items) {\n  const rows = [];\n  for (const item of items) {\n    const row = rows.find((currentRow) => {\n      var _a;\n      return ((_a = currentRow[0]) == null ? void 0 : _a.rowId) === item.rowId;\n    });\n    if (row) {\n      row.push(item);\n    } else {\n      rows.push([item]);\n    }\n  }\n  return rows;\n}\nfunction selectTextField(element, collapseToEnd = false) {\n  if (isTextField(element)) {\n    element.setSelectionRange(\n      collapseToEnd ? element.value.length : 0,\n      element.value.length\n    );\n  } else if (element.isContentEditable) {\n    const selection = getDocument(element).getSelection();\n    selection == null ? void 0 : selection.selectAllChildren(element);\n    if (collapseToEnd) {\n      selection == null ? void 0 : selection.collapseToEnd();\n    }\n  }\n}\nvar FOCUS_SILENTLY = Symbol(\"FOCUS_SILENTLY\");\nfunction focusSilently(element) {\n  element[FOCUS_SILENTLY] = true;\n  element.focus({ preventScroll: true });\n}\nfunction silentlyFocused(element) {\n  const isSilentlyFocused = element[FOCUS_SILENTLY];\n  delete element[FOCUS_SILENTLY];\n  return isSilentlyFocused;\n}\nfunction isItem(store, element, exclude) {\n  if (!element) return false;\n  if (element === exclude) return false;\n  const item = store.item(element.id);\n  if (!item) return false;\n  if (exclude && item.element === exclude) return false;\n  return true;\n}\n\nexport {\n  flipItems,\n  findFirstEnabledItem,\n  getEnabledItem,\n  groupItemsByRows,\n  selectTextField,\n  focusSilently,\n  silentlyFocused,\n  isItem\n};\n","\"use client\";\nimport {\n  setRef\n} from \"./SK3NAZA3.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/utils/hooks.ts\nimport { canUseDOM } from \"@ariakit/core/utils/dom\";\nimport { addGlobalEventListener } from \"@ariakit/core/utils/events\";\nimport {\n  useCallback,\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useReducer,\n  useRef,\n  useState\n} from \"react\";\nimport * as React from \"react\";\nvar _React = __spreadValues({}, React);\nvar useReactId = _React.useId;\nvar useReactDeferredValue = _React.useDeferredValue;\nvar useReactInsertionEffect = _React.useInsertionEffect;\nvar useSafeLayoutEffect = canUseDOM ? useLayoutEffect : useEffect;\nfunction useInitialValue(value) {\n  const [initialValue] = useState(value);\n  return initialValue;\n}\nfunction useLazyValue(init) {\n  const ref = useRef();\n  if (ref.current === void 0) {\n    ref.current = init();\n  }\n  return ref.current;\n}\nfunction useLiveRef(value) {\n  const ref = useRef(value);\n  useSafeLayoutEffect(() => {\n    ref.current = value;\n  });\n  return ref;\n}\nfunction usePreviousValue(value) {\n  const [previousValue, setPreviousValue] = useState(value);\n  if (value !== previousValue) {\n    setPreviousValue(value);\n  }\n  return previousValue;\n}\nfunction useEvent(callback) {\n  const ref = useRef(() => {\n    throw new Error(\"Cannot call an event handler while rendering.\");\n  });\n  if (useReactInsertionEffect) {\n    useReactInsertionEffect(() => {\n      ref.current = callback;\n    });\n  } else {\n    ref.current = callback;\n  }\n  return useCallback((...args) => {\n    var _a;\n    return (_a = ref.current) == null ? void 0 : _a.call(ref, ...args);\n  }, []);\n}\nfunction useTransactionState(callback) {\n  const [state, setState] = useState(null);\n  useSafeLayoutEffect(() => {\n    if (state == null) return;\n    if (!callback) return;\n    let prevState = null;\n    callback((prev) => {\n      prevState = prev;\n      return state;\n    });\n    return () => {\n      callback(prevState);\n    };\n  }, [state, callback]);\n  return [state, setState];\n}\nfunction useMergeRefs(...refs) {\n  return useMemo(() => {\n    if (!refs.some(Boolean)) return;\n    return (value) => {\n      for (const ref of refs) {\n        setRef(ref, value);\n      }\n    };\n  }, refs);\n}\nfunction useId(defaultId) {\n  if (useReactId) {\n    const reactId = useReactId();\n    if (defaultId) return defaultId;\n    return reactId;\n  }\n  const [id, setId] = useState(defaultId);\n  useSafeLayoutEffect(() => {\n    if (defaultId || id) return;\n    const random = Math.random().toString(36).slice(2, 8);\n    setId(`id-${random}`);\n  }, [defaultId, id]);\n  return defaultId || id;\n}\nfunction useDeferredValue(value) {\n  if (useReactDeferredValue) {\n    return useReactDeferredValue(value);\n  }\n  const [deferredValue, setDeferredValue] = useState(value);\n  useEffect(() => {\n    const raf = requestAnimationFrame(() => setDeferredValue(value));\n    return () => cancelAnimationFrame(raf);\n  }, [value]);\n  return deferredValue;\n}\nfunction useTagName(refOrElement, type) {\n  const stringOrUndefined = (type2) => {\n    if (typeof type2 !== \"string\") return;\n    return type2;\n  };\n  const [tagName, setTagName] = useState(() => stringOrUndefined(type));\n  useSafeLayoutEffect(() => {\n    const element = refOrElement && \"current\" in refOrElement ? refOrElement.current : refOrElement;\n    setTagName((element == null ? void 0 : element.tagName.toLowerCase()) || stringOrUndefined(type));\n  }, [refOrElement, type]);\n  return tagName;\n}\nfunction useAttribute(refOrElement, attributeName, defaultValue) {\n  const initialValue = useInitialValue(defaultValue);\n  const [attribute, setAttribute] = useState(initialValue);\n  useEffect(() => {\n    const element = refOrElement && \"current\" in refOrElement ? refOrElement.current : refOrElement;\n    if (!element) return;\n    const callback = () => {\n      const value = element.getAttribute(attributeName);\n      setAttribute(value == null ? initialValue : value);\n    };\n    const observer = new MutationObserver(callback);\n    observer.observe(element, { attributeFilter: [attributeName] });\n    callback();\n    return () => observer.disconnect();\n  }, [refOrElement, attributeName, initialValue]);\n  return attribute;\n}\nfunction useUpdateEffect(effect, deps) {\n  const mounted = useRef(false);\n  useEffect(() => {\n    if (mounted.current) {\n      return effect();\n    }\n    mounted.current = true;\n  }, deps);\n  useEffect(\n    () => () => {\n      mounted.current = false;\n    },\n    []\n  );\n}\nfunction useUpdateLayoutEffect(effect, deps) {\n  const mounted = useRef(false);\n  useSafeLayoutEffect(() => {\n    if (mounted.current) {\n      return effect();\n    }\n    mounted.current = true;\n  }, deps);\n  useSafeLayoutEffect(\n    () => () => {\n      mounted.current = false;\n    },\n    []\n  );\n}\nfunction useForceUpdate() {\n  return useReducer(() => [], []);\n}\nfunction useBooleanEvent(booleanOrCallback) {\n  return useEvent(\n    typeof booleanOrCallback === \"function\" ? booleanOrCallback : () => booleanOrCallback\n  );\n}\nfunction useWrapElement(props, callback, deps = []) {\n  const wrapElement = useCallback(\n    (element) => {\n      if (props.wrapElement) {\n        element = props.wrapElement(element);\n      }\n      return callback(element);\n    },\n    [...deps, props.wrapElement]\n  );\n  return __spreadProps(__spreadValues({}, props), { wrapElement });\n}\nfunction usePortalRef(portalProp = false, portalRefProp) {\n  const [portalNode, setPortalNode] = useState(null);\n  const portalRef = useMergeRefs(setPortalNode, portalRefProp);\n  const domReady = !portalProp || portalNode;\n  return { portalRef, portalNode, domReady };\n}\nfunction useMetadataProps(props, key, value) {\n  const parent = props.onLoadedMetadataCapture;\n  const onLoadedMetadataCapture = useMemo(() => {\n    return Object.assign(() => {\n    }, __spreadProps(__spreadValues({}, parent), { [key]: value }));\n  }, [parent, key, value]);\n  return [parent == null ? void 0 : parent[key], { onLoadedMetadataCapture }];\n}\nfunction useIsMouseMoving() {\n  useEffect(() => {\n    addGlobalEventListener(\"mousemove\", setMouseMoving, true);\n    addGlobalEventListener(\"mousedown\", resetMouseMoving, true);\n    addGlobalEventListener(\"mouseup\", resetMouseMoving, true);\n    addGlobalEventListener(\"keydown\", resetMouseMoving, true);\n    addGlobalEventListener(\"scroll\", resetMouseMoving, true);\n  }, []);\n  const isMouseMoving = useEvent(() => mouseMoving);\n  return isMouseMoving;\n}\nvar mouseMoving = false;\nvar previousScreenX = 0;\nvar previousScreenY = 0;\nfunction hasMouseMovement(event) {\n  const movementX = event.movementX || event.screenX - previousScreenX;\n  const movementY = event.movementY || event.screenY - previousScreenY;\n  previousScreenX = event.screenX;\n  previousScreenY = event.screenY;\n  return movementX || movementY || process.env.NODE_ENV === \"test\";\n}\nfunction setMouseMoving(event) {\n  if (!hasMouseMovement(event)) return;\n  mouseMoving = true;\n}\nfunction resetMouseMoving() {\n  mouseMoving = false;\n}\n\nexport {\n  useSafeLayoutEffect,\n  useInitialValue,\n  useLazyValue,\n  useLiveRef,\n  usePreviousValue,\n  useEvent,\n  useTransactionState,\n  useMergeRefs,\n  useId,\n  useDeferredValue,\n  useTagName,\n  useAttribute,\n  useUpdateEffect,\n  useUpdateLayoutEffect,\n  useForceUpdate,\n  useBooleanEvent,\n  useWrapElement,\n  usePortalRef,\n  useMetadataProps,\n  useIsMouseMoving\n};\n","\"use client\";\nimport {\n  useDisclosureStoreProps\n} from \"./WYCIER3C.js\";\nimport {\n  useStore\n} from \"./YV4JVR4I.js\";\n\n// src/dialog/dialog-store.ts\nimport * as Core from \"@ariakit/core/dialog/dialog-store\";\nfunction useDialogStoreProps(store, update, props) {\n  return useDisclosureStoreProps(store, update, props);\n}\nfunction useDialogStore(props = {}) {\n  const [store, update] = useStore(Core.createDialogStore, props);\n  return useDialogStoreProps(store, update, props);\n}\n\nexport {\n  useDialogStoreProps,\n  useDialogStore\n};\n","\"use client\";\nimport {\n  useHovercardProviderContext\n} from \"./EM5CXX6A.js\";\nimport {\n  useFocusable\n} from \"./LVA2YJMS.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\nimport {\n  useBooleanEvent,\n  useEvent,\n  useIsMouseMoving,\n  useMergeRefs\n} from \"./ABQUS43J.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/hovercard/hovercard-anchor.tsx\nimport { addGlobalEventListener } from \"@ariakit/core/utils/events\";\nimport { disabledFromProps, invariant } from \"@ariakit/core/utils/misc\";\nimport { useCallback, useEffect, useRef } from \"react\";\nvar TagName = \"a\";\nvar useHovercardAnchor = createHook(\n  function useHovercardAnchor2(_a) {\n    var _b = _a, { store, showOnHover = true } = _b, props = __objRest(_b, [\"store\", \"showOnHover\"]);\n    const context = useHovercardProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"HovercardAnchor must receive a `store` prop or be wrapped in a HovercardProvider component.\"\n    );\n    const disabled = disabledFromProps(props);\n    const showTimeoutRef = useRef(0);\n    useEffect(() => () => window.clearTimeout(showTimeoutRef.current), []);\n    useEffect(() => {\n      const onMouseLeave = (event) => {\n        if (!store) return;\n        const { anchorElement } = store.getState();\n        if (!anchorElement) return;\n        if (event.target !== anchorElement) return;\n        window.clearTimeout(showTimeoutRef.current);\n        showTimeoutRef.current = 0;\n      };\n      return addGlobalEventListener(\"mouseleave\", onMouseLeave, true);\n    }, [store]);\n    const onMouseMoveProp = props.onMouseMove;\n    const showOnHoverProp = useBooleanEvent(showOnHover);\n    const isMouseMoving = useIsMouseMoving();\n    const onMouseMove = useEvent((event) => {\n      onMouseMoveProp == null ? void 0 : onMouseMoveProp(event);\n      if (disabled) return;\n      if (!store) return;\n      if (event.defaultPrevented) return;\n      if (showTimeoutRef.current) return;\n      if (!isMouseMoving()) return;\n      if (!showOnHoverProp(event)) return;\n      const element = event.currentTarget;\n      store.setAnchorElement(element);\n      store.setDisclosureElement(element);\n      const { showTimeout, timeout } = store.getState();\n      const showHovercard = () => {\n        showTimeoutRef.current = 0;\n        if (!isMouseMoving()) return;\n        store == null ? void 0 : store.setAnchorElement(element);\n        store == null ? void 0 : store.show();\n        queueMicrotask(() => {\n          store == null ? void 0 : store.setDisclosureElement(element);\n        });\n      };\n      const timeoutMs = showTimeout != null ? showTimeout : timeout;\n      if (timeoutMs === 0) {\n        showHovercard();\n      } else {\n        showTimeoutRef.current = window.setTimeout(showHovercard, timeoutMs);\n      }\n    });\n    const onClickProp = props.onClick;\n    const onClick = useEvent((event) => {\n      onClickProp == null ? void 0 : onClickProp(event);\n      if (!store) return;\n      window.clearTimeout(showTimeoutRef.current);\n      showTimeoutRef.current = 0;\n    });\n    const ref = useCallback(\n      (element) => {\n        if (!store) return;\n        const { anchorElement } = store.getState();\n        if (anchorElement == null ? void 0 : anchorElement.isConnected) return;\n        store.setAnchorElement(element);\n      },\n      [store]\n    );\n    props = __spreadProps(__spreadValues({}, props), {\n      ref: useMergeRefs(ref, props.ref),\n      onMouseMove,\n      onClick\n    });\n    props = useFocusable(props);\n    return props;\n  }\n);\nvar HovercardAnchor = forwardRef(function HovercardAnchor2(props) {\n  const htmlProps = useHovercardAnchor(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport {\n  useHovercardAnchor,\n  HovercardAnchor\n};\n","\"use client\";\nimport {\n  PopoverContextProvider,\n  PopoverScopedContextProvider\n} from \"./MTZPJQMC.js\";\nimport {\n  createStoreContext\n} from \"./LMDWO4NN.js\";\n\n// src/hovercard/hovercard-context.tsx\nvar ctx = createStoreContext(\n  [PopoverContextProvider],\n  [PopoverScopedContextProvider]\n);\nvar useHovercardContext = ctx.useContext;\nvar useHovercardScopedContext = ctx.useScopedContext;\nvar useHovercardProviderContext = ctx.useProviderContext;\nvar HovercardContextProvider = ctx.ContextProvider;\nvar HovercardScopedContextProvider = ctx.ScopedContextProvider;\n\nexport {\n  useHovercardContext,\n  useHovercardScopedContext,\n  useHovercardProviderContext,\n  HovercardContextProvider,\n  HovercardScopedContextProvider\n};\n","\"use client\";\nimport {\n  HovercardContextProvider,\n  HovercardScopedContextProvider\n} from \"./EM5CXX6A.js\";\nimport {\n  createStoreContext\n} from \"./LMDWO4NN.js\";\n\n// src/tooltip/tooltip-context.tsx\nvar ctx = createStoreContext(\n  [HovercardContextProvider],\n  [HovercardScopedContextProvider]\n);\nvar useTooltipContext = ctx.useContext;\nvar useTooltipScopedContext = ctx.useScopedContext;\nvar useTooltipProviderContext = ctx.useProviderContext;\nvar TooltipContextProvider = ctx.ContextProvider;\nvar TooltipScopedContextProvider = ctx.ScopedContextProvider;\n\nexport {\n  useTooltipContext,\n  useTooltipScopedContext,\n  useTooltipProviderContext,\n  TooltipContextProvider,\n  TooltipScopedContextProvider\n};\n","\"use client\";\nimport {\n  CompositeContextProvider,\n  CompositeScopedContextProvider\n} from \"./P7GR5CS5.js\";\nimport {\n  createStoreContext\n} from \"./LMDWO4NN.js\";\n\n// src/tag/tag-context.tsx\nimport { createContext } from \"react\";\nvar TagValueContext = createContext(null);\nvar TagRemoveIdContext = createContext(\n  null\n);\nvar ctx = createStoreContext(\n  [CompositeContextProvider],\n  [CompositeScopedContextProvider]\n);\nvar useTagContext = ctx.useContext;\nvar useTagScopedContext = ctx.useScopedContext;\nvar useTagProviderContext = ctx.useProviderContext;\nvar TagContextProvider = ctx.ContextProvider;\nvar TagScopedContextProvider = ctx.ScopedContextProvider;\n\nexport {\n  TagValueContext,\n  TagRemoveIdContext,\n  useTagContext,\n  useTagScopedContext,\n  useTagProviderContext,\n  TagContextProvider,\n  TagScopedContextProvider\n};\n","\"use client\";\nimport {\n  createCompositeStore\n} from \"../__chunks/AJZ4BYF3.js\";\nimport \"../__chunks/CYQWQL4J.js\";\nimport \"../__chunks/7PRQYBBV.js\";\nimport {\n  createPopoverStore\n} from \"../__chunks/ME2CUF3F.js\";\nimport \"../__chunks/FZZ2AVHF.js\";\nimport \"../__chunks/RCQ5P4YE.js\";\nimport {\n  batch,\n  createStore,\n  mergeStore,\n  pick,\n  setup,\n  sync,\n  throwOnConflictingProps\n} from \"../__chunks/BCALMBPZ.js\";\nimport {\n  chain,\n  defaultValue\n} from \"../__chunks/PBFD2E7P.js\";\nimport {\n  isSafari,\n  isTouchDevice\n} from \"../__chunks/QAGXQEUG.js\";\nimport \"../__chunks/DTR5TSDJ.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"../__chunks/3YLGPPWQ.js\";\n\n// src/combobox/combobox-store.ts\nvar isTouchSafari = isSafari() && isTouchDevice();\nfunction createComboboxStore(_a = {}) {\n  var _b = _a, {\n    tag\n  } = _b, props = __objRest(_b, [\n    \"tag\"\n  ]);\n  const store = mergeStore(props.store, pick(tag, [\"value\", \"rtl\"]));\n  throwOnConflictingProps(props, store);\n  const tagState = tag == null ? void 0 : tag.getState();\n  const syncState = store == null ? void 0 : store.getState();\n  const activeId = defaultValue(\n    props.activeId,\n    syncState == null ? void 0 : syncState.activeId,\n    props.defaultActiveId,\n    null\n  );\n  const composite = createCompositeStore(__spreadProps(__spreadValues({}, props), {\n    activeId,\n    includesBaseElement: defaultValue(\n      props.includesBaseElement,\n      syncState == null ? void 0 : syncState.includesBaseElement,\n      true\n    ),\n    orientation: defaultValue(\n      props.orientation,\n      syncState == null ? void 0 : syncState.orientation,\n      \"vertical\"\n    ),\n    focusLoop: defaultValue(props.focusLoop, syncState == null ? void 0 : syncState.focusLoop, true),\n    focusWrap: defaultValue(props.focusWrap, syncState == null ? void 0 : syncState.focusWrap, true),\n    virtualFocus: defaultValue(\n      props.virtualFocus,\n      syncState == null ? void 0 : syncState.virtualFocus,\n      true\n    )\n  }));\n  const popover = createPopoverStore(__spreadProps(__spreadValues({}, props), {\n    placement: defaultValue(\n      props.placement,\n      syncState == null ? void 0 : syncState.placement,\n      \"bottom-start\"\n    )\n  }));\n  const value = defaultValue(\n    props.value,\n    syncState == null ? void 0 : syncState.value,\n    props.defaultValue,\n    \"\"\n  );\n  const selectedValue = defaultValue(\n    props.selectedValue,\n    syncState == null ? void 0 : syncState.selectedValue,\n    tagState == null ? void 0 : tagState.values,\n    props.defaultSelectedValue,\n    \"\"\n  );\n  const multiSelectable = Array.isArray(selectedValue);\n  const initialState = __spreadProps(__spreadValues(__spreadValues({}, composite.getState()), popover.getState()), {\n    value,\n    selectedValue,\n    resetValueOnSelect: defaultValue(\n      props.resetValueOnSelect,\n      syncState == null ? void 0 : syncState.resetValueOnSelect,\n      multiSelectable\n    ),\n    resetValueOnHide: defaultValue(\n      props.resetValueOnHide,\n      syncState == null ? void 0 : syncState.resetValueOnHide,\n      multiSelectable && !tag\n    ),\n    activeValue: syncState == null ? void 0 : syncState.activeValue\n  });\n  const combobox = createStore(initialState, composite, popover, store);\n  if (isTouchSafari) {\n    setup(\n      combobox,\n      () => sync(combobox, [\"virtualFocus\"], () => {\n        combobox.setState(\"virtualFocus\", false);\n      })\n    );\n  }\n  setup(combobox, () => {\n    if (!tag) return;\n    return chain(\n      sync(combobox, [\"selectedValue\"], (state) => {\n        if (!Array.isArray(state.selectedValue)) return;\n        tag.setValues(state.selectedValue);\n      }),\n      sync(tag, [\"values\"], (state) => {\n        combobox.setState(\"selectedValue\", state.values);\n      })\n    );\n  });\n  setup(\n    combobox,\n    () => sync(combobox, [\"resetValueOnHide\", \"mounted\"], (state) => {\n      if (!state.resetValueOnHide) return;\n      if (state.mounted) return;\n      combobox.setState(\"value\", value);\n    })\n  );\n  setup(\n    combobox,\n    () => sync(combobox, [\"open\"], (state) => {\n      if (state.open) return;\n      combobox.setState(\"activeId\", activeId);\n      combobox.setState(\"moves\", 0);\n    })\n  );\n  setup(\n    combobox,\n    () => sync(combobox, [\"moves\", \"activeId\"], (state, prevState) => {\n      if (state.moves === prevState.moves) {\n        combobox.setState(\"activeValue\", void 0);\n      }\n    })\n  );\n  setup(\n    combobox,\n    () => batch(combobox, [\"moves\", \"renderedItems\"], (state, prev) => {\n      if (state.moves === prev.moves) return;\n      const { activeId: activeId2 } = combobox.getState();\n      const activeItem = composite.item(activeId2);\n      combobox.setState(\"activeValue\", activeItem == null ? void 0 : activeItem.value);\n    })\n  );\n  return __spreadProps(__spreadValues(__spreadValues(__spreadValues({}, popover), composite), combobox), {\n    tag,\n    setValue: (value2) => combobox.setState(\"value\", value2),\n    resetValue: () => combobox.setState(\"value\", initialState.value),\n    setSelectedValue: (selectedValue2) => combobox.setState(\"selectedValue\", selectedValue2)\n  });\n}\nexport {\n  createComboboxStore\n};\n","\"use client\";\nimport {\n  useTagContext\n} from \"./3XAVFTCA.js\";\nimport {\n  useCompositeStoreOptions,\n  useCompositeStoreProps\n} from \"./4CMBR7SL.js\";\nimport {\n  usePopoverStoreProps\n} from \"./O2PQ2652.js\";\nimport {\n  useStore,\n  useStoreProps\n} from \"./YV4JVR4I.js\";\nimport {\n  useUpdateEffect\n} from \"./ABQUS43J.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/combobox/combobox-store.ts\nimport * as Core from \"@ariakit/core/combobox/combobox-store\";\nfunction useComboboxStoreOptions(props) {\n  const tag = useTagContext();\n  props = __spreadProps(__spreadValues({}, props), {\n    tag: props.tag !== void 0 ? props.tag : tag\n  });\n  return useCompositeStoreOptions(props);\n}\nfunction useComboboxStoreProps(store, update, props) {\n  useUpdateEffect(update, [props.tag]);\n  useStoreProps(store, props, \"value\", \"setValue\");\n  useStoreProps(store, props, \"selectedValue\", \"setSelectedValue\");\n  useStoreProps(store, props, \"resetValueOnHide\");\n  useStoreProps(store, props, \"resetValueOnSelect\");\n  return Object.assign(\n    useCompositeStoreProps(\n      usePopoverStoreProps(store, update, props),\n      update,\n      props\n    ),\n    { tag: props.tag }\n  );\n}\nfunction useComboboxStore(props = {}) {\n  props = useComboboxStoreOptions(props);\n  const [store, update] = useStore(Core.createComboboxStore, props);\n  return useComboboxStoreProps(store, update, props);\n}\n\nexport {\n  useComboboxStoreOptions,\n  useComboboxStoreProps,\n  useComboboxStore\n};\n","\"use client\";\nimport {\n  usePopoverStoreProps\n} from \"./O2PQ2652.js\";\nimport {\n  useStore,\n  useStoreProps\n} from \"./YV4JVR4I.js\";\n\n// src/hovercard/hovercard-store.ts\nimport * as Core from \"@ariakit/core/hovercard/hovercard-store\";\nfunction useHovercardStoreProps(store, update, props) {\n  useStoreProps(store, props, \"timeout\");\n  useStoreProps(store, props, \"showTimeout\");\n  useStoreProps(store, props, \"hideTimeout\");\n  return usePopoverStoreProps(store, update, props);\n}\nfunction useHovercardStore(props = {}) {\n  const [store, update] = useStore(Core.createHovercardStore, props);\n  return useHovercardStoreProps(store, update, props);\n}\n\nexport {\n  useHovercardStoreProps,\n  useHovercardStore\n};\n","\"use client\";\nimport {\n  ComboboxListRoleContext,\n  ComboboxScopedContextProvider,\n  useComboboxContext,\n  useComboboxScopedContext\n} from \"./VEVQD5MH.js\";\nimport {\n  isHidden\n} from \"./VGCJ63VH.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\nimport {\n  useAttribute,\n  useId,\n  useMergeRefs,\n  useSafeLayoutEffect,\n  useWrapElement\n} from \"./ABQUS43J.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/combobox/combobox-list.tsx\nimport { invariant, removeUndefinedValues } from \"@ariakit/core/utils/misc\";\nimport { useRef, useState } from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nvar useComboboxList = createHook(\n  function useComboboxList2(_a) {\n    var _b = _a, { store, alwaysVisible } = _b, props = __objRest(_b, [\"store\", \"alwaysVisible\"]);\n    const scopedContext = useComboboxScopedContext(true);\n    const context = useComboboxContext();\n    store = store || context;\n    const scopedContextSameStore = !!store && store === scopedContext;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"ComboboxList must receive a `store` prop or be wrapped in a ComboboxProvider component.\"\n    );\n    const ref = useRef(null);\n    const id = useId(props.id);\n    const mounted = store.useState(\"mounted\");\n    const hidden = isHidden(mounted, props.hidden, alwaysVisible);\n    const style = hidden ? __spreadProps(__spreadValues({}, props.style), { display: \"none\" }) : props.style;\n    const multiSelectable = store.useState(\n      (state) => Array.isArray(state.selectedValue)\n    );\n    const role = useAttribute(ref, \"role\", props.role);\n    const isCompositeRole = role === \"listbox\" || role === \"tree\" || role === \"grid\";\n    const ariaMultiSelectable = isCompositeRole ? multiSelectable || void 0 : void 0;\n    const [hasListboxInside, setHasListboxInside] = useState(false);\n    const contentElement = store.useState(\"contentElement\");\n    useSafeLayoutEffect(() => {\n      if (!mounted) return;\n      const element = ref.current;\n      if (!element) return;\n      if (contentElement !== element) return;\n      const callback = () => {\n        setHasListboxInside(!!element.querySelector(\"[role='listbox']\"));\n      };\n      const observer = new MutationObserver(callback);\n      observer.observe(element, {\n        subtree: true,\n        childList: true,\n        attributeFilter: [\"role\"]\n      });\n      callback();\n      return () => observer.disconnect();\n    }, [mounted, contentElement]);\n    if (!hasListboxInside) {\n      props = __spreadValues({\n        role: \"listbox\",\n        \"aria-multiselectable\": ariaMultiSelectable\n      }, props);\n    }\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(ComboboxScopedContextProvider, { value: store, children: /* @__PURE__ */ jsx(ComboboxListRoleContext.Provider, { value: role, children: element }) }),\n      [store, role]\n    );\n    const setContentElement = id && (!scopedContext || !scopedContextSameStore) ? store.setContentElement : null;\n    props = __spreadProps(__spreadValues({\n      id,\n      hidden\n    }, props), {\n      ref: useMergeRefs(setContentElement, ref, props.ref),\n      style\n    });\n    return removeUndefinedValues(props);\n  }\n);\nvar ComboboxList = forwardRef(function ComboboxList2(props) {\n  const htmlProps = useComboboxList(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport {\n  useComboboxList,\n  ComboboxList\n};\n","\"use client\";\nimport {\n  findFirstEnabledItem,\n  getEnabledItem,\n  groupItemsByRows,\n  isItem,\n  silentlyFocused\n} from \"./5VQZOHHZ.js\";\nimport {\n  CompositeContextProvider,\n  useCompositeProviderContext\n} from \"./P7GR5CS5.js\";\nimport {\n  useFocusable\n} from \"./LVA2YJMS.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\nimport {\n  useBooleanEvent,\n  useEvent,\n  useMergeRefs,\n  useSafeLayoutEffect,\n  useTransactionState,\n  useWrapElement\n} from \"./ABQUS43J.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/composite/composite.tsx\nimport { flatten2DArray, reverseArray } from \"@ariakit/core/utils/array\";\nimport { getActiveElement, isTextField } from \"@ariakit/core/utils/dom\";\nimport {\n  fireBlurEvent,\n  fireKeyboardEvent,\n  isSelfTarget\n} from \"@ariakit/core/utils/events\";\nimport { focusIntoView, hasFocus } from \"@ariakit/core/utils/focus\";\nimport { invariant } from \"@ariakit/core/utils/misc\";\nimport { useCallback, useEffect, useRef, useState } from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nfunction isGrid(items) {\n  return items.some((item) => !!item.rowId);\n}\nfunction isPrintableKey(event) {\n  const target = event.target;\n  if (target && !isTextField(target)) return false;\n  return event.key.length === 1 && !event.ctrlKey && !event.metaKey;\n}\nfunction isModifierKey(event) {\n  return event.key === \"Shift\" || event.key === \"Control\" || event.key === \"Alt\" || event.key === \"Meta\";\n}\nfunction useKeyboardEventProxy(store, onKeyboardEvent, previousElementRef) {\n  return useEvent((event) => {\n    var _a;\n    onKeyboardEvent == null ? void 0 : onKeyboardEvent(event);\n    if (event.defaultPrevented) return;\n    if (event.isPropagationStopped()) return;\n    if (!isSelfTarget(event)) return;\n    if (isModifierKey(event)) return;\n    if (isPrintableKey(event)) return;\n    const state = store.getState();\n    const activeElement = (_a = getEnabledItem(store, state.activeId)) == null ? void 0 : _a.element;\n    if (!activeElement) return;\n    const _b = event, { view } = _b, eventInit = __objRest(_b, [\"view\"]);\n    const previousElement = previousElementRef == null ? void 0 : previousElementRef.current;\n    if (activeElement !== previousElement) {\n      activeElement.focus();\n    }\n    if (!fireKeyboardEvent(activeElement, event.type, eventInit)) {\n      event.preventDefault();\n    }\n    if (event.currentTarget.contains(activeElement)) {\n      event.stopPropagation();\n    }\n  });\n}\nfunction findFirstEnabledItemInTheLastRow(items) {\n  return findFirstEnabledItem(\n    flatten2DArray(reverseArray(groupItemsByRows(items)))\n  );\n}\nfunction useScheduleFocus(store) {\n  const [scheduled, setScheduled] = useState(false);\n  const schedule = useCallback(() => setScheduled(true), []);\n  const activeItem = store.useState(\n    (state) => getEnabledItem(store, state.activeId)\n  );\n  useEffect(() => {\n    const activeElement = activeItem == null ? void 0 : activeItem.element;\n    if (!scheduled) return;\n    if (!activeElement) return;\n    setScheduled(false);\n    activeElement.focus({ preventScroll: true });\n  }, [activeItem, scheduled]);\n  return schedule;\n}\nvar useComposite = createHook(\n  function useComposite2(_a) {\n    var _b = _a, {\n      store,\n      composite = true,\n      focusOnMove = composite,\n      moveOnKeyPress = true\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"composite\",\n      \"focusOnMove\",\n      \"moveOnKeyPress\"\n    ]);\n    const context = useCompositeProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"Composite must receive a `store` prop or be wrapped in a CompositeProvider component.\"\n    );\n    const ref = useRef(null);\n    const previousElementRef = useRef(null);\n    const scheduleFocus = useScheduleFocus(store);\n    const moves = store.useState(\"moves\");\n    const [, setBaseElement] = useTransactionState(\n      composite ? store.setBaseElement : null\n    );\n    useEffect(() => {\n      var _a2;\n      if (!store) return;\n      if (!moves) return;\n      if (!composite) return;\n      if (!focusOnMove) return;\n      const { activeId: activeId2 } = store.getState();\n      const itemElement = (_a2 = getEnabledItem(store, activeId2)) == null ? void 0 : _a2.element;\n      if (!itemElement) return;\n      focusIntoView(itemElement);\n    }, [store, moves, composite, focusOnMove]);\n    useSafeLayoutEffect(() => {\n      if (!store) return;\n      if (!moves) return;\n      if (!composite) return;\n      const { baseElement, activeId: activeId2 } = store.getState();\n      const isSelfAcive = activeId2 === null;\n      if (!isSelfAcive) return;\n      if (!baseElement) return;\n      const previousElement = previousElementRef.current;\n      previousElementRef.current = null;\n      if (previousElement) {\n        fireBlurEvent(previousElement, { relatedTarget: baseElement });\n      }\n      if (!hasFocus(baseElement)) {\n        baseElement.focus();\n      }\n    }, [store, moves, composite]);\n    const activeId = store.useState(\"activeId\");\n    const virtualFocus = store.useState(\"virtualFocus\");\n    useSafeLayoutEffect(() => {\n      var _a2;\n      if (!store) return;\n      if (!composite) return;\n      if (!virtualFocus) return;\n      const previousElement = previousElementRef.current;\n      previousElementRef.current = null;\n      if (!previousElement) return;\n      const activeElement = (_a2 = getEnabledItem(store, activeId)) == null ? void 0 : _a2.element;\n      const relatedTarget = activeElement || getActiveElement(previousElement);\n      if (relatedTarget === previousElement) return;\n      fireBlurEvent(previousElement, { relatedTarget });\n    }, [store, activeId, virtualFocus, composite]);\n    const onKeyDownCapture = useKeyboardEventProxy(\n      store,\n      props.onKeyDownCapture,\n      previousElementRef\n    );\n    const onKeyUpCapture = useKeyboardEventProxy(\n      store,\n      props.onKeyUpCapture,\n      previousElementRef\n    );\n    const onFocusCaptureProp = props.onFocusCapture;\n    const onFocusCapture = useEvent((event) => {\n      onFocusCaptureProp == null ? void 0 : onFocusCaptureProp(event);\n      if (event.defaultPrevented) return;\n      if (!store) return;\n      const { virtualFocus: virtualFocus2 } = store.getState();\n      if (!virtualFocus2) return;\n      const previousActiveElement = event.relatedTarget;\n      const isSilentlyFocused = silentlyFocused(event.currentTarget);\n      if (isSelfTarget(event) && isSilentlyFocused) {\n        event.stopPropagation();\n        previousElementRef.current = previousActiveElement;\n      }\n    });\n    const onFocusProp = props.onFocus;\n    const onFocus = useEvent((event) => {\n      onFocusProp == null ? void 0 : onFocusProp(event);\n      if (event.defaultPrevented) return;\n      if (!composite) return;\n      if (!store) return;\n      const { relatedTarget } = event;\n      const { virtualFocus: virtualFocus2 } = store.getState();\n      if (virtualFocus2) {\n        if (isSelfTarget(event) && !isItem(store, relatedTarget)) {\n          queueMicrotask(scheduleFocus);\n        }\n      } else if (isSelfTarget(event)) {\n        store.setActiveId(null);\n      }\n    });\n    const onBlurCaptureProp = props.onBlurCapture;\n    const onBlurCapture = useEvent((event) => {\n      var _a2;\n      onBlurCaptureProp == null ? void 0 : onBlurCaptureProp(event);\n      if (event.defaultPrevented) return;\n      if (!store) return;\n      const { virtualFocus: virtualFocus2, activeId: activeId2 } = store.getState();\n      if (!virtualFocus2) return;\n      const activeElement = (_a2 = getEnabledItem(store, activeId2)) == null ? void 0 : _a2.element;\n      const nextActiveElement = event.relatedTarget;\n      const nextActiveElementIsItem = isItem(store, nextActiveElement);\n      const previousElement = previousElementRef.current;\n      previousElementRef.current = null;\n      if (isSelfTarget(event) && nextActiveElementIsItem) {\n        if (nextActiveElement === activeElement) {\n          if (previousElement && previousElement !== nextActiveElement) {\n            fireBlurEvent(previousElement, event);\n          }\n        } else if (activeElement) {\n          fireBlurEvent(activeElement, event);\n        } else if (previousElement) {\n          fireBlurEvent(previousElement, event);\n        }\n        event.stopPropagation();\n      } else {\n        const targetIsItem = isItem(store, event.target);\n        if (!targetIsItem && activeElement) {\n          fireBlurEvent(activeElement, event);\n        }\n      }\n    });\n    const onKeyDownProp = props.onKeyDown;\n    const moveOnKeyPressProp = useBooleanEvent(moveOnKeyPress);\n    const onKeyDown = useEvent((event) => {\n      var _a2;\n      onKeyDownProp == null ? void 0 : onKeyDownProp(event);\n      if (event.defaultPrevented) return;\n      if (!store) return;\n      if (!isSelfTarget(event)) return;\n      const { orientation, renderedItems, activeId: activeId2 } = store.getState();\n      const activeItem = getEnabledItem(store, activeId2);\n      if ((_a2 = activeItem == null ? void 0 : activeItem.element) == null ? void 0 : _a2.isConnected) return;\n      const isVertical = orientation !== \"horizontal\";\n      const isHorizontal = orientation !== \"vertical\";\n      const grid = isGrid(renderedItems);\n      const isHorizontalKey = event.key === \"ArrowLeft\" || event.key === \"ArrowRight\" || event.key === \"Home\" || event.key === \"End\";\n      if (isHorizontalKey && isTextField(event.currentTarget)) return;\n      const up = () => {\n        if (grid) {\n          const item = findFirstEnabledItemInTheLastRow(renderedItems);\n          return item == null ? void 0 : item.id;\n        }\n        return store == null ? void 0 : store.last();\n      };\n      const keyMap = {\n        ArrowUp: (grid || isVertical) && up,\n        ArrowRight: (grid || isHorizontal) && store.first,\n        ArrowDown: (grid || isVertical) && store.first,\n        ArrowLeft: (grid || isHorizontal) && store.last,\n        Home: store.first,\n        End: store.last,\n        PageUp: store.first,\n        PageDown: store.last\n      };\n      const action = keyMap[event.key];\n      if (action) {\n        const id = action();\n        if (id !== void 0) {\n          if (!moveOnKeyPressProp(event)) return;\n          event.preventDefault();\n          store.move(id);\n        }\n      }\n    });\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(CompositeContextProvider, { value: store, children: element }),\n      [store]\n    );\n    const activeDescendant = store.useState((state) => {\n      var _a2;\n      if (!store) return;\n      if (!composite) return;\n      if (!state.virtualFocus) return;\n      return (_a2 = getEnabledItem(store, state.activeId)) == null ? void 0 : _a2.id;\n    });\n    props = __spreadProps(__spreadValues({\n      \"aria-activedescendant\": activeDescendant\n    }, props), {\n      ref: useMergeRefs(ref, setBaseElement, props.ref),\n      onKeyDownCapture,\n      onKeyUpCapture,\n      onFocusCapture,\n      onFocus,\n      onBlurCapture,\n      onKeyDown\n    });\n    const focusable = store.useState(\n      (state) => composite && (state.virtualFocus || state.activeId === null)\n    );\n    props = useFocusable(__spreadValues({ focusable }, props));\n    return props;\n  }\n);\nvar Composite = forwardRef(function Composite2(props) {\n  const htmlProps = useComposite(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport {\n  useComposite,\n  Composite\n};\n","\"use client\";\n\n// src/dialog/utils/is-backdrop.ts\nfunction isBackdrop(element, ...ids) {\n  if (!element) return false;\n  const backdrop = element.getAttribute(\"data-backdrop\");\n  if (backdrop == null) return false;\n  if (backdrop === \"\") return true;\n  if (backdrop === \"true\") return true;\n  if (!ids.length) return true;\n  return ids.some((id) => backdrop === id);\n}\n\nexport {\n  isBackdrop\n};\n","\"use client\";\n\n// src/dialog/utils/orchestrate.ts\nvar cleanups = /* @__PURE__ */ new WeakMap();\nfunction orchestrate(element, key, setup) {\n  if (!cleanups.has(element)) {\n    cleanups.set(element, /* @__PURE__ */ new Map());\n  }\n  const elementCleanups = cleanups.get(element);\n  const prevCleanup = elementCleanups.get(key);\n  if (!prevCleanup) {\n    elementCleanups.set(key, setup());\n    return () => {\n      var _a;\n      (_a = elementCleanups.get(key)) == null ? void 0 : _a();\n      elementCleanups.delete(key);\n    };\n  }\n  const cleanup = setup();\n  const nextCleanup = () => {\n    cleanup();\n    prevCleanup();\n    elementCleanups.delete(key);\n  };\n  elementCleanups.set(key, nextCleanup);\n  return () => {\n    const isCurrent = elementCleanups.get(key) === nextCleanup;\n    if (!isCurrent) return;\n    cleanup();\n    elementCleanups.set(key, prevCleanup);\n  };\n}\nfunction setAttribute(element, attr, value) {\n  const setup = () => {\n    const previousValue = element.getAttribute(attr);\n    element.setAttribute(attr, value);\n    return () => {\n      if (previousValue == null) {\n        element.removeAttribute(attr);\n      } else {\n        element.setAttribute(attr, previousValue);\n      }\n    };\n  };\n  return orchestrate(element, attr, setup);\n}\nfunction setProperty(element, property, value) {\n  const setup = () => {\n    const exists = property in element;\n    const previousValue = element[property];\n    element[property] = value;\n    return () => {\n      if (!exists) {\n        delete element[property];\n      } else {\n        element[property] = previousValue;\n      }\n    };\n  };\n  return orchestrate(element, property, setup);\n}\nfunction assignStyle(element, style) {\n  if (!element) return () => {\n  };\n  const setup = () => {\n    const prevStyle = element.style.cssText;\n    Object.assign(element.style, style);\n    return () => {\n      element.style.cssText = prevStyle;\n    };\n  };\n  return orchestrate(element, \"style\", setup);\n}\nfunction setCSSProperty(element, property, value) {\n  if (!element) return () => {\n  };\n  const setup = () => {\n    const previousValue = element.style.getPropertyValue(property);\n    element.style.setProperty(property, value);\n    return () => {\n      if (previousValue) {\n        element.style.setProperty(property, previousValue);\n      } else {\n        element.style.removeProperty(property);\n      }\n    };\n  };\n  return orchestrate(element, property, setup);\n}\n\nexport {\n  orchestrate,\n  setAttribute,\n  setProperty,\n  assignStyle,\n  setCSSProperty\n};\n","\"use client\";\nimport {\n  setProperty\n} from \"./K2ZF5NU7.js\";\n\n// src/dialog/utils/walk-tree-outside.ts\nimport { contains, getDocument } from \"@ariakit/core/utils/dom\";\nimport { chain } from \"@ariakit/core/utils/misc\";\nvar ignoreTags = [\"SCRIPT\", \"STYLE\"];\nfunction getSnapshotPropertyName(id) {\n  return `__ariakit-dialog-snapshot-${id}`;\n}\nfunction inSnapshot(id, element) {\n  const doc = getDocument(element);\n  const propertyName = getSnapshotPropertyName(id);\n  if (!doc.body[propertyName]) return true;\n  do {\n    if (element === doc.body) return false;\n    if (element[propertyName]) return true;\n    if (!element.parentElement) return false;\n    element = element.parentElement;\n  } while (true);\n}\nfunction isValidElement(id, element, ignoredElements) {\n  if (ignoreTags.includes(element.tagName)) return false;\n  if (!inSnapshot(id, element)) return false;\n  return !ignoredElements.some(\n    (enabledElement) => enabledElement && contains(element, enabledElement)\n  );\n}\nfunction walkTreeOutside(id, elements, callback, ancestorCallback) {\n  for (let element of elements) {\n    if (!(element == null ? void 0 : element.isConnected)) continue;\n    const hasAncestorAlready = elements.some((maybeAncestor) => {\n      if (!maybeAncestor) return false;\n      if (maybeAncestor === element) return false;\n      return maybeAncestor.contains(element);\n    });\n    const doc = getDocument(element);\n    const originalElement = element;\n    while (element.parentElement && element !== doc.body) {\n      ancestorCallback == null ? void 0 : ancestorCallback(element.parentElement, originalElement);\n      if (!hasAncestorAlready) {\n        for (const child of element.parentElement.children) {\n          if (isValidElement(id, child, elements)) {\n            callback(child, originalElement);\n          }\n        }\n      }\n      element = element.parentElement;\n    }\n  }\n}\nfunction createWalkTreeSnapshot(id, elements) {\n  const { body } = getDocument(elements[0]);\n  const cleanups = [];\n  const markElement = (element) => {\n    cleanups.push(setProperty(element, getSnapshotPropertyName(id), true));\n  };\n  walkTreeOutside(id, elements, markElement);\n  return chain(setProperty(body, getSnapshotPropertyName(id), true), () => {\n    for (const cleanup of cleanups) {\n      cleanup();\n    }\n  });\n}\n\nexport {\n  isValidElement,\n  walkTreeOutside,\n  createWalkTreeSnapshot\n};\n","\"use client\";\nimport {\n  isBackdrop\n} from \"./63XF7ACK.js\";\nimport {\n  walkTreeOutside\n} from \"./AOUGVQZ3.js\";\nimport {\n  setProperty\n} from \"./K2ZF5NU7.js\";\n\n// src/dialog/utils/mark-tree-outside.ts\nimport { chain } from \"@ariakit/core/utils/misc\";\nfunction getPropertyName(id = \"\", ancestor = false) {\n  return `__ariakit-dialog-${ancestor ? \"ancestor\" : \"outside\"}${id ? `-${id}` : \"\"}`;\n}\nfunction markElement(element, id = \"\") {\n  return chain(\n    setProperty(element, getPropertyName(), true),\n    setProperty(element, getPropertyName(id), true)\n  );\n}\nfunction markAncestor(element, id = \"\") {\n  return chain(\n    setProperty(element, getPropertyName(\"\", true), true),\n    setProperty(element, getPropertyName(id, true), true)\n  );\n}\nfunction isElementMarked(element, id) {\n  const ancestorProperty = getPropertyName(id, true);\n  if (element[ancestorProperty]) return true;\n  const elementProperty = getPropertyName(id);\n  do {\n    if (element[elementProperty]) return true;\n    if (!element.parentElement) return false;\n    element = element.parentElement;\n  } while (true);\n}\nfunction markTreeOutside(id, elements) {\n  const cleanups = [];\n  const ids = elements.map((el) => el == null ? void 0 : el.id);\n  walkTreeOutside(\n    id,\n    elements,\n    (element) => {\n      if (isBackdrop(element, ...ids)) return;\n      cleanups.unshift(markElement(element, id));\n    },\n    (ancestor, element) => {\n      const isAnotherDialogAncestor = element.hasAttribute(\"data-dialog\") && element.id !== id;\n      if (isAnotherDialogAncestor) return;\n      cleanups.unshift(markAncestor(ancestor, id));\n    }\n  );\n  const restoreAccessibilityTree = () => {\n    for (const cleanup of cleanups) {\n      cleanup();\n    }\n  };\n  return restoreAccessibilityTree;\n}\n\nexport {\n  markElement,\n  markAncestor,\n  isElementMarked,\n  markTreeOutside\n};\n","\"use client\";\nimport {\n  markAncestor\n} from \"./2PGBN2Y4.js\";\nimport {\n  useDisclosureContent\n} from \"./VGCJ63VH.js\";\nimport {\n  Role\n} from \"./XL7CSKGW.js\";\nimport {\n  useDisclosureStore\n} from \"./WYCIER3C.js\";\nimport {\n  useStoreState\n} from \"./YV4JVR4I.js\";\nimport {\n  useSafeLayoutEffect\n} from \"./ABQUS43J.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/dialog/dialog-backdrop.tsx\nimport { isValidElement, useEffect, useRef } from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nfunction DialogBackdrop({\n  store,\n  backdrop,\n  alwaysVisible,\n  hidden\n}) {\n  const ref = useRef(null);\n  const disclosure = useDisclosureStore({ disclosure: store });\n  const contentElement = useStoreState(store, \"contentElement\");\n  useEffect(() => {\n    const backdrop2 = ref.current;\n    const dialog = contentElement;\n    if (!backdrop2) return;\n    if (!dialog) return;\n    backdrop2.style.zIndex = getComputedStyle(dialog).zIndex;\n  }, [contentElement]);\n  useSafeLayoutEffect(() => {\n    const id = contentElement == null ? void 0 : contentElement.id;\n    if (!id) return;\n    const backdrop2 = ref.current;\n    if (!backdrop2) return;\n    return markAncestor(backdrop2, id);\n  }, [contentElement]);\n  const props = useDisclosureContent({\n    ref,\n    store: disclosure,\n    role: \"presentation\",\n    \"data-backdrop\": (contentElement == null ? void 0 : contentElement.id) || \"\",\n    alwaysVisible,\n    hidden: hidden != null ? hidden : void 0,\n    style: {\n      position: \"fixed\",\n      top: 0,\n      right: 0,\n      bottom: 0,\n      left: 0\n    }\n  });\n  if (!backdrop) return null;\n  if (isValidElement(backdrop)) {\n    return /* @__PURE__ */ jsx(Role, __spreadProps(__spreadValues({}, props), { render: backdrop }));\n  }\n  const Component = typeof backdrop !== \"boolean\" ? backdrop : \"div\";\n  return /* @__PURE__ */ jsx(Role, __spreadProps(__spreadValues({}, props), { render: /* @__PURE__ */ jsx(Component, {}) }));\n}\n\nexport {\n  DialogBackdrop\n};\n","\"use client\";\nimport {\n  isBackdrop\n} from \"./63XF7ACK.js\";\nimport {\n  walkTreeOutside\n} from \"./AOUGVQZ3.js\";\nimport {\n  setAttribute\n} from \"./K2ZF5NU7.js\";\n\n// src/dialog/utils/disable-accessibility-tree-outside.ts\nfunction hideElementFromAccessibilityTree(element) {\n  return setAttribute(element, \"aria-hidden\", \"true\");\n}\nfunction disableAccessibilityTreeOutside(id, elements) {\n  const cleanups = [];\n  const ids = elements.map((el) => el == null ? void 0 : el.id);\n  walkTreeOutside(id, elements, (element) => {\n    if (isBackdrop(element, ...ids)) return;\n    cleanups.unshift(hideElementFromAccessibilityTree(element));\n  });\n  const restoreAccessibilityTree = () => {\n    for (const cleanup of cleanups) {\n      cleanup();\n    }\n  };\n  return restoreAccessibilityTree;\n}\n\nexport {\n  hideElementFromAccessibilityTree,\n  disableAccessibilityTreeOutside\n};\n","\"use client\";\n\n// src/dialog/utils/supports-inert.ts\nfunction supportsInert() {\n  return \"inert\" in HTMLElement.prototype;\n}\n\nexport {\n  supportsInert\n};\n","\"use client\";\nimport {\n  isFocusTrap\n} from \"./IGR4SXG2.js\";\nimport {\n  hideElementFromAccessibilityTree\n} from \"./ESSM74HH.js\";\nimport {\n  isBackdrop\n} from \"./63XF7ACK.js\";\nimport {\n  supportsInert\n} from \"./677M2CI3.js\";\nimport {\n  walkTreeOutside\n} from \"./AOUGVQZ3.js\";\nimport {\n  assignStyle,\n  orchestrate,\n  setAttribute,\n  setProperty\n} from \"./K2ZF5NU7.js\";\n\n// src/dialog/utils/disable-tree.ts\nimport { contains } from \"@ariakit/core/utils/dom\";\nimport { getAllTabbableIn } from \"@ariakit/core/utils/focus\";\nimport { chain, noop } from \"@ariakit/core/utils/misc\";\nfunction disableTree(element, ignoredElements) {\n  if (!(\"style\" in element)) return noop;\n  if (supportsInert()) {\n    return setProperty(element, \"inert\", true);\n  }\n  const tabbableElements = getAllTabbableIn(element, true);\n  const enableElements = tabbableElements.map((element2) => {\n    if (ignoredElements == null ? void 0 : ignoredElements.some((el) => el && contains(el, element2))) return noop;\n    const restoreFocusMethod = orchestrate(element2, \"focus\", () => {\n      element2.focus = noop;\n      return () => {\n        delete element2.focus;\n      };\n    });\n    return chain(setAttribute(element2, \"tabindex\", \"-1\"), restoreFocusMethod);\n  });\n  return chain(\n    ...enableElements,\n    hideElementFromAccessibilityTree(element),\n    assignStyle(element, {\n      pointerEvents: \"none\",\n      userSelect: \"none\",\n      cursor: \"default\"\n    })\n  );\n}\nfunction disableTreeOutside(id, elements) {\n  const cleanups = [];\n  const ids = elements.map((el) => el == null ? void 0 : el.id);\n  walkTreeOutside(\n    id,\n    elements,\n    (element) => {\n      if (isBackdrop(element, ...ids)) return;\n      if (isFocusTrap(element, ...ids)) return;\n      cleanups.unshift(disableTree(element, elements));\n    },\n    (element) => {\n      if (!element.hasAttribute(\"role\")) return;\n      if (elements.some((el) => el && contains(el, element))) return;\n      cleanups.unshift(setAttribute(element, \"role\", \"none\"));\n    }\n  );\n  const restoreTreeOutside = () => {\n    for (const cleanup of cleanups) {\n      cleanup();\n    }\n  };\n  return restoreTreeOutside;\n}\n\nexport {\n  disableTree,\n  disableTreeOutside\n};\n","\"use client\";\nimport {\n  useRootDialog\n} from \"./YKJECYU7.js\";\nimport {\n  assignStyle,\n  setCSSProperty\n} from \"./K2ZF5NU7.js\";\n\n// src/dialog/utils/use-prevent-body-scroll.ts\nimport { getDocument, getWindow } from \"@ariakit/core/utils/dom\";\nimport { chain } from \"@ariakit/core/utils/misc\";\nimport { isApple, isMac } from \"@ariakit/core/utils/platform\";\nimport { useEffect } from \"react\";\nfunction getPaddingProperty(documentElement) {\n  const documentLeft = documentElement.getBoundingClientRect().left;\n  const scrollbarX = Math.round(documentLeft) + documentElement.scrollLeft;\n  return scrollbarX ? \"paddingLeft\" : \"paddingRight\";\n}\nfunction usePreventBodyScroll(contentElement, contentId, enabled) {\n  const isRootDialog = useRootDialog({\n    attribute: \"data-dialog-prevent-body-scroll\",\n    contentElement,\n    contentId,\n    enabled\n  });\n  useEffect(() => {\n    if (!isRootDialog()) return;\n    if (!contentElement) return;\n    const doc = getDocument(contentElement);\n    const win = getWindow(contentElement);\n    const { documentElement, body } = doc;\n    const cssScrollbarWidth = documentElement.style.getPropertyValue(\"--scrollbar-width\");\n    const scrollbarWidth = cssScrollbarWidth ? Number.parseInt(cssScrollbarWidth) : win.innerWidth - documentElement.clientWidth;\n    const setScrollbarWidthProperty = () => setCSSProperty(\n      documentElement,\n      \"--scrollbar-width\",\n      `${scrollbarWidth}px`\n    );\n    const paddingProperty = getPaddingProperty(documentElement);\n    const setStyle = () => assignStyle(body, {\n      overflow: \"hidden\",\n      [paddingProperty]: `${scrollbarWidth}px`\n    });\n    const setIOSStyle = () => {\n      var _a, _b;\n      const { scrollX, scrollY, visualViewport } = win;\n      const offsetLeft = (_a = visualViewport == null ? void 0 : visualViewport.offsetLeft) != null ? _a : 0;\n      const offsetTop = (_b = visualViewport == null ? void 0 : visualViewport.offsetTop) != null ? _b : 0;\n      const restoreStyle = assignStyle(body, {\n        position: \"fixed\",\n        overflow: \"hidden\",\n        top: `${-(scrollY - Math.floor(offsetTop))}px`,\n        left: `${-(scrollX - Math.floor(offsetLeft))}px`,\n        right: \"0\",\n        [paddingProperty]: `${scrollbarWidth}px`\n      });\n      return () => {\n        restoreStyle();\n        if (process.env.NODE_ENV !== \"test\") {\n          win.scrollTo({ left: scrollX, top: scrollY, behavior: \"instant\" });\n        }\n      };\n    };\n    const isIOS = isApple() && !isMac();\n    return chain(\n      setScrollbarWidthProperty(),\n      isIOS ? setIOSStyle() : setStyle()\n    );\n  }, [isRootDialog, contentElement]);\n}\n\nexport {\n  usePreventBodyScroll\n};\n","\"use client\";\nimport {\n  useForceUpdate\n} from \"./ABQUS43J.js\";\n\n// src/dialog/utils/use-root-dialog.ts\nimport { getDocument } from \"@ariakit/core/utils/dom\";\nimport { useCallback, useEffect } from \"react\";\nimport { flushSync } from \"react-dom\";\nfunction useRootDialog({\n  attribute,\n  contentId,\n  contentElement,\n  enabled\n}) {\n  const [updated, retry] = useForceUpdate();\n  const isRootDialog = useCallback(() => {\n    if (!enabled) return false;\n    if (!contentElement) return false;\n    const { body } = getDocument(contentElement);\n    const id = body.getAttribute(attribute);\n    return !id || id === contentId;\n  }, [updated, enabled, contentElement, attribute, contentId]);\n  useEffect(() => {\n    if (!enabled) return;\n    if (!contentId) return;\n    if (!contentElement) return;\n    const { body } = getDocument(contentElement);\n    if (isRootDialog()) {\n      body.setAttribute(attribute, contentId);\n      return () => body.removeAttribute(attribute);\n    }\n    const observer = new MutationObserver(() => flushSync(retry));\n    observer.observe(body, { attributeFilter: [attribute] });\n    return () => observer.disconnect();\n  }, [updated, enabled, contentId, contentElement, isRootDialog, attribute]);\n  return isRootDialog;\n}\n\nexport {\n  useRootDialog\n};\n","\"use client\";\nimport {\n  useSafeLayoutEffect\n} from \"./ABQUS43J.js\";\n\n// src/dialog/utils/use-nested-dialogs.tsx\nimport { chain } from \"@ariakit/core/utils/misc\";\nimport { sync } from \"@ariakit/core/utils/store\";\nimport {\n  createContext,\n  useCallback,\n  useContext,\n  useMemo,\n  useState\n} from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nvar NestedDialogsContext = createContext({});\nfunction useNestedDialogs(store) {\n  const context = useContext(NestedDialogsContext);\n  const [dialogs, setDialogs] = useState([]);\n  const add = useCallback(\n    (dialog) => {\n      var _a;\n      setDialogs((dialogs2) => [...dialogs2, dialog]);\n      return chain((_a = context.add) == null ? void 0 : _a.call(context, dialog), () => {\n        setDialogs((dialogs2) => dialogs2.filter((d) => d !== dialog));\n      });\n    },\n    [context]\n  );\n  useSafeLayoutEffect(() => {\n    return sync(store, [\"open\", \"contentElement\"], (state) => {\n      var _a;\n      if (!state.open) return;\n      if (!state.contentElement) return;\n      return (_a = context.add) == null ? void 0 : _a.call(context, store);\n    });\n  }, [store, context]);\n  const providerValue = useMemo(() => ({ store, add }), [store, add]);\n  const wrapElement = useCallback(\n    (element) => /* @__PURE__ */ jsx(NestedDialogsContext.Provider, { value: providerValue, children: element }),\n    [providerValue]\n  );\n  return { wrapElement, nestedDialogs: dialogs };\n}\n\nexport {\n  useNestedDialogs\n};\n","\"use client\";\nimport {\n  isElementMarked\n} from \"./2PGBN2Y4.js\";\nimport {\n  usePreviousMouseDownRef\n} from \"./HLTQOHKZ.js\";\nimport {\n  isSafariFocusAncestor\n} from \"./LVA2YJMS.js\";\nimport {\n  useStoreState\n} from \"./YV4JVR4I.js\";\nimport {\n  useEvent,\n  useSafeLayoutEffect\n} from \"./ABQUS43J.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/dialog/utils/use-hide-on-interact-outside.ts\nimport { contains, getDocument, isVisible } from \"@ariakit/core/utils/dom\";\nimport { addGlobalEventListener } from \"@ariakit/core/utils/events\";\nimport { useEffect, useRef } from \"react\";\nfunction isInDocument(target) {\n  if (target.tagName === \"HTML\") return true;\n  return contains(getDocument(target).body, target);\n}\nfunction isDisclosure(disclosure, target) {\n  if (!disclosure) return false;\n  if (contains(disclosure, target)) return true;\n  const activeId = target.getAttribute(\"aria-activedescendant\");\n  if (activeId) {\n    const activeElement = getDocument(disclosure).getElementById(activeId);\n    if (activeElement) {\n      return contains(disclosure, activeElement);\n    }\n  }\n  return false;\n}\nfunction isMouseEventOnDialog(event, dialog) {\n  if (!(\"clientY\" in event)) return false;\n  const rect = dialog.getBoundingClientRect();\n  if (rect.width === 0 || rect.height === 0) return false;\n  return rect.top <= event.clientY && event.clientY <= rect.top + rect.height && rect.left <= event.clientX && event.clientX <= rect.left + rect.width;\n}\nfunction useEventOutside({\n  store,\n  type,\n  listener,\n  capture,\n  domReady\n}) {\n  const callListener = useEvent(listener);\n  const open = useStoreState(store, \"open\");\n  const focusedRef = useRef(false);\n  useSafeLayoutEffect(() => {\n    if (!open) return;\n    if (!domReady) return;\n    const { contentElement } = store.getState();\n    if (!contentElement) return;\n    const onFocus = () => {\n      focusedRef.current = true;\n    };\n    contentElement.addEventListener(\"focusin\", onFocus, true);\n    return () => contentElement.removeEventListener(\"focusin\", onFocus, true);\n  }, [store, open, domReady]);\n  useEffect(() => {\n    if (!open) return;\n    const onEvent = (event) => {\n      const { contentElement, disclosureElement } = store.getState();\n      const target = event.target;\n      if (!contentElement) return;\n      if (!target) return;\n      if (!isInDocument(target)) return;\n      if (contains(contentElement, target)) return;\n      if (isDisclosure(disclosureElement, target)) return;\n      if (target.hasAttribute(\"data-focus-trap\")) return;\n      if (isMouseEventOnDialog(event, contentElement)) return;\n      const focused = focusedRef.current;\n      if (focused && !isElementMarked(target, contentElement.id)) return;\n      if (isSafariFocusAncestor(target)) return;\n      callListener(event);\n    };\n    return addGlobalEventListener(type, onEvent, capture);\n  }, [open, capture]);\n}\nfunction shouldHideOnInteractOutside(hideOnInteractOutside, event) {\n  if (typeof hideOnInteractOutside === \"function\") {\n    return hideOnInteractOutside(event);\n  }\n  return !!hideOnInteractOutside;\n}\nfunction useHideOnInteractOutside(store, hideOnInteractOutside, domReady) {\n  const open = useStoreState(store, \"open\");\n  const previousMouseDownRef = usePreviousMouseDownRef(open);\n  const props = { store, domReady, capture: true };\n  useEventOutside(__spreadProps(__spreadValues({}, props), {\n    type: \"click\",\n    listener: (event) => {\n      const { contentElement } = store.getState();\n      const previousMouseDown = previousMouseDownRef.current;\n      if (!previousMouseDown) return;\n      if (!isVisible(previousMouseDown)) return;\n      if (!isElementMarked(previousMouseDown, contentElement == null ? void 0 : contentElement.id)) return;\n      if (!shouldHideOnInteractOutside(hideOnInteractOutside, event)) return;\n      store.hide();\n    }\n  }));\n  useEventOutside(__spreadProps(__spreadValues({}, props), {\n    type: \"focusin\",\n    listener: (event) => {\n      const { contentElement } = store.getState();\n      if (!contentElement) return;\n      if (event.target === getDocument(contentElement)) return;\n      if (!shouldHideOnInteractOutside(hideOnInteractOutside, event)) return;\n      store.hide();\n    }\n  }));\n  useEventOutside(__spreadProps(__spreadValues({}, props), {\n    type: \"contextmenu\",\n    listener: (event) => {\n      if (!shouldHideOnInteractOutside(hideOnInteractOutside, event)) return;\n      store.hide();\n    }\n  }));\n}\n\nexport {\n  useHideOnInteractOutside\n};\n","\"use client\";\n\n// src/dialog/utils/use-previous-mouse-down-ref.ts\nimport { addGlobalEventListener } from \"@ariakit/core/utils/events\";\nimport { useEffect, useRef } from \"react\";\nfunction usePreviousMouseDownRef(enabled) {\n  const previousMouseDownRef = useRef();\n  useEffect(() => {\n    if (!enabled) {\n      previousMouseDownRef.current = null;\n      return;\n    }\n    const onMouseDown = (event) => {\n      previousMouseDownRef.current = event.target;\n    };\n    return addGlobalEventListener(\"mousedown\", onMouseDown, true);\n  }, [enabled]);\n  return previousMouseDownRef;\n}\n\nexport {\n  usePreviousMouseDownRef\n};\n","\"use client\";\nimport {\n  FocusableContext\n} from \"./SWN3JYXT.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\nimport {\n  useWrapElement\n} from \"./ABQUS43J.js\";\nimport {\n  __objRest\n} from \"./3YLGPPWQ.js\";\n\n// src/focusable/focusable-container.tsx\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nvar useFocusableContainer = createHook(function useFocusableContainer2(_a) {\n  var _b = _a, { autoFocusOnShow = true } = _b, props = __objRest(_b, [\"autoFocusOnShow\"]);\n  props = useWrapElement(\n    props,\n    (element) => /* @__PURE__ */ jsx(FocusableContext.Provider, { value: autoFocusOnShow, children: element }),\n    [autoFocusOnShow]\n  );\n  return props;\n});\nvar FocusableContainer = forwardRef(function FocusableContainer2(props) {\n  const htmlProps = useFocusableContainer(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport {\n  useFocusableContainer,\n  FocusableContainer\n};\n","\"use client\";\n\n// src/heading/heading-context.tsx\nimport { createContext } from \"react\";\nvar HeadingContext = createContext(0);\n\nexport {\n  HeadingContext\n};\n","\"use client\";\nimport {\n  HeadingContext\n} from \"./CZ4GFWYL.js\";\n\n// src/heading/heading-level.tsx\nimport { useContext } from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nfunction HeadingLevel({ level, children }) {\n  const contextLevel = useContext(HeadingContext);\n  const nextLevel = Math.max(\n    Math.min(level || contextLevel + 1, 6),\n    1\n  );\n  return /* @__PURE__ */ jsx(HeadingContext.Provider, { value: nextLevel, children });\n}\n\nexport {\n  HeadingLevel\n};\n","\"use client\";\nimport {\n  DialogBackdrop\n} from \"./63FEHJZV.js\";\nimport {\n  disableTree,\n  disableTreeOutside\n} from \"./KZAQFFOU.js\";\nimport {\n  usePreventBodyScroll\n} from \"./BGQ3KQ5M.js\";\nimport {\n  useNestedDialogs\n} from \"./TOU75OXH.js\";\nimport {\n  useHideOnInteractOutside\n} from \"./WBDYNH73.js\";\nimport {\n  isElementMarked,\n  markTreeOutside\n} from \"./2PGBN2Y4.js\";\nimport {\n  supportsInert\n} from \"./677M2CI3.js\";\nimport {\n  prependHiddenDismiss\n} from \"./6GXEOXGT.js\";\nimport {\n  createWalkTreeSnapshot\n} from \"./AOUGVQZ3.js\";\nimport {\n  useFocusableContainer\n} from \"./ZWYATQFU.js\";\nimport {\n  HeadingLevel\n} from \"./5M6RIVE2.js\";\nimport {\n  usePortal\n} from \"./O37CNYMR.js\";\nimport {\n  isHidden,\n  useDisclosureContent\n} from \"./VGCJ63VH.js\";\nimport {\n  DialogDescriptionContext,\n  DialogHeadingContext,\n  DialogScopedContextProvider,\n  useDialogProviderContext\n} from \"./RS7LB2H4.js\";\nimport {\n  useFocusable\n} from \"./LVA2YJMS.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\nimport {\n  useDialogStore\n} from \"./BM6PGYQY.js\";\nimport {\n  useStoreState\n} from \"./YV4JVR4I.js\";\nimport {\n  useBooleanEvent,\n  useEvent,\n  useId,\n  useMergeRefs,\n  usePortalRef,\n  useSafeLayoutEffect,\n  useWrapElement\n} from \"./ABQUS43J.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/dialog/dialog.tsx\nimport {\n  contains,\n  getActiveElement,\n  getDocument,\n  getWindow,\n  isButton\n} from \"@ariakit/core/utils/dom\";\nimport {\n  addGlobalEventListener,\n  queueBeforeEvent\n} from \"@ariakit/core/utils/events\";\nimport {\n  focusIfNeeded,\n  getFirstTabbableIn,\n  isFocusable\n} from \"@ariakit/core/utils/focus\";\nimport { chain } from \"@ariakit/core/utils/misc\";\nimport { isSafari } from \"@ariakit/core/utils/platform\";\nimport { useCallback, useEffect, useRef, useState } from \"react\";\nimport { Fragment, jsx, jsxs } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nvar isSafariBrowser = isSafari();\nfunction isAlreadyFocusingAnotherElement(dialog) {\n  const activeElement = getActiveElement();\n  if (!activeElement) return false;\n  if (dialog && contains(dialog, activeElement)) return false;\n  if (isFocusable(activeElement)) return true;\n  return false;\n}\nfunction getElementFromProp(prop, focusable = false) {\n  if (!prop) return null;\n  const element = \"current\" in prop ? prop.current : prop;\n  if (!element) return null;\n  if (focusable) return isFocusable(element) ? element : null;\n  return element;\n}\nvar useDialog = createHook(function useDialog2(_a) {\n  var _b = _a, {\n    store: storeProp,\n    open: openProp,\n    onClose,\n    focusable = true,\n    modal = true,\n    portal = !!modal,\n    backdrop = !!modal,\n    hideOnEscape = true,\n    hideOnInteractOutside = true,\n    getPersistentElements,\n    preventBodyScroll = !!modal,\n    autoFocusOnShow = true,\n    autoFocusOnHide = true,\n    initialFocus,\n    finalFocus,\n    unmountOnHide,\n    unstable_treeSnapshotKey\n  } = _b, props = __objRest(_b, [\n    \"store\",\n    \"open\",\n    \"onClose\",\n    \"focusable\",\n    \"modal\",\n    \"portal\",\n    \"backdrop\",\n    \"hideOnEscape\",\n    \"hideOnInteractOutside\",\n    \"getPersistentElements\",\n    \"preventBodyScroll\",\n    \"autoFocusOnShow\",\n    \"autoFocusOnHide\",\n    \"initialFocus\",\n    \"finalFocus\",\n    \"unmountOnHide\",\n    \"unstable_treeSnapshotKey\"\n  ]);\n  const context = useDialogProviderContext();\n  const ref = useRef(null);\n  const store = useDialogStore({\n    store: storeProp || context,\n    open: openProp,\n    setOpen(open2) {\n      if (open2) return;\n      const dialog = ref.current;\n      if (!dialog) return;\n      const event = new Event(\"close\", { bubbles: false, cancelable: true });\n      if (onClose) {\n        dialog.addEventListener(\"close\", onClose, { once: true });\n      }\n      dialog.dispatchEvent(event);\n      if (!event.defaultPrevented) return;\n      store.setOpen(true);\n    }\n  });\n  const { portalRef, domReady } = usePortalRef(portal, props.portalRef);\n  const preserveTabOrderProp = props.preserveTabOrder;\n  const preserveTabOrder = useStoreState(\n    store,\n    (state) => preserveTabOrderProp && !modal && state.mounted\n  );\n  const id = useId(props.id);\n  const open = useStoreState(store, \"open\");\n  const mounted = useStoreState(store, \"mounted\");\n  const contentElement = useStoreState(store, \"contentElement\");\n  const hidden = isHidden(mounted, props.hidden, props.alwaysVisible);\n  usePreventBodyScroll(contentElement, id, preventBodyScroll && !hidden);\n  useHideOnInteractOutside(store, hideOnInteractOutside, domReady);\n  const { wrapElement, nestedDialogs } = useNestedDialogs(store);\n  props = useWrapElement(props, wrapElement, [wrapElement]);\n  useSafeLayoutEffect(() => {\n    if (!open) return;\n    const dialog = ref.current;\n    const activeElement = getActiveElement(dialog, true);\n    if (!activeElement) return;\n    if (activeElement.tagName === \"BODY\") return;\n    if (dialog && contains(dialog, activeElement)) return;\n    store.setDisclosureElement(activeElement);\n  }, [store, open]);\n  if (isSafariBrowser) {\n    useEffect(() => {\n      if (!mounted) return;\n      const { disclosureElement } = store.getState();\n      if (!disclosureElement) return;\n      if (!isButton(disclosureElement)) return;\n      const onMouseDown = () => {\n        let receivedFocus = false;\n        const onFocus = () => {\n          receivedFocus = true;\n        };\n        const options = { capture: true, once: true };\n        disclosureElement.addEventListener(\"focusin\", onFocus, options);\n        queueBeforeEvent(disclosureElement, \"mouseup\", () => {\n          disclosureElement.removeEventListener(\"focusin\", onFocus, true);\n          if (receivedFocus) return;\n          focusIfNeeded(disclosureElement);\n        });\n      };\n      disclosureElement.addEventListener(\"mousedown\", onMouseDown);\n      return () => {\n        disclosureElement.removeEventListener(\"mousedown\", onMouseDown);\n      };\n    }, [store, mounted]);\n  }\n  useEffect(() => {\n    if (!mounted) return;\n    if (!domReady) return;\n    const dialog = ref.current;\n    if (!dialog) return;\n    const win = getWindow(dialog);\n    const viewport = win.visualViewport || win;\n    const setViewportHeight = () => {\n      var _a2, _b2;\n      const height = (_b2 = (_a2 = win.visualViewport) == null ? void 0 : _a2.height) != null ? _b2 : win.innerHeight;\n      dialog.style.setProperty(\"--dialog-viewport-height\", `${height}px`);\n    };\n    setViewportHeight();\n    viewport.addEventListener(\"resize\", setViewportHeight);\n    return () => {\n      viewport.removeEventListener(\"resize\", setViewportHeight);\n    };\n  }, [mounted, domReady]);\n  useEffect(() => {\n    if (!modal) return;\n    if (!mounted) return;\n    if (!domReady) return;\n    const dialog = ref.current;\n    if (!dialog) return;\n    const existingDismiss = dialog.querySelector(\"[data-dialog-dismiss]\");\n    if (existingDismiss) return;\n    return prependHiddenDismiss(dialog, store.hide);\n  }, [store, modal, mounted, domReady]);\n  useSafeLayoutEffect(() => {\n    if (!supportsInert()) return;\n    if (open) return;\n    if (!mounted) return;\n    if (!domReady) return;\n    const dialog = ref.current;\n    if (!dialog) return;\n    return disableTree(dialog);\n  }, [open, mounted, domReady]);\n  const canTakeTreeSnapshot = open && domReady;\n  useSafeLayoutEffect(() => {\n    if (!id) return;\n    if (!canTakeTreeSnapshot) return;\n    const dialog = ref.current;\n    return createWalkTreeSnapshot(id, [dialog]);\n  }, [id, canTakeTreeSnapshot, unstable_treeSnapshotKey]);\n  const getPersistentElementsProp = useEvent(getPersistentElements);\n  useSafeLayoutEffect(() => {\n    if (!id) return;\n    if (!canTakeTreeSnapshot) return;\n    const { disclosureElement } = store.getState();\n    const dialog = ref.current;\n    const persistentElements = getPersistentElementsProp() || [];\n    const allElements = [\n      dialog,\n      ...persistentElements,\n      ...nestedDialogs.map((dialog2) => dialog2.getState().contentElement)\n    ];\n    if (modal) {\n      return chain(\n        markTreeOutside(id, allElements),\n        disableTreeOutside(id, allElements)\n      );\n    }\n    return markTreeOutside(id, [disclosureElement, ...allElements]);\n  }, [\n    id,\n    store,\n    canTakeTreeSnapshot,\n    getPersistentElementsProp,\n    nestedDialogs,\n    modal,\n    unstable_treeSnapshotKey\n  ]);\n  const mayAutoFocusOnShow = !!autoFocusOnShow;\n  const autoFocusOnShowProp = useBooleanEvent(autoFocusOnShow);\n  const [autoFocusEnabled, setAutoFocusEnabled] = useState(false);\n  useEffect(() => {\n    if (!open) return;\n    if (!mayAutoFocusOnShow) return;\n    if (!domReady) return;\n    if (!(contentElement == null ? void 0 : contentElement.isConnected)) return;\n    const element = getElementFromProp(initialFocus, true) || // If no initial focus is specified, we try to focus the first element\n    // with the autofocus attribute. If it's an Ariakit component, the\n    // Focusable component will consume the autoFocus prop and add the\n    // data-autofocus attribute to the element instead.\n    contentElement.querySelector(\n      \"[data-autofocus=true],[autofocus]\"\n    ) || // We have to fallback to the first focusable element otherwise portaled\n    // dialogs with preserveTabOrder set to true will not receive focus\n    // properly because the elements aren't tabbable until the dialog receives\n    // focus.\n    getFirstTabbableIn(contentElement, true, portal && preserveTabOrder) || // Finally, we fallback to the dialog element itself.\n    contentElement;\n    const isElementFocusable = isFocusable(element);\n    if (!autoFocusOnShowProp(isElementFocusable ? element : null)) return;\n    setAutoFocusEnabled(true);\n    queueMicrotask(() => {\n      element.focus();\n      if (!isSafariBrowser) return;\n      element.scrollIntoView({ block: \"nearest\", inline: \"nearest\" });\n    });\n  }, [\n    open,\n    mayAutoFocusOnShow,\n    domReady,\n    contentElement,\n    initialFocus,\n    portal,\n    preserveTabOrder,\n    autoFocusOnShowProp\n  ]);\n  const mayAutoFocusOnHide = !!autoFocusOnHide;\n  const autoFocusOnHideProp = useBooleanEvent(autoFocusOnHide);\n  const [hasOpened, setHasOpened] = useState(false);\n  useEffect(() => {\n    if (!open) return;\n    setHasOpened(true);\n    return () => setHasOpened(false);\n  }, [open]);\n  const focusOnHide = useCallback(\n    (dialog, retry = true) => {\n      const { disclosureElement } = store.getState();\n      if (isAlreadyFocusingAnotherElement(dialog)) return;\n      let element = getElementFromProp(finalFocus) || disclosureElement;\n      if (element == null ? void 0 : element.id) {\n        const doc = getDocument(element);\n        const selector = `[aria-activedescendant=\"${element.id}\"]`;\n        const composite = doc.querySelector(selector);\n        if (composite) {\n          element = composite;\n        }\n      }\n      if (element && !isFocusable(element)) {\n        const maybeParentDialog = element.closest(\"[data-dialog]\");\n        if (maybeParentDialog == null ? void 0 : maybeParentDialog.id) {\n          const doc = getDocument(maybeParentDialog);\n          const selector = `[aria-controls~=\"${maybeParentDialog.id}\"]`;\n          const control = doc.querySelector(selector);\n          if (control) {\n            element = control;\n          }\n        }\n      }\n      const isElementFocusable = element && isFocusable(element);\n      if (!isElementFocusable && retry) {\n        requestAnimationFrame(() => focusOnHide(dialog, false));\n        return;\n      }\n      if (!autoFocusOnHideProp(isElementFocusable ? element : null)) return;\n      if (!isElementFocusable) return;\n      element == null ? void 0 : element.focus();\n    },\n    [store, finalFocus, autoFocusOnHideProp]\n  );\n  const focusedOnHideRef = useRef(false);\n  useSafeLayoutEffect(() => {\n    if (open) return;\n    if (!hasOpened) return;\n    if (!mayAutoFocusOnHide) return;\n    const dialog = ref.current;\n    focusedOnHideRef.current = true;\n    focusOnHide(dialog);\n  }, [open, hasOpened, domReady, mayAutoFocusOnHide, focusOnHide]);\n  useEffect(() => {\n    if (!hasOpened) return;\n    if (!mayAutoFocusOnHide) return;\n    const dialog = ref.current;\n    return () => {\n      if (focusedOnHideRef.current) {\n        focusedOnHideRef.current = false;\n        return;\n      }\n      focusOnHide(dialog);\n    };\n  }, [hasOpened, mayAutoFocusOnHide, focusOnHide]);\n  const hideOnEscapeProp = useBooleanEvent(hideOnEscape);\n  useEffect(() => {\n    if (!domReady) return;\n    if (!mounted) return;\n    const onKeyDown = (event) => {\n      if (event.key !== \"Escape\") return;\n      if (event.defaultPrevented) return;\n      const dialog = ref.current;\n      if (!dialog) return;\n      if (isElementMarked(dialog)) return;\n      const target = event.target;\n      if (!target) return;\n      const { disclosureElement } = store.getState();\n      const isValidTarget = () => {\n        if (target.tagName === \"BODY\") return true;\n        if (contains(dialog, target)) return true;\n        if (!disclosureElement) return true;\n        if (contains(disclosureElement, target)) return true;\n        return false;\n      };\n      if (!isValidTarget()) return;\n      if (!hideOnEscapeProp(event)) return;\n      store.hide();\n    };\n    return addGlobalEventListener(\"keydown\", onKeyDown, true);\n  }, [store, domReady, mounted, hideOnEscapeProp]);\n  props = useWrapElement(\n    props,\n    (element) => /* @__PURE__ */ jsx(HeadingLevel, { level: modal ? 1 : void 0, children: element }),\n    [modal]\n  );\n  const hiddenProp = props.hidden;\n  const alwaysVisible = props.alwaysVisible;\n  props = useWrapElement(\n    props,\n    (element) => {\n      if (!backdrop) return element;\n      return /* @__PURE__ */ jsxs(Fragment, { children: [\n        /* @__PURE__ */ jsx(\n          DialogBackdrop,\n          {\n            store,\n            backdrop,\n            hidden: hiddenProp,\n            alwaysVisible\n          }\n        ),\n        element\n      ] });\n    },\n    [store, backdrop, hiddenProp, alwaysVisible]\n  );\n  const [headingId, setHeadingId] = useState();\n  const [descriptionId, setDescriptionId] = useState();\n  props = useWrapElement(\n    props,\n    (element) => /* @__PURE__ */ jsx(DialogScopedContextProvider, { value: store, children: /* @__PURE__ */ jsx(DialogHeadingContext.Provider, { value: setHeadingId, children: /* @__PURE__ */ jsx(DialogDescriptionContext.Provider, { value: setDescriptionId, children: element }) }) }),\n    [store]\n  );\n  props = __spreadProps(__spreadValues({\n    id,\n    \"data-dialog\": \"\",\n    role: \"dialog\",\n    tabIndex: focusable ? -1 : void 0,\n    \"aria-labelledby\": headingId,\n    \"aria-describedby\": descriptionId\n  }, props), {\n    ref: useMergeRefs(ref, props.ref)\n  });\n  props = useFocusableContainer(__spreadProps(__spreadValues({}, props), {\n    autoFocusOnShow: autoFocusEnabled\n  }));\n  props = useDisclosureContent(__spreadValues({ store }, props));\n  props = useFocusable(__spreadProps(__spreadValues({}, props), { focusable }));\n  props = usePortal(__spreadProps(__spreadValues({ portal }, props), { portalRef, preserveTabOrder }));\n  return props;\n});\nfunction createDialogComponent(Component, useProviderContext = useDialogProviderContext) {\n  return forwardRef(function DialogComponent(props) {\n    const context = useProviderContext();\n    const store = props.store || context;\n    const mounted = useStoreState(\n      store,\n      (state) => !props.unmountOnHide || (state == null ? void 0 : state.mounted) || !!props.open\n    );\n    if (!mounted) return null;\n    return /* @__PURE__ */ jsx(Component, __spreadValues({}, props));\n  });\n}\nvar Dialog = createDialogComponent(\n  forwardRef(function Dialog2(props) {\n    const htmlProps = useDialog(props);\n    return createElement(TagName, htmlProps);\n  }),\n  useDialogProviderContext\n);\n\nexport {\n  useDialog,\n  createDialogComponent,\n  Dialog\n};\n","\"use client\";\n\n// src/dialog/utils/prepend-hidden-dismiss.ts\nimport { getDocument } from \"@ariakit/core/utils/dom\";\nfunction prependHiddenDismiss(container, onClick) {\n  const document = getDocument(container);\n  const button = document.createElement(\"button\");\n  button.type = \"button\";\n  button.tabIndex = -1;\n  button.textContent = \"Dismiss popup\";\n  Object.assign(button.style, {\n    border: \"0px\",\n    clip: \"rect(0 0 0 0)\",\n    height: \"1px\",\n    margin: \"-1px\",\n    overflow: \"hidden\",\n    padding: \"0px\",\n    position: \"absolute\",\n    whiteSpace: \"nowrap\",\n    width: \"1px\"\n  });\n  button.addEventListener(\"click\", onClick);\n  container.prepend(button);\n  const removeHiddenDismiss = () => {\n    button.removeEventListener(\"click\", onClick);\n    button.remove();\n  };\n  return removeHiddenDismiss;\n}\n\nexport {\n  prependHiddenDismiss\n};\n","\"use client\";\n\n// src/dialog/utils/is-focus-trap.ts\nfunction isFocusTrap(element, ...ids) {\n  if (!element) return false;\n  const attr = element.getAttribute(\"data-focus-trap\");\n  if (attr == null) return false;\n  if (!ids.length) return true;\n  if (attr === \"\") return false;\n  return ids.some((id) => attr === id);\n}\n\nexport {\n  isFocusTrap\n};\n","\"use client\";\n\n// src/hovercard/utils/polygon.ts\nfunction getEventPoint(event) {\n  return [event.clientX, event.clientY];\n}\nfunction isPointInPolygon(point, polygon) {\n  const [x, y] = point;\n  let inside = false;\n  const length = polygon.length;\n  for (let l = length, i = 0, j = l - 1; i < l; j = i++) {\n    const [xi, yi] = polygon[i];\n    const [xj, yj] = polygon[j];\n    const [, vy] = polygon[j === 0 ? l - 1 : j - 1] || [0, 0];\n    const where = (yi - yj) * (x - xi) - (xi - xj) * (y - yi);\n    if (yj < yi) {\n      if (y >= yj && y < yi) {\n        if (where === 0) return true;\n        if (where > 0) {\n          if (y === yj) {\n            if (y > vy) {\n              inside = !inside;\n            }\n          } else {\n            inside = !inside;\n          }\n        }\n      }\n    } else if (yi < yj) {\n      if (y > yi && y <= yj) {\n        if (where === 0) return true;\n        if (where < 0) {\n          if (y === yj) {\n            if (y < vy) {\n              inside = !inside;\n            }\n          } else {\n            inside = !inside;\n          }\n        }\n      }\n    } else if (y === yi && (x >= xj && x <= xi || x >= xi && x <= xj)) {\n      return true;\n    }\n  }\n  return inside;\n}\nfunction getEnterPointPlacement(enterPoint, rect) {\n  const { top, right, bottom, left } = rect;\n  const [x, y] = enterPoint;\n  const placementX = x < left ? \"left\" : x > right ? \"right\" : null;\n  const placementY = y < top ? \"top\" : y > bottom ? \"bottom\" : null;\n  return [placementX, placementY];\n}\nfunction getElementPolygon(element, enterPoint) {\n  const rect = element.getBoundingClientRect();\n  const { top, right, bottom, left } = rect;\n  const [x, y] = getEnterPointPlacement(enterPoint, rect);\n  const polygon = [enterPoint];\n  if (x) {\n    if (y !== \"top\") {\n      polygon.push([x === \"left\" ? left : right, top]);\n    }\n    polygon.push([x === \"left\" ? right : left, top]);\n    polygon.push([x === \"left\" ? right : left, bottom]);\n    if (y !== \"bottom\") {\n      polygon.push([x === \"left\" ? left : right, bottom]);\n    }\n  } else if (y === \"top\") {\n    polygon.push([left, top]);\n    polygon.push([left, bottom]);\n    polygon.push([right, bottom]);\n    polygon.push([right, top]);\n  } else {\n    polygon.push([left, bottom]);\n    polygon.push([left, top]);\n    polygon.push([right, top]);\n    polygon.push([right, bottom]);\n  }\n  return polygon;\n}\n\nexport {\n  getEventPoint,\n  isPointInPolygon,\n  getElementPolygon\n};\n","\"use client\";\nimport {\n  getElementPolygon,\n  getEventPoint,\n  isPointInPolygon\n} from \"./X7QOZUD3.js\";\nimport {\n  usePopover\n} from \"./T6C2RYFI.js\";\nimport {\n  createDialogComponent\n} from \"./JC64G2H7.js\";\nimport {\n  HovercardScopedContextProvider,\n  useHovercardProviderContext\n} from \"./EM5CXX6A.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\nimport {\n  useBooleanEvent,\n  useEvent,\n  useIsMouseMoving,\n  useLiveRef,\n  useMergeRefs,\n  usePortalRef,\n  useSafeLayoutEffect,\n  useWrapElement\n} from \"./ABQUS43J.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/hovercard/hovercard.tsx\nimport { contains } from \"@ariakit/core/utils/dom\";\nimport { addGlobalEventListener } from \"@ariakit/core/utils/events\";\nimport { hasFocusWithin } from \"@ariakit/core/utils/focus\";\nimport {\n  chain,\n  invariant,\n  isFalsyBooleanCallback\n} from \"@ariakit/core/utils/misc\";\nimport { sync } from \"@ariakit/core/utils/store\";\nimport {\n  createContext,\n  useCallback,\n  useContext,\n  useEffect,\n  useRef,\n  useState\n} from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nfunction isMovingOnHovercard(target, card, anchor, nested) {\n  if (hasFocusWithin(card)) return true;\n  if (!target) return false;\n  if (contains(card, target)) return true;\n  if (anchor && contains(anchor, target)) return true;\n  if (nested == null ? void 0 : nested.some((card2) => isMovingOnHovercard(target, card2, anchor))) {\n    return true;\n  }\n  return false;\n}\nfunction useAutoFocusOnHide(_a) {\n  var _b = _a, {\n    store\n  } = _b, props = __objRest(_b, [\n    \"store\"\n  ]);\n  const [autoFocusOnHide, setAutoFocusOnHide] = useState(false);\n  const mounted = store.useState(\"mounted\");\n  useEffect(() => {\n    if (!mounted) {\n      setAutoFocusOnHide(false);\n    }\n  }, [mounted]);\n  const onFocusProp = props.onFocus;\n  const onFocus = useEvent((event) => {\n    onFocusProp == null ? void 0 : onFocusProp(event);\n    if (event.defaultPrevented) return;\n    setAutoFocusOnHide(true);\n  });\n  const finalFocusRef = useRef(null);\n  useEffect(() => {\n    return sync(store, [\"anchorElement\"], (state) => {\n      finalFocusRef.current = state.anchorElement;\n    });\n  }, []);\n  props = __spreadProps(__spreadValues({\n    autoFocusOnHide,\n    finalFocus: finalFocusRef\n  }, props), {\n    onFocus\n  });\n  return props;\n}\nvar NestedHovercardContext = createContext(null);\nvar useHovercard = createHook(\n  function useHovercard2(_a) {\n    var _b = _a, {\n      store,\n      modal = false,\n      portal = !!modal,\n      hideOnEscape = true,\n      hideOnHoverOutside = true,\n      disablePointerEventsOnApproach = !!hideOnHoverOutside\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"modal\",\n      \"portal\",\n      \"hideOnEscape\",\n      \"hideOnHoverOutside\",\n      \"disablePointerEventsOnApproach\"\n    ]);\n    const context = useHovercardProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"Hovercard must receive a `store` prop or be wrapped in a HovercardProvider component.\"\n    );\n    const ref = useRef(null);\n    const [nestedHovercards, setNestedHovercards] = useState([]);\n    const hideTimeoutRef = useRef(0);\n    const enterPointRef = useRef(null);\n    const { portalRef, domReady } = usePortalRef(portal, props.portalRef);\n    const isMouseMoving = useIsMouseMoving();\n    const mayHideOnHoverOutside = !!hideOnHoverOutside;\n    const hideOnHoverOutsideProp = useBooleanEvent(hideOnHoverOutside);\n    const mayDisablePointerEvents = !!disablePointerEventsOnApproach;\n    const disablePointerEventsProp = useBooleanEvent(\n      disablePointerEventsOnApproach\n    );\n    const open = store.useState(\"open\");\n    const mounted = store.useState(\"mounted\");\n    useEffect(() => {\n      if (!domReady) return;\n      if (!mounted) return;\n      if (!mayHideOnHoverOutside && !mayDisablePointerEvents) return;\n      const element = ref.current;\n      if (!element) return;\n      const onMouseMove = (event) => {\n        if (!store) return;\n        if (!isMouseMoving()) return;\n        const { anchorElement, hideTimeout, timeout } = store.getState();\n        const enterPoint = enterPointRef.current;\n        const [target] = event.composedPath();\n        const anchor = anchorElement;\n        if (isMovingOnHovercard(target, element, anchor, nestedHovercards)) {\n          enterPointRef.current = target && anchor && contains(anchor, target) ? getEventPoint(event) : null;\n          window.clearTimeout(hideTimeoutRef.current);\n          hideTimeoutRef.current = 0;\n          return;\n        }\n        if (hideTimeoutRef.current) return;\n        if (enterPoint) {\n          const currentPoint = getEventPoint(event);\n          const polygon = getElementPolygon(element, enterPoint);\n          if (isPointInPolygon(currentPoint, polygon)) {\n            enterPointRef.current = currentPoint;\n            if (!disablePointerEventsProp(event)) return;\n            event.preventDefault();\n            event.stopPropagation();\n            return;\n          }\n        }\n        if (!hideOnHoverOutsideProp(event)) return;\n        hideTimeoutRef.current = window.setTimeout(() => {\n          hideTimeoutRef.current = 0;\n          store == null ? void 0 : store.hide();\n        }, hideTimeout != null ? hideTimeout : timeout);\n      };\n      return chain(\n        addGlobalEventListener(\"mousemove\", onMouseMove, true),\n        () => clearTimeout(hideTimeoutRef.current)\n      );\n    }, [\n      store,\n      isMouseMoving,\n      domReady,\n      mounted,\n      mayHideOnHoverOutside,\n      mayDisablePointerEvents,\n      nestedHovercards,\n      disablePointerEventsProp,\n      hideOnHoverOutsideProp\n    ]);\n    useEffect(() => {\n      if (!domReady) return;\n      if (!mounted) return;\n      if (!mayDisablePointerEvents) return;\n      const disableEvent = (event) => {\n        const element = ref.current;\n        if (!element) return;\n        const enterPoint = enterPointRef.current;\n        if (!enterPoint) return;\n        const polygon = getElementPolygon(element, enterPoint);\n        if (isPointInPolygon(getEventPoint(event), polygon)) {\n          if (!disablePointerEventsProp(event)) return;\n          event.preventDefault();\n          event.stopPropagation();\n        }\n      };\n      return chain(\n        // Note: we may need to add pointer events here in the future.\n        addGlobalEventListener(\"mouseenter\", disableEvent, true),\n        addGlobalEventListener(\"mouseover\", disableEvent, true),\n        addGlobalEventListener(\"mouseout\", disableEvent, true),\n        addGlobalEventListener(\"mouseleave\", disableEvent, true)\n      );\n    }, [domReady, mounted, mayDisablePointerEvents, disablePointerEventsProp]);\n    useEffect(() => {\n      if (!domReady) return;\n      if (open) return;\n      store == null ? void 0 : store.setAutoFocusOnShow(false);\n    }, [store, domReady, open]);\n    const openRef = useLiveRef(open);\n    useEffect(() => {\n      if (!domReady) return;\n      return () => {\n        if (!openRef.current) {\n          store == null ? void 0 : store.setAutoFocusOnShow(false);\n        }\n      };\n    }, [store, domReady]);\n    const registerOnParent = useContext(NestedHovercardContext);\n    useSafeLayoutEffect(() => {\n      if (modal) return;\n      if (!portal) return;\n      if (!mounted) return;\n      if (!domReady) return;\n      const element = ref.current;\n      if (!element) return;\n      return registerOnParent == null ? void 0 : registerOnParent(element);\n    }, [modal, portal, mounted, domReady]);\n    const registerNestedHovercard = useCallback(\n      (element) => {\n        setNestedHovercards((prevElements) => [...prevElements, element]);\n        const parentUnregister = registerOnParent == null ? void 0 : registerOnParent(element);\n        return () => {\n          setNestedHovercards(\n            (prevElements) => prevElements.filter((item) => item !== element)\n          );\n          parentUnregister == null ? void 0 : parentUnregister();\n        };\n      },\n      [registerOnParent]\n    );\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(HovercardScopedContextProvider, { value: store, children: /* @__PURE__ */ jsx(NestedHovercardContext.Provider, { value: registerNestedHovercard, children: element }) }),\n      [store, registerNestedHovercard]\n    );\n    props = __spreadProps(__spreadValues({}, props), {\n      ref: useMergeRefs(ref, props.ref)\n    });\n    props = useAutoFocusOnHide(__spreadValues({ store }, props));\n    const autoFocusOnShow = store.useState(\n      (state) => modal || state.autoFocusOnShow\n    );\n    props = usePopover(__spreadProps(__spreadValues({\n      store,\n      modal,\n      portal,\n      autoFocusOnShow\n    }, props), {\n      portalRef,\n      hideOnEscape(event) {\n        if (isFalsyBooleanCallback(hideOnEscape, event)) return false;\n        requestAnimationFrame(() => {\n          requestAnimationFrame(() => {\n            store == null ? void 0 : store.hide();\n          });\n        });\n        return true;\n      }\n    }));\n    return props;\n  }\n);\nvar Hovercard = createDialogComponent(\n  forwardRef(function Hovercard2(props) {\n    const htmlProps = useHovercard(props);\n    return createElement(TagName, htmlProps);\n  }),\n  useHovercardProviderContext\n);\n\nexport {\n  useHovercard,\n  Hovercard\n};\n","\"use client\";\nimport {\n  useFocusable\n} from \"./LVA2YJMS.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\nimport {\n  useEvent,\n  useMergeRefs,\n  useMetadataProps\n} from \"./ABQUS43J.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/command/command.tsx\nimport { isButton, isTextField } from \"@ariakit/core/utils/dom\";\nimport {\n  fireClickEvent,\n  isSelfTarget,\n  queueBeforeEvent\n} from \"@ariakit/core/utils/events\";\nimport { disabledFromProps } from \"@ariakit/core/utils/misc\";\nimport { isFirefox } from \"@ariakit/core/utils/platform\";\nimport { useEffect, useRef, useState } from \"react\";\nvar TagName = \"button\";\nfunction isNativeClick(event) {\n  if (!event.isTrusted) return false;\n  const element = event.currentTarget;\n  if (event.key === \"Enter\") {\n    return isButton(element) || element.tagName === \"SUMMARY\" || element.tagName === \"A\";\n  }\n  if (event.key === \" \") {\n    return isButton(element) || element.tagName === \"SUMMARY\" || element.tagName === \"INPUT\" || element.tagName === \"SELECT\";\n  }\n  return false;\n}\nvar symbol = Symbol(\"command\");\nvar useCommand = createHook(\n  function useCommand2(_a) {\n    var _b = _a, { clickOnEnter = true, clickOnSpace = true } = _b, props = __objRest(_b, [\"clickOnEnter\", \"clickOnSpace\"]);\n    const ref = useRef(null);\n    const [isNativeButton, setIsNativeButton] = useState(false);\n    useEffect(() => {\n      if (!ref.current) return;\n      setIsNativeButton(isButton(ref.current));\n    }, []);\n    const [active, setActive] = useState(false);\n    const activeRef = useRef(false);\n    const disabled = disabledFromProps(props);\n    const [isDuplicate, metadataProps] = useMetadataProps(props, symbol, true);\n    const onKeyDownProp = props.onKeyDown;\n    const onKeyDown = useEvent((event) => {\n      onKeyDownProp == null ? void 0 : onKeyDownProp(event);\n      const element = event.currentTarget;\n      if (event.defaultPrevented) return;\n      if (isDuplicate) return;\n      if (disabled) return;\n      if (!isSelfTarget(event)) return;\n      if (isTextField(element)) return;\n      if (element.isContentEditable) return;\n      const isEnter = clickOnEnter && event.key === \"Enter\";\n      const isSpace = clickOnSpace && event.key === \" \";\n      const shouldPreventEnter = event.key === \"Enter\" && !clickOnEnter;\n      const shouldPreventSpace = event.key === \" \" && !clickOnSpace;\n      if (shouldPreventEnter || shouldPreventSpace) {\n        event.preventDefault();\n        return;\n      }\n      if (isEnter || isSpace) {\n        const nativeClick = isNativeClick(event);\n        if (isEnter) {\n          if (!nativeClick) {\n            event.preventDefault();\n            const _a2 = event, { view } = _a2, eventInit = __objRest(_a2, [\"view\"]);\n            const click = () => fireClickEvent(element, eventInit);\n            if (isFirefox()) {\n              queueBeforeEvent(element, \"keyup\", click);\n            } else {\n              queueMicrotask(click);\n            }\n          }\n        } else if (isSpace) {\n          activeRef.current = true;\n          if (!nativeClick) {\n            event.preventDefault();\n            setActive(true);\n          }\n        }\n      }\n    });\n    const onKeyUpProp = props.onKeyUp;\n    const onKeyUp = useEvent((event) => {\n      onKeyUpProp == null ? void 0 : onKeyUpProp(event);\n      if (event.defaultPrevented) return;\n      if (isDuplicate) return;\n      if (disabled) return;\n      if (event.metaKey) return;\n      const isSpace = clickOnSpace && event.key === \" \";\n      if (activeRef.current && isSpace) {\n        activeRef.current = false;\n        if (!isNativeClick(event)) {\n          event.preventDefault();\n          setActive(false);\n          const element = event.currentTarget;\n          const _a2 = event, { view } = _a2, eventInit = __objRest(_a2, [\"view\"]);\n          queueMicrotask(() => fireClickEvent(element, eventInit));\n        }\n      }\n    });\n    props = __spreadProps(__spreadValues(__spreadValues({\n      \"data-active\": active || void 0,\n      type: isNativeButton ? \"button\" : void 0\n    }, metadataProps), props), {\n      ref: useMergeRefs(ref, props.ref),\n      onKeyDown,\n      onKeyUp\n    });\n    props = useFocusable(props);\n    return props;\n  }\n);\nvar Command = forwardRef(function Command2(props) {\n  const htmlProps = useCommand(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport {\n  useCommand,\n  Command\n};\n","\"use client\";\nimport {\n  useMergeRefs\n} from \"./ABQUS43J.js\";\nimport {\n  getRefProperty,\n  mergeProps\n} from \"./SK3NAZA3.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/utils/system.tsx\nimport * as React from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nfunction forwardRef2(render) {\n  const Role = React.forwardRef((props, ref) => render(__spreadProps(__spreadValues({}, props), { ref })));\n  Role.displayName = render.displayName || render.name;\n  return Role;\n}\nfunction memo2(Component, propsAreEqual) {\n  return React.memo(Component, propsAreEqual);\n}\nfunction createElement(Type, props) {\n  const _a = props, { wrapElement, render } = _a, rest = __objRest(_a, [\"wrapElement\", \"render\"]);\n  const mergedRef = useMergeRefs(props.ref, getRefProperty(render));\n  let element;\n  if (React.isValidElement(render)) {\n    const renderProps = __spreadProps(__spreadValues({}, render.props), { ref: mergedRef });\n    element = React.cloneElement(render, mergeProps(rest, renderProps));\n  } else if (render) {\n    element = render(rest);\n  } else {\n    element = /* @__PURE__ */ jsx(Type, __spreadValues({}, rest));\n  }\n  if (wrapElement) {\n    return wrapElement(element);\n  }\n  return element;\n}\nfunction createHook(useProps) {\n  const useRole = (props = {}) => {\n    return useProps(props);\n  };\n  useRole.displayName = useProps.name;\n  return useRole;\n}\nfunction createStoreContext(providers = [], scopedProviders = []) {\n  const context = React.createContext(void 0);\n  const scopedContext = React.createContext(void 0);\n  const useContext2 = () => React.useContext(context);\n  const useScopedContext = (onlyScoped = false) => {\n    const scoped = React.useContext(scopedContext);\n    const store = useContext2();\n    if (onlyScoped) return scoped;\n    return scoped || store;\n  };\n  const useProviderContext = () => {\n    const scoped = React.useContext(scopedContext);\n    const store = useContext2();\n    if (scoped && scoped === store) return;\n    return store;\n  };\n  const ContextProvider = (props) => {\n    return providers.reduceRight(\n      (children, Provider) => /* @__PURE__ */ jsx(Provider, __spreadProps(__spreadValues({}, props), { children })),\n      /* @__PURE__ */ jsx(context.Provider, __spreadValues({}, props))\n    );\n  };\n  const ScopedContextProvider = (props) => {\n    return /* @__PURE__ */ jsx(ContextProvider, __spreadProps(__spreadValues({}, props), { children: scopedProviders.reduceRight(\n      (children, Provider) => /* @__PURE__ */ jsx(Provider, __spreadProps(__spreadValues({}, props), { children })),\n      /* @__PURE__ */ jsx(scopedContext.Provider, __spreadValues({}, props))\n    ) }));\n  };\n  return {\n    context,\n    scopedContext,\n    useContext: useContext2,\n    useScopedContext,\n    useProviderContext,\n    ContextProvider,\n    ScopedContextProvider\n  };\n}\n\nexport {\n  forwardRef2 as forwardRef,\n  memo2 as memo,\n  createElement,\n  createHook,\n  createStoreContext\n};\n","\"use client\";\nimport {\n  FocusableContext\n} from \"./SWN3JYXT.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\nimport {\n  useEvent,\n  useMergeRefs,\n  useTagName\n} from \"./ABQUS43J.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/focusable/focusable.tsx\nimport { isButton } from \"@ariakit/core/utils/dom\";\nimport {\n  addGlobalEventListener,\n  isFocusEventOutside,\n  isPortalEvent,\n  isSelfTarget,\n  queueBeforeEvent\n} from \"@ariakit/core/utils/events\";\nimport {\n  focusIfNeeded,\n  getClosestFocusable,\n  hasFocus,\n  isFocusable\n} from \"@ariakit/core/utils/focus\";\nimport {\n  disabledFromProps,\n  removeUndefinedValues\n} from \"@ariakit/core/utils/misc\";\nimport { isSafari } from \"@ariakit/core/utils/platform\";\nimport { useContext, useEffect, useMemo, useRef, useState } from \"react\";\nvar TagName = \"div\";\nvar isSafariBrowser = isSafari();\nvar alwaysFocusVisibleInputTypes = [\n  \"text\",\n  \"search\",\n  \"url\",\n  \"tel\",\n  \"email\",\n  \"password\",\n  \"number\",\n  \"date\",\n  \"month\",\n  \"week\",\n  \"time\",\n  \"datetime\",\n  \"datetime-local\"\n];\nvar safariFocusAncestorSymbol = Symbol(\"safariFocusAncestor\");\nfunction isSafariFocusAncestor(element) {\n  if (!element) return false;\n  return !!element[safariFocusAncestorSymbol];\n}\nfunction markSafariFocusAncestor(element, value) {\n  if (!element) return;\n  element[safariFocusAncestorSymbol] = value;\n}\nfunction isAlwaysFocusVisible(element) {\n  const { tagName, readOnly, type } = element;\n  if (tagName === \"TEXTAREA\" && !readOnly) return true;\n  if (tagName === \"SELECT\" && !readOnly) return true;\n  if (tagName === \"INPUT\" && !readOnly) {\n    return alwaysFocusVisibleInputTypes.includes(type);\n  }\n  if (element.isContentEditable) return true;\n  const role = element.getAttribute(\"role\");\n  if (role === \"combobox\" && element.dataset.name) {\n    return true;\n  }\n  return false;\n}\nfunction getLabels(element) {\n  if (\"labels\" in element) {\n    return element.labels;\n  }\n  return null;\n}\nfunction isNativeCheckboxOrRadio(element) {\n  const tagName = element.tagName.toLowerCase();\n  if (tagName === \"input\" && element.type) {\n    return element.type === \"radio\" || element.type === \"checkbox\";\n  }\n  return false;\n}\nfunction isNativeTabbable(tagName) {\n  if (!tagName) return true;\n  return tagName === \"button\" || tagName === \"summary\" || tagName === \"input\" || tagName === \"select\" || tagName === \"textarea\" || tagName === \"a\";\n}\nfunction supportsDisabledAttribute(tagName) {\n  if (!tagName) return true;\n  return tagName === \"button\" || tagName === \"input\" || tagName === \"select\" || tagName === \"textarea\";\n}\nfunction getTabIndex(focusable, trulyDisabled, nativeTabbable, supportsDisabled, tabIndexProp) {\n  if (!focusable) {\n    return tabIndexProp;\n  }\n  if (trulyDisabled) {\n    if (nativeTabbable && !supportsDisabled) {\n      return -1;\n    }\n    return;\n  }\n  if (nativeTabbable) {\n    return tabIndexProp;\n  }\n  return tabIndexProp || 0;\n}\nfunction useDisableEvent(onEvent, disabled) {\n  return useEvent((event) => {\n    onEvent == null ? void 0 : onEvent(event);\n    if (event.defaultPrevented) return;\n    if (disabled) {\n      event.stopPropagation();\n      event.preventDefault();\n    }\n  });\n}\nvar isKeyboardModality = true;\nfunction onGlobalMouseDown(event) {\n  const target = event.target;\n  if (target && \"hasAttribute\" in target) {\n    if (!target.hasAttribute(\"data-focus-visible\")) {\n      isKeyboardModality = false;\n    }\n  }\n}\nfunction onGlobalKeyDown(event) {\n  if (event.metaKey) return;\n  if (event.ctrlKey) return;\n  if (event.altKey) return;\n  isKeyboardModality = true;\n}\nvar useFocusable = createHook(\n  function useFocusable2(_a) {\n    var _b = _a, {\n      focusable = true,\n      accessibleWhenDisabled,\n      autoFocus,\n      onFocusVisible\n    } = _b, props = __objRest(_b, [\n      \"focusable\",\n      \"accessibleWhenDisabled\",\n      \"autoFocus\",\n      \"onFocusVisible\"\n    ]);\n    const ref = useRef(null);\n    useEffect(() => {\n      if (!focusable) return;\n      addGlobalEventListener(\"mousedown\", onGlobalMouseDown, true);\n      addGlobalEventListener(\"keydown\", onGlobalKeyDown, true);\n    }, [focusable]);\n    if (isSafariBrowser) {\n      useEffect(() => {\n        if (!focusable) return;\n        const element = ref.current;\n        if (!element) return;\n        if (!isNativeCheckboxOrRadio(element)) return;\n        const labels = getLabels(element);\n        if (!labels) return;\n        const onMouseUp = () => queueMicrotask(() => element.focus());\n        for (const label of labels) {\n          label.addEventListener(\"mouseup\", onMouseUp);\n        }\n        return () => {\n          for (const label of labels) {\n            label.removeEventListener(\"mouseup\", onMouseUp);\n          }\n        };\n      }, [focusable]);\n    }\n    const disabled = focusable && disabledFromProps(props);\n    const trulyDisabled = !!disabled && !accessibleWhenDisabled;\n    const [focusVisible, setFocusVisible] = useState(false);\n    useEffect(() => {\n      if (!focusable) return;\n      if (trulyDisabled && focusVisible) {\n        setFocusVisible(false);\n      }\n    }, [focusable, trulyDisabled, focusVisible]);\n    useEffect(() => {\n      if (!focusable) return;\n      if (!focusVisible) return;\n      const element = ref.current;\n      if (!element) return;\n      if (typeof IntersectionObserver === \"undefined\") return;\n      const observer = new IntersectionObserver(() => {\n        if (!isFocusable(element)) {\n          setFocusVisible(false);\n        }\n      });\n      observer.observe(element);\n      return () => observer.disconnect();\n    }, [focusable, focusVisible]);\n    const onKeyPressCapture = useDisableEvent(\n      props.onKeyPressCapture,\n      disabled\n    );\n    const onMouseDownCapture = useDisableEvent(\n      props.onMouseDownCapture,\n      disabled\n    );\n    const onClickCapture = useDisableEvent(props.onClickCapture, disabled);\n    const onMouseDownProp = props.onMouseDown;\n    const onMouseDown = useEvent((event) => {\n      onMouseDownProp == null ? void 0 : onMouseDownProp(event);\n      if (event.defaultPrevented) return;\n      if (!focusable) return;\n      const element = event.currentTarget;\n      if (!isSafariBrowser) return;\n      if (isPortalEvent(event)) return;\n      if (!isButton(element) && !isNativeCheckboxOrRadio(element)) return;\n      let receivedFocus = false;\n      const onFocus = () => {\n        receivedFocus = true;\n      };\n      const options = { capture: true, once: true };\n      element.addEventListener(\"focusin\", onFocus, options);\n      const focusableContainer = getClosestFocusable(element.parentElement);\n      markSafariFocusAncestor(focusableContainer, true);\n      queueBeforeEvent(element, \"mouseup\", () => {\n        element.removeEventListener(\"focusin\", onFocus, true);\n        markSafariFocusAncestor(focusableContainer, false);\n        if (receivedFocus) return;\n        focusIfNeeded(element);\n      });\n    });\n    const handleFocusVisible = (event, currentTarget) => {\n      if (currentTarget) {\n        event.currentTarget = currentTarget;\n      }\n      if (!focusable) return;\n      const element = event.currentTarget;\n      if (!element) return;\n      if (!hasFocus(element)) return;\n      onFocusVisible == null ? void 0 : onFocusVisible(event);\n      if (event.defaultPrevented) return;\n      element.dataset.focusVisible = \"true\";\n      setFocusVisible(true);\n    };\n    const onKeyDownCaptureProp = props.onKeyDownCapture;\n    const onKeyDownCapture = useEvent((event) => {\n      onKeyDownCaptureProp == null ? void 0 : onKeyDownCaptureProp(event);\n      if (event.defaultPrevented) return;\n      if (!focusable) return;\n      if (focusVisible) return;\n      if (event.metaKey) return;\n      if (event.altKey) return;\n      if (event.ctrlKey) return;\n      if (!isSelfTarget(event)) return;\n      const element = event.currentTarget;\n      const applyFocusVisible = () => handleFocusVisible(event, element);\n      queueBeforeEvent(element, \"focusout\", applyFocusVisible);\n    });\n    const onFocusCaptureProp = props.onFocusCapture;\n    const onFocusCapture = useEvent((event) => {\n      onFocusCaptureProp == null ? void 0 : onFocusCaptureProp(event);\n      if (event.defaultPrevented) return;\n      if (!focusable) return;\n      if (!isSelfTarget(event)) {\n        setFocusVisible(false);\n        return;\n      }\n      const element = event.currentTarget;\n      const applyFocusVisible = () => handleFocusVisible(event, element);\n      if (isKeyboardModality || isAlwaysFocusVisible(event.target)) {\n        queueBeforeEvent(event.target, \"focusout\", applyFocusVisible);\n      } else {\n        setFocusVisible(false);\n      }\n    });\n    const onBlurProp = props.onBlur;\n    const onBlur = useEvent((event) => {\n      onBlurProp == null ? void 0 : onBlurProp(event);\n      if (!focusable) return;\n      if (!isFocusEventOutside(event)) return;\n      setFocusVisible(false);\n    });\n    const autoFocusOnShow = useContext(FocusableContext);\n    const autoFocusRef = useEvent((element) => {\n      if (!focusable) return;\n      if (!autoFocus) return;\n      if (!element) return;\n      if (!autoFocusOnShow) return;\n      queueMicrotask(() => {\n        if (hasFocus(element)) return;\n        if (!isFocusable(element)) return;\n        element.focus();\n      });\n    });\n    const tagName = useTagName(ref);\n    const nativeTabbable = focusable && isNativeTabbable(tagName);\n    const supportsDisabled = focusable && supportsDisabledAttribute(tagName);\n    const styleProp = props.style;\n    const style = useMemo(() => {\n      if (trulyDisabled) {\n        return __spreadValues({ pointerEvents: \"none\" }, styleProp);\n      }\n      return styleProp;\n    }, [trulyDisabled, styleProp]);\n    props = __spreadProps(__spreadValues({\n      \"data-focus-visible\": focusable && focusVisible || void 0,\n      \"data-autofocus\": autoFocus || void 0,\n      \"aria-disabled\": disabled || void 0\n    }, props), {\n      ref: useMergeRefs(ref, autoFocusRef, props.ref),\n      style,\n      tabIndex: getTabIndex(\n        focusable,\n        trulyDisabled,\n        nativeTabbable,\n        supportsDisabled,\n        props.tabIndex\n      ),\n      disabled: supportsDisabled && trulyDisabled ? true : void 0,\n      // TODO: Test Focusable contentEditable.\n      contentEditable: disabled ? void 0 : props.contentEditable,\n      onKeyPressCapture,\n      onClickCapture,\n      onMouseDownCapture,\n      onMouseDown,\n      onKeyDownCapture,\n      onFocusCapture,\n      onBlur\n    });\n    return removeUndefinedValues(props);\n  }\n);\nvar Focusable = forwardRef(function Focusable2(props) {\n  const htmlProps = useFocusable(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport {\n  isSafariFocusAncestor,\n  useFocusable,\n  Focusable\n};\n","\"use client\";\nimport {\n  DialogContextProvider,\n  DialogScopedContextProvider\n} from \"./RS7LB2H4.js\";\nimport {\n  createStoreContext\n} from \"./LMDWO4NN.js\";\n\n// src/popover/popover-context.tsx\nvar ctx = createStoreContext(\n  [DialogContextProvider],\n  [DialogScopedContextProvider]\n);\nvar usePopoverContext = ctx.useContext;\nvar usePopoverScopedContext = ctx.useScopedContext;\nvar usePopoverProviderContext = ctx.useProviderContext;\nvar PopoverContextProvider = ctx.ContextProvider;\nvar PopoverScopedContextProvider = ctx.ScopedContextProvider;\n\nexport {\n  usePopoverContext,\n  usePopoverScopedContext,\n  usePopoverProviderContext,\n  PopoverContextProvider,\n  PopoverScopedContextProvider\n};\n","\"use client\";\nimport {\n  useDialogStoreProps\n} from \"./BM6PGYQY.js\";\nimport {\n  useStore,\n  useStoreProps\n} from \"./YV4JVR4I.js\";\nimport {\n  useUpdateEffect\n} from \"./ABQUS43J.js\";\n\n// src/popover/popover-store.ts\nimport * as Core from \"@ariakit/core/popover/popover-store\";\nfunction usePopoverStoreProps(store, update, props) {\n  useUpdateEffect(update, [props.popover]);\n  useStoreProps(store, props, \"placement\");\n  return useDialogStoreProps(store, update, props);\n}\nfunction usePopoverStore(props = {}) {\n  const [store, update] = useStore(Core.createPopoverStore, props);\n  return usePopoverStoreProps(store, update, props);\n}\n\nexport {\n  usePopoverStoreProps,\n  usePopoverStore\n};\n","\"use client\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/visually-hidden/visually-hidden.tsx\nvar TagName = \"span\";\nvar useVisuallyHidden = createHook(\n  function useVisuallyHidden2(props) {\n    props = __spreadProps(__spreadValues({}, props), {\n      style: __spreadValues({\n        border: 0,\n        clip: \"rect(0 0 0 0)\",\n        height: \"1px\",\n        margin: \"-1px\",\n        overflow: \"hidden\",\n        padding: 0,\n        position: \"absolute\",\n        whiteSpace: \"nowrap\",\n        width: \"1px\"\n      }, props.style)\n    });\n    return props;\n  }\n);\nvar VisuallyHidden = forwardRef(function VisuallyHidden2(props) {\n  const htmlProps = useVisuallyHidden(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport {\n  useVisuallyHidden,\n  VisuallyHidden\n};\n","\"use client\";\nimport {\n  useVisuallyHidden\n} from \"./XX67R432.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/focus-trap/focus-trap.tsx\nvar TagName = \"span\";\nvar useFocusTrap = createHook(\n  function useFocusTrap2(props) {\n    props = __spreadProps(__spreadValues({\n      \"data-focus-trap\": \"\",\n      tabIndex: 0,\n      \"aria-hidden\": true\n    }, props), {\n      style: __spreadValues({\n        // Prevents unintended scroll jumps.\n        position: \"fixed\",\n        top: 0,\n        left: 0\n      }, props.style)\n    });\n    props = useVisuallyHidden(props);\n    return props;\n  }\n);\nvar FocusTrap = forwardRef(function FocusTrap2(props) {\n  const htmlProps = useFocusTrap(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport {\n  useFocusTrap,\n  FocusTrap\n};\n","\"use client\";\n\n// src/portal/portal-context.tsx\nimport { createContext } from \"react\";\nvar PortalContext = createContext(null);\n\nexport {\n  PortalContext\n};\n","\"use client\";\nimport {\n  FocusTrap\n} from \"./W3VI7GFU.js\";\nimport {\n  PortalContext\n} from \"./AOQQTIBO.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\nimport {\n  useMergeRefs,\n  useSafeLayoutEffect,\n  useWrapElement\n} from \"./ABQUS43J.js\";\nimport {\n  setRef\n} from \"./SK3NAZA3.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/portal/portal.tsx\nimport { getDocument } from \"@ariakit/core/utils/dom\";\nimport { isFocusEventOutside } from \"@ariakit/core/utils/events\";\nimport {\n  disableFocusIn,\n  getNextTabbable,\n  getPreviousTabbable,\n  restoreFocusIn\n} from \"@ariakit/core/utils/focus\";\nimport { useContext, useEffect, useRef, useState } from \"react\";\nimport { createPortal } from \"react-dom\";\nimport { Fragment, jsx, jsxs } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nfunction getRootElement(element) {\n  return getDocument(element).body;\n}\nfunction getPortalElement(element, portalElement) {\n  if (!portalElement) {\n    return getDocument(element).createElement(\"div\");\n  }\n  if (typeof portalElement === \"function\") {\n    return portalElement(element);\n  }\n  return portalElement;\n}\nfunction getRandomId(prefix = \"id\") {\n  return `${prefix ? `${prefix}-` : \"\"}${Math.random().toString(36).slice(2, 8)}`;\n}\nfunction queueFocus(element) {\n  queueMicrotask(() => {\n    element == null ? void 0 : element.focus();\n  });\n}\nvar usePortal = createHook(function usePortal2(_a) {\n  var _b = _a, {\n    preserveTabOrder,\n    preserveTabOrderAnchor,\n    portalElement,\n    portalRef,\n    portal = true\n  } = _b, props = __objRest(_b, [\n    \"preserveTabOrder\",\n    \"preserveTabOrderAnchor\",\n    \"portalElement\",\n    \"portalRef\",\n    \"portal\"\n  ]);\n  const ref = useRef(null);\n  const refProp = useMergeRefs(ref, props.ref);\n  const context = useContext(PortalContext);\n  const [portalNode, setPortalNode] = useState(null);\n  const [anchorPortalNode, setAnchorPortalNode] = useState(\n    null\n  );\n  const outerBeforeRef = useRef(null);\n  const innerBeforeRef = useRef(null);\n  const innerAfterRef = useRef(null);\n  const outerAfterRef = useRef(null);\n  useSafeLayoutEffect(() => {\n    const element = ref.current;\n    if (!element || !portal) {\n      setPortalNode(null);\n      return;\n    }\n    const portalEl = getPortalElement(element, portalElement);\n    if (!portalEl) {\n      setPortalNode(null);\n      return;\n    }\n    const isPortalInDocument = portalEl.isConnected;\n    if (!isPortalInDocument) {\n      const rootElement = context || getRootElement(element);\n      rootElement.appendChild(portalEl);\n    }\n    if (!portalEl.id) {\n      portalEl.id = element.id ? `portal/${element.id}` : getRandomId();\n    }\n    setPortalNode(portalEl);\n    setRef(portalRef, portalEl);\n    if (isPortalInDocument) return;\n    return () => {\n      portalEl.remove();\n      setRef(portalRef, null);\n    };\n  }, [portal, portalElement, context, portalRef]);\n  useSafeLayoutEffect(() => {\n    if (!portal) return;\n    if (!preserveTabOrder) return;\n    if (!preserveTabOrderAnchor) return;\n    const doc = getDocument(preserveTabOrderAnchor);\n    const element = doc.createElement(\"span\");\n    element.style.position = \"fixed\";\n    preserveTabOrderAnchor.insertAdjacentElement(\"afterend\", element);\n    setAnchorPortalNode(element);\n    return () => {\n      element.remove();\n      setAnchorPortalNode(null);\n    };\n  }, [portal, preserveTabOrder, preserveTabOrderAnchor]);\n  useEffect(() => {\n    if (!portalNode) return;\n    if (!preserveTabOrder) return;\n    let raf = 0;\n    const onFocus = (event) => {\n      if (!isFocusEventOutside(event)) return;\n      const focusing = event.type === \"focusin\";\n      cancelAnimationFrame(raf);\n      if (focusing) {\n        return restoreFocusIn(portalNode);\n      }\n      raf = requestAnimationFrame(() => {\n        disableFocusIn(portalNode, true);\n      });\n    };\n    portalNode.addEventListener(\"focusin\", onFocus, true);\n    portalNode.addEventListener(\"focusout\", onFocus, true);\n    return () => {\n      cancelAnimationFrame(raf);\n      portalNode.removeEventListener(\"focusin\", onFocus, true);\n      portalNode.removeEventListener(\"focusout\", onFocus, true);\n    };\n  }, [portalNode, preserveTabOrder]);\n  props = useWrapElement(\n    props,\n    (element) => {\n      element = // While the portal node is not in the DOM, we need to pass the\n      // current context to the portal context, otherwise it's going to\n      // reset to the body element on nested portals.\n      /* @__PURE__ */ jsx(PortalContext.Provider, { value: portalNode || context, children: element });\n      if (!portal) return element;\n      if (!portalNode) {\n        return /* @__PURE__ */ jsx(\n          \"span\",\n          {\n            ref: refProp,\n            id: props.id,\n            style: { position: \"fixed\" },\n            hidden: true\n          }\n        );\n      }\n      element = /* @__PURE__ */ jsxs(Fragment, { children: [\n        preserveTabOrder && portalNode && /* @__PURE__ */ jsx(\n          FocusTrap,\n          {\n            ref: innerBeforeRef,\n            \"data-focus-trap\": props.id,\n            className: \"__focus-trap-inner-before\",\n            onFocus: (event) => {\n              if (isFocusEventOutside(event, portalNode)) {\n                queueFocus(getNextTabbable());\n              } else {\n                queueFocus(outerBeforeRef.current);\n              }\n            }\n          }\n        ),\n        element,\n        preserveTabOrder && portalNode && /* @__PURE__ */ jsx(\n          FocusTrap,\n          {\n            ref: innerAfterRef,\n            \"data-focus-trap\": props.id,\n            className: \"__focus-trap-inner-after\",\n            onFocus: (event) => {\n              if (isFocusEventOutside(event, portalNode)) {\n                queueFocus(getPreviousTabbable());\n              } else {\n                queueFocus(outerAfterRef.current);\n              }\n            }\n          }\n        )\n      ] });\n      if (portalNode) {\n        element = createPortal(element, portalNode);\n      }\n      let preserveTabOrderElement = /* @__PURE__ */ jsxs(Fragment, { children: [\n        preserveTabOrder && portalNode && /* @__PURE__ */ jsx(\n          FocusTrap,\n          {\n            ref: outerBeforeRef,\n            \"data-focus-trap\": props.id,\n            className: \"__focus-trap-outer-before\",\n            onFocus: (event) => {\n              const fromOuter = event.relatedTarget === outerAfterRef.current;\n              if (!fromOuter && isFocusEventOutside(event, portalNode)) {\n                queueFocus(innerBeforeRef.current);\n              } else {\n                queueFocus(getPreviousTabbable());\n              }\n            }\n          }\n        ),\n        preserveTabOrder && // We're using position: fixed here so that the browser doesn't\n        // add margin to the element when setting gap on a parent element.\n        /* @__PURE__ */ jsx(\"span\", { \"aria-owns\": portalNode == null ? void 0 : portalNode.id, style: { position: \"fixed\" } }),\n        preserveTabOrder && portalNode && /* @__PURE__ */ jsx(\n          FocusTrap,\n          {\n            ref: outerAfterRef,\n            \"data-focus-trap\": props.id,\n            className: \"__focus-trap-outer-after\",\n            onFocus: (event) => {\n              if (isFocusEventOutside(event, portalNode)) {\n                queueFocus(innerAfterRef.current);\n              } else {\n                const nextTabbable = getNextTabbable();\n                if (nextTabbable === innerBeforeRef.current) {\n                  requestAnimationFrame(() => {\n                    var _a2;\n                    return (_a2 = getNextTabbable()) == null ? void 0 : _a2.focus();\n                  });\n                  return;\n                }\n                queueFocus(nextTabbable);\n              }\n            }\n          }\n        )\n      ] });\n      if (anchorPortalNode && preserveTabOrder) {\n        preserveTabOrderElement = createPortal(\n          preserveTabOrderElement,\n          anchorPortalNode\n        );\n      }\n      return /* @__PURE__ */ jsxs(Fragment, { children: [\n        preserveTabOrderElement,\n        element\n      ] });\n    },\n    [portalNode, context, portal, props.id, preserveTabOrder, anchorPortalNode]\n  );\n  props = __spreadProps(__spreadValues({}, props), {\n    ref: refProp\n  });\n  return props;\n});\nvar Portal = forwardRef(function Portal2(props) {\n  const htmlProps = usePortal(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport {\n  usePortal,\n  Portal\n};\n","\"use client\";\nimport {\n  usePopoverProviderContext\n} from \"./MTZPJQMC.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\nimport {\n  useMergeRefs\n} from \"./ABQUS43J.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/popover/popover-anchor.tsx\nvar TagName = \"div\";\nvar usePopoverAnchor = createHook(\n  function usePopoverAnchor2(_a) {\n    var _b = _a, { store } = _b, props = __objRest(_b, [\"store\"]);\n    const context = usePopoverProviderContext();\n    store = store || context;\n    props = __spreadProps(__spreadValues({}, props), {\n      ref: useMergeRefs(store == null ? void 0 : store.setAnchorElement, props.ref)\n    });\n    return props;\n  }\n);\nvar PopoverAnchor = forwardRef(function PopoverAnchor2(props) {\n  const htmlProps = usePopoverAnchor(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport {\n  usePopoverAnchor,\n  PopoverAnchor\n};\n","\"use client\";\nimport {\n  useCollectionItem\n} from \"./RZ4GPYOB.js\";\nimport {\n  useCommand\n} from \"./KUU7WJ55.js\";\nimport {\n  focusSilently,\n  getEnabledItem,\n  isItem,\n  selectTextField\n} from \"./5VQZOHHZ.js\";\nimport {\n  CompositeItemContext,\n  CompositeRowContext,\n  useCompositeContext\n} from \"./P7GR5CS5.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef,\n  memo\n} from \"./LMDWO4NN.js\";\nimport {\n  useStoreStateObject\n} from \"./YV4JVR4I.js\";\nimport {\n  useBooleanEvent,\n  useEvent,\n  useId,\n  useMergeRefs,\n  useWrapElement\n} from \"./ABQUS43J.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/composite/composite-item.tsx\nimport {\n  getScrollingElement,\n  getTextboxSelection,\n  getTextboxValue,\n  isButton,\n  isTextField,\n  isTextbox\n} from \"@ariakit/core/utils/dom\";\nimport { isPortalEvent, isSelfTarget } from \"@ariakit/core/utils/events\";\nimport {\n  disabledFromProps,\n  removeUndefinedValues\n} from \"@ariakit/core/utils/misc\";\nimport { isSafari } from \"@ariakit/core/utils/platform\";\nimport { useCallback, useContext, useMemo, useRef } from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"button\";\nfunction isEditableElement(element) {\n  if (isTextbox(element)) return true;\n  return element.tagName === \"INPUT\" && !isButton(element);\n}\nfunction getNextPageOffset(scrollingElement, pageUp = false) {\n  const height = scrollingElement.clientHeight;\n  const { top } = scrollingElement.getBoundingClientRect();\n  const pageSize = Math.max(height * 0.875, height - 40) * 1.5;\n  const pageOffset = pageUp ? height - pageSize + top : pageSize + top;\n  if (scrollingElement.tagName === \"HTML\") {\n    return pageOffset + scrollingElement.scrollTop;\n  }\n  return pageOffset;\n}\nfunction getItemOffset(itemElement, pageUp = false) {\n  const { top } = itemElement.getBoundingClientRect();\n  if (pageUp) {\n    return top + itemElement.clientHeight;\n  }\n  return top;\n}\nfunction findNextPageItemId(element, store, next, pageUp = false) {\n  var _a;\n  if (!store) return;\n  if (!next) return;\n  const { renderedItems } = store.getState();\n  const scrollingElement = getScrollingElement(element);\n  if (!scrollingElement) return;\n  const nextPageOffset = getNextPageOffset(scrollingElement, pageUp);\n  let id;\n  let prevDifference;\n  for (let i = 0; i < renderedItems.length; i += 1) {\n    const previousId = id;\n    id = next(i);\n    if (!id) break;\n    if (id === previousId) continue;\n    const itemElement = (_a = getEnabledItem(store, id)) == null ? void 0 : _a.element;\n    if (!itemElement) continue;\n    const itemOffset = getItemOffset(itemElement, pageUp);\n    const difference = itemOffset - nextPageOffset;\n    const absDifference = Math.abs(difference);\n    if (pageUp && difference <= 0 || !pageUp && difference >= 0) {\n      if (prevDifference !== void 0 && prevDifference < absDifference) {\n        id = previousId;\n      }\n      break;\n    }\n    prevDifference = absDifference;\n  }\n  return id;\n}\nfunction targetIsAnotherItem(event, store) {\n  if (isSelfTarget(event)) return false;\n  return isItem(store, event.target);\n}\nvar useCompositeItem = createHook(\n  function useCompositeItem2(_a) {\n    var _b = _a, {\n      store,\n      rowId: rowIdProp,\n      preventScrollOnKeyDown = false,\n      moveOnKeyPress = true,\n      tabbable = false,\n      getItem: getItemProp,\n      \"aria-setsize\": ariaSetSizeProp,\n      \"aria-posinset\": ariaPosInSetProp\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"rowId\",\n      \"preventScrollOnKeyDown\",\n      \"moveOnKeyPress\",\n      \"tabbable\",\n      \"getItem\",\n      \"aria-setsize\",\n      \"aria-posinset\"\n    ]);\n    const context = useCompositeContext();\n    store = store || context;\n    const id = useId(props.id);\n    const ref = useRef(null);\n    const row = useContext(CompositeRowContext);\n    const disabled = disabledFromProps(props);\n    const trulyDisabled = disabled && !props.accessibleWhenDisabled;\n    const {\n      rowId,\n      baseElement,\n      isActiveItem,\n      ariaSetSize,\n      ariaPosInSet,\n      isTabbable\n    } = useStoreStateObject(store, {\n      rowId(state) {\n        if (rowIdProp) return rowIdProp;\n        if (!state) return;\n        if (!(row == null ? void 0 : row.baseElement)) return;\n        if (row.baseElement !== state.baseElement) return;\n        return row.id;\n      },\n      baseElement(state) {\n        return (state == null ? void 0 : state.baseElement) || void 0;\n      },\n      isActiveItem(state) {\n        return !!state && state.activeId === id;\n      },\n      ariaSetSize(state) {\n        if (ariaSetSizeProp != null) return ariaSetSizeProp;\n        if (!state) return;\n        if (!(row == null ? void 0 : row.ariaSetSize)) return;\n        if (row.baseElement !== state.baseElement) return;\n        return row.ariaSetSize;\n      },\n      ariaPosInSet(state) {\n        if (ariaPosInSetProp != null) return ariaPosInSetProp;\n        if (!state) return;\n        if (!(row == null ? void 0 : row.ariaPosInSet)) return;\n        if (row.baseElement !== state.baseElement) return;\n        const itemsInRow = state.renderedItems.filter(\n          (item) => item.rowId === rowId\n        );\n        return row.ariaPosInSet + itemsInRow.findIndex((item) => item.id === id);\n      },\n      isTabbable(state) {\n        if (!(state == null ? void 0 : state.renderedItems.length)) return true;\n        if (state.virtualFocus) return false;\n        if (tabbable) return true;\n        if (state.activeId === null) return false;\n        const item = store == null ? void 0 : store.item(state.activeId);\n        if (item == null ? void 0 : item.disabled) return true;\n        if (!(item == null ? void 0 : item.element)) return true;\n        return state.activeId === id;\n      }\n    });\n    const getItem = useCallback(\n      (item) => {\n        var _a2;\n        const nextItem = __spreadProps(__spreadValues({}, item), {\n          id: id || item.id,\n          rowId,\n          disabled: !!trulyDisabled,\n          children: (_a2 = item.element) == null ? void 0 : _a2.textContent\n        });\n        if (getItemProp) {\n          return getItemProp(nextItem);\n        }\n        return nextItem;\n      },\n      [id, rowId, trulyDisabled, getItemProp]\n    );\n    const onFocusProp = props.onFocus;\n    const hasFocusedComposite = useRef(false);\n    const onFocus = useEvent((event) => {\n      onFocusProp == null ? void 0 : onFocusProp(event);\n      if (event.defaultPrevented) return;\n      if (isPortalEvent(event)) return;\n      if (!id) return;\n      if (!store) return;\n      if (targetIsAnotherItem(event, store)) return;\n      const { virtualFocus, baseElement: baseElement2 } = store.getState();\n      store.setActiveId(id);\n      if (isTextbox(event.currentTarget)) {\n        selectTextField(event.currentTarget);\n      }\n      if (!virtualFocus) return;\n      if (!isSelfTarget(event)) return;\n      if (isEditableElement(event.currentTarget)) return;\n      if (!(baseElement2 == null ? void 0 : baseElement2.isConnected)) return;\n      if (isSafari() && event.currentTarget.hasAttribute(\"data-autofocus\")) {\n        event.currentTarget.scrollIntoView({\n          block: \"nearest\",\n          inline: \"nearest\"\n        });\n      }\n      hasFocusedComposite.current = true;\n      const fromComposite = event.relatedTarget === baseElement2 || isItem(store, event.relatedTarget);\n      if (fromComposite) {\n        focusSilently(baseElement2);\n      } else {\n        baseElement2.focus();\n      }\n    });\n    const onBlurCaptureProp = props.onBlurCapture;\n    const onBlurCapture = useEvent((event) => {\n      onBlurCaptureProp == null ? void 0 : onBlurCaptureProp(event);\n      if (event.defaultPrevented) return;\n      const state = store == null ? void 0 : store.getState();\n      if ((state == null ? void 0 : state.virtualFocus) && hasFocusedComposite.current) {\n        hasFocusedComposite.current = false;\n        event.preventDefault();\n        event.stopPropagation();\n      }\n    });\n    const onKeyDownProp = props.onKeyDown;\n    const preventScrollOnKeyDownProp = useBooleanEvent(preventScrollOnKeyDown);\n    const moveOnKeyPressProp = useBooleanEvent(moveOnKeyPress);\n    const onKeyDown = useEvent((event) => {\n      onKeyDownProp == null ? void 0 : onKeyDownProp(event);\n      if (event.defaultPrevented) return;\n      if (!isSelfTarget(event)) return;\n      if (!store) return;\n      const { currentTarget } = event;\n      const state = store.getState();\n      const item = store.item(id);\n      const isGrid = !!(item == null ? void 0 : item.rowId);\n      const isVertical = state.orientation !== \"horizontal\";\n      const isHorizontal = state.orientation !== \"vertical\";\n      const canHomeEnd = () => {\n        if (isGrid) return true;\n        if (isHorizontal) return true;\n        if (!state.baseElement) return true;\n        if (!isTextField(state.baseElement)) return true;\n        return false;\n      };\n      const keyMap = {\n        ArrowUp: (isGrid || isVertical) && store.up,\n        ArrowRight: (isGrid || isHorizontal) && store.next,\n        ArrowDown: (isGrid || isVertical) && store.down,\n        ArrowLeft: (isGrid || isHorizontal) && store.previous,\n        Home: () => {\n          if (!canHomeEnd()) return;\n          if (!isGrid || event.ctrlKey) {\n            return store == null ? void 0 : store.first();\n          }\n          return store == null ? void 0 : store.previous(-1);\n        },\n        End: () => {\n          if (!canHomeEnd()) return;\n          if (!isGrid || event.ctrlKey) {\n            return store == null ? void 0 : store.last();\n          }\n          return store == null ? void 0 : store.next(-1);\n        },\n        PageUp: () => {\n          return findNextPageItemId(currentTarget, store, store == null ? void 0 : store.up, true);\n        },\n        PageDown: () => {\n          return findNextPageItemId(currentTarget, store, store == null ? void 0 : store.down);\n        }\n      };\n      const action = keyMap[event.key];\n      if (action) {\n        if (isTextbox(currentTarget)) {\n          const selection = getTextboxSelection(currentTarget);\n          const isLeft = isHorizontal && event.key === \"ArrowLeft\";\n          const isRight = isHorizontal && event.key === \"ArrowRight\";\n          const isUp = isVertical && event.key === \"ArrowUp\";\n          const isDown = isVertical && event.key === \"ArrowDown\";\n          if (isRight || isDown) {\n            const { length: valueLength } = getTextboxValue(currentTarget);\n            if (selection.end !== valueLength) return;\n          } else if ((isLeft || isUp) && selection.start !== 0) return;\n        }\n        const nextId = action();\n        if (preventScrollOnKeyDownProp(event) || nextId !== void 0) {\n          if (!moveOnKeyPressProp(event)) return;\n          event.preventDefault();\n          store.move(nextId);\n        }\n      }\n    });\n    const providerValue = useMemo(\n      () => ({ id, baseElement }),\n      [id, baseElement]\n    );\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(CompositeItemContext.Provider, { value: providerValue, children: element }),\n      [providerValue]\n    );\n    props = __spreadProps(__spreadValues({\n      id,\n      \"data-active-item\": isActiveItem || void 0\n    }, props), {\n      ref: useMergeRefs(ref, props.ref),\n      tabIndex: isTabbable ? props.tabIndex : -1,\n      onFocus,\n      onBlurCapture,\n      onKeyDown\n    });\n    props = useCommand(props);\n    props = useCollectionItem(__spreadProps(__spreadValues({\n      store\n    }, props), {\n      getItem,\n      shouldRegisterItem: id ? props.shouldRegisterItem : false\n    }));\n    return removeUndefinedValues(__spreadProps(__spreadValues({}, props), {\n      \"aria-setsize\": ariaSetSize,\n      \"aria-posinset\": ariaPosInSet\n    }));\n  }\n);\nvar CompositeItem = memo(\n  forwardRef(function CompositeItem2(props) {\n    const htmlProps = useCompositeItem(props);\n    return createElement(TagName, htmlProps);\n  })\n);\n\nexport {\n  useCompositeItem,\n  CompositeItem\n};\n","\"use client\";\nimport {\n  CollectionContextProvider,\n  CollectionScopedContextProvider\n} from \"./VDHZ5F7K.js\";\nimport {\n  createStoreContext\n} from \"./LMDWO4NN.js\";\n\n// src/composite/composite-context.tsx\nimport { createContext } from \"react\";\nvar ctx = createStoreContext(\n  [CollectionContextProvider],\n  [CollectionScopedContextProvider]\n);\nvar useCompositeContext = ctx.useContext;\nvar useCompositeScopedContext = ctx.useScopedContext;\nvar useCompositeProviderContext = ctx.useProviderContext;\nvar CompositeContextProvider = ctx.ContextProvider;\nvar CompositeScopedContextProvider = ctx.ScopedContextProvider;\nvar CompositeItemContext = createContext(\n  void 0\n);\nvar CompositeRowContext = createContext(\n  void 0\n);\n\nexport {\n  useCompositeContext,\n  useCompositeScopedContext,\n  useCompositeProviderContext,\n  CompositeContextProvider,\n  CompositeScopedContextProvider,\n  CompositeItemContext,\n  CompositeRowContext\n};\n","\"use client\";\nimport {\n  DisclosureContextProvider,\n  DisclosureScopedContextProvider\n} from \"./S6EF7IVO.js\";\nimport {\n  createStoreContext\n} from \"./LMDWO4NN.js\";\n\n// src/dialog/dialog-context.tsx\nimport { createContext } from \"react\";\nvar ctx = createStoreContext(\n  [DisclosureContextProvider],\n  [DisclosureScopedContextProvider]\n);\nvar useDialogContext = ctx.useContext;\nvar useDialogScopedContext = ctx.useScopedContext;\nvar useDialogProviderContext = ctx.useProviderContext;\nvar DialogContextProvider = ctx.ContextProvider;\nvar DialogScopedContextProvider = ctx.ScopedContextProvider;\nvar DialogHeadingContext = createContext(void 0);\nvar DialogDescriptionContext = createContext(void 0);\n\nexport {\n  useDialogContext,\n  useDialogScopedContext,\n  useDialogProviderContext,\n  DialogContextProvider,\n  DialogScopedContextProvider,\n  DialogHeadingContext,\n  DialogDescriptionContext\n};\n","\"use client\";\nimport {\n  useCollectionContext\n} from \"./VDHZ5F7K.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\nimport {\n  useId,\n  useMergeRefs\n} from \"./ABQUS43J.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/collection/collection-item.tsx\nimport { identity, removeUndefinedValues } from \"@ariakit/core/utils/misc\";\nimport { useEffect, useRef } from \"react\";\nvar TagName = \"div\";\nvar useCollectionItem = createHook(\n  function useCollectionItem2(_a) {\n    var _b = _a, {\n      store,\n      shouldRegisterItem = true,\n      getItem = identity,\n      element: element\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"shouldRegisterItem\",\n      \"getItem\",\n      // @ts-expect-error This prop may come from a collection renderer.\n      \"element\"\n    ]);\n    const context = useCollectionContext();\n    store = store || context;\n    const id = useId(props.id);\n    const ref = useRef(element);\n    useEffect(() => {\n      const element2 = ref.current;\n      if (!id) return;\n      if (!element2) return;\n      if (!shouldRegisterItem) return;\n      const item = getItem({ id, element: element2 });\n      return store == null ? void 0 : store.renderItem(item);\n    }, [id, shouldRegisterItem, getItem, store]);\n    props = __spreadProps(__spreadValues({}, props), {\n      ref: useMergeRefs(ref, props.ref)\n    });\n    return removeUndefinedValues(props);\n  }\n);\nvar CollectionItem = forwardRef(function CollectionItem2(props) {\n  const htmlProps = useCollectionItem(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport {\n  useCollectionItem,\n  CollectionItem\n};\n","\"use client\";\nimport {\n  createStoreContext\n} from \"./LMDWO4NN.js\";\n\n// src/disclosure/disclosure-context.tsx\nvar ctx = createStoreContext();\nvar useDisclosureContext = ctx.useContext;\nvar useDisclosureScopedContext = ctx.useScopedContext;\nvar useDisclosureProviderContext = ctx.useProviderContext;\nvar DisclosureContextProvider = ctx.ContextProvider;\nvar DisclosureScopedContextProvider = ctx.ScopedContextProvider;\n\nexport {\n  useDisclosureContext,\n  useDisclosureScopedContext,\n  useDisclosureProviderContext,\n  DisclosureContextProvider,\n  DisclosureScopedContextProvider\n};\n","\"use client\";\nimport {\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/utils/misc.ts\nimport { hasOwnProperty } from \"@ariakit/core/utils/misc\";\nimport { isValidElement } from \"react\";\nfunction setRef(ref, value) {\n  if (typeof ref === \"function\") {\n    ref(value);\n  } else if (ref) {\n    ref.current = value;\n  }\n}\nfunction isValidElementWithRef(element) {\n  if (!element) return false;\n  if (!isValidElement(element)) return false;\n  if (\"ref\" in element.props) return true;\n  if (\"ref\" in element) return true;\n  return false;\n}\nfunction getRefProperty(element) {\n  if (!isValidElementWithRef(element)) return null;\n  const props = __spreadValues({}, element.props);\n  return props.ref || element.ref;\n}\nfunction mergeProps(base, overrides) {\n  const props = __spreadValues({}, base);\n  for (const key in overrides) {\n    if (!hasOwnProperty(overrides, key)) continue;\n    if (key === \"className\") {\n      const prop = \"className\";\n      props[prop] = base[prop] ? `${base[prop]} ${overrides[prop]}` : overrides[prop];\n      continue;\n    }\n    if (key === \"style\") {\n      const prop = \"style\";\n      props[prop] = base[prop] ? __spreadValues(__spreadValues({}, base[prop]), overrides[prop]) : overrides[prop];\n      continue;\n    }\n    const overrideValue = overrides[key];\n    if (typeof overrideValue === \"function\" && key.startsWith(\"on\")) {\n      const baseValue = base[key];\n      if (typeof baseValue === \"function\") {\n        props[key] = (...args) => {\n          overrideValue(...args);\n          baseValue(...args);\n        };\n        continue;\n      }\n    }\n    props[key] = overrideValue;\n  }\n  return props;\n}\n\nexport {\n  setRef,\n  isValidElementWithRef,\n  getRefProperty,\n  mergeProps\n};\n","\"use client\";\n\n// src/focusable/focusable-context.tsx\nimport { createContext } from \"react\";\nvar FocusableContext = createContext(true);\n\nexport {\n  FocusableContext\n};\n","\"use client\";\nimport {\n  createDialogComponent,\n  useDialog\n} from \"./JC64G2H7.js\";\nimport {\n  PopoverScopedContextProvider,\n  usePopoverProviderContext\n} from \"./MTZPJQMC.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\nimport {\n  useEvent,\n  usePortalRef,\n  useSafeLayoutEffect,\n  useWrapElement\n} from \"./ABQUS43J.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/popover/popover.tsx\nimport { invariant } from \"@ariakit/core/utils/misc\";\nimport {\n  arrow,\n  autoUpdate,\n  computePosition,\n  flip,\n  limitShift,\n  offset,\n  shift,\n  size\n} from \"@floating-ui/dom\";\nimport { useRef, useState } from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nfunction createDOMRect(x = 0, y = 0, width = 0, height = 0) {\n  if (typeof DOMRect === \"function\") {\n    return new DOMRect(x, y, width, height);\n  }\n  const rect = {\n    x,\n    y,\n    width,\n    height,\n    top: y,\n    right: x + width,\n    bottom: y + height,\n    left: x\n  };\n  return __spreadProps(__spreadValues({}, rect), { toJSON: () => rect });\n}\nfunction getDOMRect(anchorRect) {\n  if (!anchorRect) return createDOMRect();\n  const { x, y, width, height } = anchorRect;\n  return createDOMRect(x, y, width, height);\n}\nfunction getAnchorElement(anchorElement, getAnchorRect) {\n  const contextElement = anchorElement || void 0;\n  return {\n    contextElement,\n    getBoundingClientRect: () => {\n      const anchor = anchorElement;\n      const anchorRect = getAnchorRect == null ? void 0 : getAnchorRect(anchor);\n      if (anchorRect || !anchor) {\n        return getDOMRect(anchorRect);\n      }\n      return anchor.getBoundingClientRect();\n    }\n  };\n}\nfunction isValidPlacement(flip2) {\n  return /^(?:top|bottom|left|right)(?:-(?:start|end))?$/.test(flip2);\n}\nfunction roundByDPR(value) {\n  const dpr = window.devicePixelRatio || 1;\n  return Math.round(value * dpr) / dpr;\n}\nfunction getOffsetMiddleware(arrowElement, props) {\n  return offset(({ placement }) => {\n    var _a;\n    const arrowOffset = ((arrowElement == null ? void 0 : arrowElement.clientHeight) || 0) / 2;\n    const finalGutter = typeof props.gutter === \"number\" ? props.gutter + arrowOffset : (_a = props.gutter) != null ? _a : arrowOffset;\n    const hasAlignment = !!placement.split(\"-\")[1];\n    return {\n      crossAxis: !hasAlignment ? props.shift : void 0,\n      mainAxis: finalGutter,\n      alignmentAxis: props.shift\n    };\n  });\n}\nfunction getFlipMiddleware(props) {\n  if (props.flip === false) return;\n  const fallbackPlacements = typeof props.flip === \"string\" ? props.flip.split(\" \") : void 0;\n  invariant(\n    !fallbackPlacements || fallbackPlacements.every(isValidPlacement),\n    process.env.NODE_ENV !== \"production\" && \"`flip` expects a spaced-delimited list of placements\"\n  );\n  return flip({\n    padding: props.overflowPadding,\n    fallbackPlacements\n  });\n}\nfunction getShiftMiddleware(props) {\n  if (!props.slide && !props.overlap) return;\n  return shift({\n    mainAxis: props.slide,\n    crossAxis: props.overlap,\n    padding: props.overflowPadding,\n    limiter: limitShift()\n  });\n}\nfunction getSizeMiddleware(props) {\n  return size({\n    padding: props.overflowPadding,\n    apply({ elements, availableWidth, availableHeight, rects }) {\n      const wrapper = elements.floating;\n      const referenceWidth = Math.round(rects.reference.width);\n      availableWidth = Math.floor(availableWidth);\n      availableHeight = Math.floor(availableHeight);\n      wrapper.style.setProperty(\n        \"--popover-anchor-width\",\n        `${referenceWidth}px`\n      );\n      wrapper.style.setProperty(\n        \"--popover-available-width\",\n        `${availableWidth}px`\n      );\n      wrapper.style.setProperty(\n        \"--popover-available-height\",\n        `${availableHeight}px`\n      );\n      if (props.sameWidth) {\n        wrapper.style.width = `${referenceWidth}px`;\n      }\n      if (props.fitViewport) {\n        wrapper.style.maxWidth = `${availableWidth}px`;\n        wrapper.style.maxHeight = `${availableHeight}px`;\n      }\n    }\n  });\n}\nfunction getArrowMiddleware(arrowElement, props) {\n  if (!arrowElement) return;\n  return arrow({\n    element: arrowElement,\n    padding: props.arrowPadding\n  });\n}\nvar usePopover = createHook(\n  function usePopover2(_a) {\n    var _b = _a, {\n      store,\n      modal = false,\n      portal = !!modal,\n      preserveTabOrder = true,\n      autoFocusOnShow = true,\n      wrapperProps,\n      fixed = false,\n      flip: flip2 = true,\n      shift: shift2 = 0,\n      slide = true,\n      overlap = false,\n      sameWidth = false,\n      fitViewport = false,\n      gutter,\n      arrowPadding = 4,\n      overflowPadding = 8,\n      getAnchorRect,\n      updatePosition\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"modal\",\n      \"portal\",\n      \"preserveTabOrder\",\n      \"autoFocusOnShow\",\n      \"wrapperProps\",\n      \"fixed\",\n      \"flip\",\n      \"shift\",\n      \"slide\",\n      \"overlap\",\n      \"sameWidth\",\n      \"fitViewport\",\n      \"gutter\",\n      \"arrowPadding\",\n      \"overflowPadding\",\n      \"getAnchorRect\",\n      \"updatePosition\"\n    ]);\n    const context = usePopoverProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"Popover must receive a `store` prop or be wrapped in a PopoverProvider component.\"\n    );\n    const arrowElement = store.useState(\"arrowElement\");\n    const anchorElement = store.useState(\"anchorElement\");\n    const disclosureElement = store.useState(\"disclosureElement\");\n    const popoverElement = store.useState(\"popoverElement\");\n    const contentElement = store.useState(\"contentElement\");\n    const placement = store.useState(\"placement\");\n    const mounted = store.useState(\"mounted\");\n    const rendered = store.useState(\"rendered\");\n    const defaultArrowElementRef = useRef(null);\n    const [positioned, setPositioned] = useState(false);\n    const { portalRef, domReady } = usePortalRef(portal, props.portalRef);\n    const getAnchorRectProp = useEvent(getAnchorRect);\n    const updatePositionProp = useEvent(updatePosition);\n    const hasCustomUpdatePosition = !!updatePosition;\n    useSafeLayoutEffect(() => {\n      if (!(popoverElement == null ? void 0 : popoverElement.isConnected)) return;\n      popoverElement.style.setProperty(\n        \"--popover-overflow-padding\",\n        `${overflowPadding}px`\n      );\n      const anchor = getAnchorElement(anchorElement, getAnchorRectProp);\n      const updatePosition2 = async () => {\n        if (!mounted) return;\n        if (!arrowElement) {\n          defaultArrowElementRef.current = defaultArrowElementRef.current || document.createElement(\"div\");\n        }\n        const arrow2 = arrowElement || defaultArrowElementRef.current;\n        const middleware = [\n          getOffsetMiddleware(arrow2, { gutter, shift: shift2 }),\n          getFlipMiddleware({ flip: flip2, overflowPadding }),\n          getShiftMiddleware({ slide, shift: shift2, overlap, overflowPadding }),\n          getArrowMiddleware(arrow2, { arrowPadding }),\n          getSizeMiddleware({\n            sameWidth,\n            fitViewport,\n            overflowPadding\n          })\n        ];\n        const pos = await computePosition(anchor, popoverElement, {\n          placement,\n          strategy: fixed ? \"fixed\" : \"absolute\",\n          middleware\n        });\n        store == null ? void 0 : store.setState(\"currentPlacement\", pos.placement);\n        setPositioned(true);\n        const x = roundByDPR(pos.x);\n        const y = roundByDPR(pos.y);\n        Object.assign(popoverElement.style, {\n          top: \"0\",\n          left: \"0\",\n          transform: `translate3d(${x}px,${y}px,0)`\n        });\n        if (arrow2 && pos.middlewareData.arrow) {\n          const { x: arrowX, y: arrowY } = pos.middlewareData.arrow;\n          const side = pos.placement.split(\"-\")[0];\n          const centerX = arrow2.clientWidth / 2;\n          const centerY = arrow2.clientHeight / 2;\n          const originX = arrowX != null ? arrowX + centerX : -centerX;\n          const originY = arrowY != null ? arrowY + centerY : -centerY;\n          popoverElement.style.setProperty(\n            \"--popover-transform-origin\",\n            {\n              top: `${originX}px calc(100% + ${centerY}px)`,\n              bottom: `${originX}px ${-centerY}px`,\n              left: `calc(100% + ${centerX}px) ${originY}px`,\n              right: `${-centerX}px ${originY}px`\n            }[side]\n          );\n          Object.assign(arrow2.style, {\n            left: arrowX != null ? `${arrowX}px` : \"\",\n            top: arrowY != null ? `${arrowY}px` : \"\",\n            [side]: \"100%\"\n          });\n        }\n      };\n      const update = async () => {\n        if (hasCustomUpdatePosition) {\n          await updatePositionProp({ updatePosition: updatePosition2 });\n          setPositioned(true);\n        } else {\n          await updatePosition2();\n        }\n      };\n      const cancelAutoUpdate = autoUpdate(anchor, popoverElement, update, {\n        // JSDOM doesn't support ResizeObserver\n        elementResize: typeof ResizeObserver === \"function\"\n      });\n      return () => {\n        setPositioned(false);\n        cancelAutoUpdate();\n      };\n    }, [\n      store,\n      rendered,\n      popoverElement,\n      arrowElement,\n      anchorElement,\n      popoverElement,\n      placement,\n      mounted,\n      domReady,\n      fixed,\n      flip2,\n      shift2,\n      slide,\n      overlap,\n      sameWidth,\n      fitViewport,\n      gutter,\n      arrowPadding,\n      overflowPadding,\n      getAnchorRectProp,\n      hasCustomUpdatePosition,\n      updatePositionProp\n    ]);\n    useSafeLayoutEffect(() => {\n      if (!mounted) return;\n      if (!domReady) return;\n      if (!(popoverElement == null ? void 0 : popoverElement.isConnected)) return;\n      if (!(contentElement == null ? void 0 : contentElement.isConnected)) return;\n      const applyZIndex = () => {\n        popoverElement.style.zIndex = getComputedStyle(contentElement).zIndex;\n      };\n      applyZIndex();\n      let raf = requestAnimationFrame(() => {\n        raf = requestAnimationFrame(applyZIndex);\n      });\n      return () => cancelAnimationFrame(raf);\n    }, [mounted, domReady, popoverElement, contentElement]);\n    const position = fixed ? \"fixed\" : \"absolute\";\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(\n        \"div\",\n        __spreadProps(__spreadValues({}, wrapperProps), {\n          style: __spreadValues({\n            // https://floating-ui.com/docs/computeposition#initial-layout\n            position,\n            top: 0,\n            left: 0,\n            width: \"max-content\"\n          }, wrapperProps == null ? void 0 : wrapperProps.style),\n          ref: store == null ? void 0 : store.setPopoverElement,\n          children: element\n        })\n      ),\n      [store, position, wrapperProps]\n    );\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(PopoverScopedContextProvider, { value: store, children: element }),\n      [store]\n    );\n    props = __spreadProps(__spreadValues({\n      // data-placing is not part of the public API. We're setting this here so\n      // we can wait for the popover to be positioned before other components\n      // move focus into it. For example, this attribute is observed by the\n      // Combobox component with the autoSelect behavior.\n      \"data-placing\": !positioned || void 0\n    }, props), {\n      style: __spreadValues({\n        position: \"relative\"\n      }, props.style)\n    });\n    props = useDialog(__spreadProps(__spreadValues({\n      store,\n      modal,\n      portal,\n      preserveTabOrder,\n      preserveTabOrderAnchor: disclosureElement || anchorElement,\n      autoFocusOnShow: positioned && autoFocusOnShow\n    }, props), {\n      portalRef\n    }));\n    return props;\n  }\n);\nvar Popover = createDialogComponent(\n  forwardRef(function Popover2(props) {\n    const htmlProps = usePopover(props);\n    return createElement(TagName, htmlProps);\n  }),\n  usePopoverProviderContext\n);\n\nexport {\n  usePopover,\n  Popover\n};\n","\"use client\";\nimport {\n  useCompositeContext\n} from \"./P7GR5CS5.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef,\n  memo\n} from \"./LMDWO4NN.js\";\nimport {\n  useBooleanEvent,\n  useEvent,\n  useIsMouseMoving,\n  useMergeRefs\n} from \"./ABQUS43J.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/composite/composite-hover.tsx\nimport { contains } from \"@ariakit/core/utils/dom\";\nimport { hasFocus, hasFocusWithin } from \"@ariakit/core/utils/focus\";\nimport {\n  hasOwnProperty,\n  invariant,\n  removeUndefinedValues\n} from \"@ariakit/core/utils/misc\";\nimport { useCallback } from \"react\";\nvar TagName = \"div\";\nfunction getMouseDestination(event) {\n  const relatedTarget = event.relatedTarget;\n  if ((relatedTarget == null ? void 0 : relatedTarget.nodeType) === Node.ELEMENT_NODE) {\n    return relatedTarget;\n  }\n  return null;\n}\nfunction hoveringInside(event) {\n  const nextElement = getMouseDestination(event);\n  if (!nextElement) return false;\n  return contains(event.currentTarget, nextElement);\n}\nvar symbol = Symbol(\"composite-hover\");\nfunction movingToAnotherItem(event) {\n  let dest = getMouseDestination(event);\n  if (!dest) return false;\n  do {\n    if (hasOwnProperty(dest, symbol) && dest[symbol]) return true;\n    dest = dest.parentElement;\n  } while (dest);\n  return false;\n}\nvar useCompositeHover = createHook(\n  function useCompositeHover2(_a) {\n    var _b = _a, {\n      store,\n      focusOnHover = true,\n      blurOnHoverEnd = !!focusOnHover\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"focusOnHover\",\n      \"blurOnHoverEnd\"\n    ]);\n    const context = useCompositeContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"CompositeHover must be wrapped in a Composite component.\"\n    );\n    const isMouseMoving = useIsMouseMoving();\n    const onMouseMoveProp = props.onMouseMove;\n    const focusOnHoverProp = useBooleanEvent(focusOnHover);\n    const onMouseMove = useEvent((event) => {\n      onMouseMoveProp == null ? void 0 : onMouseMoveProp(event);\n      if (event.defaultPrevented) return;\n      if (!isMouseMoving()) return;\n      if (!focusOnHoverProp(event)) return;\n      if (!hasFocusWithin(event.currentTarget)) {\n        const baseElement = store == null ? void 0 : store.getState().baseElement;\n        if (baseElement && !hasFocus(baseElement)) {\n          baseElement.focus();\n        }\n      }\n      store == null ? void 0 : store.setActiveId(event.currentTarget.id);\n    });\n    const onMouseLeaveProp = props.onMouseLeave;\n    const blurOnHoverEndProp = useBooleanEvent(blurOnHoverEnd);\n    const onMouseLeave = useEvent((event) => {\n      var _a2;\n      onMouseLeaveProp == null ? void 0 : onMouseLeaveProp(event);\n      if (event.defaultPrevented) return;\n      if (!isMouseMoving()) return;\n      if (hoveringInside(event)) return;\n      if (movingToAnotherItem(event)) return;\n      if (!focusOnHoverProp(event)) return;\n      if (!blurOnHoverEndProp(event)) return;\n      store == null ? void 0 : store.setActiveId(null);\n      (_a2 = store == null ? void 0 : store.getState().baseElement) == null ? void 0 : _a2.focus();\n    });\n    const ref = useCallback((element) => {\n      if (!element) return;\n      element[symbol] = true;\n    }, []);\n    props = __spreadProps(__spreadValues({}, props), {\n      ref: useMergeRefs(ref, props.ref),\n      onMouseMove,\n      onMouseLeave\n    });\n    return removeUndefinedValues(props);\n  }\n);\nvar CompositeHover = memo(\n  forwardRef(function CompositeHover2(props) {\n    const htmlProps = useCompositeHover(props);\n    return createElement(TagName, htmlProps);\n  })\n);\n\nexport {\n  useCompositeHover,\n  CompositeHover\n};\n","\"use client\";\nimport {\n  createStoreContext\n} from \"./LMDWO4NN.js\";\n\n// src/collection/collection-context.tsx\nvar ctx = createStoreContext();\nvar useCollectionContext = ctx.useContext;\nvar useCollectionScopedContext = ctx.useScopedContext;\nvar useCollectionProviderContext = ctx.useProviderContext;\nvar CollectionContextProvider = ctx.ContextProvider;\nvar CollectionScopedContextProvider = ctx.ScopedContextProvider;\n\nexport {\n  useCollectionContext,\n  useCollectionScopedContext,\n  useCollectionProviderContext,\n  CollectionContextProvider,\n  CollectionScopedContextProvider\n};\n","\"use client\";\nimport {\n  CompositeContextProvider,\n  CompositeScopedContextProvider\n} from \"./P7GR5CS5.js\";\nimport {\n  PopoverContextProvider,\n  PopoverScopedContextProvider\n} from \"./MTZPJQMC.js\";\nimport {\n  createStoreContext\n} from \"./LMDWO4NN.js\";\n\n// src/combobox/combobox-context.tsx\nimport { createContext } from \"react\";\nvar ComboboxListRoleContext = createContext(\n  void 0\n);\nvar ctx = createStoreContext(\n  [PopoverContextProvider, CompositeContextProvider],\n  [PopoverScopedContextProvider, CompositeScopedContextProvider]\n);\nvar useComboboxContext = ctx.useContext;\nvar useComboboxScopedContext = ctx.useScopedContext;\nvar useComboboxProviderContext = ctx.useProviderContext;\nvar ComboboxContextProvider = ctx.ContextProvider;\nvar ComboboxScopedContextProvider = ctx.ScopedContextProvider;\nvar ComboboxItemValueContext = createContext(\n  void 0\n);\nvar ComboboxItemCheckedContext = createContext(false);\n\nexport {\n  ComboboxListRoleContext,\n  useComboboxContext,\n  useComboboxScopedContext,\n  useComboboxProviderContext,\n  ComboboxContextProvider,\n  ComboboxScopedContextProvider,\n  ComboboxItemValueContext,\n  ComboboxItemCheckedContext\n};\n","\"use client\";\nimport {\n  DialogScopedContextProvider\n} from \"./RS7LB2H4.js\";\nimport {\n  useDisclosureProviderContext\n} from \"./S6EF7IVO.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\nimport {\n  useStoreState\n} from \"./YV4JVR4I.js\";\nimport {\n  useId,\n  useMergeRefs,\n  useSafeLayoutEffect,\n  useWrapElement\n} from \"./ABQUS43J.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/disclosure/disclosure-content.tsx\nimport { invariant, removeUndefinedValues } from \"@ariakit/core/utils/misc\";\nimport { useMemo, useRef, useState } from \"react\";\nimport { flushSync } from \"react-dom\";\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nfunction afterTimeout(timeoutMs, cb) {\n  const timeoutId = setTimeout(cb, timeoutMs);\n  return () => clearTimeout(timeoutId);\n}\nfunction afterPaint(cb) {\n  let raf = requestAnimationFrame(() => {\n    raf = requestAnimationFrame(cb);\n  });\n  return () => cancelAnimationFrame(raf);\n}\nfunction parseCSSTime(...times) {\n  return times.join(\", \").split(\", \").reduce((longestTime, currentTimeString) => {\n    const multiplier = currentTimeString.endsWith(\"ms\") ? 1 : 1e3;\n    const currentTime = Number.parseFloat(currentTimeString || \"0s\") * multiplier;\n    if (currentTime > longestTime) return currentTime;\n    return longestTime;\n  }, 0);\n}\nfunction isHidden(mounted, hidden, alwaysVisible) {\n  return !alwaysVisible && hidden !== false && (!mounted || !!hidden);\n}\nvar useDisclosureContent = createHook(function useDisclosureContent2(_a) {\n  var _b = _a, { store, alwaysVisible } = _b, props = __objRest(_b, [\"store\", \"alwaysVisible\"]);\n  const context = useDisclosureProviderContext();\n  store = store || context;\n  invariant(\n    store,\n    process.env.NODE_ENV !== \"production\" && \"DisclosureContent must receive a `store` prop or be wrapped in a DisclosureProvider component.\"\n  );\n  const ref = useRef(null);\n  const id = useId(props.id);\n  const [transition, setTransition] = useState(null);\n  const open = store.useState(\"open\");\n  const mounted = store.useState(\"mounted\");\n  const animated = store.useState(\"animated\");\n  const contentElement = store.useState(\"contentElement\");\n  const otherElement = useStoreState(store.disclosure, \"contentElement\");\n  useSafeLayoutEffect(() => {\n    if (!ref.current) return;\n    store == null ? void 0 : store.setContentElement(ref.current);\n  }, [store]);\n  useSafeLayoutEffect(() => {\n    let previousAnimated;\n    store == null ? void 0 : store.setState(\"animated\", (animated2) => {\n      previousAnimated = animated2;\n      return true;\n    });\n    return () => {\n      if (previousAnimated === void 0) return;\n      store == null ? void 0 : store.setState(\"animated\", previousAnimated);\n    };\n  }, [store]);\n  useSafeLayoutEffect(() => {\n    if (!animated) return;\n    if (!(contentElement == null ? void 0 : contentElement.isConnected)) {\n      setTransition(null);\n      return;\n    }\n    return afterPaint(() => {\n      setTransition(open ? \"enter\" : mounted ? \"leave\" : null);\n    });\n  }, [animated, contentElement, open, mounted]);\n  useSafeLayoutEffect(() => {\n    if (!store) return;\n    if (!animated) return;\n    if (!transition) return;\n    if (!contentElement) return;\n    const stopAnimation = () => store == null ? void 0 : store.setState(\"animating\", false);\n    const stopAnimationSync = () => flushSync(stopAnimation);\n    if (transition === \"leave\" && open) return;\n    if (transition === \"enter\" && !open) return;\n    if (typeof animated === \"number\") {\n      const timeout2 = animated;\n      return afterTimeout(timeout2, stopAnimationSync);\n    }\n    const {\n      transitionDuration,\n      animationDuration,\n      transitionDelay,\n      animationDelay\n    } = getComputedStyle(contentElement);\n    const {\n      transitionDuration: transitionDuration2 = \"0\",\n      animationDuration: animationDuration2 = \"0\",\n      transitionDelay: transitionDelay2 = \"0\",\n      animationDelay: animationDelay2 = \"0\"\n    } = otherElement ? getComputedStyle(otherElement) : {};\n    const delay = parseCSSTime(\n      transitionDelay,\n      animationDelay,\n      transitionDelay2,\n      animationDelay2\n    );\n    const duration = parseCSSTime(\n      transitionDuration,\n      animationDuration,\n      transitionDuration2,\n      animationDuration2\n    );\n    const timeout = delay + duration;\n    if (!timeout) {\n      if (transition === \"enter\") {\n        store.setState(\"animated\", false);\n      }\n      stopAnimation();\n      return;\n    }\n    const frameRate = 1e3 / 60;\n    const maxTimeout = Math.max(timeout - frameRate, 0);\n    return afterTimeout(maxTimeout, stopAnimationSync);\n  }, [store, animated, contentElement, otherElement, open, transition]);\n  props = useWrapElement(\n    props,\n    (element) => /* @__PURE__ */ jsx(DialogScopedContextProvider, { value: store, children: element }),\n    [store]\n  );\n  const hidden = isHidden(mounted, props.hidden, alwaysVisible);\n  const styleProp = props.style;\n  const style = useMemo(() => {\n    if (hidden) {\n      return __spreadProps(__spreadValues({}, styleProp), { display: \"none\" });\n    }\n    return styleProp;\n  }, [hidden, styleProp]);\n  props = __spreadProps(__spreadValues({\n    id,\n    \"data-open\": open || void 0,\n    \"data-enter\": transition === \"enter\" || void 0,\n    \"data-leave\": transition === \"leave\" || void 0,\n    hidden\n  }, props), {\n    ref: useMergeRefs(id ? store.setContentElement : null, ref, props.ref),\n    style\n  });\n  return removeUndefinedValues(props);\n});\nvar DisclosureContentImpl = forwardRef(function DisclosureContentImpl2(props) {\n  const htmlProps = useDisclosureContent(props);\n  return createElement(TagName, htmlProps);\n});\nvar DisclosureContent = forwardRef(function DisclosureContent2(_a) {\n  var _b = _a, {\n    unmountOnHide\n  } = _b, props = __objRest(_b, [\n    \"unmountOnHide\"\n  ]);\n  const context = useDisclosureProviderContext();\n  const store = props.store || context;\n  const mounted = useStoreState(\n    store,\n    (state) => !unmountOnHide || (state == null ? void 0 : state.mounted)\n  );\n  if (mounted === false) return null;\n  return /* @__PURE__ */ jsx(DisclosureContentImpl, __spreadValues({}, props));\n});\n\nexport {\n  isHidden,\n  useDisclosureContent,\n  DisclosureContent\n};\n","\"use client\";\nimport {\n  useStore,\n  useStoreProps\n} from \"./YV4JVR4I.js\";\nimport {\n  useUpdateEffect\n} from \"./ABQUS43J.js\";\n\n// src/disclosure/disclosure-store.ts\nimport * as Core from \"@ariakit/core/disclosure/disclosure-store\";\nfunction useDisclosureStoreProps(store, update, props) {\n  useUpdateEffect(update, [props.store, props.disclosure]);\n  useStoreProps(store, props, \"open\", \"setOpen\");\n  useStoreProps(store, props, \"mounted\", \"setMounted\");\n  useStoreProps(store, props, \"animated\");\n  return Object.assign(store, { disclosure: props.disclosure });\n}\nfunction useDisclosureStore(props = {}) {\n  const [store, update] = useStore(Core.createDisclosureStore, props);\n  return useDisclosureStoreProps(store, update, props);\n}\n\nexport {\n  useDisclosureStoreProps,\n  useDisclosureStore\n};\n","\"use client\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\n\n// src/role/role.tsx\nvar TagName = \"div\";\nvar elements = [\n  \"a\",\n  \"button\",\n  \"details\",\n  \"dialog\",\n  \"div\",\n  \"form\",\n  \"h1\",\n  \"h2\",\n  \"h3\",\n  \"h4\",\n  \"h5\",\n  \"h6\",\n  \"header\",\n  \"img\",\n  \"input\",\n  \"label\",\n  \"li\",\n  \"nav\",\n  \"ol\",\n  \"p\",\n  \"section\",\n  \"select\",\n  \"span\",\n  \"summary\",\n  \"textarea\",\n  \"ul\",\n  \"svg\"\n];\nvar useRole = createHook(\n  function useRole2(props) {\n    return props;\n  }\n);\nvar Role = forwardRef(\n  // @ts-expect-error\n  function Role2(props) {\n    return createElement(TagName, props);\n  }\n);\nObject.assign(\n  Role,\n  elements.reduce((acc, element) => {\n    acc[element] = forwardRef(function Role3(props) {\n      return createElement(element, props);\n    });\n    return acc;\n  }, {})\n);\n\nexport {\n  useRole,\n  Role\n};\n","\"use client\";\nimport {\n  createHovercardStore\n} from \"../__chunks/JTLIIJ4U.js\";\nimport \"../__chunks/ME2CUF3F.js\";\nimport \"../__chunks/FZZ2AVHF.js\";\nimport \"../__chunks/RCQ5P4YE.js\";\nimport {\n  createStore\n} from \"../__chunks/BCALMBPZ.js\";\nimport {\n  defaultValue\n} from \"../__chunks/PBFD2E7P.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"../__chunks/3YLGPPWQ.js\";\n\n// src/tooltip/tooltip-store.ts\nfunction createTooltipStore(props = {}) {\n  var _a;\n  if (process.env.NODE_ENV !== \"production\") {\n    if (props.type === \"label\") {\n      console.warn(\n        \"The `type` option on the tooltip store is deprecated.\",\n        \"Render a visually hidden label or use the `aria-label` or `aria-labelledby` attributes on the anchor element instead.\",\n        \"See https://ariakit.org/components/tooltip#tooltip-anchors-must-have-accessible-names\"\n      );\n    }\n  }\n  const syncState = (_a = props.store) == null ? void 0 : _a.getState();\n  const hovercard = createHovercardStore(__spreadProps(__spreadValues({}, props), {\n    placement: defaultValue(\n      props.placement,\n      syncState == null ? void 0 : syncState.placement,\n      \"top\"\n    ),\n    hideTimeout: defaultValue(props.hideTimeout, syncState == null ? void 0 : syncState.hideTimeout, 0)\n  }));\n  const initialState = __spreadProps(__spreadValues({}, hovercard.getState()), {\n    type: defaultValue(props.type, syncState == null ? void 0 : syncState.type, \"description\"),\n    skipTimeout: defaultValue(props.skipTimeout, syncState == null ? void 0 : syncState.skipTimeout, 300)\n  });\n  const tooltip = createStore(initialState, hovercard, props.store);\n  return __spreadValues(__spreadValues({}, hovercard), tooltip);\n}\nexport {\n  createTooltipStore\n};\n","\"use client\";\nimport {\n  useHovercardStoreProps\n} from \"./FTXTWCCT.js\";\nimport {\n  useStore,\n  useStoreProps\n} from \"./YV4JVR4I.js\";\n\n// src/tooltip/tooltip-store.ts\nimport * as Core from \"@ariakit/core/tooltip/tooltip-store\";\nfunction useTooltipStoreProps(store, update, props) {\n  useStoreProps(store, props, \"type\");\n  useStoreProps(store, props, \"skipTimeout\");\n  return useHovercardStoreProps(store, update, props);\n}\nfunction useTooltipStore(props = {}) {\n  const [store, update] = useStore(Core.createTooltipStore, props);\n  return useTooltipStoreProps(store, update, props);\n}\n\nexport {\n  useTooltipStoreProps,\n  useTooltipStore\n};\n","\"use client\";\nimport {\n  useEvent,\n  useLiveRef,\n  useSafeLayoutEffect\n} from \"./ABQUS43J.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/utils/store.tsx\nimport { hasOwnProperty, identity } from \"@ariakit/core/utils/misc\";\nimport { batch, init, subscribe, sync } from \"@ariakit/core/utils/store\";\nimport * as React from \"react\";\nimport useSyncExternalStoreExports from \"use-sync-external-store/shim/index.js\";\nvar { useSyncExternalStore } = useSyncExternalStoreExports;\nvar noopSubscribe = () => () => {\n};\nfunction useStoreState(store, keyOrSelector = identity) {\n  const storeSubscribe = React.useCallback(\n    (callback) => {\n      if (!store) return noopSubscribe();\n      return subscribe(store, null, callback);\n    },\n    [store]\n  );\n  const getSnapshot = () => {\n    const key = typeof keyOrSelector === \"string\" ? keyOrSelector : null;\n    const selector = typeof keyOrSelector === \"function\" ? keyOrSelector : null;\n    const state = store == null ? void 0 : store.getState();\n    if (selector) return selector(state);\n    if (!state) return;\n    if (!key) return;\n    if (!hasOwnProperty(state, key)) return;\n    return state[key];\n  };\n  return useSyncExternalStore(storeSubscribe, getSnapshot, getSnapshot);\n}\nfunction useStoreStateObject(store, object) {\n  const objRef = React.useRef(\n    {}\n  );\n  const storeSubscribe = React.useCallback(\n    (callback) => {\n      if (!store) return noopSubscribe();\n      return subscribe(store, null, callback);\n    },\n    [store]\n  );\n  const getSnapshot = () => {\n    const state = store == null ? void 0 : store.getState();\n    let updated = false;\n    const obj = objRef.current;\n    for (const prop in object) {\n      const keyOrSelector = object[prop];\n      if (typeof keyOrSelector === \"function\") {\n        const value = keyOrSelector(state);\n        if (value !== obj[prop]) {\n          obj[prop] = value;\n          updated = true;\n        }\n      }\n      if (typeof keyOrSelector === \"string\") {\n        if (!state) continue;\n        if (!hasOwnProperty(state, keyOrSelector)) continue;\n        const value = state[keyOrSelector];\n        if (value !== obj[prop]) {\n          obj[prop] = value;\n          updated = true;\n        }\n      }\n    }\n    if (updated) {\n      objRef.current = __spreadValues({}, obj);\n    }\n    return objRef.current;\n  };\n  return useSyncExternalStore(storeSubscribe, getSnapshot, getSnapshot);\n}\nfunction useStoreProps(store, props, key, setKey) {\n  const value = hasOwnProperty(props, key) ? props[key] : void 0;\n  const setValue = setKey ? props[setKey] : void 0;\n  const propsRef = useLiveRef({ value, setValue });\n  useSafeLayoutEffect(() => {\n    return sync(store, [key], (state, prev) => {\n      const { value: value2, setValue: setValue2 } = propsRef.current;\n      if (!setValue2) return;\n      if (state[key] === prev[key]) return;\n      if (state[key] === value2) return;\n      setValue2(state[key]);\n    });\n  }, [store, key]);\n  useSafeLayoutEffect(() => {\n    if (value === void 0) return;\n    store.setState(key, value);\n    return batch(store, [key], () => {\n      if (value === void 0) return;\n      store.setState(key, value);\n    });\n  });\n}\nfunction useStore(createStore, props) {\n  const [store, setStore] = React.useState(() => createStore(props));\n  useSafeLayoutEffect(() => init(store), [store]);\n  const useState2 = React.useCallback(\n    (keyOrSelector) => useStoreState(store, keyOrSelector),\n    [store]\n  );\n  const memoizedStore = React.useMemo(\n    () => __spreadProps(__spreadValues({}, store), { useState: useState2 }),\n    [store, useState2]\n  );\n  const updateStore = useEvent(() => {\n    setStore((store2) => createStore(__spreadValues(__spreadValues({}, props), store2.getState())));\n  });\n  return [memoizedStore, updateStore];\n}\n\nexport {\n  useStoreState,\n  useStoreStateObject,\n  useStoreProps,\n  useStore\n};\n","\"use client\";\nimport {\n  useCompositeHover\n} from \"./UQQRIHDV.js\";\nimport {\n  ComboboxItemCheckedContext,\n  ComboboxItemValueContext,\n  ComboboxListRoleContext,\n  useComboboxScopedContext\n} from \"./VEVQD5MH.js\";\nimport {\n  useCompositeItem\n} from \"./P2CTZE2T.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef,\n  memo\n} from \"./LMDWO4NN.js\";\nimport {\n  useStoreStateObject\n} from \"./YV4JVR4I.js\";\nimport {\n  useBooleanEvent,\n  useEvent,\n  useWrapElement\n} from \"./ABQUS43J.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/combobox/combobox-item.tsx\nimport { isTextField } from \"@ariakit/core/utils/dom\";\nimport { isDownloading, isOpeningInNewTab } from \"@ariakit/core/utils/events\";\nimport { hasFocus } from \"@ariakit/core/utils/focus\";\nimport { invariant } from \"@ariakit/core/utils/misc\";\nimport { useCallback, useContext } from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nfunction isSelected(storeValue, itemValue) {\n  if (itemValue == null) return;\n  if (storeValue == null) return false;\n  if (Array.isArray(storeValue)) {\n    return storeValue.includes(itemValue);\n  }\n  return storeValue === itemValue;\n}\nfunction getItemRole(popupRole) {\n  var _a;\n  const itemRoleByPopupRole = {\n    menu: \"menuitem\",\n    listbox: \"option\",\n    tree: \"treeitem\"\n  };\n  const key = popupRole;\n  return (_a = itemRoleByPopupRole[key]) != null ? _a : \"option\";\n}\nvar useComboboxItem = createHook(\n  function useComboboxItem2(_a) {\n    var _b = _a, {\n      store,\n      value,\n      hideOnClick,\n      setValueOnClick,\n      selectValueOnClick = true,\n      resetValueOnSelect,\n      focusOnHover = false,\n      moveOnKeyPress = true,\n      getItem: getItemProp\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"value\",\n      \"hideOnClick\",\n      \"setValueOnClick\",\n      \"selectValueOnClick\",\n      \"resetValueOnSelect\",\n      \"focusOnHover\",\n      \"moveOnKeyPress\",\n      \"getItem\"\n    ]);\n    var _a2;\n    const context = useComboboxScopedContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"ComboboxItem must be wrapped in a ComboboxList or ComboboxPopover component.\"\n    );\n    const { resetValueOnSelectState, multiSelectable, selected } = useStoreStateObject(store, {\n      resetValueOnSelectState: \"resetValueOnSelect\",\n      multiSelectable(state) {\n        return Array.isArray(state.selectedValue);\n      },\n      selected(state) {\n        return isSelected(state.selectedValue, value);\n      }\n    });\n    const getItem = useCallback(\n      (item) => {\n        const nextItem = __spreadProps(__spreadValues({}, item), { value });\n        if (getItemProp) {\n          return getItemProp(nextItem);\n        }\n        return nextItem;\n      },\n      [value, getItemProp]\n    );\n    setValueOnClick = setValueOnClick != null ? setValueOnClick : !multiSelectable;\n    hideOnClick = hideOnClick != null ? hideOnClick : value != null && !multiSelectable;\n    const onClickProp = props.onClick;\n    const setValueOnClickProp = useBooleanEvent(setValueOnClick);\n    const selectValueOnClickProp = useBooleanEvent(selectValueOnClick);\n    const resetValueOnSelectProp = useBooleanEvent(\n      (_a2 = resetValueOnSelect != null ? resetValueOnSelect : resetValueOnSelectState) != null ? _a2 : multiSelectable\n    );\n    const hideOnClickProp = useBooleanEvent(hideOnClick);\n    const onClick = useEvent((event) => {\n      onClickProp == null ? void 0 : onClickProp(event);\n      if (event.defaultPrevented) return;\n      if (isDownloading(event)) return;\n      if (isOpeningInNewTab(event)) return;\n      if (value != null) {\n        if (selectValueOnClickProp(event)) {\n          if (resetValueOnSelectProp(event)) {\n            store == null ? void 0 : store.resetValue();\n          }\n          store == null ? void 0 : store.setSelectedValue((prevValue) => {\n            if (!Array.isArray(prevValue)) return value;\n            if (prevValue.includes(value)) {\n              return prevValue.filter((v) => v !== value);\n            }\n            return [...prevValue, value];\n          });\n        }\n        if (setValueOnClickProp(event)) {\n          store == null ? void 0 : store.setValue(value);\n        }\n      }\n      if (hideOnClickProp(event)) {\n        store == null ? void 0 : store.hide();\n      }\n    });\n    const onKeyDownProp = props.onKeyDown;\n    const onKeyDown = useEvent((event) => {\n      onKeyDownProp == null ? void 0 : onKeyDownProp(event);\n      if (event.defaultPrevented) return;\n      const baseElement = store == null ? void 0 : store.getState().baseElement;\n      if (!baseElement) return;\n      if (hasFocus(baseElement)) return;\n      const printable = event.key.length === 1;\n      if (printable || event.key === \"Backspace\" || event.key === \"Delete\") {\n        queueMicrotask(() => baseElement.focus());\n        if (isTextField(baseElement)) {\n          store == null ? void 0 : store.setValue(baseElement.value);\n        }\n      }\n    });\n    if (multiSelectable && selected != null) {\n      props = __spreadValues({\n        \"aria-selected\": selected\n      }, props);\n    }\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(ComboboxItemValueContext.Provider, { value, children: /* @__PURE__ */ jsx(ComboboxItemCheckedContext.Provider, { value: selected != null ? selected : false, children: element }) }),\n      [value, selected]\n    );\n    const popupRole = useContext(ComboboxListRoleContext);\n    props = __spreadProps(__spreadValues({\n      role: getItemRole(popupRole),\n      children: value\n    }, props), {\n      onClick,\n      onKeyDown\n    });\n    const moveOnKeyPressProp = useBooleanEvent(moveOnKeyPress);\n    props = useCompositeItem(__spreadProps(__spreadValues({\n      store\n    }, props), {\n      getItem,\n      // Dispatch a custom event on the combobox input when moving to an item\n      // with the keyboard so the Combobox component can enable inline\n      // autocompletion.\n      moveOnKeyPress: (event) => {\n        if (!moveOnKeyPressProp(event)) return false;\n        const moveEvent = new Event(\"combobox-item-move\");\n        const baseElement = store == null ? void 0 : store.getState().baseElement;\n        baseElement == null ? void 0 : baseElement.dispatchEvent(moveEvent);\n        return true;\n      }\n    }));\n    props = useCompositeHover(__spreadValues({ store, focusOnHover }, props));\n    return props;\n  }\n);\nvar ComboboxItem = memo(\n  forwardRef(function ComboboxItem2(props) {\n    const htmlProps = useComboboxItem(props);\n    return createElement(TagName, htmlProps);\n  })\n);\n\nexport {\n  useComboboxItem,\n  ComboboxItem\n};\n","\"use client\";\nimport {\n  useComboboxList\n} from \"../__chunks/HUWAI7RB.js\";\nimport {\n  useComboboxProviderContext\n} from \"../__chunks/VEVQD5MH.js\";\nimport \"../__chunks/P7GR5CS5.js\";\nimport \"../__chunks/VDHZ5F7K.js\";\nimport {\n  usePopover\n} from \"../__chunks/T6C2RYFI.js\";\nimport {\n  createDialogComponent\n} from \"../__chunks/JC64G2H7.js\";\nimport \"../__chunks/63FEHJZV.js\";\nimport \"../__chunks/KZAQFFOU.js\";\nimport \"../__chunks/IGR4SXG2.js\";\nimport \"../__chunks/ESSM74HH.js\";\nimport \"../__chunks/BGQ3KQ5M.js\";\nimport \"../__chunks/YKJECYU7.js\";\nimport \"../__chunks/TOU75OXH.js\";\nimport \"../__chunks/WBDYNH73.js\";\nimport \"../__chunks/2PGBN2Y4.js\";\nimport \"../__chunks/63XF7ACK.js\";\nimport \"../__chunks/HLTQOHKZ.js\";\nimport \"../__chunks/677M2CI3.js\";\nimport \"../__chunks/6GXEOXGT.js\";\nimport \"../__chunks/AOUGVQZ3.js\";\nimport \"../__chunks/K2ZF5NU7.js\";\nimport \"../__chunks/ZWYATQFU.js\";\nimport \"../__chunks/5M6RIVE2.js\";\nimport \"../__chunks/O37CNYMR.js\";\nimport \"../__chunks/W3VI7GFU.js\";\nimport \"../__chunks/AOQQTIBO.js\";\nimport \"../__chunks/CZ4GFWYL.js\";\nimport \"../__chunks/VGCJ63VH.js\";\nimport \"../__chunks/XL7CSKGW.js\";\nimport \"../__chunks/MTZPJQMC.js\";\nimport \"../__chunks/RS7LB2H4.js\";\nimport \"../__chunks/S6EF7IVO.js\";\nimport \"../__chunks/LVA2YJMS.js\";\nimport \"../__chunks/SWN3JYXT.js\";\nimport \"../__chunks/XX67R432.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"../__chunks/LMDWO4NN.js\";\nimport \"../__chunks/BM6PGYQY.js\";\nimport \"../__chunks/WYCIER3C.js\";\nimport {\n  useStoreState\n} from \"../__chunks/YV4JVR4I.js\";\nimport \"../__chunks/ABQUS43J.js\";\nimport \"../__chunks/SK3NAZA3.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"../__chunks/3YLGPPWQ.js\";\n\n// src/combobox/combobox-popover.tsx\nimport { getDocument } from \"@ariakit/core/utils/dom\";\nimport { invariant, isFalsyBooleanCallback } from \"@ariakit/core/utils/misc\";\nimport { useRef } from \"react\";\nvar TagName = \"div\";\nfunction isController(target, ...ids) {\n  if (!target) return false;\n  if (\"id\" in target) {\n    const selector = ids.filter(Boolean).map((id) => `[aria-controls~=\"${id}\"]`).join(\", \");\n    if (!selector) return false;\n    return target.matches(selector);\n  }\n  return false;\n}\nvar useComboboxPopover = createHook(\n  function useComboboxPopover2(_a) {\n    var _b = _a, {\n      store,\n      modal,\n      tabIndex,\n      alwaysVisible,\n      autoFocusOnHide = true,\n      hideOnInteractOutside = true\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"modal\",\n      \"tabIndex\",\n      \"alwaysVisible\",\n      \"autoFocusOnHide\",\n      \"hideOnInteractOutside\"\n    ]);\n    const context = useComboboxProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"ComboboxPopover must receive a `store` prop or be wrapped in a ComboboxProvider component.\"\n    );\n    const baseElement = store.useState(\"baseElement\");\n    const hiddenByClickOutsideRef = useRef(false);\n    const treeSnapshotKey = useStoreState(\n      store.tag,\n      (state) => state == null ? void 0 : state.renderedItems.length\n    );\n    props = useComboboxList(__spreadValues({ store, alwaysVisible }, props));\n    props = usePopover(__spreadProps(__spreadValues({\n      store,\n      modal,\n      alwaysVisible,\n      backdrop: false,\n      autoFocusOnShow: false,\n      finalFocus: baseElement,\n      preserveTabOrderAnchor: null,\n      unstable_treeSnapshotKey: treeSnapshotKey\n    }, props), {\n      // When the combobox popover is modal, we make sure to include the\n      // combobox input and all the combobox controls (cancel, disclosure) in\n      // the list of persistent elements so they make part of the modal context,\n      // allowing users to tab through them.\n      getPersistentElements() {\n        var _a2;\n        const elements = ((_a2 = props.getPersistentElements) == null ? void 0 : _a2.call(props)) || [];\n        if (!modal) return elements;\n        if (!store) return elements;\n        const { contentElement, baseElement: baseElement2 } = store.getState();\n        if (!baseElement2) return elements;\n        const doc = getDocument(baseElement2);\n        const selectors = [];\n        if (contentElement == null ? void 0 : contentElement.id) {\n          selectors.push(`[aria-controls~=\"${contentElement.id}\"]`);\n        }\n        if (baseElement2 == null ? void 0 : baseElement2.id) {\n          selectors.push(`[aria-controls~=\"${baseElement2.id}\"]`);\n        }\n        if (!selectors.length) return [...elements, baseElement2];\n        const selector = selectors.join(\",\");\n        const controlElements = doc.querySelectorAll(selector);\n        return [...elements, ...controlElements];\n      },\n      // The combobox popover should focus on the combobox input when it hides,\n      // unless the event was triggered by a click outside the popover, in which\n      // case the input shouldn't be re-focused.\n      autoFocusOnHide(element) {\n        if (isFalsyBooleanCallback(autoFocusOnHide, element)) return false;\n        if (hiddenByClickOutsideRef.current) {\n          hiddenByClickOutsideRef.current = false;\n          return false;\n        }\n        return true;\n      },\n      // Make sure we don't hide the popover when the user interacts with the\n      // combobox cancel or the combobox disclosure buttons. They will have the\n      // aria-controls attribute pointing to either the combobox input or the\n      // combobox popover elements.\n      hideOnInteractOutside(event) {\n        var _a2, _b2;\n        const state = store == null ? void 0 : store.getState();\n        const contentId = (_a2 = state == null ? void 0 : state.contentElement) == null ? void 0 : _a2.id;\n        const baseId = (_b2 = state == null ? void 0 : state.baseElement) == null ? void 0 : _b2.id;\n        if (isController(event.target, contentId, baseId)) return false;\n        const result = typeof hideOnInteractOutside === \"function\" ? hideOnInteractOutside(event) : hideOnInteractOutside;\n        if (result) {\n          hiddenByClickOutsideRef.current = event.type === \"click\";\n        }\n        return result;\n      }\n    }));\n    return props;\n  }\n);\nvar ComboboxPopover = createDialogComponent(\n  forwardRef(function ComboboxPopover2(props) {\n    const htmlProps = useComboboxPopover(props);\n    return createElement(TagName, htmlProps);\n  }),\n  useComboboxProviderContext\n);\nexport {\n  ComboboxPopover,\n  useComboboxPopover\n};\n","\"use client\";\nimport {\n  useComboboxProviderContext\n} from \"../__chunks/VEVQD5MH.js\";\nimport {\n  usePopoverAnchor\n} from \"../__chunks/OMU7RWRV.js\";\nimport {\n  useComposite\n} from \"../__chunks/ITI7HKP4.js\";\nimport \"../__chunks/5VQZOHHZ.js\";\nimport \"../__chunks/P7GR5CS5.js\";\nimport \"../__chunks/VDHZ5F7K.js\";\nimport \"../__chunks/MTZPJQMC.js\";\nimport \"../__chunks/RS7LB2H4.js\";\nimport \"../__chunks/S6EF7IVO.js\";\nimport \"../__chunks/LVA2YJMS.js\";\nimport \"../__chunks/SWN3JYXT.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"../__chunks/LMDWO4NN.js\";\nimport {\n  useBooleanEvent,\n  useEvent,\n  useForceUpdate,\n  useId,\n  useMergeRefs,\n  useSafeLayoutEffect,\n  useUpdateEffect,\n  useUpdateLayoutEffect\n} from \"../__chunks/ABQUS43J.js\";\nimport \"../__chunks/SK3NAZA3.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"../__chunks/3YLGPPWQ.js\";\n\n// src/combobox/combobox.tsx\nimport {\n  getPopupRole,\n  getScrollingElement,\n  getTextboxSelection,\n  setSelectionRange\n} from \"@ariakit/core/utils/dom\";\nimport {\n  isFocusEventOutside,\n  queueBeforeEvent\n} from \"@ariakit/core/utils/events\";\nimport { hasFocus } from \"@ariakit/core/utils/focus\";\nimport {\n  invariant,\n  isFalsyBooleanCallback,\n  noop,\n  normalizeString\n} from \"@ariakit/core/utils/misc\";\nimport { sync } from \"@ariakit/core/utils/store\";\nimport { useEffect, useMemo, useRef, useState } from \"react\";\nvar TagName = \"input\";\nfunction isFirstItemAutoSelected(items, activeValue, autoSelect) {\n  if (!autoSelect) return false;\n  const firstItem = items.find((item) => !item.disabled && item.value);\n  return (firstItem == null ? void 0 : firstItem.value) === activeValue;\n}\nfunction hasCompletionString(value, activeValue) {\n  if (!activeValue) return false;\n  if (value == null) return false;\n  value = normalizeString(value);\n  return activeValue.length > value.length && activeValue.toLowerCase().indexOf(value.toLowerCase()) === 0;\n}\nfunction isInputEvent(event) {\n  return event.type === \"input\";\n}\nfunction isAriaAutoCompleteValue(value) {\n  return value === \"inline\" || value === \"list\" || value === \"both\" || value === \"none\";\n}\nfunction getDefaultAutoSelectId(items) {\n  const item = items.find((item2) => {\n    var _a;\n    if (item2.disabled) return false;\n    return ((_a = item2.element) == null ? void 0 : _a.getAttribute(\"role\")) !== \"tab\";\n  });\n  return item == null ? void 0 : item.id;\n}\nvar useCombobox = createHook(\n  function useCombobox2(_a) {\n    var _b = _a, {\n      store,\n      focusable = true,\n      autoSelect: autoSelectProp = false,\n      getAutoSelectId,\n      setValueOnChange,\n      showMinLength = 0,\n      showOnChange,\n      showOnMouseDown,\n      showOnClick = showOnMouseDown,\n      showOnKeyDown,\n      showOnKeyPress = showOnKeyDown,\n      blurActiveItemOnClick,\n      setValueOnClick = true,\n      moveOnKeyPress = true,\n      autoComplete = \"list\"\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"focusable\",\n      \"autoSelect\",\n      \"getAutoSelectId\",\n      \"setValueOnChange\",\n      \"showMinLength\",\n      \"showOnChange\",\n      \"showOnMouseDown\",\n      \"showOnClick\",\n      \"showOnKeyDown\",\n      \"showOnKeyPress\",\n      \"blurActiveItemOnClick\",\n      \"setValueOnClick\",\n      \"moveOnKeyPress\",\n      \"autoComplete\"\n    ]);\n    const context = useComboboxProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"Combobox must receive a `store` prop or be wrapped in a ComboboxProvider component.\"\n    );\n    const ref = useRef(null);\n    const [valueUpdated, forceValueUpdate] = useForceUpdate();\n    const canAutoSelectRef = useRef(false);\n    const composingRef = useRef(false);\n    const autoSelect = store.useState(\n      (state) => state.virtualFocus && autoSelectProp\n    );\n    const inline = autoComplete === \"inline\" || autoComplete === \"both\";\n    const [canInline, setCanInline] = useState(inline);\n    useUpdateLayoutEffect(() => {\n      if (!inline) return;\n      setCanInline(true);\n    }, [inline]);\n    const storeValue = store.useState(\"value\");\n    const prevSelectedValueRef = useRef();\n    useEffect(() => {\n      return sync(store, [\"selectedValue\", \"activeId\"], (_, prev) => {\n        prevSelectedValueRef.current = prev.selectedValue;\n      });\n    }, []);\n    const inlineActiveValue = store.useState((state) => {\n      var _a2;\n      if (!inline) return;\n      if (!canInline) return;\n      if (state.activeValue && Array.isArray(state.selectedValue)) {\n        if (state.selectedValue.includes(state.activeValue)) return;\n        if ((_a2 = prevSelectedValueRef.current) == null ? void 0 : _a2.includes(state.activeValue)) return;\n      }\n      return state.activeValue;\n    });\n    const items = store.useState(\"renderedItems\");\n    const open = store.useState(\"open\");\n    const contentElement = store.useState(\"contentElement\");\n    const value = useMemo(() => {\n      if (!inline) return storeValue;\n      if (!canInline) return storeValue;\n      const firstItemAutoSelected = isFirstItemAutoSelected(\n        items,\n        inlineActiveValue,\n        autoSelect\n      );\n      if (firstItemAutoSelected) {\n        if (hasCompletionString(storeValue, inlineActiveValue)) {\n          const slice = (inlineActiveValue == null ? void 0 : inlineActiveValue.slice(storeValue.length)) || \"\";\n          return storeValue + slice;\n        }\n        return storeValue;\n      }\n      return inlineActiveValue || storeValue;\n    }, [inline, canInline, items, inlineActiveValue, autoSelect, storeValue]);\n    useEffect(() => {\n      const element = ref.current;\n      if (!element) return;\n      const onCompositeItemMove = () => setCanInline(true);\n      element.addEventListener(\"combobox-item-move\", onCompositeItemMove);\n      return () => {\n        element.removeEventListener(\"combobox-item-move\", onCompositeItemMove);\n      };\n    }, []);\n    useEffect(() => {\n      if (!inline) return;\n      if (!canInline) return;\n      if (!inlineActiveValue) return;\n      const firstItemAutoSelected = isFirstItemAutoSelected(\n        items,\n        inlineActiveValue,\n        autoSelect\n      );\n      if (!firstItemAutoSelected) return;\n      if (!hasCompletionString(storeValue, inlineActiveValue)) return;\n      let cleanup = noop;\n      queueMicrotask(() => {\n        const element = ref.current;\n        if (!element) return;\n        const { start: prevStart, end: prevEnd } = getTextboxSelection(element);\n        const nextStart = storeValue.length;\n        const nextEnd = inlineActiveValue.length;\n        setSelectionRange(element, nextStart, nextEnd);\n        cleanup = () => {\n          if (!hasFocus(element)) return;\n          const { start, end } = getTextboxSelection(element);\n          if (start !== nextStart) return;\n          if (end !== nextEnd) return;\n          setSelectionRange(element, prevStart, prevEnd);\n        };\n      });\n      return () => cleanup();\n    }, [\n      valueUpdated,\n      inline,\n      canInline,\n      inlineActiveValue,\n      items,\n      autoSelect,\n      storeValue\n    ]);\n    const scrollingElementRef = useRef(null);\n    const getAutoSelectIdProp = useEvent(getAutoSelectId);\n    const autoSelectIdRef = useRef(null);\n    useEffect(() => {\n      if (!open) return;\n      if (!contentElement) return;\n      const scrollingElement = getScrollingElement(contentElement);\n      if (!scrollingElement) return;\n      scrollingElementRef.current = scrollingElement;\n      const onUserScroll = () => {\n        canAutoSelectRef.current = false;\n      };\n      const onScroll = () => {\n        if (!store) return;\n        if (!canAutoSelectRef.current) return;\n        const { activeId } = store.getState();\n        if (activeId === null) return;\n        if (activeId === autoSelectIdRef.current) return;\n        canAutoSelectRef.current = false;\n      };\n      const options = { passive: true, capture: true };\n      scrollingElement.addEventListener(\"wheel\", onUserScroll, options);\n      scrollingElement.addEventListener(\"touchmove\", onUserScroll, options);\n      scrollingElement.addEventListener(\"scroll\", onScroll, options);\n      return () => {\n        scrollingElement.removeEventListener(\"wheel\", onUserScroll, true);\n        scrollingElement.removeEventListener(\"touchmove\", onUserScroll, true);\n        scrollingElement.removeEventListener(\"scroll\", onScroll, true);\n      };\n    }, [open, contentElement, store]);\n    useSafeLayoutEffect(() => {\n      if (!storeValue) return;\n      if (composingRef.current) return;\n      canAutoSelectRef.current = true;\n    }, [storeValue]);\n    useSafeLayoutEffect(() => {\n      if (autoSelect !== \"always\" && open) return;\n      canAutoSelectRef.current = open;\n    }, [autoSelect, open]);\n    const resetValueOnSelect = store.useState(\"resetValueOnSelect\");\n    useUpdateEffect(() => {\n      var _a2, _b2;\n      const canAutoSelect = canAutoSelectRef.current;\n      if (!store) return;\n      if (!open) return;\n      if (!canAutoSelect && !resetValueOnSelect) return;\n      const { baseElement, contentElement: contentElement2, activeId } = store.getState();\n      if (baseElement && !hasFocus(baseElement)) return;\n      if (contentElement2 == null ? void 0 : contentElement2.hasAttribute(\"data-placing\")) {\n        const observer = new MutationObserver(forceValueUpdate);\n        observer.observe(contentElement2, { attributeFilter: [\"data-placing\"] });\n        return () => observer.disconnect();\n      }\n      if (autoSelect && canAutoSelect) {\n        const userAutoSelectId = getAutoSelectIdProp(items);\n        const autoSelectId = userAutoSelectId !== void 0 ? userAutoSelectId : (_a2 = getDefaultAutoSelectId(items)) != null ? _a2 : store.first();\n        autoSelectIdRef.current = autoSelectId;\n        store.move(autoSelectId != null ? autoSelectId : null);\n      } else {\n        const element = (_b2 = store.item(activeId || store.first())) == null ? void 0 : _b2.element;\n        if (element && \"scrollIntoView\" in element) {\n          element.scrollIntoView({ block: \"nearest\", inline: \"nearest\" });\n        }\n      }\n      return;\n    }, [\n      store,\n      open,\n      valueUpdated,\n      storeValue,\n      autoSelect,\n      resetValueOnSelect,\n      getAutoSelectIdProp,\n      items\n    ]);\n    useEffect(() => {\n      if (!inline) return;\n      const combobox = ref.current;\n      if (!combobox) return;\n      const elements = [combobox, contentElement].filter(\n        (value2) => !!value2\n      );\n      const onBlur2 = (event) => {\n        if (elements.every((el) => isFocusEventOutside(event, el))) {\n          store == null ? void 0 : store.setValue(value);\n        }\n      };\n      for (const element of elements) {\n        element.addEventListener(\"focusout\", onBlur2);\n      }\n      return () => {\n        for (const element of elements) {\n          element.removeEventListener(\"focusout\", onBlur2);\n        }\n      };\n    }, [inline, contentElement, store, value]);\n    const canShow = (event) => {\n      const currentTarget = event.currentTarget;\n      return currentTarget.value.length >= showMinLength;\n    };\n    const onChangeProp = props.onChange;\n    const showOnChangeProp = useBooleanEvent(showOnChange != null ? showOnChange : canShow);\n    const setValueOnChangeProp = useBooleanEvent(\n      // If the combobox is combined with tags, the value will be set by the tag\n      // input component.\n      setValueOnChange != null ? setValueOnChange : !store.tag\n    );\n    const onChange = useEvent((event) => {\n      onChangeProp == null ? void 0 : onChangeProp(event);\n      if (event.defaultPrevented) return;\n      if (!store) return;\n      const currentTarget = event.currentTarget;\n      const { value: value2, selectionStart, selectionEnd } = currentTarget;\n      const nativeEvent = event.nativeEvent;\n      canAutoSelectRef.current = true;\n      if (isInputEvent(nativeEvent)) {\n        if (nativeEvent.isComposing) {\n          canAutoSelectRef.current = false;\n          composingRef.current = true;\n        }\n        if (inline) {\n          const textInserted = nativeEvent.inputType === \"insertText\" || nativeEvent.inputType === \"insertCompositionText\";\n          const caretAtEnd = selectionStart === value2.length;\n          setCanInline(textInserted && caretAtEnd);\n        }\n      }\n      if (setValueOnChangeProp(event)) {\n        const isSameValue = value2 === store.getState().value;\n        store.setValue(value2);\n        queueMicrotask(() => {\n          setSelectionRange(currentTarget, selectionStart, selectionEnd);\n        });\n        if (inline && autoSelect && isSameValue) {\n          forceValueUpdate();\n        }\n      }\n      if (showOnChangeProp(event)) {\n        store.show();\n      }\n      if (!autoSelect || !canAutoSelectRef.current) {\n        store.setActiveId(null);\n      }\n    });\n    const onCompositionEndProp = props.onCompositionEnd;\n    const onCompositionEnd = useEvent((event) => {\n      canAutoSelectRef.current = true;\n      composingRef.current = false;\n      onCompositionEndProp == null ? void 0 : onCompositionEndProp(event);\n      if (event.defaultPrevented) return;\n      if (!autoSelect) return;\n      forceValueUpdate();\n    });\n    const onMouseDownProp = props.onMouseDown;\n    const blurActiveItemOnClickProp = useBooleanEvent(\n      blurActiveItemOnClick != null ? blurActiveItemOnClick : () => !!(store == null ? void 0 : store.getState().includesBaseElement)\n    );\n    const setValueOnClickProp = useBooleanEvent(setValueOnClick);\n    const showOnClickProp = useBooleanEvent(showOnClick != null ? showOnClick : canShow);\n    const onMouseDown = useEvent((event) => {\n      onMouseDownProp == null ? void 0 : onMouseDownProp(event);\n      if (event.defaultPrevented) return;\n      if (event.button) return;\n      if (event.ctrlKey) return;\n      if (!store) return;\n      if (blurActiveItemOnClickProp(event)) {\n        store.setActiveId(null);\n      }\n      if (setValueOnClickProp(event)) {\n        store.setValue(value);\n      }\n      if (showOnClickProp(event)) {\n        queueBeforeEvent(event.currentTarget, \"mouseup\", store.show);\n      }\n    });\n    const onKeyDownProp = props.onKeyDown;\n    const showOnKeyPressProp = useBooleanEvent(showOnKeyPress != null ? showOnKeyPress : canShow);\n    const onKeyDown = useEvent((event) => {\n      onKeyDownProp == null ? void 0 : onKeyDownProp(event);\n      if (!event.repeat) {\n        canAutoSelectRef.current = false;\n      }\n      if (event.defaultPrevented) return;\n      if (event.ctrlKey) return;\n      if (event.altKey) return;\n      if (event.shiftKey) return;\n      if (event.metaKey) return;\n      if (!store) return;\n      const { open: open2 } = store.getState();\n      if (open2) return;\n      if (event.key === \"ArrowUp\" || event.key === \"ArrowDown\") {\n        if (showOnKeyPressProp(event)) {\n          event.preventDefault();\n          store.show();\n        }\n      }\n    });\n    const onBlurProp = props.onBlur;\n    const onBlur = useEvent((event) => {\n      canAutoSelectRef.current = false;\n      onBlurProp == null ? void 0 : onBlurProp(event);\n      if (event.defaultPrevented) return;\n    });\n    const id = useId(props.id);\n    const ariaAutoComplete = isAriaAutoCompleteValue(autoComplete) ? autoComplete : void 0;\n    const isActiveItem = store.useState((state) => state.activeId === null);\n    props = __spreadProps(__spreadValues({\n      id,\n      role: \"combobox\",\n      \"aria-autocomplete\": ariaAutoComplete,\n      \"aria-haspopup\": getPopupRole(contentElement, \"listbox\"),\n      \"aria-expanded\": open,\n      \"aria-controls\": contentElement == null ? void 0 : contentElement.id,\n      \"data-active-item\": isActiveItem || void 0,\n      value\n    }, props), {\n      ref: useMergeRefs(ref, props.ref),\n      onChange,\n      onCompositionEnd,\n      onMouseDown,\n      onKeyDown,\n      onBlur\n    });\n    props = useComposite(__spreadProps(__spreadValues({\n      store,\n      focusable\n    }, props), {\n      // Enable inline autocomplete when the user moves from the combobox input\n      // to an item.\n      moveOnKeyPress: (event) => {\n        if (isFalsyBooleanCallback(moveOnKeyPress, event)) return false;\n        if (inline) setCanInline(true);\n        return true;\n      }\n    }));\n    props = usePopoverAnchor(__spreadValues({ store }, props));\n    return __spreadValues({ autoComplete: \"off\" }, props);\n  }\n);\nvar Combobox = forwardRef(function Combobox2(props) {\n  const htmlProps = useCombobox(props);\n  return createElement(TagName, htmlProps);\n});\nexport {\n  Combobox,\n  useCombobox\n};\n","\"use client\";\nimport {\n  useHovercardAnchor\n} from \"../__chunks/BYC7LY2E.js\";\nimport {\n  useTooltipProviderContext\n} from \"../__chunks/F4IYJ42G.js\";\nimport \"../__chunks/EM5CXX6A.js\";\nimport \"../__chunks/MTZPJQMC.js\";\nimport \"../__chunks/RS7LB2H4.js\";\nimport \"../__chunks/S6EF7IVO.js\";\nimport \"../__chunks/LVA2YJMS.js\";\nimport \"../__chunks/SWN3JYXT.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"../__chunks/LMDWO4NN.js\";\nimport {\n  useEvent\n} from \"../__chunks/ABQUS43J.js\";\nimport \"../__chunks/SK3NAZA3.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"../__chunks/3YLGPPWQ.js\";\n\n// src/tooltip/tooltip-anchor.tsx\nimport {\n  chain,\n  invariant,\n  isFalsyBooleanCallback\n} from \"@ariakit/core/utils/misc\";\nimport { createStore, sync } from \"@ariakit/core/utils/store\";\nimport { useEffect, useRef } from \"react\";\nvar TagName = \"div\";\nvar globalStore = createStore({\n  activeStore: null\n});\nfunction createRemoveStoreCallback(store) {\n  return () => {\n    const { activeStore } = globalStore.getState();\n    if (activeStore !== store) return;\n    globalStore.setState(\"activeStore\", null);\n  };\n}\nvar useTooltipAnchor = createHook(\n  function useTooltipAnchor2(_a) {\n    var _b = _a, { store, showOnHover = true } = _b, props = __objRest(_b, [\"store\", \"showOnHover\"]);\n    const context = useTooltipProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"TooltipAnchor must receive a `store` prop or be wrapped in a TooltipProvider component.\"\n    );\n    const canShowOnHoverRef = useRef(false);\n    useEffect(() => {\n      return sync(store, [\"mounted\"], (state) => {\n        if (state.mounted) return;\n        canShowOnHoverRef.current = false;\n      });\n    }, [store]);\n    useEffect(() => {\n      if (!store) return;\n      return chain(\n        // Immediately remove the current store from the global store when\n        // the component unmounts. This is useful, for example, to avoid\n        // showing tooltips immediately on serial tests.\n        createRemoveStoreCallback(store),\n        sync(store, [\"mounted\", \"skipTimeout\"], (state) => {\n          if (!store) return;\n          if (state.mounted) {\n            const { activeStore } = globalStore.getState();\n            if (activeStore !== store) {\n              activeStore == null ? void 0 : activeStore.hide();\n            }\n            return globalStore.setState(\"activeStore\", store);\n          }\n          const id = setTimeout(\n            createRemoveStoreCallback(store),\n            state.skipTimeout\n          );\n          return () => clearTimeout(id);\n        })\n      );\n    }, [store]);\n    const onMouseEnterProp = props.onMouseEnter;\n    const onMouseEnter = useEvent((event) => {\n      onMouseEnterProp == null ? void 0 : onMouseEnterProp(event);\n      canShowOnHoverRef.current = true;\n    });\n    const onFocusVisibleProp = props.onFocusVisible;\n    const onFocusVisible = useEvent((event) => {\n      onFocusVisibleProp == null ? void 0 : onFocusVisibleProp(event);\n      if (event.defaultPrevented) return;\n      store == null ? void 0 : store.setAnchorElement(event.currentTarget);\n      store == null ? void 0 : store.show();\n    });\n    const onBlurProp = props.onBlur;\n    const onBlur = useEvent((event) => {\n      onBlurProp == null ? void 0 : onBlurProp(event);\n      if (event.defaultPrevented) return;\n      const { activeStore } = globalStore.getState();\n      canShowOnHoverRef.current = false;\n      if (activeStore === store) {\n        globalStore.setState(\"activeStore\", null);\n      }\n    });\n    const type = store.useState(\"type\");\n    const contentId = store.useState((state) => {\n      var _a2;\n      return (_a2 = state.contentElement) == null ? void 0 : _a2.id;\n    });\n    props = __spreadProps(__spreadValues({\n      \"aria-labelledby\": type === \"label\" ? contentId : void 0\n    }, props), {\n      onMouseEnter,\n      onFocusVisible,\n      onBlur\n    });\n    props = useHovercardAnchor(__spreadValues({\n      store,\n      showOnHover(event) {\n        if (!canShowOnHoverRef.current) return false;\n        if (isFalsyBooleanCallback(showOnHover, event)) return false;\n        const { activeStore } = globalStore.getState();\n        if (!activeStore) return true;\n        store == null ? void 0 : store.show();\n        return false;\n      }\n    }, props));\n    return props;\n  }\n);\nvar TooltipAnchor = forwardRef(function TooltipAnchor2(props) {\n  const htmlProps = useTooltipAnchor(props);\n  return createElement(TagName, htmlProps);\n});\nexport {\n  TooltipAnchor,\n  useTooltipAnchor\n};\n","\"use client\";\n\n// src/popover/popover-arrow-path.ts\nvar POPOVER_ARROW_PATH = \"M23,27.8c1.1,1.2,3.4,2.2,5,2.2h2H0h2c1.7,0,3.9-1,5-2.2l6.6-7.2c0.7-0.8,2-0.8,2.7,0L23,27.8L23,27.8z\";\n\nexport {\n  POPOVER_ARROW_PATH\n};\n","\"use client\";\nimport {\n  POPOVER_ARROW_PATH\n} from \"./QFL5V2DO.js\";\nimport {\n  usePopoverContext\n} from \"./MTZPJQMC.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./LMDWO4NN.js\";\nimport {\n  useMergeRefs,\n  useSafeLayoutEffect\n} from \"./ABQUS43J.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./3YLGPPWQ.js\";\n\n// src/popover/popover-arrow.tsx\nimport { getWindow } from \"@ariakit/core/utils/dom\";\nimport { invariant, removeUndefinedValues } from \"@ariakit/core/utils/misc\";\nimport { useMemo, useState } from \"react\";\nimport { jsx, jsxs } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nvar defaultSize = 30;\nvar halfDefaultSize = defaultSize / 2;\nvar rotateMap = {\n  top: `rotate(180 ${halfDefaultSize} ${halfDefaultSize})`,\n  right: `rotate(-90 ${halfDefaultSize} ${halfDefaultSize})`,\n  bottom: `rotate(0 ${halfDefaultSize} ${halfDefaultSize})`,\n  left: `rotate(90 ${halfDefaultSize} ${halfDefaultSize})`\n};\nfunction useComputedStyle(store) {\n  const [style, setStyle] = useState();\n  const contentElement = store.useState(\"contentElement\");\n  useSafeLayoutEffect(() => {\n    if (!contentElement) return;\n    const win = getWindow(contentElement);\n    const computedStyle = win.getComputedStyle(contentElement);\n    setStyle(computedStyle);\n  }, [contentElement]);\n  return style;\n}\nvar usePopoverArrow = createHook(\n  function usePopoverArrow2(_a) {\n    var _b = _a, { store, size = defaultSize } = _b, props = __objRest(_b, [\"store\", \"size\"]);\n    const context = usePopoverContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"PopoverArrow must be wrapped in a Popover component.\"\n    );\n    const dir = store.useState(\n      (state) => state.currentPlacement.split(\"-\")[0]\n    );\n    const style = useComputedStyle(store);\n    const fill = (style == null ? void 0 : style.getPropertyValue(\"background-color\")) || \"none\";\n    const stroke = (style == null ? void 0 : style.getPropertyValue(`border-${dir}-color`)) || \"none\";\n    const borderWidth = (style == null ? void 0 : style.getPropertyValue(`border-${dir}-width`)) || \"0px\";\n    const strokeWidth = Number.parseInt(borderWidth) * 2 * (defaultSize / size);\n    const transform = rotateMap[dir];\n    const children = useMemo(\n      () => /* @__PURE__ */ jsx(\"svg\", { display: \"block\", viewBox: \"0 0 30 30\", children: /* @__PURE__ */ jsxs(\"g\", { transform, children: [\n        /* @__PURE__ */ jsx(\"path\", { fill: \"none\", d: POPOVER_ARROW_PATH }),\n        /* @__PURE__ */ jsx(\"path\", { stroke: \"none\", d: POPOVER_ARROW_PATH })\n      ] }) }),\n      [transform]\n    );\n    props = __spreadProps(__spreadValues({\n      children,\n      \"aria-hidden\": true\n    }, props), {\n      ref: useMergeRefs(store.setArrowElement, props.ref),\n      style: __spreadValues({\n        // server side rendering\n        position: \"absolute\",\n        fontSize: size,\n        width: \"1em\",\n        height: \"1em\",\n        pointerEvents: \"none\",\n        fill,\n        stroke,\n        strokeWidth\n      }, props.style)\n    });\n    return removeUndefinedValues(props);\n  }\n);\nvar PopoverArrow = forwardRef(function PopoverArrow2(props) {\n  const htmlProps = usePopoverArrow(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport {\n  usePopoverArrow,\n  PopoverArrow\n};\n","\"use client\";\nimport {\n  usePopoverArrow\n} from \"../__chunks/IS6J7QCK.js\";\nimport \"../__chunks/QFL5V2DO.js\";\nimport {\n  useTooltipContext\n} from \"../__chunks/F4IYJ42G.js\";\nimport \"../__chunks/EM5CXX6A.js\";\nimport \"../__chunks/MTZPJQMC.js\";\nimport \"../__chunks/RS7LB2H4.js\";\nimport \"../__chunks/S6EF7IVO.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"../__chunks/LMDWO4NN.js\";\nimport \"../__chunks/ABQUS43J.js\";\nimport \"../__chunks/SK3NAZA3.js\";\nimport {\n  __objRest,\n  __spreadValues\n} from \"../__chunks/3YLGPPWQ.js\";\n\n// src/tooltip/tooltip-arrow.tsx\nimport { invariant } from \"@ariakit/core/utils/misc\";\nvar TagName = \"div\";\nvar useTooltipArrow = createHook(\n  function useTooltipArrow2(_a) {\n    var _b = _a, { store, size = 16 } = _b, props = __objRest(_b, [\"store\", \"size\"]);\n    const context = useTooltipContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"TooltipArrow must be wrapped in a Tooltip component.\"\n    );\n    props = usePopoverArrow(__spreadValues({ store, size }, props));\n    return props;\n  }\n);\nvar TooltipArrow = forwardRef(function TooltipArrow2(props) {\n  const htmlProps = useTooltipArrow(props);\n  return createElement(TagName, htmlProps);\n});\nexport {\n  TooltipArrow,\n  useTooltipArrow\n};\n","\"use client\";\nimport {\n  TooltipContextProvider\n} from \"../__chunks/F4IYJ42G.js\";\nimport \"../__chunks/EM5CXX6A.js\";\nimport \"../__chunks/MTZPJQMC.js\";\nimport \"../__chunks/RS7LB2H4.js\";\nimport \"../__chunks/S6EF7IVO.js\";\nimport \"../__chunks/LMDWO4NN.js\";\nimport {\n  useTooltipStore\n} from \"../__chunks/YTDK2NGG.js\";\nimport \"../__chunks/FTXTWCCT.js\";\nimport \"../__chunks/O2PQ2652.js\";\nimport \"../__chunks/BM6PGYQY.js\";\nimport \"../__chunks/WYCIER3C.js\";\nimport \"../__chunks/YV4JVR4I.js\";\nimport \"../__chunks/ABQUS43J.js\";\nimport \"../__chunks/SK3NAZA3.js\";\nimport \"../__chunks/3YLGPPWQ.js\";\n\n// src/tooltip/tooltip-provider.tsx\nimport { jsx } from \"react/jsx-runtime\";\nfunction TooltipProvider(props = {}) {\n  const store = useTooltipStore(props);\n  return /* @__PURE__ */ jsx(TooltipContextProvider, { value: store, children: props.children });\n}\nexport {\n  TooltipProvider\n};\n","\"use client\";\nimport {\n  useHovercard\n} from \"../__chunks/KQKDTOT4.js\";\nimport \"../__chunks/X7QOZUD3.js\";\nimport \"../__chunks/T6C2RYFI.js\";\nimport {\n  createDialogComponent\n} from \"../__chunks/JC64G2H7.js\";\nimport \"../__chunks/63FEHJZV.js\";\nimport \"../__chunks/KZAQFFOU.js\";\nimport \"../__chunks/IGR4SXG2.js\";\nimport \"../__chunks/ESSM74HH.js\";\nimport \"../__chunks/BGQ3KQ5M.js\";\nimport \"../__chunks/YKJECYU7.js\";\nimport \"../__chunks/TOU75OXH.js\";\nimport \"../__chunks/WBDYNH73.js\";\nimport \"../__chunks/2PGBN2Y4.js\";\nimport \"../__chunks/63XF7ACK.js\";\nimport \"../__chunks/HLTQOHKZ.js\";\nimport \"../__chunks/677M2CI3.js\";\nimport \"../__chunks/6GXEOXGT.js\";\nimport \"../__chunks/AOUGVQZ3.js\";\nimport \"../__chunks/K2ZF5NU7.js\";\nimport \"../__chunks/ZWYATQFU.js\";\nimport \"../__chunks/5M6RIVE2.js\";\nimport \"../__chunks/O37CNYMR.js\";\nimport \"../__chunks/W3VI7GFU.js\";\nimport \"../__chunks/AOQQTIBO.js\";\nimport \"../__chunks/CZ4GFWYL.js\";\nimport \"../__chunks/VGCJ63VH.js\";\nimport \"../__chunks/XL7CSKGW.js\";\nimport {\n  TooltipScopedContextProvider,\n  useTooltipProviderContext\n} from \"../__chunks/F4IYJ42G.js\";\nimport \"../__chunks/EM5CXX6A.js\";\nimport \"../__chunks/MTZPJQMC.js\";\nimport \"../__chunks/RS7LB2H4.js\";\nimport \"../__chunks/S6EF7IVO.js\";\nimport \"../__chunks/LVA2YJMS.js\";\nimport \"../__chunks/SWN3JYXT.js\";\nimport \"../__chunks/XX67R432.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"../__chunks/LMDWO4NN.js\";\nimport \"../__chunks/BM6PGYQY.js\";\nimport \"../__chunks/WYCIER3C.js\";\nimport \"../__chunks/YV4JVR4I.js\";\nimport {\n  useWrapElement\n} from \"../__chunks/ABQUS43J.js\";\nimport \"../__chunks/SK3NAZA3.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"../__chunks/3YLGPPWQ.js\";\n\n// src/tooltip/tooltip.tsx\nimport { contains } from \"@ariakit/core/utils/dom\";\nimport { invariant, isFalsyBooleanCallback } from \"@ariakit/core/utils/misc\";\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nvar useTooltip = createHook(\n  function useTooltip2(_a) {\n    var _b = _a, {\n      store,\n      portal = true,\n      gutter = 8,\n      preserveTabOrder = false,\n      hideOnHoverOutside = true,\n      hideOnInteractOutside = true\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"portal\",\n      \"gutter\",\n      \"preserveTabOrder\",\n      \"hideOnHoverOutside\",\n      \"hideOnInteractOutside\"\n    ]);\n    const context = useTooltipProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"Tooltip must receive a `store` prop or be wrapped in a TooltipProvider component.\"\n    );\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(TooltipScopedContextProvider, { value: store, children: element }),\n      [store]\n    );\n    const role = store.useState(\n      (state) => state.type === \"description\" ? \"tooltip\" : \"none\"\n    );\n    props = __spreadValues({ role }, props);\n    props = useHovercard(__spreadProps(__spreadValues({}, props), {\n      store,\n      portal,\n      gutter,\n      preserveTabOrder,\n      hideOnHoverOutside(event) {\n        if (isFalsyBooleanCallback(hideOnHoverOutside, event)) return false;\n        const anchorElement = store == null ? void 0 : store.getState().anchorElement;\n        if (!anchorElement) return true;\n        if (\"focusVisible\" in anchorElement.dataset) return false;\n        return true;\n      },\n      hideOnInteractOutside: (event) => {\n        if (isFalsyBooleanCallback(hideOnInteractOutside, event)) return false;\n        const anchorElement = store == null ? void 0 : store.getState().anchorElement;\n        if (!anchorElement) return true;\n        if (contains(anchorElement, event.target)) return false;\n        return true;\n      }\n    }));\n    return props;\n  }\n);\nvar Tooltip = createDialogComponent(\n  forwardRef(function Tooltip2(props) {\n    const htmlProps = useTooltip(props);\n    return createElement(TagName, htmlProps);\n  }),\n  useTooltipProviderContext\n);\nexport {\n  Tooltip,\n  useTooltip\n};\n","/**\n * Custom positioning reference element.\n * @see https://floating-ui.com/docs/virtual-elements\n */\n\nconst sides = ['top', 'right', 'bottom', 'left'];\nconst alignments = ['start', 'end'];\nconst placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + \"-\" + alignments[0], side + \"-\" + alignments[1]), []);\nconst min = Math.min;\nconst max = Math.max;\nconst round = Math.round;\nconst floor = Math.floor;\nconst createCoords = v => ({\n  x: v,\n  y: v\n});\nconst oppositeSideMap = {\n  left: 'right',\n  right: 'left',\n  bottom: 'top',\n  top: 'bottom'\n};\nconst oppositeAlignmentMap = {\n  start: 'end',\n  end: 'start'\n};\nfunction clamp(start, value, end) {\n  return max(start, min(value, end));\n}\nfunction evaluate(value, param) {\n  return typeof value === 'function' ? value(param) : value;\n}\nfunction getSide(placement) {\n  return placement.split('-')[0];\n}\nfunction getAlignment(placement) {\n  return placement.split('-')[1];\n}\nfunction getOppositeAxis(axis) {\n  return axis === 'x' ? 'y' : 'x';\n}\nfunction getAxisLength(axis) {\n  return axis === 'y' ? 'height' : 'width';\n}\nfunction getSideAxis(placement) {\n  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';\n}\nfunction getAlignmentAxis(placement) {\n  return getOppositeAxis(getSideAxis(placement));\n}\nfunction getAlignmentSides(placement, rects, rtl) {\n  if (rtl === void 0) {\n    rtl = false;\n  }\n  const alignment = getAlignment(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const length = getAxisLength(alignmentAxis);\n  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';\n  if (rects.reference[length] > rects.floating[length]) {\n    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);\n  }\n  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];\n}\nfunction getExpandedPlacements(placement) {\n  const oppositePlacement = getOppositePlacement(placement);\n  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];\n}\nfunction getOppositeAlignmentPlacement(placement) {\n  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);\n}\nfunction getSideList(side, isStart, rtl) {\n  const lr = ['left', 'right'];\n  const rl = ['right', 'left'];\n  const tb = ['top', 'bottom'];\n  const bt = ['bottom', 'top'];\n  switch (side) {\n    case 'top':\n    case 'bottom':\n      if (rtl) return isStart ? rl : lr;\n      return isStart ? lr : rl;\n    case 'left':\n    case 'right':\n      return isStart ? tb : bt;\n    default:\n      return [];\n  }\n}\nfunction getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {\n  const alignment = getAlignment(placement);\n  let list = getSideList(getSide(placement), direction === 'start', rtl);\n  if (alignment) {\n    list = list.map(side => side + \"-\" + alignment);\n    if (flipAlignment) {\n      list = list.concat(list.map(getOppositeAlignmentPlacement));\n    }\n  }\n  return list;\n}\nfunction getOppositePlacement(placement) {\n  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);\n}\nfunction expandPaddingObject(padding) {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0,\n    ...padding\n  };\n}\nfunction getPaddingObject(padding) {\n  return typeof padding !== 'number' ? expandPaddingObject(padding) : {\n    top: padding,\n    right: padding,\n    bottom: padding,\n    left: padding\n  };\n}\nfunction rectToClientRect(rect) {\n  const {\n    x,\n    y,\n    width,\n    height\n  } = rect;\n  return {\n    width,\n    height,\n    top: y,\n    left: x,\n    right: x + width,\n    bottom: y + height,\n    x,\n    y\n  };\n}\n\nexport { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };\n","import { getSideAxis, getAlignmentAxis, getAxisLength, getSide, getAlignment, evaluate, getPaddingObject, rectToClientRect, min, clamp, placements, getAlignmentSides, getOppositeAlignmentPlacement, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, sides, max, getOppositeAxis } from '@floating-ui/utils';\nexport { rectToClientRect } from '@floating-ui/utils';\n\nfunction computeCoordsFromPlacement(_ref, placement, rtl) {\n  let {\n    reference,\n    floating\n  } = _ref;\n  const sideAxis = getSideAxis(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const alignLength = getAxisLength(alignmentAxis);\n  const side = getSide(placement);\n  const isVertical = sideAxis === 'y';\n  const commonX = reference.x + reference.width / 2 - floating.width / 2;\n  const commonY = reference.y + reference.height / 2 - floating.height / 2;\n  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;\n  let coords;\n  switch (side) {\n    case 'top':\n      coords = {\n        x: commonX,\n        y: reference.y - floating.height\n      };\n      break;\n    case 'bottom':\n      coords = {\n        x: commonX,\n        y: reference.y + reference.height\n      };\n      break;\n    case 'right':\n      coords = {\n        x: reference.x + reference.width,\n        y: commonY\n      };\n      break;\n    case 'left':\n      coords = {\n        x: reference.x - floating.width,\n        y: commonY\n      };\n      break;\n    default:\n      coords = {\n        x: reference.x,\n        y: reference.y\n      };\n  }\n  switch (getAlignment(placement)) {\n    case 'start':\n      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n    case 'end':\n      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n  }\n  return coords;\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n *\n * This export does not have any `platform` interface logic. You will need to\n * write one for the platform you are using Floating UI with.\n */\nconst computePosition = async (reference, floating, config) => {\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform\n  } = config;\n  const validMiddleware = middleware.filter(Boolean);\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));\n  let rects = await platform.getElementRects({\n    reference,\n    floating,\n    strategy\n  });\n  let {\n    x,\n    y\n  } = computeCoordsFromPlacement(rects, placement, rtl);\n  let statefulPlacement = placement;\n  let middlewareData = {};\n  let resetCount = 0;\n  for (let i = 0; i < validMiddleware.length; i++) {\n    const {\n      name,\n      fn\n    } = validMiddleware[i];\n    const {\n      x: nextX,\n      y: nextY,\n      data,\n      reset\n    } = await fn({\n      x,\n      y,\n      initialPlacement: placement,\n      placement: statefulPlacement,\n      strategy,\n      middlewareData,\n      rects,\n      platform,\n      elements: {\n        reference,\n        floating\n      }\n    });\n    x = nextX != null ? nextX : x;\n    y = nextY != null ? nextY : y;\n    middlewareData = {\n      ...middlewareData,\n      [name]: {\n        ...middlewareData[name],\n        ...data\n      }\n    };\n    if (reset && resetCount <= 50) {\n      resetCount++;\n      if (typeof reset === 'object') {\n        if (reset.placement) {\n          statefulPlacement = reset.placement;\n        }\n        if (reset.rects) {\n          rects = reset.rects === true ? await platform.getElementRects({\n            reference,\n            floating,\n            strategy\n          }) : reset.rects;\n        }\n        ({\n          x,\n          y\n        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));\n      }\n      i = -1;\n    }\n  }\n  return {\n    x,\n    y,\n    placement: statefulPlacement,\n    strategy,\n    middlewareData\n  };\n};\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nasync function detectOverflow(state, options) {\n  var _await$platform$isEle;\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    x,\n    y,\n    platform,\n    rects,\n    elements,\n    strategy\n  } = state;\n  const {\n    boundary = 'clippingAncestors',\n    rootBoundary = 'viewport',\n    elementContext = 'floating',\n    altBoundary = false,\n    padding = 0\n  } = evaluate(options, state);\n  const paddingObject = getPaddingObject(padding);\n  const altContext = elementContext === 'floating' ? 'reference' : 'floating';\n  const element = elements[altBoundary ? altContext : elementContext];\n  const clippingClientRect = rectToClientRect(await platform.getClippingRect({\n    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),\n    boundary,\n    rootBoundary,\n    strategy\n  }));\n  const rect = elementContext === 'floating' ? {\n    x,\n    y,\n    width: rects.floating.width,\n    height: rects.floating.height\n  } : rects.reference;\n  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));\n  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {\n    x: 1,\n    y: 1\n  } : {\n    x: 1,\n    y: 1\n  };\n  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  }) : rect);\n  return {\n    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,\n    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,\n    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,\n    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x\n  };\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => ({\n  name: 'arrow',\n  options,\n  async fn(state) {\n    const {\n      x,\n      y,\n      placement,\n      rects,\n      platform,\n      elements,\n      middlewareData\n    } = state;\n    // Since `element` is required, we don't Partial<> the type.\n    const {\n      element,\n      padding = 0\n    } = evaluate(options, state) || {};\n    if (element == null) {\n      return {};\n    }\n    const paddingObject = getPaddingObject(padding);\n    const coords = {\n      x,\n      y\n    };\n    const axis = getAlignmentAxis(placement);\n    const length = getAxisLength(axis);\n    const arrowDimensions = await platform.getDimensions(element);\n    const isYAxis = axis === 'y';\n    const minProp = isYAxis ? 'top' : 'left';\n    const maxProp = isYAxis ? 'bottom' : 'right';\n    const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';\n    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];\n    const startDiff = coords[axis] - rects.reference[axis];\n    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));\n    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;\n\n    // DOM platform can return `window` as the `offsetParent`.\n    if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {\n      clientSize = elements.floating[clientProp] || rects.floating[length];\n    }\n    const centerToReference = endDiff / 2 - startDiff / 2;\n\n    // If the padding is large enough that it causes the arrow to no longer be\n    // centered, modify the padding so that it is centered.\n    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;\n    const minPadding = min(paddingObject[minProp], largestPossiblePadding);\n    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);\n\n    // Make sure the arrow doesn't overflow the floating element if the center\n    // point is outside the floating element's bounds.\n    const min$1 = minPadding;\n    const max = clientSize - arrowDimensions[length] - maxPadding;\n    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;\n    const offset = clamp(min$1, center, max);\n\n    // If the reference is small enough that the arrow's padding causes it to\n    // to point to nothing for an aligned placement, adjust the offset of the\n    // floating element itself. To ensure `shift()` continues to take action,\n    // a single reset is performed when this is true.\n    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;\n    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;\n    return {\n      [axis]: coords[axis] + alignmentOffset,\n      data: {\n        [axis]: offset,\n        centerOffset: center - offset - alignmentOffset,\n        ...(shouldAddOffset && {\n          alignmentOffset\n        })\n      },\n      reset: shouldAddOffset\n    };\n  }\n});\n\nfunction getPlacementList(alignment, autoAlignment, allowedPlacements) {\n  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);\n  return allowedPlacementsSortedByAlignment.filter(placement => {\n    if (alignment) {\n      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);\n    }\n    return true;\n  });\n}\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'autoPlacement',\n    options,\n    async fn(state) {\n      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;\n      const {\n        rects,\n        middlewareData,\n        placement,\n        platform,\n        elements\n      } = state;\n      const {\n        crossAxis = false,\n        alignment,\n        allowedPlacements = placements,\n        autoAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;\n      const currentPlacement = placements$1[currentIndex];\n      if (currentPlacement == null) {\n        return {};\n      }\n      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));\n\n      // Make `computeCoords` start from the right place.\n      if (placement !== currentPlacement) {\n        return {\n          reset: {\n            placement: placements$1[0]\n          }\n        };\n      }\n      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];\n      const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {\n        placement: currentPlacement,\n        overflows: currentOverflows\n      }];\n      const nextPlacement = placements$1[currentIndex + 1];\n\n      // There are more placements to check.\n      if (nextPlacement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: nextPlacement\n          }\n        };\n      }\n      const placementsSortedByMostSpace = allOverflows.map(d => {\n        const alignment = getAlignment(d.placement);\n        return [d.placement, alignment && crossAxis ?\n        // Check along the mainAxis and main crossAxis side.\n        d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :\n        // Check only the mainAxis.\n        d.overflows[0], d.overflows];\n      }).sort((a, b) => a[1] - b[1]);\n      const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,\n      // Aligned placements should not check their opposite crossAxis\n      // side.\n      getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));\n      const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];\n      if (resetPlacement !== placement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: resetPlacement\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'flip',\n    options,\n    async fn(state) {\n      var _middlewareData$arrow, _middlewareData$flip;\n      const {\n        placement,\n        middlewareData,\n        rects,\n        initialPlacement,\n        platform,\n        elements\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true,\n        fallbackPlacements: specifiedFallbackPlacements,\n        fallbackStrategy = 'bestFit',\n        fallbackAxisSideDirection = 'none',\n        flipAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n\n      // If a reset by the arrow was caused due to an alignment offset being\n      // added, we should skip any logic now since `flip()` has already done its\n      // work.\n      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643\n      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      const side = getSide(placement);\n      const initialSideAxis = getSideAxis(initialPlacement);\n      const isBasePlacement = getSide(initialPlacement) === initialPlacement;\n      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));\n      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';\n      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {\n        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));\n      }\n      const placements = [initialPlacement, ...fallbackPlacements];\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const overflows = [];\n      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];\n      if (checkMainAxis) {\n        overflows.push(overflow[side]);\n      }\n      if (checkCrossAxis) {\n        const sides = getAlignmentSides(placement, rects, rtl);\n        overflows.push(overflow[sides[0]], overflow[sides[1]]);\n      }\n      overflowsData = [...overflowsData, {\n        placement,\n        overflows\n      }];\n\n      // One or more sides is overflowing.\n      if (!overflows.every(side => side <= 0)) {\n        var _middlewareData$flip2, _overflowsData$filter;\n        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;\n        const nextPlacement = placements[nextIndex];\n        if (nextPlacement) {\n          // Try next placement and re-run the lifecycle.\n          return {\n            data: {\n              index: nextIndex,\n              overflows: overflowsData\n            },\n            reset: {\n              placement: nextPlacement\n            }\n          };\n        }\n\n        // First, find the candidates that fit on the mainAxis side of overflow,\n        // then find the placement that fits the best on the main crossAxis side.\n        let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;\n\n        // Otherwise fallback.\n        if (!resetPlacement) {\n          switch (fallbackStrategy) {\n            case 'bestFit':\n              {\n                var _overflowsData$filter2;\n                const placement = (_overflowsData$filter2 = overflowsData.filter(d => {\n                  if (hasFallbackAxisSideDirection) {\n                    const currentSideAxis = getSideAxis(d.placement);\n                    return currentSideAxis === initialSideAxis ||\n                    // Create a bias to the `y` side axis due to horizontal\n                    // reading directions favoring greater width.\n                    currentSideAxis === 'y';\n                  }\n                  return true;\n                }).map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];\n                if (placement) {\n                  resetPlacement = placement;\n                }\n                break;\n              }\n            case 'initialPlacement':\n              resetPlacement = initialPlacement;\n              break;\n          }\n        }\n        if (placement !== resetPlacement) {\n          return {\n            reset: {\n              placement: resetPlacement\n            }\n          };\n        }\n      }\n      return {};\n    }\n  };\n};\n\nfunction getSideOffsets(overflow, rect) {\n  return {\n    top: overflow.top - rect.height,\n    right: overflow.right - rect.width,\n    bottom: overflow.bottom - rect.height,\n    left: overflow.left - rect.width\n  };\n}\nfunction isAnySideFullyClipped(overflow) {\n  return sides.some(side => overflow[side] >= 0);\n}\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'hide',\n    options,\n    async fn(state) {\n      const {\n        rects\n      } = state;\n      const {\n        strategy = 'referenceHidden',\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      switch (strategy) {\n        case 'referenceHidden':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              elementContext: 'reference'\n            });\n            const offsets = getSideOffsets(overflow, rects.reference);\n            return {\n              data: {\n                referenceHiddenOffsets: offsets,\n                referenceHidden: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        case 'escaped':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              altBoundary: true\n            });\n            const offsets = getSideOffsets(overflow, rects.floating);\n            return {\n              data: {\n                escapedOffsets: offsets,\n                escaped: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        default:\n          {\n            return {};\n          }\n      }\n    }\n  };\n};\n\nfunction getBoundingRect(rects) {\n  const minX = min(...rects.map(rect => rect.left));\n  const minY = min(...rects.map(rect => rect.top));\n  const maxX = max(...rects.map(rect => rect.right));\n  const maxY = max(...rects.map(rect => rect.bottom));\n  return {\n    x: minX,\n    y: minY,\n    width: maxX - minX,\n    height: maxY - minY\n  };\n}\nfunction getRectsByLine(rects) {\n  const sortedRects = rects.slice().sort((a, b) => a.y - b.y);\n  const groups = [];\n  let prevRect = null;\n  for (let i = 0; i < sortedRects.length; i++) {\n    const rect = sortedRects[i];\n    if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {\n      groups.push([rect]);\n    } else {\n      groups[groups.length - 1].push(rect);\n    }\n    prevRect = rect;\n  }\n  return groups.map(rect => rectToClientRect(getBoundingRect(rect)));\n}\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'inline',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        elements,\n        rects,\n        platform,\n        strategy\n      } = state;\n      // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a\n      // ClientRect's bounds, despite the event listener being triggered. A\n      // padding of 2 seems to handle this issue.\n      const {\n        padding = 2,\n        x,\n        y\n      } = evaluate(options, state);\n      const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);\n      const clientRects = getRectsByLine(nativeClientRects);\n      const fallback = rectToClientRect(getBoundingRect(nativeClientRects));\n      const paddingObject = getPaddingObject(padding);\n      function getBoundingClientRect() {\n        // There are two rects and they are disjoined.\n        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {\n          // Find the first rect in which the point is fully inside.\n          return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;\n        }\n\n        // There are 2 or more connected rects.\n        if (clientRects.length >= 2) {\n          if (getSideAxis(placement) === 'y') {\n            const firstRect = clientRects[0];\n            const lastRect = clientRects[clientRects.length - 1];\n            const isTop = getSide(placement) === 'top';\n            const top = firstRect.top;\n            const bottom = lastRect.bottom;\n            const left = isTop ? firstRect.left : lastRect.left;\n            const right = isTop ? firstRect.right : lastRect.right;\n            const width = right - left;\n            const height = bottom - top;\n            return {\n              top,\n              bottom,\n              left,\n              right,\n              width,\n              height,\n              x: left,\n              y: top\n            };\n          }\n          const isLeftSide = getSide(placement) === 'left';\n          const maxRight = max(...clientRects.map(rect => rect.right));\n          const minLeft = min(...clientRects.map(rect => rect.left));\n          const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);\n          const top = measureRects[0].top;\n          const bottom = measureRects[measureRects.length - 1].bottom;\n          const left = minLeft;\n          const right = maxRight;\n          const width = right - left;\n          const height = bottom - top;\n          return {\n            top,\n            bottom,\n            left,\n            right,\n            width,\n            height,\n            x: left,\n            y: top\n          };\n        }\n        return fallback;\n      }\n      const resetRects = await platform.getElementRects({\n        reference: {\n          getBoundingClientRect\n        },\n        floating: elements.floating,\n        strategy\n      });\n      if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {\n        return {\n          reset: {\n            rects: resetRects\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n// For type backwards-compatibility, the `OffsetOptions` type was also\n// Derivable.\n\nasync function convertValueToCoords(state, options) {\n  const {\n    placement,\n    platform,\n    elements\n  } = state;\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n  const side = getSide(placement);\n  const alignment = getAlignment(placement);\n  const isVertical = getSideAxis(placement) === 'y';\n  const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;\n  const crossAxisMulti = rtl && isVertical ? -1 : 1;\n  const rawValue = evaluate(options, state);\n\n  // eslint-disable-next-line prefer-const\n  let {\n    mainAxis,\n    crossAxis,\n    alignmentAxis\n  } = typeof rawValue === 'number' ? {\n    mainAxis: rawValue,\n    crossAxis: 0,\n    alignmentAxis: null\n  } : {\n    mainAxis: 0,\n    crossAxis: 0,\n    alignmentAxis: null,\n    ...rawValue\n  };\n  if (alignment && typeof alignmentAxis === 'number') {\n    crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;\n  }\n  return isVertical ? {\n    x: crossAxis * crossAxisMulti,\n    y: mainAxis * mainAxisMulti\n  } : {\n    x: mainAxis * mainAxisMulti,\n    y: crossAxis * crossAxisMulti\n  };\n}\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = function (options) {\n  if (options === void 0) {\n    options = 0;\n  }\n  return {\n    name: 'offset',\n    options,\n    async fn(state) {\n      var _middlewareData$offse, _middlewareData$arrow;\n      const {\n        x,\n        y,\n        placement,\n        middlewareData\n      } = state;\n      const diffCoords = await convertValueToCoords(state, options);\n\n      // If the placement is the same and the arrow caused an alignment offset\n      // then we don't need to change the positioning coordinates.\n      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      return {\n        x: x + diffCoords.x,\n        y: y + diffCoords.y,\n        data: {\n          ...diffCoords,\n          placement\n        }\n      };\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'shift',\n    options,\n    async fn(state) {\n      const {\n        x,\n        y,\n        placement\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = false,\n        limiter = {\n          fn: _ref => {\n            let {\n              x,\n              y\n            } = _ref;\n            return {\n              x,\n              y\n            };\n          }\n        },\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const crossAxis = getSideAxis(getSide(placement));\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      if (checkMainAxis) {\n        const minSide = mainAxis === 'y' ? 'top' : 'left';\n        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';\n        const min = mainAxisCoord + overflow[minSide];\n        const max = mainAxisCoord - overflow[maxSide];\n        mainAxisCoord = clamp(min, mainAxisCoord, max);\n      }\n      if (checkCrossAxis) {\n        const minSide = crossAxis === 'y' ? 'top' : 'left';\n        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';\n        const min = crossAxisCoord + overflow[minSide];\n        const max = crossAxisCoord - overflow[maxSide];\n        crossAxisCoord = clamp(min, crossAxisCoord, max);\n      }\n      const limitedCoords = limiter.fn({\n        ...state,\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      });\n      return {\n        ...limitedCoords,\n        data: {\n          x: limitedCoords.x - x,\n          y: limitedCoords.y - y\n        }\n      };\n    }\n  };\n};\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    options,\n    fn(state) {\n      const {\n        x,\n        y,\n        placement,\n        rects,\n        middlewareData\n      } = state;\n      const {\n        offset = 0,\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const crossAxis = getSideAxis(placement);\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      const rawOffset = evaluate(offset, state);\n      const computedOffset = typeof rawOffset === 'number' ? {\n        mainAxis: rawOffset,\n        crossAxis: 0\n      } : {\n        mainAxis: 0,\n        crossAxis: 0,\n        ...rawOffset\n      };\n      if (checkMainAxis) {\n        const len = mainAxis === 'y' ? 'height' : 'width';\n        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;\n        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;\n        if (mainAxisCoord < limitMin) {\n          mainAxisCoord = limitMin;\n        } else if (mainAxisCoord > limitMax) {\n          mainAxisCoord = limitMax;\n        }\n      }\n      if (checkCrossAxis) {\n        var _middlewareData$offse, _middlewareData$offse2;\n        const len = mainAxis === 'y' ? 'width' : 'height';\n        const isOriginSide = ['top', 'left'].includes(getSide(placement));\n        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);\n        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);\n        if (crossAxisCoord < limitMin) {\n          crossAxisCoord = limitMin;\n        } else if (crossAxisCoord > limitMax) {\n          crossAxisCoord = limitMax;\n        }\n      }\n      return {\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      };\n    }\n  };\n};\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'size',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        rects,\n        platform,\n        elements\n      } = state;\n      const {\n        apply = () => {},\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const side = getSide(placement);\n      const alignment = getAlignment(placement);\n      const isYAxis = getSideAxis(placement) === 'y';\n      const {\n        width,\n        height\n      } = rects.floating;\n      let heightSide;\n      let widthSide;\n      if (side === 'top' || side === 'bottom') {\n        heightSide = side;\n        widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';\n      } else {\n        widthSide = side;\n        heightSide = alignment === 'end' ? 'top' : 'bottom';\n      }\n      const maximumClippingHeight = height - overflow.top - overflow.bottom;\n      const maximumClippingWidth = width - overflow.left - overflow.right;\n      const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);\n      const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);\n      const noShift = !state.middlewareData.shift;\n      let availableHeight = overflowAvailableHeight;\n      let availableWidth = overflowAvailableWidth;\n      if (isYAxis) {\n        availableWidth = alignment || noShift ? min(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;\n      } else {\n        availableHeight = alignment || noShift ? min(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;\n      }\n      if (noShift && !alignment) {\n        const xMin = max(overflow.left, 0);\n        const xMax = max(overflow.right, 0);\n        const yMin = max(overflow.top, 0);\n        const yMax = max(overflow.bottom, 0);\n        if (isYAxis) {\n          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));\n        } else {\n          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));\n        }\n      }\n      await apply({\n        ...state,\n        availableWidth,\n        availableHeight\n      });\n      const nextDimensions = await platform.getDimensions(elements.floating);\n      if (width !== nextDimensions.width || height !== nextDimensions.height) {\n        return {\n          reset: {\n            rects: true\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\nexport { arrow, autoPlacement, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, shift, size };\n","import { rectToClientRect, detectOverflow as detectOverflow$1, offset as offset$1, autoPlacement as autoPlacement$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, arrow as arrow$1, inline as inline$1, limitShift as limitShift$1, computePosition as computePosition$1 } from '@floating-ui/core';\nimport { round, createCoords, max, min, floor } from '@floating-ui/utils';\nimport { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getFrameElement, getNodeScroll, getDocumentElement, isTopLayer, getNodeName, isOverflowElement, getOverflowAncestors, getParentNode, isLastTraversableNode, isContainingBlock, isTableElement, getContainingBlock } from '@floating-ui/utils/dom';\nexport { getOverflowAncestors } from '@floating-ui/utils/dom';\n\nfunction getCssDimensions(element) {\n  const css = getComputedStyle(element);\n  // In testing environments, the `width` and `height` properties are empty\n  // strings for SVG elements, returning NaN. Fallback to `0` in this case.\n  let width = parseFloat(css.width) || 0;\n  let height = parseFloat(css.height) || 0;\n  const hasOffset = isHTMLElement(element);\n  const offsetWidth = hasOffset ? element.offsetWidth : width;\n  const offsetHeight = hasOffset ? element.offsetHeight : height;\n  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;\n  if (shouldFallback) {\n    width = offsetWidth;\n    height = offsetHeight;\n  }\n  return {\n    width,\n    height,\n    $: shouldFallback\n  };\n}\n\nfunction unwrapElement(element) {\n  return !isElement(element) ? element.contextElement : element;\n}\n\nfunction getScale(element) {\n  const domElement = unwrapElement(element);\n  if (!isHTMLElement(domElement)) {\n    return createCoords(1);\n  }\n  const rect = domElement.getBoundingClientRect();\n  const {\n    width,\n    height,\n    $\n  } = getCssDimensions(domElement);\n  let x = ($ ? round(rect.width) : rect.width) / width;\n  let y = ($ ? round(rect.height) : rect.height) / height;\n\n  // 0, NaN, or Infinity should always fallback to 1.\n\n  if (!x || !Number.isFinite(x)) {\n    x = 1;\n  }\n  if (!y || !Number.isFinite(y)) {\n    y = 1;\n  }\n  return {\n    x,\n    y\n  };\n}\n\nconst noOffsets = /*#__PURE__*/createCoords(0);\nfunction getVisualOffsets(element) {\n  const win = getWindow(element);\n  if (!isWebKit() || !win.visualViewport) {\n    return noOffsets;\n  }\n  return {\n    x: win.visualViewport.offsetLeft,\n    y: win.visualViewport.offsetTop\n  };\n}\nfunction shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {\n  if (isFixed === void 0) {\n    isFixed = false;\n  }\n  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {\n    return false;\n  }\n  return isFixed;\n}\n\nfunction getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {\n  if (includeScale === void 0) {\n    includeScale = false;\n  }\n  if (isFixedStrategy === void 0) {\n    isFixedStrategy = false;\n  }\n  const clientRect = element.getBoundingClientRect();\n  const domElement = unwrapElement(element);\n  let scale = createCoords(1);\n  if (includeScale) {\n    if (offsetParent) {\n      if (isElement(offsetParent)) {\n        scale = getScale(offsetParent);\n      }\n    } else {\n      scale = getScale(element);\n    }\n  }\n  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);\n  let x = (clientRect.left + visualOffsets.x) / scale.x;\n  let y = (clientRect.top + visualOffsets.y) / scale.y;\n  let width = clientRect.width / scale.x;\n  let height = clientRect.height / scale.y;\n  if (domElement) {\n    const win = getWindow(domElement);\n    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;\n    let currentWin = win;\n    let currentIFrame = getFrameElement(currentWin);\n    while (currentIFrame && offsetParent && offsetWin !== currentWin) {\n      const iframeScale = getScale(currentIFrame);\n      const iframeRect = currentIFrame.getBoundingClientRect();\n      const css = getComputedStyle(currentIFrame);\n      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;\n      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;\n      x *= iframeScale.x;\n      y *= iframeScale.y;\n      width *= iframeScale.x;\n      height *= iframeScale.y;\n      x += left;\n      y += top;\n      currentWin = getWindow(currentIFrame);\n      currentIFrame = getFrameElement(currentWin);\n    }\n  }\n  return rectToClientRect({\n    width,\n    height,\n    x,\n    y\n  });\n}\n\n// If <html> has a CSS width greater than the viewport, then this will be\n// incorrect for RTL.\nfunction getWindowScrollBarX(element, rect) {\n  const leftScroll = getNodeScroll(element).scrollLeft;\n  if (!rect) {\n    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;\n  }\n  return rect.left + leftScroll;\n}\n\nfunction getHTMLOffset(documentElement, scroll, ignoreScrollbarX) {\n  if (ignoreScrollbarX === void 0) {\n    ignoreScrollbarX = false;\n  }\n  const htmlRect = documentElement.getBoundingClientRect();\n  const x = htmlRect.left + scroll.scrollLeft - (ignoreScrollbarX ? 0 :\n  // RTL <body> scrollbar.\n  getWindowScrollBarX(documentElement, htmlRect));\n  const y = htmlRect.top + scroll.scrollTop;\n  return {\n    x,\n    y\n  };\n}\n\nfunction convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {\n  let {\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  } = _ref;\n  const isFixed = strategy === 'fixed';\n  const documentElement = getDocumentElement(offsetParent);\n  const topLayer = elements ? isTopLayer(elements.floating) : false;\n  if (offsetParent === documentElement || topLayer && isFixed) {\n    return rect;\n  }\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  let scale = createCoords(1);\n  const offsets = createCoords(0);\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isHTMLElement(offsetParent)) {\n      const offsetRect = getBoundingClientRect(offsetParent);\n      scale = getScale(offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    }\n  }\n  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll, true) : createCoords(0);\n  return {\n    width: rect.width * scale.x,\n    height: rect.height * scale.y,\n    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,\n    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y\n  };\n}\n\nfunction getClientRects(element) {\n  return Array.from(element.getClientRects());\n}\n\n// Gets the entire size of the scrollable document area, even extending outside\n// of the `<html>` and `<body>` rect bounds if horizontally scrollable.\nfunction getDocumentRect(element) {\n  const html = getDocumentElement(element);\n  const scroll = getNodeScroll(element);\n  const body = element.ownerDocument.body;\n  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);\n  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);\n  let x = -scroll.scrollLeft + getWindowScrollBarX(element);\n  const y = -scroll.scrollTop;\n  if (getComputedStyle(body).direction === 'rtl') {\n    x += max(html.clientWidth, body.clientWidth) - width;\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\nfunction getViewportRect(element, strategy) {\n  const win = getWindow(element);\n  const html = getDocumentElement(element);\n  const visualViewport = win.visualViewport;\n  let width = html.clientWidth;\n  let height = html.clientHeight;\n  let x = 0;\n  let y = 0;\n  if (visualViewport) {\n    width = visualViewport.width;\n    height = visualViewport.height;\n    const visualViewportBased = isWebKit();\n    if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {\n      x = visualViewport.offsetLeft;\n      y = visualViewport.offsetTop;\n    }\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\n// Returns the inner client rect, subtracting scrollbars if present.\nfunction getInnerBoundingClientRect(element, strategy) {\n  const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');\n  const top = clientRect.top + element.clientTop;\n  const left = clientRect.left + element.clientLeft;\n  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);\n  const width = element.clientWidth * scale.x;\n  const height = element.clientHeight * scale.y;\n  const x = left * scale.x;\n  const y = top * scale.y;\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\nfunction getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {\n  let rect;\n  if (clippingAncestor === 'viewport') {\n    rect = getViewportRect(element, strategy);\n  } else if (clippingAncestor === 'document') {\n    rect = getDocumentRect(getDocumentElement(element));\n  } else if (isElement(clippingAncestor)) {\n    rect = getInnerBoundingClientRect(clippingAncestor, strategy);\n  } else {\n    const visualOffsets = getVisualOffsets(element);\n    rect = {\n      x: clippingAncestor.x - visualOffsets.x,\n      y: clippingAncestor.y - visualOffsets.y,\n      width: clippingAncestor.width,\n      height: clippingAncestor.height\n    };\n  }\n  return rectToClientRect(rect);\n}\nfunction hasFixedPositionAncestor(element, stopNode) {\n  const parentNode = getParentNode(element);\n  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {\n    return false;\n  }\n  return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);\n}\n\n// A \"clipping ancestor\" is an `overflow` element with the characteristic of\n// clipping (or hiding) child elements. This returns all clipping ancestors\n// of the given element up the tree.\nfunction getClippingElementAncestors(element, cache) {\n  const cachedResult = cache.get(element);\n  if (cachedResult) {\n    return cachedResult;\n  }\n  let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');\n  let currentContainingBlockComputedStyle = null;\n  const elementIsFixed = getComputedStyle(element).position === 'fixed';\n  let currentNode = elementIsFixed ? getParentNode(element) : element;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    const computedStyle = getComputedStyle(currentNode);\n    const currentNodeIsContaining = isContainingBlock(currentNode);\n    if (!currentNodeIsContaining && computedStyle.position === 'fixed') {\n      currentContainingBlockComputedStyle = null;\n    }\n    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);\n    if (shouldDropCurrentNode) {\n      // Drop non-containing blocks.\n      result = result.filter(ancestor => ancestor !== currentNode);\n    } else {\n      // Record last containing block for next iteration.\n      currentContainingBlockComputedStyle = computedStyle;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  cache.set(element, result);\n  return result;\n}\n\n// Gets the maximum area that the element is visible in due to any number of\n// clipping ancestors.\nfunction getClippingRect(_ref) {\n  let {\n    element,\n    boundary,\n    rootBoundary,\n    strategy\n  } = _ref;\n  const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);\n  const clippingAncestors = [...elementClippingAncestors, rootBoundary];\n  const firstClippingAncestor = clippingAncestors[0];\n  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {\n    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);\n    accRect.top = max(rect.top, accRect.top);\n    accRect.right = min(rect.right, accRect.right);\n    accRect.bottom = min(rect.bottom, accRect.bottom);\n    accRect.left = max(rect.left, accRect.left);\n    return accRect;\n  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));\n  return {\n    width: clippingRect.right - clippingRect.left,\n    height: clippingRect.bottom - clippingRect.top,\n    x: clippingRect.left,\n    y: clippingRect.top\n  };\n}\n\nfunction getDimensions(element) {\n  const {\n    width,\n    height\n  } = getCssDimensions(element);\n  return {\n    width,\n    height\n  };\n}\n\nfunction getRectRelativeToOffsetParent(element, offsetParent, strategy) {\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n  const isFixed = strategy === 'fixed';\n  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  const offsets = createCoords(0);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isOffsetParentAnElement) {\n      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    } else if (documentElement) {\n      // If the <body> scrollbar appears on the left (e.g. RTL systems). Use\n      // Firefox with layout.scrollbar.side = 3 in about:config to test this.\n      offsets.x = getWindowScrollBarX(documentElement);\n    }\n  }\n  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);\n  const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;\n  const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;\n  return {\n    x,\n    y,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\nfunction isStaticPositioned(element) {\n  return getComputedStyle(element).position === 'static';\n}\n\nfunction getTrueOffsetParent(element, polyfill) {\n  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {\n    return null;\n  }\n  if (polyfill) {\n    return polyfill(element);\n  }\n  let rawOffsetParent = element.offsetParent;\n\n  // Firefox returns the <html> element as the offsetParent if it's non-static,\n  // while Chrome and Safari return the <body> element. The <body> element must\n  // be used to perform the correct calculations even if the <html> element is\n  // non-static.\n  if (getDocumentElement(element) === rawOffsetParent) {\n    rawOffsetParent = rawOffsetParent.ownerDocument.body;\n  }\n  return rawOffsetParent;\n}\n\n// Gets the closest ancestor positioned element. Handles some edge cases,\n// such as table ancestors and cross browser bugs.\nfunction getOffsetParent(element, polyfill) {\n  const win = getWindow(element);\n  if (isTopLayer(element)) {\n    return win;\n  }\n  if (!isHTMLElement(element)) {\n    let svgOffsetParent = getParentNode(element);\n    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {\n      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {\n        return svgOffsetParent;\n      }\n      svgOffsetParent = getParentNode(svgOffsetParent);\n    }\n    return win;\n  }\n  let offsetParent = getTrueOffsetParent(element, polyfill);\n  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {\n    offsetParent = getTrueOffsetParent(offsetParent, polyfill);\n  }\n  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {\n    return win;\n  }\n  return offsetParent || getContainingBlock(element) || win;\n}\n\nconst getElementRects = async function (data) {\n  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;\n  const getDimensionsFn = this.getDimensions;\n  const floatingDimensions = await getDimensionsFn(data.floating);\n  return {\n    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),\n    floating: {\n      x: 0,\n      y: 0,\n      width: floatingDimensions.width,\n      height: floatingDimensions.height\n    }\n  };\n};\n\nfunction isRTL(element) {\n  return getComputedStyle(element).direction === 'rtl';\n}\n\nconst platform = {\n  convertOffsetParentRelativeRectToViewportRelativeRect,\n  getDocumentElement,\n  getClippingRect,\n  getOffsetParent,\n  getElementRects,\n  getClientRects,\n  getDimensions,\n  getScale,\n  isElement,\n  isRTL\n};\n\n// https://samthor.au/2021/observing-dom/\nfunction observeMove(element, onMove) {\n  let io = null;\n  let timeoutId;\n  const root = getDocumentElement(element);\n  function cleanup() {\n    var _io;\n    clearTimeout(timeoutId);\n    (_io = io) == null || _io.disconnect();\n    io = null;\n  }\n  function refresh(skip, threshold) {\n    if (skip === void 0) {\n      skip = false;\n    }\n    if (threshold === void 0) {\n      threshold = 1;\n    }\n    cleanup();\n    const {\n      left,\n      top,\n      width,\n      height\n    } = element.getBoundingClientRect();\n    if (!skip) {\n      onMove();\n    }\n    if (!width || !height) {\n      return;\n    }\n    const insetTop = floor(top);\n    const insetRight = floor(root.clientWidth - (left + width));\n    const insetBottom = floor(root.clientHeight - (top + height));\n    const insetLeft = floor(left);\n    const rootMargin = -insetTop + \"px \" + -insetRight + \"px \" + -insetBottom + \"px \" + -insetLeft + \"px\";\n    const options = {\n      rootMargin,\n      threshold: max(0, min(1, threshold)) || 1\n    };\n    let isFirstUpdate = true;\n    function handleObserve(entries) {\n      const ratio = entries[0].intersectionRatio;\n      if (ratio !== threshold) {\n        if (!isFirstUpdate) {\n          return refresh();\n        }\n        if (!ratio) {\n          // If the reference is clipped, the ratio is 0. Throttle the refresh\n          // to prevent an infinite loop of updates.\n          timeoutId = setTimeout(() => {\n            refresh(false, 1e-7);\n          }, 1000);\n        } else {\n          refresh(false, ratio);\n        }\n      }\n      isFirstUpdate = false;\n    }\n\n    // Older browsers don't support a `document` as the root and will throw an\n    // error.\n    try {\n      io = new IntersectionObserver(handleObserve, {\n        ...options,\n        // Handle <iframe>s\n        root: root.ownerDocument\n      });\n    } catch (e) {\n      io = new IntersectionObserver(handleObserve, options);\n    }\n    io.observe(element);\n  }\n  refresh(true);\n  return cleanup;\n}\n\n/**\n * Automatically updates the position of the floating element when necessary.\n * Should only be called when the floating element is mounted on the DOM or\n * visible on the screen.\n * @returns cleanup function that should be invoked when the floating element is\n * removed from the DOM or hidden from the screen.\n * @see https://floating-ui.com/docs/autoUpdate\n */\nfunction autoUpdate(reference, floating, update, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    ancestorScroll = true,\n    ancestorResize = true,\n    elementResize = typeof ResizeObserver === 'function',\n    layoutShift = typeof IntersectionObserver === 'function',\n    animationFrame = false\n  } = options;\n  const referenceEl = unwrapElement(reference);\n  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];\n  ancestors.forEach(ancestor => {\n    ancestorScroll && ancestor.addEventListener('scroll', update, {\n      passive: true\n    });\n    ancestorResize && ancestor.addEventListener('resize', update);\n  });\n  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;\n  let reobserveFrame = -1;\n  let resizeObserver = null;\n  if (elementResize) {\n    resizeObserver = new ResizeObserver(_ref => {\n      let [firstEntry] = _ref;\n      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {\n        // Prevent update loops when using the `size` middleware.\n        // https://github.com/floating-ui/floating-ui/issues/1740\n        resizeObserver.unobserve(floating);\n        cancelAnimationFrame(reobserveFrame);\n        reobserveFrame = requestAnimationFrame(() => {\n          var _resizeObserver;\n          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);\n        });\n      }\n      update();\n    });\n    if (referenceEl && !animationFrame) {\n      resizeObserver.observe(referenceEl);\n    }\n    resizeObserver.observe(floating);\n  }\n  let frameId;\n  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;\n  if (animationFrame) {\n    frameLoop();\n  }\n  function frameLoop() {\n    const nextRefRect = getBoundingClientRect(reference);\n    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {\n      update();\n    }\n    prevRefRect = nextRefRect;\n    frameId = requestAnimationFrame(frameLoop);\n  }\n  update();\n  return () => {\n    var _resizeObserver2;\n    ancestors.forEach(ancestor => {\n      ancestorScroll && ancestor.removeEventListener('scroll', update);\n      ancestorResize && ancestor.removeEventListener('resize', update);\n    });\n    cleanupIo == null || cleanupIo();\n    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();\n    resizeObserver = null;\n    if (animationFrame) {\n      cancelAnimationFrame(frameId);\n    }\n  };\n}\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nconst detectOverflow = detectOverflow$1;\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = offset$1;\n\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = autoPlacement$1;\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = shift$1;\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = flip$1;\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = size$1;\n\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = hide$1;\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = arrow$1;\n\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = inline$1;\n\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = limitShift$1;\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n */\nconst computePosition = (reference, floating, options) => {\n  // This caches the expensive `getClippingElementAncestors` function so that\n  // multiple lifecycle resets re-use the same result. It only lives for a\n  // single call. If other functions become expensive, we can add them as well.\n  const cache = new Map();\n  const mergedOptions = {\n    platform,\n    ...options\n  };\n  const platformWithCache = {\n    ...mergedOptions.platform,\n    _c: cache\n  };\n  return computePosition$1(reference, floating, {\n    ...mergedOptions,\n    platform: platformWithCache\n  });\n};\n\nexport { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, platform, shift, size };\n","function hasWindow() {\n  return typeof window !== 'undefined';\n}\nfunction getNodeName(node) {\n  if (isNode(node)) {\n    return (node.nodeName || '').toLowerCase();\n  }\n  // Mocked nodes in testing environments may not be instances of Node. By\n  // returning `#document` an infinite loop won't occur.\n  // https://github.com/floating-ui/floating-ui/issues/2317\n  return '#document';\n}\nfunction getWindow(node) {\n  var _node$ownerDocument;\n  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;\n}\nfunction getDocumentElement(node) {\n  var _ref;\n  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;\n}\nfunction isNode(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof Node || value instanceof getWindow(value).Node;\n}\nfunction isElement(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof Element || value instanceof getWindow(value).Element;\n}\nfunction isHTMLElement(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;\n}\nfunction isShadowRoot(value) {\n  if (!hasWindow() || typeof ShadowRoot === 'undefined') {\n    return false;\n  }\n  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;\n}\nfunction isOverflowElement(element) {\n  const {\n    overflow,\n    overflowX,\n    overflowY,\n    display\n  } = getComputedStyle(element);\n  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);\n}\nfunction isTableElement(element) {\n  return ['table', 'td', 'th'].includes(getNodeName(element));\n}\nfunction isTopLayer(element) {\n  return [':popover-open', ':modal'].some(selector => {\n    try {\n      return element.matches(selector);\n    } catch (e) {\n      return false;\n    }\n  });\n}\nfunction isContainingBlock(elementOrCss) {\n  const webkit = isWebKit();\n  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));\n}\nfunction getContainingBlock(element) {\n  let currentNode = getParentNode(element);\n  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    if (isContainingBlock(currentNode)) {\n      return currentNode;\n    } else if (isTopLayer(currentNode)) {\n      return null;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  return null;\n}\nfunction isWebKit() {\n  if (typeof CSS === 'undefined' || !CSS.supports) return false;\n  return CSS.supports('-webkit-backdrop-filter', 'none');\n}\nfunction isLastTraversableNode(node) {\n  return ['html', 'body', '#document'].includes(getNodeName(node));\n}\nfunction getComputedStyle(element) {\n  return getWindow(element).getComputedStyle(element);\n}\nfunction getNodeScroll(element) {\n  if (isElement(element)) {\n    return {\n      scrollLeft: element.scrollLeft,\n      scrollTop: element.scrollTop\n    };\n  }\n  return {\n    scrollLeft: element.scrollX,\n    scrollTop: element.scrollY\n  };\n}\nfunction getParentNode(node) {\n  if (getNodeName(node) === 'html') {\n    return node;\n  }\n  const result =\n  // Step into the shadow DOM of the parent of a slotted node.\n  node.assignedSlot ||\n  // DOM Element detected.\n  node.parentNode ||\n  // ShadowRoot detected.\n  isShadowRoot(node) && node.host ||\n  // Fallback.\n  getDocumentElement(node);\n  return isShadowRoot(result) ? result.host : result;\n}\nfunction getNearestOverflowAncestor(node) {\n  const parentNode = getParentNode(node);\n  if (isLastTraversableNode(parentNode)) {\n    return node.ownerDocument ? node.ownerDocument.body : node.body;\n  }\n  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {\n    return parentNode;\n  }\n  return getNearestOverflowAncestor(parentNode);\n}\nfunction getOverflowAncestors(node, list, traverseIframes) {\n  var _node$ownerDocument2;\n  if (list === void 0) {\n    list = [];\n  }\n  if (traverseIframes === void 0) {\n    traverseIframes = true;\n  }\n  const scrollableAncestor = getNearestOverflowAncestor(node);\n  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);\n  const win = getWindow(scrollableAncestor);\n  if (isBody) {\n    const frameElement = getFrameElement(win);\n    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);\n  }\n  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));\n}\nfunction getFrameElement(win) {\n  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;\n}\n\nexport { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isTopLayer, isWebKit };\n"],"names":["_extends","Object","assign","bind","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","apply","this","Action","PopStateEventType","createBrowserHistory","options","getUrlBasedHistory","window","globalHistory","pathname","search","hash","location","createLocation","state","usr","to","createPath","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","listen","fn","addEventListener","removeEventListener","encodeLocation","url","push","Push","historyState","pushState","error","DOMException","name","Replace","go","n","ResultType","immutableRouteKeys","Set","convertRoutesToDataRoutes","routes","mapRouteProperties","parentPath","manifest","map","route","treePath","String","id","join","children","isIndexRoute","indexRoute","pathOrLayoutRoute","undefined","matchRoutes","locationArg","basename","matchRoutesImpl","allowPartial","stripBasename","branches","flattenRoutes","sort","a","b","score","siblings","slice","every","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","dynamicSegmentValue","indexRouteValue","emptySegmentValue","staticSegmentValue","splatPenalty","isSplat","s","initialScore","some","filter","reduce","segment","test","branch","matchedParams","matchedPathname","end","remainingPathname","matchPath","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","json","init","responseInit","status","headers","Headers","has","set","Response","AbortedDeferredError","redirect","response","ErrorResponseImpl","constructor","statusText","internal","isRouteErrorResponse","validMutationMethodsArr","validMutationMethods","validRequestMethodsArr","validRequestMethods","redirectStatusCodes","redirectPreserveMethodStatusCodes","IDLE_NAVIGATION","formMethod","formAction","formEncType","formData","text","IDLE_FETCHER","IDLE_BLOCKER","proceed","reset","ABSOLUTE_URL_REGEX","defaultMapRouteProperties","hasErrorBoundary","Boolean","TRANSITIONS_STORAGE_KEY","createRouter","routerWindow","isBrowser","createElement","isServer","detectErrorBoundary","inFlightDataRoutes","initialized","router","dataRoutes","dataStrategyImpl","unstable_dataStrategy","defaultDataStrategy","patchRoutesOnMissImpl","unstable_patchRoutesOnMiss","future","v7_fetcherPersist","v7_normalizeFormMethod","v7_partialHydration","v7_prependBasename","v7_skipActionErrorRevalidation","unlistenHistory","subscribers","savedScrollPositions","getScrollRestorationKey","getScrollPosition","initialScrollRestored","hydrationData","initialMatches","initialErrors","getInternalRouterError","getShortCircuitMatches","checkFogOfWar","active","m","lazy","loader","errors","isRouteInitialized","hydrate","findIndex","fogOfWar","pendingNavigationController","historyAction","navigation","restoreScrollPosition","preventScrollReset","revalidation","actionData","fetchers","Map","blockers","pendingAction","pendingPreventScrollReset","pendingViewTransitionEnabled","appliedViewTransitions","removePageHideEventListener","isUninterruptedRevalidation","isRevalidationRequired","cancelledDeferredRoutes","cancelledFetcherLoads","fetchControllers","incrementingLoadId","pendingNavigationLoadId","fetchReloadIds","fetchRedirectIds","fetchLoadMatches","activeFetchers","deletedFetchers","activeDeferreds","blockerFunctions","pendingPatchRoutes","ignoreNextHistoryUpdate","updateState","newState","opts","completedFetchers","deletedFetchersKeys","fetcher","subscriber","unstable_viewTransitionOpts","viewTransitionOpts","unstable_flushSync","flushSync","delete","deleteFetcher","completeNavigation","_temp","_location$state","_location$state2","isActionReload","isMutationMethod","_isRedirect","keys","mergeLoaderData","size","k","priorPaths","get","currentLocation","nextLocation","toPaths","add","getSavedScrollPosition","async","startNavigation","abort","startUninterruptedRevalidation","getScrollKey","saveScrollPosition","enableViewTransition","routesToUse","loadingNavigation","overrideNavigation","notFoundMatches","handleNavigational404","isHashChangeOnly","submission","AbortController","pendingActionResult","request","createClientSideRequest","signal","pendingError","findNearestBoundary","type","actionResult","isFogOfWar","interruptActiveLoads","getSubmittingNavigation","discoverResult","discoverRoutes","shortCircuited","boundaryId","handleDiscoverRouteError","partialMatches","actionMatch","getTargetMatch","callDataStrategy","aborted","method","routeId","isRedirectResult","normalizeRedirectLocation","startRedirectNavigation","isDeferredResult","isErrorResult","boundaryMatch","handleAction","getLoadingNavigation","updatedMatches","fetcherSubmission","initialHydration","activeSubmission","getSubmissionFromNavigation","shouldUpdateNavigationState","getUpdatedActionData","matchesToLoad","revalidatingFetchers","getMatchesToLoad","cancelActiveDeferreds","updatedFetchers","markFetchRedirectsDone","getActionDataForCommit","updates","rf","revalidatingFetcher","getLoadingFetcher","getUpdatedRevalidatingFetchers","abortFetcher","controller","abortPendingFetchRevalidations","f","loaderResults","fetcherResults","callLoadersAndMaybeResolveData","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","leafRoute","isNonHMR","loadLazyRouteChildren","newMatches","matchedSplat","newPartialMatches","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","detectAndHandle405Error","existingFetcher","getSubmittingFetcher","abortController","fetchRequest","originatingLoadId","actionResults","revalidationRequest","loadId","loadFetcher","staleKey","handleFetcherAction","resolveDeferredData","handleFetcherLoader","revalidate","count","dispose","clear","getBlocker","patchRoutes","patchRoutesImpl","_internalFetchControllers","_internalActiveDeferreds","_internalSetRoutes","newRoutes","Symbol","prependBasename","contextualMatches","activeRouteMatch","hasNakedIndexQuery","normalizeFormMethod","isFetcher","body","isSubmissionNavigation","isValidMethod","searchParams","getInvalidBodyError","rawFormMethod","toUpperCase","stripHashFromPath","FormData","URLSearchParams","acc","_ref5","convertFormDataToSearchParams","convertSearchParamsToFormData","append","getLoaderMatchesUntilBoundary","boundaryMatches","isInitialLoad","skipActionErrorRevalidation","currentUrl","nextUrl","actionStatus","statusCode","shouldSkipRevalidation","navigationMatches","currentLoaderData","currentMatch","isNew","isMissingData","isNewLoader","currentRouteMatch","nextRouteMatch","shouldRevalidateLoader","currentParams","nextParams","defaultShouldRevalidate","isNewRouteInstance","fetcherMatches","fetcherMatch","shouldRevalidate","currentPath","loaderMatch","arg","routeChoice","pendingRouteChildren","pending","patch","val","_route$children","dataChildren","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","isDataWithResponseInit","_result$init2","_result$init","_result$init3","_result$init4","_result$init5","_result$init6","deferred","resolveData","isDeferredData","trimmedMatches","normalizedLocation","protocol","isSameBasename","Request","processRouteLoaderData","skipLoaderErrorBubbling","foundError","loaderHeaders","newLoaderData","mergedLoaderData","reverse","find","_temp5","errorMessage","signals","isRevalidatingLoader","unwrap","unwrappedData","getAll","FUNC_ERROR_TEXT","NAN","symbolTag","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","freeGlobal","g","freeSelf","self","root","Function","objectToString","nativeMax","max","nativeMin","min","now","Date","debounce","func","wait","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","TypeError","invokeFunc","time","args","thisArg","shouldInvoke","timeSinceLastCall","timerExpired","trailingEdge","setTimeout","remainingWait","debounced","isInvoking","leadingEdge","toNumber","isObject","clearTimeout","flush","isObjectLike","isSymbol","other","valueOf","isBinary","module","exports","_Iter_peek","__classPrivateFieldGet","receiver","kind","__classPrivateFieldSet","defineProperty","TokenData","compile","encode","encodeURIComponent","delimiter","DEFAULT_DELIMITER","tokensToFunction","tokens","missing","decode","regexp","pathToRegexp","decoders","NOOP_VALUE","input","exec","create","decoder","stringifyToken","token","isSafe","ID_START","ID_CONTINUE","isNameSafe","isNextNameSafe","DEBUG_URL","SIMPLE_TOKENS","escape","str","Iter","peek","next","tryConsume","consume","nextType","WeakMap","encodePath","it","chars","pos","lexer","endType","param","wildcard","encoders","encodeValue","tokenToFunction","encoder","extras","sensitive","sources","flags","items","seq","flatten","sequenceToRegExp","fork","backtrack","isSafeSegmentParam","negate","values","_objectWithoutPropertiesLoose","excluded","sourceKeys","defaultMethod","defaultEncType","isHtmlElement","object","tagName","createSearchParams","_formDataSupportsSubmitter","supportedFormEncTypes","getFormEncType","encType","getFormSubmissionInfo","attr","getAttribute","isButtonElement","isInputElement","form","isFormDataSubmitterSupported","prefix","_excluded","_excluded2","_excluded3","__reactRouterVersion","createBrowserRouter","parseHydrationData","__staticRouterHydrationData","deserializeErrors","serialized","__type","__subType","ErrorConstructor","stack","ViewTransitionContext","isTransitioning","FetchersContext","startTransitionImpl","flushSyncImpl","flushSyncSafe","cb","Deferred","promise","reason","RouterProvider","fallbackElement","setStateImpl","pendingState","setPendingState","vtContext","setVtContext","renderDfd","setRenderDfd","transition","setTransition","interruption","setInterruption","fetcherData","v7_startTransition","optInStartTransition","startTransitionSafe","setState","isViewTransitionUnavailable","startViewTransition","skipTransition","t","finished","finally","renderPromise","navigator","dataRouterContext","static","routerFuture","Provider","navigationType","MemoizedDataRoutes","DataRoutes","BrowserRouter","historyRef","Link","_ref7","ref","absoluteHref","onClick","reloadDocument","isExternal","targetUrl","internalOnClick","replaceProp","event","button","metaKey","altKey","ctrlKey","shiftKey","isModifiedEvent","shouldProcessLinkClick","preventDefault","useLinkClickHandler","defaultPrevented","NavLink","_ref8","ariaCurrentProp","className","classNameProp","style","styleProp","routerState","useDataRouterContext","DataRouterHook","useViewTransitionState","nextPath","nextLocationPathname","endSlashPosition","isActive","isPending","renderProps","ariaCurrent","Form","_ref9","forwardedRef","onSubmit","props","submit","useSubmit","routeContext","useFormAction","submitter","nativeEvent","submitMethod","currentTarget","ScrollRestoration","_ref10","storageKey","_temp4","UseScrollRestoration","useDataRouterState","DataRouterStateHook","scrollRestoration","callback","capture","usePageHide","scrollY","SCROLL_RESTORATION_STORAGE_KEY","getKeyWithoutBasename","disableScrollRestoration","el","getElementById","scrollIntoView","scrollTo","useScrollRestoration","hookName","useSearchParams","defaultInit","defaultSearchParamsRef","hasSetSearchParamsRef","locationSearch","defaultSearchParams","getSearchParamsForLocation","setSearchParams","nextInit","navigateOptions","newSearchParams","fetcherId","getUniqueFetcherId","UseSubmit","currentRouteId","validateClientSideSubmission","DataRouterContext","DataRouterStateContext","NavigationContext","LocationContext","RouteContext","outlet","isDataRoute","RouteErrorContext","useHref","useInRouterContext","useResolvedPath","joinedPathname","useLocation","useIsomorphicLayoutEffect","useNavigate","UseNavigateStable","useCurrentRouteId","activeRef","useNavigateStable","routePathnamesJson","useNavigateUnstable","OutletContext","useRoutesImpl","dataRouterState","parentMatches","routeMatch","parentParams","parentPathnameBase","locationFromContext","_parsedLocationArg$pa","parsedLocationArg","parentSegments","renderedMatches","_renderMatches","DefaultErrorComponent","useRouteError","lightgrey","preStyles","padding","backgroundColor","fontStyle","defaultErrorElement","RenderErrorBoundary","super","getDerivedStateFromError","getDerivedStateFromProps","componentDidCatch","errorInfo","render","component","RenderedRoute","errorElement","ErrorBoundary","_deepestRenderedBoundaryId","_dataRouterState","_future","errorIndex","renderFallback","fallbackIndex","HydrateFallback","hydrateFallbackElement","needsToRunLoader","reduceRight","shouldRenderHydrateFallback","alreadyWarned","getChildren","Component","element","useRouteContext","thisRoute","useRouteId","UseRouteId","useNavigation","UseNavigation","useRevalidator","UseRevalidator","useMatches","UseMatches","useLoaderData","UseLoaderData","useActionData","UseActionData","_state$errors","UseRouteError","Outlet","useOutlet","Route","_props","Router","basenameProp","locationProp","staticProp","navigationContext","locationContext","trailingPathname","Routes","_ref6","createRoutesFromChildren","hasOwn","classNames","classes","appendClass","parseValue","newClass","default","uncurryThis","$Error","TEST","V8_OR_CHAKRA_STACK_ENTRY","IS_V8_OR_CHAKRA_STACK","dropEntries","prepareStackTrace","createNonEnumerableProperty","clearErrorStack","ERROR_STACK_INSTALLABLE","captureStackTrace","C","fails","createPropertyDescriptor","O","cause","argument","$default","getBuiltIn","isPrototypeOf","setPrototypeOf","copyConstructorProperties","proxyAccessor","inheritIfRequired","normalizeStringArgument","installErrorCause","installErrorStack","DESCRIPTORS","IS_PURE","FULL_NAME","wrapper","FORCED","IS_AGGREGATE_ERROR","STACK_TRACE_LIMIT","OPTIONS_POSITION","ERROR_NAME","OriginalError","OriginalErrorPrototype","BaseError","WrappedError","$","global","wrapErrorConstructorWithCause","WEB_ASSEMBLY","WebAssembly","exportGlobalErrorCauseWrapper","arity","forced","exportWebAssemblyErrorCauseWrapper","stat","__defProp","__defProps","defineProperties","__getOwnPropDescs","getOwnPropertyDescriptors","__getOwnPropSymbols","getOwnPropertySymbols","__hasOwnProp","__propIsEnum","propertyIsEnumerable","__defNormalProp","obj","enumerable","configurable","writable","__spreadValues","prop","__spreadProps","__objRest","exclude","toArray","flatten2DArray","array","flattened","row","reverseArray","NULL_ITEM","findFirstEnabledItem","excludeId","item","disabled","getItemsInRow","rowId","groupItemsByRows","rows","currentRow","_a","getMaxRowLength","maxLength","createCompositeStore","syncState","store","getState","collection","activeId","defaultActiveId","initialState","baseElement","includesBaseElement","moves","orientation","rtl","virtualFocus","focusLoop","focusWrap","focusShift","composite","activeId2","_a2","renderedItems","getNextId","direction","_b","defaultState","skip","isVerticalDirection","isNextDirection","canReverse","canShift","previousItem","normalizeRows","verticalized","verticalizeItems","activeItem","isGrid","activeIndex","nextItems","nextItemsInRow","nextEnabledItemsInRow","getEnabledItems","nextItem2","canLoop","canWrap","hasNullItem","sortedItems","shouldInsertNullItem","flipItems","nextItem","setBaseElement","setActiveId","move","last","previous","down","up","getInternal","internals","__unstableInternals","createStore","stores","prevStateBatch","lastUpdate","destroy","instances","updatedKeys","setups","listeners","batchListeners","disposables","listenerKeys","sub","fromStores","nextValue","prevState","thisUpdate","run","prev","uKeys","queueMicrotask","snapshot","finalStore","setup","instance","maybeDestroy","desyncs","storeState","sync","state2","teardowns","setup2","cleanups","batch","pick","omit","omit2","pick2","mergeStore","store2","nextState","throwOnConflictingProps","createCollectionStore","defaultItems","itemsMap","syncPrivateStore","__unstablePrivateStore","privateStore","sortItems","firstRun","raf","requestAnimationFrame","IntersectionObserver","cancelAnimationFrame","firstItem","lastItem","parentElement","contains","getCommonParent","observer","observe","disconnect","mergeItem","setItems","canDeleteFromMap","prevItem","items2","registerItem","getItems","renderItem","item2","canUseDOM","getDocument","node","ownerDocument","getWindow","getActiveElement","activeDescendant","activeElement","nodeName","isFrame","contentDocument","parent","child","isButton","buttonInputTypes","isVisible","checkVisibility","htmlElement","offsetWidth","offsetHeight","getClientRects","isTextField","isTextInput","HTMLInputElement","selectionStart","isTextArea","isTextbox","isContentEditable","getTextboxValue","range","createRange","selectNodeContents","getTextboxSelection","start","selectionEnd","selection","getSelection","rangeCount","anchorNode","focusNode","getRangeAt","nextRange","cloneRange","setEnd","startContainer","startOffset","endContainer","endOffset","getPopupRole","fallback","role","getPopupItemRole","popupRole","menu","listbox","tree","getScrollingElement","isScrollableOverflow","overflow","clientHeight","scrollHeight","overflowY","getComputedStyle","clientWidth","scrollWidth","overflowX","scrollingElement","setSelectionRange","sortBasedOnDOMPosition","getElement","pairs","isOrderDifferent","indexA","indexB","elementA","elementB","compareDocumentPosition","Node","DOCUMENT_POSITION_PRECEDING","isElementPreceding","createDialogStore","createHovercardStore","popover","placement","timeout","showTimeout","hideTimeout","autoFocusOnShow","hovercard","setAutoFocusOnShow","createPopoverStore","otherPopover","dialog","currentPlacement","anchorElement","popoverElement","arrowElement","rendered","setAnchorElement","setPopoverElement","setArrowElement","noop","shallowEqual","aKeys","bKeys","applyState","currentValue","isUpdater","isLazyValue","chain","fns","normalizeString","normalize","identity","condition","getKeys","isFalsyBooleanCallback","booleanOrCallback","disabledFromProps","removeUndefinedValues","defaultValue","isTouchDevice","maxTouchPoints","isApple","platform","isSafari","vendor","isFirefox","userAgent","isMac","createDisclosureStore","disclosure","open","defaultOpen","animated","animating","mounted","contentElement","disclosureElement","setOpen","show","hide","toggle","open2","stopAnimation","setContentElement","setDisclosureElement","isPortalEvent","isSelfTarget","isOpeningInNewTab","isAppleDevice","isDownloading","fireEvent","eventInit","Event","dispatchEvent","fireBlurEvent","FocusEvent","defaultAllowed","bubbleInit","bubbles","fireKeyboardEvent","KeyboardEvent","fireClickEvent","MouseEvent","isFocusEventOutside","container","containerElement","relatedTarget","queueBeforeEvent","cancelTimer","callback2","timerId2","createTimer","callSync","once","addGlobalEventListener","scope","frame","frames","remove","selector","isFocusable","closest","isTabbable","Number","hasNegativeTabIndex","checked","radioGroup","elements","namedItem","getAllFocusableIn","includeContainer","querySelectorAll","unshift","focusableElements","frameBody","splice","getAllTabbableIn","fallbackToFocusable","tabbableElements","allFrameTabbable","getFirstTabbableIn","getNextTabbable","fallbackToFirst","allFocusable","nextFocusableElements","getNextTabbableIn","getPreviousTabbable","fallbackToLast","previousFocusableElements","getPreviousTabbableIn","getClosestFocusable","hasFocus","hasFocusWithin","querySelector","CSS","focusIfNeeded","focus","disableFocus","currentTabindex","setAttribute","disableFocusIn","restoreFocusIn","restoreTabIndex","tabindex","removeAttribute","hasAttribute","focusIntoView","preventScroll","block","inline","useCollectionStoreProps","update","useCompositeStoreOptions","useCompositeStoreProps","getEnabledItem","selectTextField","collapseToEnd","selectAllChildren","FOCUS_SILENTLY","focusSilently","silentlyFocused","isSilentlyFocused","isItem","_React","useReactId","useId","useReactInsertionEffect","useDeferredValue","useInsertionEffect","useSafeLayoutEffect","useLayoutEffect","useEffect","useLiveRef","useRef","useEvent","useCallback","useTransactionState","useState","useMergeRefs","refs","useMemo","defaultId","reactId","setId","useTagName","refOrElement","stringOrUndefined","type2","setTagName","useAttribute","attributeName","initialValue","useInitialValue","attribute","MutationObserver","attributeFilter","useUpdateEffect","effect","deps","useUpdateLayoutEffect","useForceUpdate","useReducer","useBooleanEvent","useWrapElement","wrapElement","usePortalRef","portalProp","portalRefProp","portalNode","setPortalNode","portalRef","domReady","useMetadataProps","onLoadedMetadataCapture","useIsMouseMoving","setMouseMoving","resetMouseMoving","mouseMoving","previousScreenX","previousScreenY","movementX","screenX","movementY","screenY","hasMouseMovement","useDialogStoreProps","useDialogStore","useHovercardAnchor","showOnHover","showTimeoutRef","onMouseMoveProp","onMouseMove","showOnHoverProp","isMouseMoving","showHovercard","timeoutMs","onClickProp","isConnected","htmlProps","useHovercardProviderContext","useContext","useScopedContext","useProviderContext","HovercardContextProvider","ContextProvider","HovercardScopedContextProvider","ScopedContextProvider","useTooltipContext","useTooltipProviderContext","TooltipContextProvider","TooltipScopedContextProvider","createContext","useTagContext","isTouchSafari","createComboboxStore","tag","tagState","selectedValue","defaultSelectedValue","multiSelectable","resetValueOnSelect","resetValueOnHide","activeValue","combobox","setValues","setValue","value2","resetValue","setSelectedValue","selectedValue2","useComboboxStore","useComboboxStoreOptions","useComboboxStoreProps","useHovercardStoreProps","useComboboxList","alwaysVisible","scopedContext","scopedContextSameStore","hidden","display","ariaMultiSelectable","hasListboxInside","setHasListboxInside","subtree","childList","jsx","ComboboxList","useKeyboardEventProxy","onKeyboardEvent","previousElementRef","isPropagationStopped","isModifierKey","isPrintableKey","view","stopPropagation","useComposite","focusOnMove","moveOnKeyPress","scheduleFocus","scheduled","setScheduled","schedule","useScheduleFocus","itemElement","previousElement","onKeyDownCapture","onKeyUpCapture","onFocusCaptureProp","onFocusCapture","virtualFocus2","previousActiveElement","onFocusProp","onFocus","onBlurCaptureProp","onBlurCapture","nextActiveElement","nextActiveElementIsItem","onKeyDownProp","onKeyDown","moveOnKeyPressProp","isVertical","isHorizontal","grid","keyMap","ArrowUp","findFirstEnabledItemInTheLastRow","ArrowRight","ArrowDown","ArrowLeft","Home","End","PageUp","PageDown","focusable","ids","backdrop","orchestrate","elementCleanups","prevCleanup","cleanup","nextCleanup","previousValue","setProperty","property","exists","assignStyle","prevStyle","cssText","ignoreTags","getSnapshotPropertyName","isValidElement","ignoredElements","doc","propertyName","inSnapshot","enabledElement","ancestorCallback","hasAncestorAlready","maybeAncestor","originalElement","getPropertyName","ancestor","markAncestor","isElementMarked","elementProperty","markTreeOutside","markElement","DialogBackdrop","backdrop2","zIndex","position","top","right","bottom","left","hideElementFromAccessibilityTree","supportsInert","HTMLElement","disableTree","enableElements","element2","restoreFocusMethod","pointerEvents","userSelect","cursor","usePreventBodyScroll","contentId","enabled","isRootDialog","updated","retry","useRootDialog","win","documentElement","cssScrollbarWidth","getPropertyValue","scrollbarWidth","innerWidth","paddingProperty","documentLeft","getBoundingClientRect","round","scrollLeft","getPaddingProperty","isIOS","removeProperty","scrollX","visualViewport","offsetLeft","offsetTop","restoreStyle","floor","behavior","setIOSStyle","NestedDialogsContext","useEventOutside","callListener","focusedRef","isInDocument","isDisclosure","rect","width","height","clientY","clientX","isMouseEventOnDialog","shouldHideOnInteractOutside","hideOnInteractOutside","useHideOnInteractOutside","previousMouseDownRef","usePreviousMouseDownRef","previousMouseDown","useFocusableContainer","HeadingContext","HeadingLevel","level","contextLevel","nextLevel","isSafariBrowser","getElementFromProp","useDialog","storeProp","openProp","onClose","modal","portal","hideOnEscape","getPersistentElements","preventBodyScroll","autoFocusOnHide","initialFocus","finalFocus","unmountOnHide","unstable_treeSnapshotKey","cancelable","preserveTabOrderProp","preserveTabOrder","nestedDialogs","dialogs","setDialogs","dialogs2","d","providerValue","useNestedDialogs","onMouseDown","receivedFocus","viewport","setViewportHeight","_b2","innerHeight","tabIndex","textContent","border","clip","margin","whiteSpace","prepend","prependHiddenDismiss","canTakeTreeSnapshot","createWalkTreeSnapshot","getPersistentElementsProp","allElements","dialog2","isFocusTrap","disableTreeOutside","mayAutoFocusOnShow","autoFocusOnShowProp","autoFocusEnabled","setAutoFocusEnabled","isElementFocusable","mayAutoFocusOnHide","autoFocusOnHideProp","hasOpened","setHasOpened","focusOnHide","isAlreadyFocusingAnotherElement","maybeParentDialog","control","focusedOnHideRef","hideOnEscapeProp","hiddenProp","jsxs","Fragment","headingId","setHeadingId","descriptionId","setDescriptionId","createDialogComponent","Dialog","getEventPoint","isPointInPolygon","point","polygon","x","inside","l","j","xi","yi","xj","yj","vy","where","getElementPolygon","enterPoint","getEnterPointPlacement","isMovingOnHovercard","card","anchor","nested","card2","NestedHovercardContext","useHovercard","hideOnHoverOutside","disablePointerEventsOnApproach","nestedHovercards","setNestedHovercards","hideTimeoutRef","enterPointRef","mayHideOnHoverOutside","hideOnHoverOutsideProp","mayDisablePointerEvents","disablePointerEventsProp","composedPath","currentPoint","disableEvent","openRef","registerOnParent","registerNestedHovercard","prevElements","parentUnregister","setAutoFocusOnHide","finalFocusRef","useAutoFocusOnHide","isNativeClick","isTrusted","symbol","useCommand","clickOnEnter","clickOnSpace","isNativeButton","setIsNativeButton","setActive","isDuplicate","metadataProps","isEnter","isSpace","shouldPreventEnter","shouldPreventSpace","nativeClick","click","onKeyUpProp","onKeyUp","forwardRef2","Role","displayName","memo2","propsAreEqual","Type","mergedRef","createHook","useProps","useRole","createStoreContext","providers","scopedProviders","useContext2","onlyScoped","scoped","alwaysFocusVisibleInputTypes","safariFocusAncestorSymbol","isSafariFocusAncestor","markSafariFocusAncestor","isNativeCheckboxOrRadio","getTabIndex","trulyDisabled","nativeTabbable","supportsDisabled","tabIndexProp","useDisableEvent","onEvent","isKeyboardModality","onGlobalMouseDown","onGlobalKeyDown","useFocusable","accessibleWhenDisabled","autoFocus","onFocusVisible","labels","getLabels","onMouseUp","label","focusVisible","setFocusVisible","onKeyPressCapture","onMouseDownCapture","onClickCapture","onMouseDownProp","focusableContainer","handleFocusVisible","dataset","onKeyDownCaptureProp","applyFocusVisible","readOnly","isAlwaysFocusVisible","onBlurProp","onBlur","autoFocusRef","isNativeTabbable","supportsDisabledAttribute","contentEditable","usePopoverContext","usePopoverProviderContext","PopoverContextProvider","PopoverScopedContextProvider","usePopoverStoreProps","usePopoverStore","useVisuallyHidden","useFocusTrap","FocusTrap","PortalContext","queueFocus","usePortal","preserveTabOrderAnchor","portalElement","refProp","anchorPortalNode","setAnchorPortalNode","outerBeforeRef","innerBeforeRef","innerAfterRef","outerAfterRef","portalEl","getPortalElement","isPortalInDocument","rootElement","getRootElement","appendChild","getRandomId","insertAdjacentElement","focusing","createPortal","preserveTabOrderElement","nextTabbable","Portal","usePopoverAnchor","PopoverAnchor","getItemOffset","pageUp","findNextPageItemId","nextPageOffset","pageSize","pageOffset","scrollTop","getNextPageOffset","prevDifference","previousId","difference","absDifference","abs","useCompositeItem","rowIdProp","preventScrollOnKeyDown","tabbable","getItemProp","ariaSetSizeProp","ariaPosInSetProp","isActiveItem","ariaSetSize","ariaPosInSet","itemsInRow","hasFocusedComposite","targetIsAnotherItem","baseElement2","preventScrollOnKeyDownProp","canHomeEnd","isLeft","isRight","isUp","isDown","valueLength","nextId","shouldRegisterItem","CompositeItem","useCompositeContext","useCompositeProviderContext","CompositeContextProvider","CompositeScopedContextProvider","CompositeItemContext","CompositeRowContext","useDialogScopedContext","useDialogProviderContext","DialogContextProvider","DialogScopedContextProvider","DialogHeadingContext","DialogDescriptionContext","useCollectionItem","useDisclosureProviderContext","DisclosureContextProvider","DisclosureScopedContextProvider","setRef","getRefProperty","isValidElementWithRef","mergeProps","overrides","overrideValue","baseValue","FocusableContext","createDOMRect","DOMRect","toJSON","getAnchorElement","getAnchorRect","contextElement","anchorRect","getDOMRect","isValidPlacement","flip2","roundByDPR","dpr","devicePixelRatio","getOffsetMiddleware","arrowOffset","finalGutter","gutter","crossAxis","mainAxis","alignmentAxis","getFlipMiddleware","flip","fallbackPlacements","overflowPadding","getShiftMiddleware","slide","overlap","limiter","getSizeMiddleware","availableWidth","availableHeight","rects","floating","referenceWidth","reference","sameWidth","fitViewport","maxWidth","maxHeight","getArrowMiddleware","arrowPadding","usePopover","wrapperProps","fixed","shift2","updatePosition","defaultArrowElementRef","positioned","setPositioned","getAnchorRectProp","updatePositionProp","hasCustomUpdatePosition","updatePosition2","arrow2","middleware","strategy","transform","middlewareData","arrow","arrowX","arrowY","side","centerX","centerY","originX","originY","cancelAutoUpdate","elementResize","ResizeObserver","applyZIndex","Popover","getMouseDestination","nodeType","ELEMENT_NODE","useCompositeHover","focusOnHover","blurOnHoverEnd","focusOnHoverProp","onMouseLeaveProp","onMouseLeave","blurOnHoverEndProp","nextElement","hoveringInside","movingToAnotherItem","useCollectionContext","CollectionContextProvider","CollectionScopedContextProvider","ComboboxListRoleContext","useComboboxContext","useComboboxScopedContext","useComboboxProviderContext","ComboboxContextProvider","ComboboxScopedContextProvider","ComboboxItemValueContext","ComboboxItemCheckedContext","afterTimeout","timeoutId","parseCSSTime","times","longestTime","currentTimeString","multiplier","currentTime","parseFloat","isHidden","useDisclosureContent","otherElement","previousAnimated","animated2","afterPaint","stopAnimationSync","transitionDuration","animationDuration","transitionDelay","animationDelay","transitionDuration2","animationDuration2","transitionDelay2","animationDelay2","DisclosureContentImpl","useDisclosureStoreProps","useDisclosureStore","createTooltipStore","skipTimeout","tooltip","useTooltipStore","useTooltipStoreProps","useSyncExternalStore","noopSubscribe","useStoreState","keyOrSelector","storeSubscribe","getSnapshot","useStoreStateObject","objRef","useStoreProps","setKey","propsRef","setValue2","useStore","setStore","useState2","getItemRole","useComboboxItem","hideOnClick","setValueOnClick","selectValueOnClick","resetValueOnSelectState","selected","storeValue","itemValue","isSelected","setValueOnClickProp","selectValueOnClickProp","resetValueOnSelectProp","hideOnClickProp","prevValue","moveEvent","ComboboxItem","useComboboxPopover","hiddenByClickOutsideRef","treeSnapshotKey","selectors","controlElements","baseId","isController","ComboboxPopover","isFirstItemAutoSelected","autoSelect","hasCompletionString","useCombobox","autoSelectProp","getAutoSelectId","setValueOnChange","showMinLength","showOnChange","showOnMouseDown","showOnClick","showOnKeyDown","showOnKeyPress","blurActiveItemOnClick","autoComplete","valueUpdated","forceValueUpdate","canAutoSelectRef","composingRef","canInline","setCanInline","prevSelectedValueRef","inlineActiveValue","onCompositeItemMove","prevStart","prevEnd","nextStart","nextEnd","scrollingElementRef","getAutoSelectIdProp","autoSelectIdRef","onUserScroll","onScroll","passive","canAutoSelect","contentElement2","userAutoSelectId","autoSelectId","getDefaultAutoSelectId","onBlur2","canShow","onChangeProp","onChange","showOnChangeProp","setValueOnChangeProp","isInputEvent","isComposing","textInserted","inputType","caretAtEnd","isSameValue","onCompositionEndProp","onCompositionEnd","blurActiveItemOnClickProp","showOnClickProp","showOnKeyPressProp","repeat","ariaAutoComplete","isAriaAutoCompleteValue","Combobox","globalStore","activeStore","createRemoveStoreCallback","useTooltipAnchor","canShowOnHoverRef","onMouseEnterProp","onMouseEnter","onFocusVisibleProp","TooltipAnchor","POPOVER_ARROW_PATH","defaultSize","halfDefaultSize","rotateMap","usePopoverArrow","dir","setStyle","computedStyle","useComputedStyle","fill","stroke","borderWidth","strokeWidth","viewBox","fontSize","useTooltipArrow","TooltipArrow","TooltipProvider","useTooltip","Tooltip","createCoords","oppositeSideMap","oppositeAlignmentMap","clamp","getOppositeAxis","axis","getAxisLength","getAlignmentAxis","alignment","getOppositePlacement","expandPaddingObject","computeCoordsFromPlacement","sideAxis","alignLength","commonX","commonY","commonAlign","coords","detectOverflow","_await$platform$isEle","boundary","rootBoundary","elementContext","altBoundary","paddingObject","clippingClientRect","getClippingRect","isElement","getDocumentElement","offsetParent","getOffsetParent","offsetScale","getScale","elementClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","getCssDimensions","css","hasOffset","shouldFallback","unwrapElement","domElement","isFinite","noOffsets","getVisualOffsets","includeScale","isFixedStrategy","clientRect","scale","visualOffsets","isFixed","floatingOffsetParent","shouldAddVisualOffsets","offsetWin","currentWin","currentIFrame","iframeScale","iframeRect","clientLeft","paddingLeft","clientTop","paddingTop","getWindowScrollBarX","leftScroll","getHTMLOffset","scroll","ignoreScrollbarX","htmlRect","getClientRectFromClippingAncestor","clippingAncestor","html","visualViewportBased","getViewportRect","getDocumentRect","getInnerBoundingClientRect","hasFixedPositionAncestor","stopNode","parentNode","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsets","offsetRect","htmlOffset","isStaticPositioned","getTrueOffsetParent","polyfill","rawOffsetParent","svgOffsetParent","topLayer","clippingAncestors","cache","cachedResult","currentContainingBlockComputedStyle","elementIsFixed","currentNode","currentNodeIsContaining","getClippingElementAncestors","_c","firstClippingAncestor","clippingRect","accRect","getElementRects","getOffsetParentFn","getDimensionsFn","getDimensions","floatingDimensions","isRTL","autoUpdate","ancestorScroll","ancestorResize","layoutShift","animationFrame","referenceEl","ancestors","cleanupIo","onMove","io","_io","refresh","threshold","rootMargin","isFirstUpdate","handleObserve","ratio","intersectionRatio","observeMove","frameId","reobserveFrame","resizeObserver","firstEntry","unobserve","_resizeObserver","prevRefRect","frameLoop","nextRefRect","_resizeObserver2","_middlewareData$offse","_middlewareData$arrow","diffCoords","mainAxisMulti","crossAxisMulti","rawValue","convertValueToCoords","offset","alignmentOffset","checkMainAxis","checkCrossAxis","detectOverflowOptions","mainAxisCoord","crossAxisCoord","maxSide","limitedCoords","_middlewareData$flip","initialPlacement","specifiedFallbackPlacements","fallbackStrategy","fallbackAxisSideDirection","flipAlignment","initialSideAxis","isBasePlacement","oppositePlacement","getExpandedPlacements","hasFallbackAxisSideDirection","list","isStart","lr","rl","tb","bt","getSideList","getOppositeAxisPlacements","placements","overflows","overflowsData","sides","mainAlignmentSide","_middlewareData$flip2","_overflowsData$filter","nextPlacement","resetPlacement","_overflowsData$filter2","currentSideAxis","isYAxis","heightSide","widthSide","maximumClippingHeight","maximumClippingWidth","overflowAvailableHeight","overflowAvailableWidth","noShift","xMin","xMax","yMin","yMax","nextDimensions","arrowDimensions","minProp","maxProp","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","centerToReference","largestPossiblePadding","minPadding","maxPadding","min$1","center","shouldAddOffset","centerOffset","rawOffset","computedOffset","len","limitMin","limitMax","_middlewareData$offse2","isOriginSide","mergedOptions","platformWithCache","config","validMiddleware","statefulPlacement","resetCount","nextX","nextY","computePosition","hasWindow","getNodeName","isNode","_node$ownerDocument","Element","isHTMLElement","isShadowRoot","ShadowRoot","isOverflowElement","isTableElement","isTopLayer","isContainingBlock","elementOrCss","webkit","isWebKit","perspective","containerType","backdropFilter","willChange","contain","getContainingBlock","getParentNode","isLastTraversableNode","supports","getNodeScroll","assignedSlot","host","getNearestOverflowAncestor","getOverflowAncestors","traverseIframes","_node$ownerDocument2","scrollableAncestor","isBody","frameElement","getFrameElement","getPrototypeOf"],"sourceRoot":""}