{"version":3,"file":"static/chunks/8327-6f05dcae6888cd72.js","mappings":"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","sources":["webpack://_N_E/./node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.esm.js","webpack://_N_E/./node_modules/tabbable/dist/index.esm.js","webpack://_N_E/./node_modules/@floating-ui/react/dist/floating-ui.react.esm.js","webpack://_N_E/./node_modules/@mui/material/DialogTitle/DialogTitle.js","webpack://_N_E/./node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs","webpack://_N_E/./node_modules/@floating-ui/core/dist/floating-ui.core.mjs","webpack://_N_E/./node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs","webpack://_N_E/./node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs"],"sourcesContent":["import { arrow as arrow$1, computePosition } from '@floating-ui/dom';\nexport { autoPlacement, autoUpdate, computePosition, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size } from '@floating-ui/dom';\nimport * as React from 'react';\nimport { useLayoutEffect, useEffect } from 'react';\nimport * as ReactDOM from 'react-dom';\n\n/**\n * A data provider that provides data to position an inner element of the\n * floating element (usually a triangle or caret) so that it is centered to the\n * reference element.\n * This wraps the core `arrow` middleware to allow React refs as the element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => {\n  const {\n    element,\n    padding\n  } = options;\n  function isRef(value) {\n    return Object.prototype.hasOwnProperty.call(value, 'current');\n  }\n  return {\n    name: 'arrow',\n    options,\n    fn(args) {\n      if (isRef(element)) {\n        if (element.current != null) {\n          return arrow$1({\n            element: element.current,\n            padding\n          }).fn(args);\n        }\n        return {};\n      } else if (element) {\n        return arrow$1({\n          element,\n          padding\n        }).fn(args);\n      }\n      return {};\n    }\n  };\n};\n\nvar index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\n\n// Fork of `fast-deep-equal` that only does the comparisons we need and compares\n// functions\nfunction deepEqual(a, b) {\n  if (a === b) {\n    return true;\n  }\n  if (typeof a !== typeof b) {\n    return false;\n  }\n  if (typeof a === 'function' && a.toString() === b.toString()) {\n    return true;\n  }\n  let length, i, keys;\n  if (a && b && typeof a == 'object') {\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;) {\n        if (!deepEqual(a[i], b[i])) {\n          return false;\n        }\n      }\n      return true;\n    }\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) {\n      return false;\n    }\n    for (i = length; i-- !== 0;) {\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) {\n        return false;\n      }\n    }\n    for (i = length; i-- !== 0;) {\n      const key = keys[i];\n      if (key === '_owner' && a.$$typeof) {\n        continue;\n      }\n      if (!deepEqual(a[key], b[key])) {\n        return false;\n      }\n    }\n    return true;\n  }\n  return a !== a && b !== b;\n}\n\nfunction useLatestRef(value) {\n  const ref = React.useRef(value);\n  index(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n\n/**\n * Provides data to position a floating element.\n * @see https://floating-ui.com/docs/react\n */\nfunction useFloating(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform,\n    whileElementsMounted,\n    open\n  } = options;\n  const [data, setData] = React.useState({\n    x: null,\n    y: null,\n    strategy,\n    placement,\n    middlewareData: {},\n    isPositioned: false\n  });\n  const [latestMiddleware, setLatestMiddleware] = React.useState(middleware);\n  if (!deepEqual(latestMiddleware, middleware)) {\n    setLatestMiddleware(middleware);\n  }\n  const referenceRef = React.useRef(null);\n  const floatingRef = React.useRef(null);\n  const dataRef = React.useRef(data);\n  const whileElementsMountedRef = useLatestRef(whileElementsMounted);\n  const platformRef = useLatestRef(platform);\n  const [reference, _setReference] = React.useState(null);\n  const [floating, _setFloating] = React.useState(null);\n  const setReference = React.useCallback(node => {\n    if (referenceRef.current !== node) {\n      referenceRef.current = node;\n      _setReference(node);\n    }\n  }, []);\n  const setFloating = React.useCallback(node => {\n    if (floatingRef.current !== node) {\n      floatingRef.current = node;\n      _setFloating(node);\n    }\n  }, []);\n  const update = React.useCallback(() => {\n    if (!referenceRef.current || !floatingRef.current) {\n      return;\n    }\n    const config = {\n      placement,\n      strategy,\n      middleware: latestMiddleware\n    };\n    if (platformRef.current) {\n      config.platform = platformRef.current;\n    }\n    computePosition(referenceRef.current, floatingRef.current, config).then(data => {\n      const fullData = {\n        ...data,\n        isPositioned: true\n      };\n      if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {\n        dataRef.current = fullData;\n        ReactDOM.flushSync(() => {\n          setData(fullData);\n        });\n      }\n    });\n  }, [latestMiddleware, placement, strategy, platformRef]);\n  index(() => {\n    if (open === false && dataRef.current.isPositioned) {\n      dataRef.current.isPositioned = false;\n      setData(data => ({\n        ...data,\n        isPositioned: false\n      }));\n    }\n  }, [open]);\n  const isMountedRef = React.useRef(false);\n  index(() => {\n    isMountedRef.current = true;\n    return () => {\n      isMountedRef.current = false;\n    };\n  }, []);\n  index(() => {\n    if (reference && floating) {\n      if (whileElementsMountedRef.current) {\n        return whileElementsMountedRef.current(reference, floating, update);\n      } else {\n        update();\n      }\n    }\n  }, [reference, floating, update, whileElementsMountedRef]);\n  const refs = React.useMemo(() => ({\n    reference: referenceRef,\n    floating: floatingRef,\n    setReference,\n    setFloating\n  }), [setReference, setFloating]);\n  const elements = React.useMemo(() => ({\n    reference,\n    floating\n  }), [reference, floating]);\n  return React.useMemo(() => ({\n    ...data,\n    update,\n    refs,\n    elements,\n    reference: setReference,\n    floating: setFloating\n  }), [data, update, refs, elements, setReference, setFloating]);\n}\n\nexport { arrow, useFloating };\n","/*!\n* tabbable 6.2.0\n* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE\n*/\n// NOTE: separate `:not()` selectors has broader browser support than the newer\n//  `:not([inert], [inert] *)` (Feb 2023)\n// CAREFUL: JSDom does not support `:not([inert] *)` as a selector; using it causes\n//  the entire query to fail, resulting in no nodes found, which will break a lot\n//  of things... so we have to rely on JS to identify nodes inside an inert container\nvar candidateSelectors = ['input:not([inert])', 'select:not([inert])', 'textarea:not([inert])', 'a[href]:not([inert])', 'button:not([inert])', '[tabindex]:not(slot):not([inert])', 'audio[controls]:not([inert])', 'video[controls]:not([inert])', '[contenteditable]:not([contenteditable=\"false\"]):not([inert])', 'details>summary:first-of-type:not([inert])', 'details:not([inert])'];\nvar candidateSelector = /* #__PURE__ */candidateSelectors.join(',');\nvar NoElement = typeof Element === 'undefined';\nvar matches = NoElement ? function () {} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;\nvar getRootNode = !NoElement && Element.prototype.getRootNode ? function (element) {\n  var _element$getRootNode;\n  return element === null || element === void 0 ? void 0 : (_element$getRootNode = element.getRootNode) === null || _element$getRootNode === void 0 ? void 0 : _element$getRootNode.call(element);\n} : function (element) {\n  return element === null || element === void 0 ? void 0 : element.ownerDocument;\n};\n\n/**\n * Determines if a node is inert or in an inert ancestor.\n * @param {Element} [node]\n * @param {boolean} [lookUp] If true and `node` is not inert, looks up at ancestors to\n *  see if any of them are inert. If false, only `node` itself is considered.\n * @returns {boolean} True if inert itself or by way of being in an inert ancestor.\n *  False if `node` is falsy.\n */\nvar isInert = function isInert(node, lookUp) {\n  var _node$getAttribute;\n  if (lookUp === void 0) {\n    lookUp = true;\n  }\n  // CAREFUL: JSDom does not support inert at all, so we can't use the `HTMLElement.inert`\n  //  JS API property; we have to check the attribute, which can either be empty or 'true';\n  //  if it's `null` (not specified) or 'false', it's an active element\n  var inertAtt = node === null || node === void 0 ? void 0 : (_node$getAttribute = node.getAttribute) === null || _node$getAttribute === void 0 ? void 0 : _node$getAttribute.call(node, 'inert');\n  var inert = inertAtt === '' || inertAtt === 'true';\n\n  // NOTE: this could also be handled with `node.matches('[inert], :is([inert] *)')`\n  //  if it weren't for `matches()` not being a function on shadow roots; the following\n  //  code works for any kind of node\n  // CAREFUL: JSDom does not appear to support certain selectors like `:not([inert] *)`\n  //  so it likely would not support `:is([inert] *)` either...\n  var result = inert || lookUp && node && isInert(node.parentNode); // recursive\n\n  return result;\n};\n\n/**\n * Determines if a node's content is editable.\n * @param {Element} [node]\n * @returns True if it's content-editable; false if it's not or `node` is falsy.\n */\nvar isContentEditable = function isContentEditable(node) {\n  var _node$getAttribute2;\n  // CAREFUL: JSDom does not support the `HTMLElement.isContentEditable` API so we have\n  //  to use the attribute directly to check for this, which can either be empty or 'true';\n  //  if it's `null` (not specified) or 'false', it's a non-editable element\n  var attValue = node === null || node === void 0 ? void 0 : (_node$getAttribute2 = node.getAttribute) === null || _node$getAttribute2 === void 0 ? void 0 : _node$getAttribute2.call(node, 'contenteditable');\n  return attValue === '' || attValue === 'true';\n};\n\n/**\n * @param {Element} el container to check in\n * @param {boolean} includeContainer add container to check\n * @param {(node: Element) => boolean} filter filter candidates\n * @returns {Element[]}\n */\nvar getCandidates = function getCandidates(el, includeContainer, filter) {\n  // even if `includeContainer=false`, we still have to check it for inertness because\n  //  if it's inert, all its children are inert\n  if (isInert(el)) {\n    return [];\n  }\n  var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));\n  if (includeContainer && matches.call(el, candidateSelector)) {\n    candidates.unshift(el);\n  }\n  candidates = candidates.filter(filter);\n  return candidates;\n};\n\n/**\n * @callback GetShadowRoot\n * @param {Element} element to check for shadow root\n * @returns {ShadowRoot|boolean} ShadowRoot if available or boolean indicating if a shadowRoot is attached but not available.\n */\n\n/**\n * @callback ShadowRootFilter\n * @param {Element} shadowHostNode the element which contains shadow content\n * @returns {boolean} true if a shadow root could potentially contain valid candidates.\n */\n\n/**\n * @typedef {Object} CandidateScope\n * @property {Element} scopeParent contains inner candidates\n * @property {Element[]} candidates list of candidates found in the scope parent\n */\n\n/**\n * @typedef {Object} IterativeOptions\n * @property {GetShadowRoot|boolean} getShadowRoot true if shadow support is enabled; falsy if not;\n *  if a function, implies shadow support is enabled and either returns the shadow root of an element\n *  or a boolean stating if it has an undisclosed shadow root\n * @property {(node: Element) => boolean} filter filter candidates\n * @property {boolean} flatten if true then result will flatten any CandidateScope into the returned list\n * @property {ShadowRootFilter} shadowRootFilter filter shadow roots;\n */\n\n/**\n * @param {Element[]} elements list of element containers to match candidates from\n * @param {boolean} includeContainer add container list to check\n * @param {IterativeOptions} options\n * @returns {Array.<Element|CandidateScope>}\n */\nvar getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {\n  var candidates = [];\n  var elementsToCheck = Array.from(elements);\n  while (elementsToCheck.length) {\n    var element = elementsToCheck.shift();\n    if (isInert(element, false)) {\n      // no need to look up since we're drilling down\n      // anything inside this container will also be inert\n      continue;\n    }\n    if (element.tagName === 'SLOT') {\n      // add shadow dom slot scope (slot itself cannot be focusable)\n      var assigned = element.assignedElements();\n      var content = assigned.length ? assigned : element.children;\n      var nestedCandidates = getCandidatesIteratively(content, true, options);\n      if (options.flatten) {\n        candidates.push.apply(candidates, nestedCandidates);\n      } else {\n        candidates.push({\n          scopeParent: element,\n          candidates: nestedCandidates\n        });\n      }\n    } else {\n      // check candidate element\n      var validCandidate = matches.call(element, candidateSelector);\n      if (validCandidate && options.filter(element) && (includeContainer || !elements.includes(element))) {\n        candidates.push(element);\n      }\n\n      // iterate over shadow content if possible\n      var shadowRoot = element.shadowRoot ||\n      // check for an undisclosed shadow\n      typeof options.getShadowRoot === 'function' && options.getShadowRoot(element);\n\n      // no inert look up because we're already drilling down and checking for inertness\n      //  on the way down, so all containers to this root node should have already been\n      //  vetted as non-inert\n      var validShadowRoot = !isInert(shadowRoot, false) && (!options.shadowRootFilter || options.shadowRootFilter(element));\n      if (shadowRoot && validShadowRoot) {\n        // add shadow dom scope IIF a shadow root node was given; otherwise, an undisclosed\n        //  shadow exists, so look at light dom children as fallback BUT create a scope for any\n        //  child candidates found because they're likely slotted elements (elements that are\n        //  children of the web component element (which has the shadow), in the light dom, but\n        //  slotted somewhere _inside_ the undisclosed shadow) -- the scope is created below,\n        //  _after_ we return from this recursive call\n        var _nestedCandidates = getCandidatesIteratively(shadowRoot === true ? element.children : shadowRoot.children, true, options);\n        if (options.flatten) {\n          candidates.push.apply(candidates, _nestedCandidates);\n        } else {\n          candidates.push({\n            scopeParent: element,\n            candidates: _nestedCandidates\n          });\n        }\n      } else {\n        // there's not shadow so just dig into the element's (light dom) children\n        //  __without__ giving the element special scope treatment\n        elementsToCheck.unshift.apply(elementsToCheck, element.children);\n      }\n    }\n  }\n  return candidates;\n};\n\n/**\n * @private\n * Determines if the node has an explicitly specified `tabindex` attribute.\n * @param {HTMLElement} node\n * @returns {boolean} True if so; false if not.\n */\nvar hasTabIndex = function hasTabIndex(node) {\n  return !isNaN(parseInt(node.getAttribute('tabindex'), 10));\n};\n\n/**\n * Determine the tab index of a given node.\n * @param {HTMLElement} node\n * @returns {number} Tab order (negative, 0, or positive number).\n * @throws {Error} If `node` is falsy.\n */\nvar getTabIndex = function getTabIndex(node) {\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (node.tabIndex < 0) {\n    // in Chrome, <details/>, <audio controls/> and <video controls/> elements get a default\n    // `tabIndex` of -1 when the 'tabindex' attribute isn't specified in the DOM,\n    // yet they are still part of the regular tab order; in FF, they get a default\n    // `tabIndex` of 0; since Chrome still puts those elements in the regular tab\n    // order, consider their tab index to be 0.\n    // Also browsers do not return `tabIndex` correctly for contentEditable nodes;\n    // so if they don't have a tabindex attribute specifically set, assume it's 0.\n    if ((/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || isContentEditable(node)) && !hasTabIndex(node)) {\n      return 0;\n    }\n  }\n  return node.tabIndex;\n};\n\n/**\n * Determine the tab index of a given node __for sort order purposes__.\n * @param {HTMLElement} node\n * @param {boolean} [isScope] True for a custom element with shadow root or slot that, by default,\n *  has tabIndex -1, but needs to be sorted by document order in order for its content to be\n *  inserted into the correct sort position.\n * @returns {number} Tab order (negative, 0, or positive number).\n */\nvar getSortOrderTabIndex = function getSortOrderTabIndex(node, isScope) {\n  var tabIndex = getTabIndex(node);\n  if (tabIndex < 0 && isScope && !hasTabIndex(node)) {\n    return 0;\n  }\n  return tabIndex;\n};\nvar sortOrderedTabbables = function sortOrderedTabbables(a, b) {\n  return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;\n};\nvar isInput = function isInput(node) {\n  return node.tagName === 'INPUT';\n};\nvar isHiddenInput = function isHiddenInput(node) {\n  return isInput(node) && node.type === 'hidden';\n};\nvar isDetailsWithSummary = function isDetailsWithSummary(node) {\n  var r = node.tagName === 'DETAILS' && Array.prototype.slice.apply(node.children).some(function (child) {\n    return child.tagName === 'SUMMARY';\n  });\n  return r;\n};\nvar getCheckedRadio = function getCheckedRadio(nodes, form) {\n  for (var i = 0; i < nodes.length; i++) {\n    if (nodes[i].checked && nodes[i].form === form) {\n      return nodes[i];\n    }\n  }\n};\nvar isTabbableRadio = function isTabbableRadio(node) {\n  if (!node.name) {\n    return true;\n  }\n  var radioScope = node.form || getRootNode(node);\n  var queryRadios = function queryRadios(name) {\n    return radioScope.querySelectorAll('input[type=\"radio\"][name=\"' + name + '\"]');\n  };\n  var radioSet;\n  if (typeof window !== 'undefined' && typeof window.CSS !== 'undefined' && typeof window.CSS.escape === 'function') {\n    radioSet = queryRadios(window.CSS.escape(node.name));\n  } else {\n    try {\n      radioSet = queryRadios(node.name);\n    } catch (err) {\n      // eslint-disable-next-line no-console\n      console.error('Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s', err.message);\n      return false;\n    }\n  }\n  var checked = getCheckedRadio(radioSet, node.form);\n  return !checked || checked === node;\n};\nvar isRadio = function isRadio(node) {\n  return isInput(node) && node.type === 'radio';\n};\nvar isNonTabbableRadio = function isNonTabbableRadio(node) {\n  return isRadio(node) && !isTabbableRadio(node);\n};\n\n// determines if a node is ultimately attached to the window's document\nvar isNodeAttached = function isNodeAttached(node) {\n  var _nodeRoot;\n  // The root node is the shadow root if the node is in a shadow DOM; some document otherwise\n  //  (but NOT _the_ document; see second 'If' comment below for more).\n  // If rootNode is shadow root, it'll have a host, which is the element to which the shadow\n  //  is attached, and the one we need to check if it's in the document or not (because the\n  //  shadow, and all nodes it contains, is never considered in the document since shadows\n  //  behave like self-contained DOMs; but if the shadow's HOST, which is part of the document,\n  //  is hidden, or is not in the document itself but is detached, it will affect the shadow's\n  //  visibility, including all the nodes it contains). The host could be any normal node,\n  //  or a custom element (i.e. web component). Either way, that's the one that is considered\n  //  part of the document, not the shadow root, nor any of its children (i.e. the node being\n  //  tested).\n  // To further complicate things, we have to look all the way up until we find a shadow HOST\n  //  that is attached (or find none) because the node might be in nested shadows...\n  // If rootNode is not a shadow root, it won't have a host, and so rootNode should be the\n  //  document (per the docs) and while it's a Document-type object, that document does not\n  //  appear to be the same as the node's `ownerDocument` for some reason, so it's safer\n  //  to ignore the rootNode at this point, and use `node.ownerDocument`. Otherwise,\n  //  using `rootNode.contains(node)` will _always_ be true we'll get false-positives when\n  //  node is actually detached.\n  // NOTE: If `nodeRootHost` or `node` happens to be the `document` itself (which is possible\n  //  if a tabbable/focusable node was quickly added to the DOM, focused, and then removed\n  //  from the DOM as in https://github.com/focus-trap/focus-trap-react/issues/905), then\n  //  `ownerDocument` will be `null`, hence the optional chaining on it.\n  var nodeRoot = node && getRootNode(node);\n  var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;\n\n  // in some cases, a detached node will return itself as the root instead of a document or\n  //  shadow root object, in which case, we shouldn't try to look further up the host chain\n  var attached = false;\n  if (nodeRoot && nodeRoot !== node) {\n    var _nodeRootHost, _nodeRootHost$ownerDo, _node$ownerDocument;\n    attached = !!((_nodeRootHost = nodeRootHost) !== null && _nodeRootHost !== void 0 && (_nodeRootHost$ownerDo = _nodeRootHost.ownerDocument) !== null && _nodeRootHost$ownerDo !== void 0 && _nodeRootHost$ownerDo.contains(nodeRootHost) || node !== null && node !== void 0 && (_node$ownerDocument = node.ownerDocument) !== null && _node$ownerDocument !== void 0 && _node$ownerDocument.contains(node));\n    while (!attached && nodeRootHost) {\n      var _nodeRoot2, _nodeRootHost2, _nodeRootHost2$ownerD;\n      // since it's not attached and we have a root host, the node MUST be in a nested shadow DOM,\n      //  which means we need to get the host's host and check if that parent host is contained\n      //  in (i.e. attached to) the document\n      nodeRoot = getRootNode(nodeRootHost);\n      nodeRootHost = (_nodeRoot2 = nodeRoot) === null || _nodeRoot2 === void 0 ? void 0 : _nodeRoot2.host;\n      attached = !!((_nodeRootHost2 = nodeRootHost) !== null && _nodeRootHost2 !== void 0 && (_nodeRootHost2$ownerD = _nodeRootHost2.ownerDocument) !== null && _nodeRootHost2$ownerD !== void 0 && _nodeRootHost2$ownerD.contains(nodeRootHost));\n    }\n  }\n  return attached;\n};\nvar isZeroArea = function isZeroArea(node) {\n  var _node$getBoundingClie = node.getBoundingClientRect(),\n    width = _node$getBoundingClie.width,\n    height = _node$getBoundingClie.height;\n  return width === 0 && height === 0;\n};\nvar isHidden = function isHidden(node, _ref) {\n  var displayCheck = _ref.displayCheck,\n    getShadowRoot = _ref.getShadowRoot;\n  // NOTE: visibility will be `undefined` if node is detached from the document\n  //  (see notes about this further down), which means we will consider it visible\n  //  (this is legacy behavior from a very long way back)\n  // NOTE: we check this regardless of `displayCheck=\"none\"` because this is a\n  //  _visibility_ check, not a _display_ check\n  if (getComputedStyle(node).visibility === 'hidden') {\n    return true;\n  }\n  var isDirectSummary = matches.call(node, 'details>summary:first-of-type');\n  var nodeUnderDetails = isDirectSummary ? node.parentElement : node;\n  if (matches.call(nodeUnderDetails, 'details:not([open]) *')) {\n    return true;\n  }\n  if (!displayCheck || displayCheck === 'full' || displayCheck === 'legacy-full') {\n    if (typeof getShadowRoot === 'function') {\n      // figure out if we should consider the node to be in an undisclosed shadow and use the\n      //  'non-zero-area' fallback\n      var originalNode = node;\n      while (node) {\n        var parentElement = node.parentElement;\n        var rootNode = getRootNode(node);\n        if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true // check if there's an undisclosed shadow\n        ) {\n          // node has an undisclosed shadow which means we can only treat it as a black box, so we\n          //  fall back to a non-zero-area test\n          return isZeroArea(node);\n        } else if (node.assignedSlot) {\n          // iterate up slot\n          node = node.assignedSlot;\n        } else if (!parentElement && rootNode !== node.ownerDocument) {\n          // cross shadow boundary\n          node = rootNode.host;\n        } else {\n          // iterate up normal dom\n          node = parentElement;\n        }\n      }\n      node = originalNode;\n    }\n    // else, `getShadowRoot` might be true, but all that does is enable shadow DOM support\n    //  (i.e. it does not also presume that all nodes might have undisclosed shadows); or\n    //  it might be a falsy value, which means shadow DOM support is disabled\n\n    // Since we didn't find it sitting in an undisclosed shadow (or shadows are disabled)\n    //  now we can just test to see if it would normally be visible or not, provided it's\n    //  attached to the main document.\n    // NOTE: We must consider case where node is inside a shadow DOM and given directly to\n    //  `isTabbable()` or `isFocusable()` -- regardless of `getShadowRoot` option setting.\n\n    if (isNodeAttached(node)) {\n      // this works wherever the node is: if there's at least one client rect, it's\n      //  somehow displayed; it also covers the CSS 'display: contents' case where the\n      //  node itself is hidden in place of its contents; and there's no need to search\n      //  up the hierarchy either\n      return !node.getClientRects().length;\n    }\n\n    // Else, the node isn't attached to the document, which means the `getClientRects()`\n    //  API will __always__ return zero rects (this can happen, for example, if React\n    //  is used to render nodes onto a detached tree, as confirmed in this thread:\n    //  https://github.com/facebook/react/issues/9117#issuecomment-284228870)\n    //\n    // It also means that even window.getComputedStyle(node).display will return `undefined`\n    //  because styles are only computed for nodes that are in the document.\n    //\n    // NOTE: THIS HAS BEEN THE CASE FOR YEARS. It is not new, nor is it caused by tabbable\n    //  somehow. Though it was never stated officially, anyone who has ever used tabbable\n    //  APIs on nodes in detached containers has actually implicitly used tabbable in what\n    //  was later (as of v5.2.0 on Apr 9, 2021) called `displayCheck=\"none\"` mode -- essentially\n    //  considering __everything__ to be visible because of the innability to determine styles.\n    //\n    // v6.0.0: As of this major release, the default 'full' option __no longer treats detached\n    //  nodes as visible with the 'none' fallback.__\n    if (displayCheck !== 'legacy-full') {\n      return true; // hidden\n    }\n    // else, fallback to 'none' mode and consider the node visible\n  } else if (displayCheck === 'non-zero-area') {\n    // NOTE: Even though this tests that the node's client rect is non-zero to determine\n    //  whether it's displayed, and that a detached node will __always__ have a zero-area\n    //  client rect, we don't special-case for whether the node is attached or not. In\n    //  this mode, we do want to consider nodes that have a zero area to be hidden at all\n    //  times, and that includes attached or not.\n    return isZeroArea(node);\n  }\n\n  // visible, as far as we can tell, or per current `displayCheck=none` mode, we assume\n  //  it's visible\n  return false;\n};\n\n// form fields (nested) inside a disabled fieldset are not focusable/tabbable\n//  unless they are in the _first_ <legend> element of the top-most disabled\n//  fieldset\nvar isDisabledFromFieldset = function isDisabledFromFieldset(node) {\n  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {\n    var parentNode = node.parentElement;\n    // check if `node` is contained in a disabled <fieldset>\n    while (parentNode) {\n      if (parentNode.tagName === 'FIELDSET' && parentNode.disabled) {\n        // look for the first <legend> among the children of the disabled <fieldset>\n        for (var i = 0; i < parentNode.children.length; i++) {\n          var child = parentNode.children.item(i);\n          // when the first <legend> (in document order) is found\n          if (child.tagName === 'LEGEND') {\n            // if its parent <fieldset> is not nested in another disabled <fieldset>,\n            // return whether `node` is a descendant of its first <legend>\n            return matches.call(parentNode, 'fieldset[disabled] *') ? true : !child.contains(node);\n          }\n        }\n        // the disabled <fieldset> containing `node` has no <legend>\n        return true;\n      }\n      parentNode = parentNode.parentElement;\n    }\n  }\n\n  // else, node's tabbable/focusable state should not be affected by a fieldset's\n  //  enabled/disabled state\n  return false;\n};\nvar isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable(options, node) {\n  if (node.disabled ||\n  // we must do an inert look up to filter out any elements inside an inert ancestor\n  //  because we're limited in the type of selectors we can use in JSDom (see related\n  //  note related to `candidateSelectors`)\n  isInert(node) || isHiddenInput(node) || isHidden(node, options) ||\n  // For a details element with a summary, the summary element gets the focus\n  isDetailsWithSummary(node) || isDisabledFromFieldset(node)) {\n    return false;\n  }\n  return true;\n};\nvar isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable(options, node) {\n  if (isNonTabbableRadio(node) || getTabIndex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) {\n    return false;\n  }\n  return true;\n};\nvar isValidShadowRootTabbable = function isValidShadowRootTabbable(shadowHostNode) {\n  var tabIndex = parseInt(shadowHostNode.getAttribute('tabindex'), 10);\n  if (isNaN(tabIndex) || tabIndex >= 0) {\n    return true;\n  }\n  // If a custom element has an explicit negative tabindex,\n  // browsers will not allow tab targeting said element's children.\n  return false;\n};\n\n/**\n * @param {Array.<Element|CandidateScope>} candidates\n * @returns Element[]\n */\nvar sortByOrder = function sortByOrder(candidates) {\n  var regularTabbables = [];\n  var orderedTabbables = [];\n  candidates.forEach(function (item, i) {\n    var isScope = !!item.scopeParent;\n    var element = isScope ? item.scopeParent : item;\n    var candidateTabindex = getSortOrderTabIndex(element, isScope);\n    var elements = isScope ? sortByOrder(item.candidates) : element;\n    if (candidateTabindex === 0) {\n      isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);\n    } else {\n      orderedTabbables.push({\n        documentOrder: i,\n        tabIndex: candidateTabindex,\n        item: item,\n        isScope: isScope,\n        content: elements\n      });\n    }\n  });\n  return orderedTabbables.sort(sortOrderedTabbables).reduce(function (acc, sortable) {\n    sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);\n    return acc;\n  }, []).concat(regularTabbables);\n};\nvar tabbable = function tabbable(container, options) {\n  options = options || {};\n  var candidates;\n  if (options.getShadowRoot) {\n    candidates = getCandidatesIteratively([container], options.includeContainer, {\n      filter: isNodeMatchingSelectorTabbable.bind(null, options),\n      flatten: false,\n      getShadowRoot: options.getShadowRoot,\n      shadowRootFilter: isValidShadowRootTabbable\n    });\n  } else {\n    candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));\n  }\n  return sortByOrder(candidates);\n};\nvar focusable = function focusable(container, options) {\n  options = options || {};\n  var candidates;\n  if (options.getShadowRoot) {\n    candidates = getCandidatesIteratively([container], options.includeContainer, {\n      filter: isNodeMatchingSelectorFocusable.bind(null, options),\n      flatten: true,\n      getShadowRoot: options.getShadowRoot\n    });\n  } else {\n    candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));\n  }\n  return candidates;\n};\nvar isTabbable = function isTabbable(node, options) {\n  options = options || {};\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (matches.call(node, candidateSelector) === false) {\n    return false;\n  }\n  return isNodeMatchingSelectorTabbable(options, node);\n};\nvar focusableCandidateSelector = /* #__PURE__ */candidateSelectors.concat('iframe').join(',');\nvar isFocusable = function isFocusable(node, options) {\n  options = options || {};\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (matches.call(node, focusableCandidateSelector) === false) {\n    return false;\n  }\n  return isNodeMatchingSelectorFocusable(options, node);\n};\n\nexport { focusable, getTabIndex, isFocusable, isTabbable, tabbable };\n//# sourceMappingURL=index.esm.js.map\n","import * as React from 'react';\nimport { useLayoutEffect, useEffect, useRef } from 'react';\nimport { hideOthers } from 'aria-hidden';\nimport { tabbable } from 'tabbable';\nimport { createPortal, flushSync } from 'react-dom';\nimport { getOverflowAncestors, offset, detectOverflow, useFloating as useFloating$1 } from '@floating-ui/react-dom';\nexport { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size } from '@floating-ui/react-dom';\n\nvar index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\n\nlet serverHandoffComplete = false;\nlet count = 0;\nconst genId = () => \"floating-ui-\" + count++;\nfunction useFloatingId() {\n  const [id, setId] = React.useState(() => serverHandoffComplete ? genId() : undefined);\n  index(() => {\n    if (id == null) {\n      setId(genId());\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n  React.useEffect(() => {\n    if (!serverHandoffComplete) {\n      serverHandoffComplete = true;\n    }\n  }, []);\n  return id;\n}\n\n// `toString()` prevents bundlers from trying to `import { useId } from 'react'`\nconst useReactId = React[/*#__PURE__*/'useId'.toString()];\n\n/**\n * Uses React 18's built-in `useId()` when available, or falls back to a\n * slightly less performant (requiring a double render) implementation for\n * earlier React versions.\n * @see https://floating-ui.com/docs/useId\n */\nconst useId = useReactId || useFloatingId;\n\nfunction createPubSub() {\n  const map = new Map();\n  return {\n    emit(event, data) {\n      var _map$get;\n      (_map$get = map.get(event)) == null ? void 0 : _map$get.forEach(handler => handler(data));\n    },\n    on(event, listener) {\n      map.set(event, [...(map.get(event) || []), listener]);\n    },\n    off(event, listener) {\n      map.set(event, (map.get(event) || []).filter(l => l !== listener));\n    }\n  };\n}\n\nconst FloatingNodeContext = /*#__PURE__*/React.createContext(null);\nconst FloatingTreeContext = /*#__PURE__*/React.createContext(null);\nconst useFloatingParentNodeId = () => {\n  var _React$useContext;\n  return ((_React$useContext = React.useContext(FloatingNodeContext)) == null ? void 0 : _React$useContext.id) || null;\n};\nconst useFloatingTree = () => React.useContext(FloatingTreeContext);\n\n/**\n * Registers a node into the floating tree, returning its id.\n */\nconst useFloatingNodeId = customParentId => {\n  const id = useId();\n  const tree = useFloatingTree();\n  const reactParentId = useFloatingParentNodeId();\n  const parentId = customParentId || reactParentId;\n  index(() => {\n    const node = {\n      id,\n      parentId\n    };\n    tree == null ? void 0 : tree.addNode(node);\n    return () => {\n      tree == null ? void 0 : tree.removeNode(node);\n    };\n  }, [tree, id, parentId]);\n  return id;\n};\n\n/**\n * Provides parent node context for nested floating elements.\n * @see https://floating-ui.com/docs/FloatingTree\n */\nconst FloatingNode = _ref => {\n  let {\n    children,\n    id\n  } = _ref;\n  const parentId = useFloatingParentNodeId();\n  return /*#__PURE__*/React.createElement(FloatingNodeContext.Provider, {\n    value: React.useMemo(() => ({\n      id,\n      parentId\n    }), [id, parentId])\n  }, children);\n};\n\n/**\n * Provides context for nested floating elements when they are not children of\n * each other on the DOM (i.e. portalled to a common node, rather than their\n * respective parent).\n * @see https://floating-ui.com/docs/FloatingTree\n */\nconst FloatingTree = _ref2 => {\n  let {\n    children\n  } = _ref2;\n  const nodesRef = React.useRef([]);\n  const addNode = React.useCallback(node => {\n    nodesRef.current = [...nodesRef.current, node];\n  }, []);\n  const removeNode = React.useCallback(node => {\n    nodesRef.current = nodesRef.current.filter(n => n !== node);\n  }, []);\n  const events = React.useState(() => createPubSub())[0];\n  return /*#__PURE__*/React.createElement(FloatingTreeContext.Provider, {\n    value: React.useMemo(() => ({\n      nodesRef,\n      addNode,\n      removeNode,\n      events\n    }), [nodesRef, addNode, removeNode, events])\n  }, children);\n};\n\nfunction getDocument(node) {\n  return (node == null ? void 0 : node.ownerDocument) || document;\n}\n\n// Avoid Chrome DevTools blue warning.\nfunction getPlatform() {\n  const uaData = navigator.userAgentData;\n  if (uaData != null && uaData.platform) {\n    return uaData.platform;\n  }\n  return navigator.platform;\n}\nfunction getUserAgent() {\n  const uaData = navigator.userAgentData;\n  if (uaData && Array.isArray(uaData.brands)) {\n    return uaData.brands.map(_ref => {\n      let {\n        brand,\n        version\n      } = _ref;\n      return brand + \"/\" + version;\n    }).join(' ');\n  }\n  return navigator.userAgent;\n}\n\nfunction getWindow(value) {\n  return getDocument(value).defaultView || window;\n}\nfunction isElement(value) {\n  return value ? value instanceof getWindow(value).Element : false;\n}\nfunction isHTMLElement(value) {\n  return value ? value instanceof getWindow(value).HTMLElement : false;\n}\nfunction isShadowRoot(node) {\n  // Browsers without `ShadowRoot` support\n  if (typeof ShadowRoot === 'undefined') {\n    return false;\n  }\n  const OwnElement = getWindow(node).ShadowRoot;\n  return node instanceof OwnElement || node instanceof ShadowRoot;\n}\n\n// License: https://github.com/adobe/react-spectrum/blob/b35d5c02fe900badccd0cf1a8f23bb593419f238/packages/@react-aria/utils/src/isVirtualEvent.ts\nfunction isVirtualClick(event) {\n  if (event.mozInputSource === 0 && event.isTrusted) {\n    return true;\n  }\n  const androidRe = /Android/i;\n  if ((androidRe.test(getPlatform()) || androidRe.test(getUserAgent())) && event.pointerType) {\n    return event.type === 'click' && event.buttons === 1;\n  }\n  return event.detail === 0 && !event.pointerType;\n}\nfunction isVirtualPointerEvent(event) {\n  return event.width === 0 && event.height === 0 || event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType !== 'mouse' ||\n  // iOS VoiceOver returns 0.333• for width/height.\n  event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0;\n}\nfunction isSafari() {\n  // Chrome DevTools does not complain about navigator.vendor\n  return /apple/i.test(navigator.vendor);\n}\nfunction isMac() {\n  return getPlatform().toLowerCase().startsWith('mac') && !navigator.maxTouchPoints;\n}\nfunction isMouseLikePointerType(pointerType, strict) {\n  // On some Linux machines with Chromium, mouse inputs return a `pointerType`\n  // of \"pen\": https://github.com/floating-ui/floating-ui/issues/2015\n  const values = ['mouse', 'pen'];\n  if (!strict) {\n    values.push('', undefined);\n  }\n  return values.includes(pointerType);\n}\n\nfunction useLatestRef(value) {\n  const ref = useRef(value);\n  index(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n\nconst safePolygonIdentifier = 'data-floating-ui-safe-polygon';\nfunction getDelay(value, prop, pointerType) {\n  if (pointerType && !isMouseLikePointerType(pointerType)) {\n    return 0;\n  }\n  if (typeof value === 'number') {\n    return value;\n  }\n  return value == null ? void 0 : value[prop];\n}\n/**\n * Opens the floating element while hovering over the reference element, like\n * CSS `:hover`.\n * @see https://floating-ui.com/docs/useHover\n */\nconst useHover = function (context, _temp) {\n  let {\n    enabled = true,\n    delay = 0,\n    handleClose = null,\n    mouseOnly = false,\n    restMs = 0,\n    move = true\n  } = _temp === void 0 ? {} : _temp;\n  const {\n    open,\n    onOpenChange,\n    dataRef,\n    events,\n    elements: {\n      domReference,\n      floating\n    },\n    refs\n  } = context;\n  const tree = useFloatingTree();\n  const parentId = useFloatingParentNodeId();\n  const handleCloseRef = useLatestRef(handleClose);\n  const delayRef = useLatestRef(delay);\n  const pointerTypeRef = React.useRef();\n  const timeoutRef = React.useRef();\n  const handlerRef = React.useRef();\n  const restTimeoutRef = React.useRef();\n  const blockMouseMoveRef = React.useRef(true);\n  const performedPointerEventsMutationRef = React.useRef(false);\n  const unbindMouseMoveRef = React.useRef(() => {});\n  const isHoverOpen = React.useCallback(() => {\n    var _dataRef$current$open;\n    const type = (_dataRef$current$open = dataRef.current.openEvent) == null ? void 0 : _dataRef$current$open.type;\n    return (type == null ? void 0 : type.includes('mouse')) && type !== 'mousedown';\n  }, [dataRef]);\n\n  // When dismissing before opening, clear the delay timeouts to cancel it\n  // from showing.\n  React.useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n    function onDismiss() {\n      clearTimeout(timeoutRef.current);\n      clearTimeout(restTimeoutRef.current);\n      blockMouseMoveRef.current = true;\n    }\n    events.on('dismiss', onDismiss);\n    return () => {\n      events.off('dismiss', onDismiss);\n    };\n  }, [enabled, events]);\n  React.useEffect(() => {\n    if (!enabled || !handleCloseRef.current || !open) {\n      return;\n    }\n    function onLeave() {\n      if (isHoverOpen()) {\n        onOpenChange(false);\n      }\n    }\n    const html = getDocument(floating).documentElement;\n    html.addEventListener('mouseleave', onLeave);\n    return () => {\n      html.removeEventListener('mouseleave', onLeave);\n    };\n  }, [floating, open, onOpenChange, enabled, handleCloseRef, dataRef, isHoverOpen]);\n  const closeWithDelay = React.useCallback(function (runElseBranch) {\n    if (runElseBranch === void 0) {\n      runElseBranch = true;\n    }\n    const closeDelay = getDelay(delayRef.current, 'close', pointerTypeRef.current);\n    if (closeDelay && !handlerRef.current) {\n      clearTimeout(timeoutRef.current);\n      timeoutRef.current = setTimeout(() => onOpenChange(false), closeDelay);\n    } else if (runElseBranch) {\n      clearTimeout(timeoutRef.current);\n      onOpenChange(false);\n    }\n  }, [delayRef, onOpenChange]);\n  const cleanupMouseMoveHandler = React.useCallback(() => {\n    unbindMouseMoveRef.current();\n    handlerRef.current = undefined;\n  }, []);\n  const clearPointerEvents = React.useCallback(() => {\n    if (performedPointerEventsMutationRef.current) {\n      const body = getDocument(refs.floating.current).body;\n      body.style.pointerEvents = '';\n      body.removeAttribute(safePolygonIdentifier);\n      performedPointerEventsMutationRef.current = false;\n    }\n  }, [refs]);\n\n  // Registering the mouse events on the reference directly to bypass React's\n  // delegation system. If the cursor was on a disabled element and then entered\n  // the reference (no gap), `mouseenter` doesn't fire in the delegation system.\n  React.useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n    function isClickLikeOpenEvent() {\n      return dataRef.current.openEvent ? ['click', 'mousedown'].includes(dataRef.current.openEvent.type) : false;\n    }\n    function onMouseEnter(event) {\n      clearTimeout(timeoutRef.current);\n      blockMouseMoveRef.current = false;\n      if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current) || restMs > 0 && getDelay(delayRef.current, 'open') === 0) {\n        return;\n      }\n      dataRef.current.openEvent = event;\n      const openDelay = getDelay(delayRef.current, 'open', pointerTypeRef.current);\n      if (openDelay) {\n        timeoutRef.current = setTimeout(() => {\n          onOpenChange(true);\n        }, openDelay);\n      } else {\n        onOpenChange(true);\n      }\n    }\n    function onMouseLeave(event) {\n      if (isClickLikeOpenEvent()) {\n        return;\n      }\n      unbindMouseMoveRef.current();\n      const doc = getDocument(floating);\n      clearTimeout(restTimeoutRef.current);\n      if (handleCloseRef.current) {\n        // Prevent clearing `onScrollMouseLeave` timeout.\n        if (!open) {\n          clearTimeout(timeoutRef.current);\n        }\n        handlerRef.current = handleCloseRef.current({\n          ...context,\n          tree,\n          x: event.clientX,\n          y: event.clientY,\n          onClose() {\n            clearPointerEvents();\n            cleanupMouseMoveHandler();\n            closeWithDelay();\n          }\n        });\n        const handler = handlerRef.current;\n        doc.addEventListener('mousemove', handler);\n        unbindMouseMoveRef.current = () => {\n          doc.removeEventListener('mousemove', handler);\n        };\n        return;\n      }\n      closeWithDelay();\n    }\n\n    // Ensure the floating element closes after scrolling even if the pointer\n    // did not move.\n    // https://github.com/floating-ui/floating-ui/discussions/1692\n    function onScrollMouseLeave(event) {\n      if (isClickLikeOpenEvent()) {\n        return;\n      }\n      handleCloseRef.current == null ? void 0 : handleCloseRef.current({\n        ...context,\n        tree,\n        x: event.clientX,\n        y: event.clientY,\n        onClose() {\n          clearPointerEvents();\n          cleanupMouseMoveHandler();\n          closeWithDelay();\n        }\n      })(event);\n    }\n    if (isElement(domReference)) {\n      const ref = domReference;\n      open && ref.addEventListener('mouseleave', onScrollMouseLeave);\n      floating == null ? void 0 : floating.addEventListener('mouseleave', onScrollMouseLeave);\n      move && ref.addEventListener('mousemove', onMouseEnter, {\n        once: true\n      });\n      ref.addEventListener('mouseenter', onMouseEnter);\n      ref.addEventListener('mouseleave', onMouseLeave);\n      return () => {\n        open && ref.removeEventListener('mouseleave', onScrollMouseLeave);\n        floating == null ? void 0 : floating.removeEventListener('mouseleave', onScrollMouseLeave);\n        move && ref.removeEventListener('mousemove', onMouseEnter);\n        ref.removeEventListener('mouseenter', onMouseEnter);\n        ref.removeEventListener('mouseleave', onMouseLeave);\n      };\n    }\n  }, [domReference, floating, enabled, context, mouseOnly, restMs, move, closeWithDelay, cleanupMouseMoveHandler, clearPointerEvents, onOpenChange, open, tree, delayRef, handleCloseRef, dataRef]);\n\n  // Block pointer-events of every element other than the reference and floating\n  // while the floating element is open and has a `handleClose` handler. Also\n  // handles nested floating elements.\n  // https://github.com/floating-ui/floating-ui/issues/1722\n  index(() => {\n    var _handleCloseRef$curre;\n    if (!enabled) {\n      return;\n    }\n    if (open && (_handleCloseRef$curre = handleCloseRef.current) != null && _handleCloseRef$curre.__options.blockPointerEvents && isHoverOpen()) {\n      const body = getDocument(floating).body;\n      body.setAttribute(safePolygonIdentifier, '');\n      body.style.pointerEvents = 'none';\n      performedPointerEventsMutationRef.current = true;\n      if (isElement(domReference) && floating) {\n        var _tree$nodesRef$curren, _tree$nodesRef$curren2;\n        const ref = domReference;\n        const parentFloating = tree == null ? void 0 : (_tree$nodesRef$curren = tree.nodesRef.current.find(node => node.id === parentId)) == null ? void 0 : (_tree$nodesRef$curren2 = _tree$nodesRef$curren.context) == null ? void 0 : _tree$nodesRef$curren2.elements.floating;\n        if (parentFloating) {\n          parentFloating.style.pointerEvents = '';\n        }\n        ref.style.pointerEvents = 'auto';\n        floating.style.pointerEvents = 'auto';\n        return () => {\n          ref.style.pointerEvents = '';\n          floating.style.pointerEvents = '';\n        };\n      }\n    }\n  }, [enabled, open, parentId, floating, domReference, tree, handleCloseRef, dataRef, isHoverOpen]);\n  index(() => {\n    if (!open) {\n      pointerTypeRef.current = undefined;\n      cleanupMouseMoveHandler();\n      clearPointerEvents();\n    }\n  }, [open, cleanupMouseMoveHandler, clearPointerEvents]);\n  React.useEffect(() => {\n    return () => {\n      cleanupMouseMoveHandler();\n      clearTimeout(timeoutRef.current);\n      clearTimeout(restTimeoutRef.current);\n      clearPointerEvents();\n    };\n  }, [enabled, cleanupMouseMoveHandler, clearPointerEvents]);\n  return React.useMemo(() => {\n    if (!enabled) {\n      return {};\n    }\n    function setPointerRef(event) {\n      pointerTypeRef.current = event.pointerType;\n    }\n    return {\n      reference: {\n        onPointerDown: setPointerRef,\n        onPointerEnter: setPointerRef,\n        onMouseMove() {\n          if (open || restMs === 0) {\n            return;\n          }\n          clearTimeout(restTimeoutRef.current);\n          restTimeoutRef.current = setTimeout(() => {\n            if (!blockMouseMoveRef.current) {\n              onOpenChange(true);\n            }\n          }, restMs);\n        }\n      },\n      floating: {\n        onMouseEnter() {\n          clearTimeout(timeoutRef.current);\n        },\n        onMouseLeave() {\n          events.emit('dismiss', {\n            type: 'mouseLeave',\n            data: {\n              returnFocus: false\n            }\n          });\n          closeWithDelay(false);\n        }\n      }\n    };\n  }, [events, enabled, restMs, open, onOpenChange, closeWithDelay]);\n};\n\nconst FloatingDelayGroupContext = /*#__PURE__*/React.createContext({\n  delay: 0,\n  initialDelay: 0,\n  timeoutMs: 0,\n  currentId: null,\n  setCurrentId: () => {},\n  setState: () => {},\n  isInstantPhase: false\n});\nconst useDelayGroupContext = () => React.useContext(FloatingDelayGroupContext);\n\n/**\n * Provides context for a group of floating elements that should share a\n * `delay`.\n * @see https://floating-ui.com/docs/FloatingDelayGroup\n */\nconst FloatingDelayGroup = _ref => {\n  let {\n    children,\n    delay,\n    timeoutMs = 0\n  } = _ref;\n  const [state, setState] = React.useReducer((prev, next) => ({\n    ...prev,\n    ...next\n  }), {\n    delay,\n    timeoutMs,\n    initialDelay: delay,\n    currentId: null,\n    isInstantPhase: false\n  });\n  const initialCurrentIdRef = React.useRef(null);\n  const setCurrentId = React.useCallback(currentId => {\n    setState({\n      currentId\n    });\n  }, []);\n  index(() => {\n    if (state.currentId) {\n      if (initialCurrentIdRef.current === null) {\n        initialCurrentIdRef.current = state.currentId;\n      } else {\n        setState({\n          isInstantPhase: true\n        });\n      }\n    } else {\n      setState({\n        isInstantPhase: false\n      });\n      initialCurrentIdRef.current = null;\n    }\n  }, [state.currentId]);\n  return /*#__PURE__*/React.createElement(FloatingDelayGroupContext.Provider, {\n    value: React.useMemo(() => ({\n      ...state,\n      setState,\n      setCurrentId\n    }), [state, setState, setCurrentId])\n  }, children);\n};\nconst useDelayGroup = (_ref2, _ref3) => {\n  let {\n    open,\n    onOpenChange\n  } = _ref2;\n  let {\n    id\n  } = _ref3;\n  const {\n    currentId,\n    setCurrentId,\n    initialDelay,\n    setState,\n    timeoutMs\n  } = useDelayGroupContext();\n  React.useEffect(() => {\n    if (currentId) {\n      setState({\n        delay: {\n          open: 1,\n          close: getDelay(initialDelay, 'close')\n        }\n      });\n      if (currentId !== id) {\n        onOpenChange(false);\n      }\n    }\n  }, [id, onOpenChange, setState, currentId, initialDelay]);\n  React.useEffect(() => {\n    function unset() {\n      onOpenChange(false);\n      setState({\n        delay: initialDelay,\n        currentId: null\n      });\n    }\n    if (!open && currentId === id) {\n      if (timeoutMs) {\n        const timeout = window.setTimeout(unset, timeoutMs);\n        return () => {\n          clearTimeout(timeout);\n        };\n      } else {\n        unset();\n      }\n    }\n  }, [open, setState, currentId, id, onOpenChange, initialDelay, timeoutMs]);\n  React.useEffect(() => {\n    if (open) {\n      setCurrentId(id);\n    }\n  }, [open, setCurrentId, id]);\n};\n\nfunction _extends() {\n  _extends = Object.assign || 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 * Find the real active element. Traverses into shadowRoots.\n */\nfunction activeElement$1(doc) {\n  let activeElement = doc.activeElement;\n  while (((_activeElement = activeElement) == null ? void 0 : (_activeElement$shadow = _activeElement.shadowRoot) == null ? void 0 : _activeElement$shadow.activeElement) != null) {\n    var _activeElement, _activeElement$shadow;\n    activeElement = activeElement.shadowRoot.activeElement;\n  }\n  return activeElement;\n}\n\nfunction contains(parent, child) {\n  if (!parent || !child) {\n    return false;\n  }\n  const rootNode = child.getRootNode && child.getRootNode();\n\n  // First, attempt with faster native method\n  if (parent.contains(child)) {\n    return true;\n  }\n  // then fallback to custom implementation with Shadow DOM support\n  else if (rootNode && isShadowRoot(rootNode)) {\n    let next = child;\n    do {\n      if (next && parent === next) {\n        return true;\n      }\n      // @ts-ignore\n      next = next.parentNode || next.host;\n    } while (next);\n  }\n\n  // Give up, the result is false\n  return false;\n}\n\nlet rafId = 0;\nfunction enqueueFocus(el, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    preventScroll = false,\n    cancelPrevious = true,\n    sync = false\n  } = options;\n  cancelPrevious && cancelAnimationFrame(rafId);\n  const exec = () => el == null ? void 0 : el.focus({\n    preventScroll\n  });\n  if (sync) {\n    exec();\n  } else {\n    rafId = requestAnimationFrame(exec);\n  }\n}\n\nfunction getAncestors(nodes, id) {\n  var _nodes$find;\n  let allAncestors = [];\n  let currentParentId = (_nodes$find = nodes.find(node => node.id === id)) == null ? void 0 : _nodes$find.parentId;\n  while (currentParentId) {\n    const currentNode = nodes.find(node => node.id === currentParentId);\n    currentParentId = currentNode == null ? void 0 : currentNode.parentId;\n    if (currentNode) {\n      allAncestors = allAncestors.concat(currentNode);\n    }\n  }\n  return allAncestors;\n}\n\nfunction getChildren(nodes, id) {\n  let allChildren = nodes.filter(node => {\n    var _node$context;\n    return node.parentId === id && ((_node$context = node.context) == null ? void 0 : _node$context.open);\n  }) || [];\n  let currentChildren = allChildren;\n  while (currentChildren.length) {\n    currentChildren = nodes.filter(node => {\n      var _currentChildren;\n      return (_currentChildren = currentChildren) == null ? void 0 : _currentChildren.some(n => {\n        var _node$context2;\n        return node.parentId === n.id && ((_node$context2 = node.context) == null ? void 0 : _node$context2.open);\n      });\n    }) || [];\n    allChildren = allChildren.concat(currentChildren);\n  }\n  return allChildren;\n}\n\nfunction getTarget(event) {\n  if ('composedPath' in event) {\n    return event.composedPath()[0];\n  }\n\n  // TS thinks `event` is of type never as it assumes all browsers support\n  // `composedPath()`, but browsers without shadow DOM don't.\n  return event.target;\n}\n\nconst TYPEABLE_SELECTOR = \"input:not([type='hidden']):not([disabled]),\" + \"[contenteditable]:not([contenteditable='false']),textarea:not([disabled])\";\nfunction isTypeableElement(element) {\n  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);\n}\n\nfunction stopEvent(event) {\n  event.preventDefault();\n  event.stopPropagation();\n}\n\nconst getTabbableOptions = () => ({\n  getShadowRoot: true,\n  displayCheck:\n  // JSDOM does not support the `tabbable` library. To solve this we can\n  // check if `ResizeObserver` is a real function (not polyfilled), which\n  // determines if the current environment is JSDOM-like.\n  typeof ResizeObserver === 'function' && ResizeObserver.toString().includes('[native code]') ? 'full' : 'none'\n});\nfunction getTabbableIn(container, direction) {\n  const allTabbable = tabbable(container, getTabbableOptions());\n  if (direction === 'prev') {\n    allTabbable.reverse();\n  }\n  const activeIndex = allTabbable.indexOf(activeElement$1(getDocument(container)));\n  const nextTabbableElements = allTabbable.slice(activeIndex + 1);\n  return nextTabbableElements[0];\n}\nfunction getNextTabbable() {\n  return getTabbableIn(document.body, 'next');\n}\nfunction getPreviousTabbable() {\n  return getTabbableIn(document.body, 'prev');\n}\nfunction isOutsideEvent(event, container) {\n  const containerElement = container || event.currentTarget;\n  const relatedTarget = event.relatedTarget;\n  return !relatedTarget || !contains(containerElement, relatedTarget);\n}\nfunction disableFocusInside(container) {\n  const tabbableElements = tabbable(container, getTabbableOptions());\n  tabbableElements.forEach(element => {\n    element.dataset.tabindex = element.getAttribute('tabindex') || '';\n    element.setAttribute('tabindex', '-1');\n  });\n}\nfunction enableFocusInside(container) {\n  const elements = container.querySelectorAll('[data-tabindex]');\n  elements.forEach(element => {\n    const tabindex = element.dataset.tabindex;\n    delete element.dataset.tabindex;\n    if (tabindex) {\n      element.setAttribute('tabindex', tabindex);\n    } else {\n      element.removeAttribute('tabindex');\n    }\n  });\n}\n\n// `toString()` prevents bundlers from trying to `import { useInsertionEffect } from 'react'`\nconst useInsertionEffect = React[/*#__PURE__*/'useInsertionEffect'.toString()];\nconst useSafeInsertionEffect = useInsertionEffect || (fn => fn());\nfunction useEvent(callback) {\n  const ref = React.useRef(() => {\n    if (process.env.NODE_ENV !== \"production\") {\n      throw new Error('Cannot call an event handler while rendering.');\n    }\n  });\n  useSafeInsertionEffect(() => {\n    ref.current = callback;\n  });\n  return React.useCallback(function () {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n    return ref.current == null ? void 0 : ref.current(...args);\n  }, []);\n}\n\n// See Diego Haz's Sandbox for making this logic work well on Safari/iOS:\n// https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/FocusTrap.tsx\n\nconst HIDDEN_STYLES = {\n  border: 0,\n  clip: 'rect(0 0 0 0)',\n  height: '1px',\n  margin: '-1px',\n  overflow: 'hidden',\n  padding: 0,\n  position: 'fixed',\n  whiteSpace: 'nowrap',\n  width: '1px',\n  top: 0,\n  left: 0\n};\nlet activeElement;\nlet timeoutId;\nfunction setActiveElementOnTab(event) {\n  if (event.key === 'Tab') {\n    activeElement = event.target;\n    clearTimeout(timeoutId);\n  }\n}\nfunction isTabFocus(event) {\n  const result = activeElement === event.relatedTarget;\n  activeElement = event.relatedTarget;\n  clearTimeout(timeoutId);\n  return result;\n}\nconst FocusGuard = /*#__PURE__*/React.forwardRef(function FocusGuard(props, ref) {\n  const onFocus = useEvent(props.onFocus);\n  const [role, setRole] = React.useState();\n  index(() => {\n    if (isSafari()) {\n      // Unlike other screen readers such as NVDA and JAWS, the virtual cursor\n      // on VoiceOver does trigger the onFocus event, so we can use the focus\n      // trap element. On Safari, only buttons trigger the onFocus event.\n      // NB: \"group\" role in the Sandbox no longer appears to work, must be a\n      // button role.\n      setRole('button');\n    }\n    document.addEventListener('keydown', setActiveElementOnTab);\n    return () => {\n      document.removeEventListener('keydown', setActiveElementOnTab);\n    };\n  }, []);\n  return /*#__PURE__*/React.createElement(\"span\", _extends({}, props, {\n    ref: ref,\n    tabIndex: 0\n    // Role is only for VoiceOver\n    ,\n    role: role,\n    \"aria-hidden\": role ? undefined : true,\n    \"data-floating-ui-focus-guard\": \"\",\n    style: HIDDEN_STYLES,\n    onFocus: event => {\n      if (isSafari() && isMac() && !isTabFocus(event)) {\n        // On macOS we need to wait a little bit before moving\n        // focus again.\n        event.persist();\n        timeoutId = window.setTimeout(() => {\n          onFocus(event);\n        }, 50);\n      } else {\n        onFocus(event);\n      }\n    }\n  }));\n});\n\nconst PortalContext = /*#__PURE__*/React.createContext(null);\nconst useFloatingPortalNode = function (_temp) {\n  let {\n    id,\n    enabled = true\n  } = _temp === void 0 ? {} : _temp;\n  const [portalEl, setPortalEl] = React.useState(null);\n  const uniqueId = useId();\n  const portalContext = usePortalContext();\n  index(() => {\n    if (!enabled) {\n      return;\n    }\n    const rootNode = id ? document.getElementById(id) : null;\n    if (rootNode) {\n      rootNode.setAttribute('data-floating-ui-portal', '');\n      setPortalEl(rootNode);\n    } else {\n      const newPortalEl = document.createElement('div');\n      if (id !== '') {\n        newPortalEl.id = id || uniqueId;\n      }\n      newPortalEl.setAttribute('data-floating-ui-portal', '');\n      setPortalEl(newPortalEl);\n      const container = (portalContext == null ? void 0 : portalContext.portalNode) || document.body;\n      container.appendChild(newPortalEl);\n      return () => {\n        container.removeChild(newPortalEl);\n      };\n    }\n  }, [id, portalContext, uniqueId, enabled]);\n  return portalEl;\n};\n\n/**\n * Portals the floating element into a given container element — by default,\n * outside of the app root and into the body.\n * @see https://floating-ui.com/docs/FloatingPortal\n */\nconst FloatingPortal = _ref => {\n  let {\n    children,\n    id,\n    root = null,\n    preserveTabOrder = true\n  } = _ref;\n  const portalNode = useFloatingPortalNode({\n    id,\n    enabled: !root\n  });\n  const [focusManagerState, setFocusManagerState] = React.useState(null);\n  const beforeOutsideRef = React.useRef(null);\n  const afterOutsideRef = React.useRef(null);\n  const beforeInsideRef = React.useRef(null);\n  const afterInsideRef = React.useRef(null);\n  const shouldRenderGuards =\n  // The FocusManager and therefore floating element are currently open/\n  // rendered.\n  !!focusManagerState &&\n  // Guards are only for non-modal focus management.\n  !focusManagerState.modal && !!(root || portalNode) && preserveTabOrder;\n\n  // https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/TabbablePortal.tsx\n  React.useEffect(() => {\n    if (!portalNode || !preserveTabOrder || focusManagerState != null && focusManagerState.modal) {\n      return;\n    }\n\n    // Make sure elements inside the portal element are tabbable only when the\n    // portal has already been focused, either by tabbing into a focus trap\n    // element outside or using the mouse.\n    function onFocus(event) {\n      if (portalNode && isOutsideEvent(event)) {\n        const focusing = event.type === 'focusin';\n        const manageFocus = focusing ? enableFocusInside : disableFocusInside;\n        manageFocus(portalNode);\n      }\n    }\n    // Listen to the event on the capture phase so they run before the focus\n    // trap elements onFocus prop is called.\n    portalNode.addEventListener('focusin', onFocus, true);\n    portalNode.addEventListener('focusout', onFocus, true);\n    return () => {\n      portalNode.removeEventListener('focusin', onFocus, true);\n      portalNode.removeEventListener('focusout', onFocus, true);\n    };\n  }, [portalNode, preserveTabOrder, focusManagerState == null ? void 0 : focusManagerState.modal]);\n  return /*#__PURE__*/React.createElement(PortalContext.Provider, {\n    value: React.useMemo(() => ({\n      preserveTabOrder,\n      beforeOutsideRef,\n      afterOutsideRef,\n      beforeInsideRef,\n      afterInsideRef,\n      portalNode,\n      setFocusManagerState\n    }), [preserveTabOrder, portalNode])\n  }, shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"outside\",\n    ref: beforeOutsideRef,\n    onFocus: event => {\n      if (isOutsideEvent(event, portalNode)) {\n        var _beforeInsideRef$curr;\n        (_beforeInsideRef$curr = beforeInsideRef.current) == null ? void 0 : _beforeInsideRef$curr.focus();\n      } else {\n        const prevTabbable = getPreviousTabbable() || (focusManagerState == null ? void 0 : focusManagerState.refs.domReference.current);\n        prevTabbable == null ? void 0 : prevTabbable.focus();\n      }\n    }\n  }), shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(\"span\", {\n    \"aria-owns\": portalNode.id,\n    style: HIDDEN_STYLES\n  }), root ? /*#__PURE__*/createPortal(children, root) : portalNode ? /*#__PURE__*/createPortal(children, portalNode) : null, shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"outside\",\n    ref: afterOutsideRef,\n    onFocus: event => {\n      if (isOutsideEvent(event, portalNode)) {\n        var _afterInsideRef$curre;\n        (_afterInsideRef$curre = afterInsideRef.current) == null ? void 0 : _afterInsideRef$curre.focus();\n      } else {\n        const nextTabbable = getNextTabbable() || (focusManagerState == null ? void 0 : focusManagerState.refs.domReference.current);\n        nextTabbable == null ? void 0 : nextTabbable.focus();\n        (focusManagerState == null ? void 0 : focusManagerState.closeOnFocusOut) && (focusManagerState == null ? void 0 : focusManagerState.onOpenChange(false));\n      }\n    }\n  }));\n};\nconst usePortalContext = () => React.useContext(PortalContext);\n\nconst VisuallyHiddenDismiss = /*#__PURE__*/React.forwardRef(function VisuallyHiddenDismiss(props, ref) {\n  return /*#__PURE__*/React.createElement(\"button\", _extends({}, props, {\n    type: \"button\",\n    ref: ref,\n    tabIndex: -1,\n    style: HIDDEN_STYLES\n  }));\n});\n/**\n * Provides focus management for the floating element.\n * @see https://floating-ui.com/docs/FloatingFocusManager\n */\nfunction FloatingFocusManager(_ref) {\n  let {\n    context,\n    children,\n    order = ['content'],\n    guards = true,\n    initialFocus = 0,\n    returnFocus = true,\n    modal = true,\n    visuallyHiddenDismiss = false,\n    closeOnFocusOut = true\n  } = _ref;\n  const {\n    refs,\n    nodeId,\n    onOpenChange,\n    events,\n    dataRef,\n    elements: {\n      domReference,\n      floating\n    }\n  } = context;\n  const orderRef = useLatestRef(order);\n  const tree = useFloatingTree();\n  const portalContext = usePortalContext();\n  const [tabbableContentLength, setTabbableContentLength] = React.useState(null);\n\n  // Controlled by `useListNavigation`.\n  const ignoreInitialFocus = typeof initialFocus === 'number' && initialFocus < 0;\n  const startDismissButtonRef = React.useRef(null);\n  const endDismissButtonRef = React.useRef(null);\n  const preventReturnFocusRef = React.useRef(false);\n  const previouslyFocusedElementRef = React.useRef(null);\n  const isPointerDownRef = React.useRef(false);\n  const isInsidePortal = portalContext != null;\n\n  // If the reference is a combobox and is typeable (e.g. input/textarea),\n  // there are different focus semantics. The guards should not be rendered, but\n  // aria-hidden should be applied to all nodes still. Further, the visually\n  // hidden dismiss button should only appear at the end of the list, not the\n  // start.\n  const isTypeableCombobox = domReference && domReference.getAttribute('role') === 'combobox' && isTypeableElement(domReference);\n  const getTabbableContent = React.useCallback(function (container) {\n    if (container === void 0) {\n      container = floating;\n    }\n    return container ? tabbable(container, getTabbableOptions()) : [];\n  }, [floating]);\n  const getTabbableElements = React.useCallback(container => {\n    const content = getTabbableContent(container);\n    return orderRef.current.map(type => {\n      if (domReference && type === 'reference') {\n        return domReference;\n      }\n      if (floating && type === 'floating') {\n        return floating;\n      }\n      return content;\n    }).filter(Boolean).flat();\n  }, [domReference, floating, orderRef, getTabbableContent]);\n  React.useEffect(() => {\n    if (!modal) {\n      return;\n    }\n    function onKeyDown(event) {\n      if (event.key === 'Tab') {\n        // The focus guards have nothing to focus, so we need to stop the event.\n        if (getTabbableContent().length === 0 && !isTypeableCombobox) {\n          stopEvent(event);\n        }\n        const els = getTabbableElements();\n        const target = getTarget(event);\n        if (orderRef.current[0] === 'reference' && target === domReference) {\n          stopEvent(event);\n          if (event.shiftKey) {\n            enqueueFocus(els[els.length - 1]);\n          } else {\n            enqueueFocus(els[1]);\n          }\n        }\n        if (orderRef.current[1] === 'floating' && target === floating && event.shiftKey) {\n          stopEvent(event);\n          enqueueFocus(els[0]);\n        }\n      }\n    }\n    const doc = getDocument(floating);\n    doc.addEventListener('keydown', onKeyDown);\n    return () => {\n      doc.removeEventListener('keydown', onKeyDown);\n    };\n  }, [domReference, floating, modal, orderRef, refs, isTypeableCombobox, getTabbableContent, getTabbableElements]);\n  React.useEffect(() => {\n    if (!closeOnFocusOut) {\n      return;\n    }\n\n    // In Safari, buttons lose focus when pressing them.\n    function handlePointerDown() {\n      isPointerDownRef.current = true;\n      setTimeout(() => {\n        isPointerDownRef.current = false;\n      });\n    }\n    function handleFocusOutside(event) {\n      const relatedTarget = event.relatedTarget;\n      const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext == null ? void 0 : portalContext.portalNode, relatedTarget) || relatedTarget != null && relatedTarget.hasAttribute('data-floating-ui-focus-guard') || tree && (getChildren(tree.nodesRef.current, nodeId).find(node => {\n        var _node$context, _node$context2;\n        return contains((_node$context = node.context) == null ? void 0 : _node$context.elements.floating, relatedTarget) || contains((_node$context2 = node.context) == null ? void 0 : _node$context2.elements.domReference, relatedTarget);\n      }) || getAncestors(tree.nodesRef.current, nodeId).find(node => {\n        var _node$context3, _node$context4;\n        return ((_node$context3 = node.context) == null ? void 0 : _node$context3.elements.floating) === relatedTarget || ((_node$context4 = node.context) == null ? void 0 : _node$context4.elements.domReference) === relatedTarget;\n      })));\n\n      // Focus did not move inside the floating tree, and there are no tabbable\n      // portal guards to handle closing.\n      if (relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current &&\n      // Fix React 18 Strict Mode returnFocus due to double rendering.\n      relatedTarget !== previouslyFocusedElementRef.current) {\n        preventReturnFocusRef.current = true;\n        // On iOS VoiceOver, dismissing the nested submenu will cause the\n        // first item of the list to receive focus. Delaying it appears to fix\n        // the issue.\n        setTimeout(() => onOpenChange(false));\n      }\n    }\n    if (floating && isHTMLElement(domReference)) {\n      domReference.addEventListener('focusout', handleFocusOutside);\n      domReference.addEventListener('pointerdown', handlePointerDown);\n      !modal && floating.addEventListener('focusout', handleFocusOutside);\n      return () => {\n        domReference.removeEventListener('focusout', handleFocusOutside);\n        domReference.removeEventListener('pointerdown', handlePointerDown);\n        !modal && floating.removeEventListener('focusout', handleFocusOutside);\n      };\n    }\n  }, [domReference, floating, modal, nodeId, tree, portalContext, onOpenChange, closeOnFocusOut]);\n  React.useEffect(() => {\n    var _portalContext$portal;\n    // Don't hide portals nested within the parent portal.\n    const portalNodes = Array.from((portalContext == null ? void 0 : (_portalContext$portal = portalContext.portalNode) == null ? void 0 : _portalContext$portal.querySelectorAll('[data-floating-ui-portal]')) || []);\n    function getDismissButtons() {\n      return [startDismissButtonRef.current, endDismissButtonRef.current].filter(Boolean);\n    }\n    if (floating && modal) {\n      const insideNodes = [floating, ...portalNodes, ...getDismissButtons()];\n      const cleanup = hideOthers(orderRef.current.includes('reference') || isTypeableCombobox ? insideNodes.concat(domReference || []) : insideNodes);\n      return () => {\n        cleanup();\n      };\n    }\n  }, [domReference, floating, modal, orderRef, portalContext, isTypeableCombobox]);\n  React.useEffect(() => {\n    if (modal && !guards && floating) {\n      const tabIndexValues = [];\n      const options = getTabbableOptions();\n      const allTabbable = tabbable(getDocument(floating).body, options);\n      const floatingTabbable = getTabbableElements();\n\n      // Exclude all tabbable elements that are part of the order\n      const elements = allTabbable.filter(el => !floatingTabbable.includes(el));\n      elements.forEach((el, i) => {\n        tabIndexValues[i] = el.getAttribute('tabindex');\n        el.setAttribute('tabindex', '-1');\n      });\n      return () => {\n        elements.forEach((el, i) => {\n          const value = tabIndexValues[i];\n          if (value == null) {\n            el.removeAttribute('tabindex');\n          } else {\n            el.setAttribute('tabindex', value);\n          }\n        });\n      };\n    }\n  }, [floating, modal, guards, getTabbableElements]);\n  index(() => {\n    if (!floating) return;\n    const doc = getDocument(floating);\n    let returnFocusValue = returnFocus;\n    let preventReturnFocusScroll = false;\n    const previouslyFocusedElement = activeElement$1(doc);\n    const contextData = dataRef.current;\n    previouslyFocusedElementRef.current = previouslyFocusedElement;\n    const focusableElements = getTabbableElements(floating);\n    const elToFocus = (typeof initialFocus === 'number' ? focusableElements[initialFocus] : initialFocus.current) || floating;\n\n    // If the `useListNavigation` hook is active, always ignore `initialFocus`\n    // because it has its own handling of the initial focus.\n    !ignoreInitialFocus && enqueueFocus(elToFocus, {\n      preventScroll: elToFocus === floating\n    });\n\n    // Dismissing via outside press should always ignore `returnFocus` to\n    // prevent unwanted scrolling.\n    function onDismiss(payload) {\n      if (payload.type === 'escapeKey' && refs.domReference.current) {\n        previouslyFocusedElementRef.current = refs.domReference.current;\n      }\n      if (['referencePress', 'escapeKey'].includes(payload.type)) {\n        return;\n      }\n      const returnFocus = payload.data.returnFocus;\n      if (typeof returnFocus === 'object') {\n        returnFocusValue = true;\n        preventReturnFocusScroll = returnFocus.preventScroll;\n      } else {\n        returnFocusValue = returnFocus;\n      }\n    }\n    events.on('dismiss', onDismiss);\n    return () => {\n      events.off('dismiss', onDismiss);\n      if (contains(floating, activeElement$1(doc)) && refs.domReference.current) {\n        previouslyFocusedElementRef.current = refs.domReference.current;\n      }\n      if (returnFocusValue && isHTMLElement(previouslyFocusedElementRef.current) && !preventReturnFocusRef.current) {\n        // `isPointerDownRef.current` to avoid the focus ring from appearing on\n        // the reference element when click-toggling it.\n        if (!refs.domReference.current || isPointerDownRef.current) {\n          enqueueFocus(previouslyFocusedElementRef.current, {\n            // When dismissing nested floating elements, by the time the rAF has\n            // executed, the menus will all have been unmounted. When they try\n            // to get focused, the calls get ignored — leaving the root\n            // reference focused as desired.\n            cancelPrevious: false,\n            preventScroll: preventReturnFocusScroll\n          });\n        } else {\n          var _previouslyFocusedEle;\n          // If the user has specified a `keydown` listener that calls\n          // setOpen(false) (e.g. selecting an item and closing the floating\n          // element), then sync return focus causes `useClick` to immediately\n          // re-open it, unless they call `event.preventDefault()` in the\n          // `keydown` listener. This helps keep backwards compatibility with\n          // older examples.\n          contextData.__syncReturnFocus = true;\n\n          // In Safari, `useListNavigation` moves focus sync, so making this\n          // sync ensures the initial item remains focused despite this being\n          // invoked in Strict Mode due to double-invoked useEffects. This also\n          // has the positive side effect of closing a modally focus-managed\n          // <Menu> on `Tab` keydown to move naturally to the next focusable\n          // element.\n          (_previouslyFocusedEle = previouslyFocusedElementRef.current) == null ? void 0 : _previouslyFocusedEle.focus({\n            preventScroll: preventReturnFocusScroll\n          });\n          setTimeout(() => {\n            // This isn't an actual property the user should access, make sure\n            // it doesn't persist.\n            delete contextData.__syncReturnFocus;\n          });\n        }\n      }\n    };\n  }, [floating, getTabbableElements, initialFocus, returnFocus, dataRef, refs, events, ignoreInitialFocus]);\n\n  // Synchronize the `context` & `modal` value to the FloatingPortal context.\n  // It will decide whether or not it needs to render its own guards.\n  index(() => {\n    if (!portalContext) return;\n    portalContext.setFocusManagerState({\n      ...context,\n      modal,\n      closeOnFocusOut\n      // Not concerned about the <RT> generic type.\n    });\n\n    return () => {\n      portalContext.setFocusManagerState(null);\n    };\n  }, [portalContext, modal, closeOnFocusOut, context]);\n  index(() => {\n    if (ignoreInitialFocus || !floating) return;\n    function setState() {\n      setTabbableContentLength(getTabbableContent().length);\n    }\n    setState();\n    if (typeof MutationObserver === 'function') {\n      const observer = new MutationObserver(setState);\n      observer.observe(floating, {\n        childList: true,\n        subtree: true\n      });\n      return () => {\n        observer.disconnect();\n      };\n    }\n  }, [floating, getTabbableContent, ignoreInitialFocus, refs]);\n  const shouldRenderGuards = guards && (isInsidePortal || modal) && !isTypeableCombobox;\n  function renderDismissButton(location) {\n    return visuallyHiddenDismiss && modal ? /*#__PURE__*/React.createElement(VisuallyHiddenDismiss, {\n      ref: location === 'start' ? startDismissButtonRef : endDismissButtonRef,\n      onClick: () => onOpenChange(false)\n    }, typeof visuallyHiddenDismiss === 'string' ? visuallyHiddenDismiss : 'Dismiss') : null;\n  }\n  return /*#__PURE__*/React.createElement(React.Fragment, null, shouldRenderGuards && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"inside\",\n    ref: portalContext == null ? void 0 : portalContext.beforeInsideRef,\n    onFocus: event => {\n      if (modal) {\n        const els = getTabbableElements();\n        enqueueFocus(order[0] === 'reference' ? els[0] : els[els.length - 1]);\n      } else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {\n        preventReturnFocusRef.current = false;\n        if (isOutsideEvent(event, portalContext.portalNode)) {\n          const nextTabbable = getNextTabbable() || domReference;\n          nextTabbable == null ? void 0 : nextTabbable.focus();\n        } else {\n          var _portalContext$before;\n          (_portalContext$before = portalContext.beforeOutsideRef.current) == null ? void 0 : _portalContext$before.focus();\n        }\n      }\n    }\n  }), isTypeableCombobox ? null : renderDismissButton('start'), /*#__PURE__*/React.cloneElement(children, tabbableContentLength === 0 || order.includes('floating') ? {\n    tabIndex: 0\n  } : {}), renderDismissButton('end'), shouldRenderGuards && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"inside\",\n    ref: portalContext == null ? void 0 : portalContext.afterInsideRef,\n    onFocus: event => {\n      if (modal) {\n        enqueueFocus(getTabbableElements()[0]);\n      } else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {\n        preventReturnFocusRef.current = true;\n        if (isOutsideEvent(event, portalContext.portalNode)) {\n          const prevTabbable = getPreviousTabbable() || domReference;\n          prevTabbable == null ? void 0 : prevTabbable.focus();\n        } else {\n          var _portalContext$afterO;\n          (_portalContext$afterO = portalContext.afterOutsideRef.current) == null ? void 0 : _portalContext$afterO.focus();\n        }\n      }\n    }\n  }));\n}\n\nconst identifier = 'data-floating-ui-scroll-lock';\n\n/**\n * Provides base styling for a fixed overlay element to dim content or block\n * pointer events behind a floating element.\n * It's a regular `<div>`, so it can be styled via any CSS solution you prefer.\n * @see https://floating-ui.com/docs/FloatingOverlay\n */\nconst FloatingOverlay = /*#__PURE__*/React.forwardRef(function FloatingOverlay(_ref, ref) {\n  let {\n    lockScroll = false,\n    ...rest\n  } = _ref;\n  index(() => {\n    var _window$visualViewpor, _window$visualViewpor2;\n    if (!lockScroll) {\n      return;\n    }\n    const alreadyLocked = document.body.hasAttribute(identifier);\n    if (alreadyLocked) {\n      return;\n    }\n    document.body.setAttribute(identifier, '');\n\n    // RTL <body> scrollbar\n    const scrollbarX = Math.round(document.documentElement.getBoundingClientRect().left) + document.documentElement.scrollLeft;\n    const paddingProp = scrollbarX ? 'paddingLeft' : 'paddingRight';\n    const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;\n\n    // Only iOS doesn't respect `overflow: hidden` on document.body, and this\n    // technique has fewer side effects.\n    if (!/iP(hone|ad|od)|iOS/.test(getPlatform())) {\n      Object.assign(document.body.style, {\n        overflow: 'hidden',\n        [paddingProp]: scrollbarWidth + \"px\"\n      });\n      return () => {\n        document.body.removeAttribute(identifier);\n        Object.assign(document.body.style, {\n          overflow: '',\n          [paddingProp]: ''\n        });\n      };\n    }\n\n    // iOS 12 does not support `visualViewport`.\n    const offsetLeft = ((_window$visualViewpor = window.visualViewport) == null ? void 0 : _window$visualViewpor.offsetLeft) || 0;\n    const offsetTop = ((_window$visualViewpor2 = window.visualViewport) == null ? void 0 : _window$visualViewpor2.offsetTop) || 0;\n    const scrollX = window.pageXOffset;\n    const scrollY = window.pageYOffset;\n    Object.assign(document.body.style, {\n      position: 'fixed',\n      overflow: 'hidden',\n      top: -(scrollY - Math.floor(offsetTop)) + \"px\",\n      left: -(scrollX - Math.floor(offsetLeft)) + \"px\",\n      right: '0',\n      [paddingProp]: scrollbarWidth + \"px\"\n    });\n    return () => {\n      Object.assign(document.body.style, {\n        position: '',\n        overflow: '',\n        top: '',\n        left: '',\n        right: '',\n        [paddingProp]: ''\n      });\n      document.body.removeAttribute(identifier);\n      window.scrollTo(scrollX, scrollY);\n    };\n  }, [lockScroll]);\n  return /*#__PURE__*/React.createElement(\"div\", _extends({\n    ref: ref\n  }, rest, {\n    style: {\n      position: 'fixed',\n      overflow: 'auto',\n      top: 0,\n      right: 0,\n      bottom: 0,\n      left: 0,\n      ...rest.style\n    }\n  }));\n});\n\nfunction isButtonTarget(event) {\n  return isHTMLElement(event.target) && event.target.tagName === 'BUTTON';\n}\nfunction isSpaceIgnored(element) {\n  return isTypeableElement(element);\n}\n/**\n * Opens or closes the floating element when clicking the reference element.\n * @see https://floating-ui.com/docs/useClick\n */\nconst useClick = function (_ref, _temp) {\n  let {\n    open,\n    onOpenChange,\n    dataRef,\n    elements: {\n      domReference\n    }\n  } = _ref;\n  let {\n    enabled = true,\n    event: eventOption = 'click',\n    toggle = true,\n    ignoreMouse = false,\n    keyboardHandlers = true\n  } = _temp === void 0 ? {} : _temp;\n  const pointerTypeRef = React.useRef();\n  return React.useMemo(() => {\n    if (!enabled) {\n      return {};\n    }\n    return {\n      reference: {\n        onPointerDown(event) {\n          pointerTypeRef.current = event.pointerType;\n        },\n        onMouseDown(event) {\n          // Ignore all buttons except for the \"main\" button.\n          // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button\n          if (event.button !== 0) {\n            return;\n          }\n          if (isMouseLikePointerType(pointerTypeRef.current, true) && ignoreMouse) {\n            return;\n          }\n          if (eventOption === 'click') {\n            return;\n          }\n          if (open) {\n            if (toggle && (dataRef.current.openEvent ? dataRef.current.openEvent.type === 'mousedown' : true)) {\n              onOpenChange(false);\n            }\n          } else {\n            // Prevent stealing focus from the floating element\n            event.preventDefault();\n            onOpenChange(true);\n          }\n          dataRef.current.openEvent = event.nativeEvent;\n        },\n        onClick(event) {\n          if (dataRef.current.__syncReturnFocus) {\n            return;\n          }\n          if (eventOption === 'mousedown' && pointerTypeRef.current) {\n            pointerTypeRef.current = undefined;\n            return;\n          }\n          if (isMouseLikePointerType(pointerTypeRef.current, true) && ignoreMouse) {\n            return;\n          }\n          if (open) {\n            if (toggle && (dataRef.current.openEvent ? dataRef.current.openEvent.type === 'click' : true)) {\n              onOpenChange(false);\n            }\n          } else {\n            onOpenChange(true);\n          }\n          dataRef.current.openEvent = event.nativeEvent;\n        },\n        onKeyDown(event) {\n          pointerTypeRef.current = undefined;\n          if (!keyboardHandlers) {\n            return;\n          }\n          if (isButtonTarget(event)) {\n            return;\n          }\n          if (event.key === ' ' && !isSpaceIgnored(domReference)) {\n            // Prevent scrolling\n            event.preventDefault();\n          }\n          if (event.key === 'Enter') {\n            if (open) {\n              if (toggle) {\n                onOpenChange(false);\n              }\n            } else {\n              onOpenChange(true);\n            }\n          }\n        },\n        onKeyUp(event) {\n          if (!keyboardHandlers) {\n            return;\n          }\n          if (isButtonTarget(event) || isSpaceIgnored(domReference)) {\n            return;\n          }\n          if (event.key === ' ') {\n            if (open) {\n              if (toggle) {\n                onOpenChange(false);\n              }\n            } else {\n              onOpenChange(true);\n            }\n          }\n        }\n      }\n    };\n  }, [enabled, dataRef, eventOption, ignoreMouse, keyboardHandlers, domReference, toggle, open, onOpenChange]);\n};\n\n/**\n * Check whether the event.target is within the provided node. Uses event.composedPath if available for custom element support.\n *\n * @param event The event whose target/composedPath to check\n * @param node The node to check against\n * @returns Whether the event.target/composedPath is within the node.\n */\nfunction isEventTargetWithin(event, node) {\n  if (node == null) {\n    return false;\n  }\n  if ('composedPath' in event) {\n    return event.composedPath().includes(node);\n  }\n\n  // TS thinks `event` is of type never as it assumes all browsers support composedPath, but browsers without shadow dom don't\n  const e = event;\n  return e.target != null && node.contains(e.target);\n}\n\nconst bubbleHandlerKeys = {\n  pointerdown: 'onPointerDown',\n  mousedown: 'onMouseDown',\n  click: 'onClick'\n};\nconst captureHandlerKeys = {\n  pointerdown: 'onPointerDownCapture',\n  mousedown: 'onMouseDownCapture',\n  click: 'onClickCapture'\n};\nconst normalizeBubblesProp = function (bubbles) {\n  var _bubbles$escapeKey, _bubbles$outsidePress;\n  if (bubbles === void 0) {\n    bubbles = true;\n  }\n  return {\n    escapeKeyBubbles: typeof bubbles === 'boolean' ? bubbles : (_bubbles$escapeKey = bubbles.escapeKey) != null ? _bubbles$escapeKey : true,\n    outsidePressBubbles: typeof bubbles === 'boolean' ? bubbles : (_bubbles$outsidePress = bubbles.outsidePress) != null ? _bubbles$outsidePress : true\n  };\n};\n/**\n * Closes the floating element when a dismissal is requested — by default, when\n * the user presses the `escape` key or outside of the floating element.\n * @see https://floating-ui.com/docs/useDismiss\n */\nconst useDismiss = function (_ref, _temp) {\n  let {\n    open,\n    onOpenChange,\n    events,\n    nodeId,\n    elements: {\n      reference,\n      domReference,\n      floating\n    },\n    dataRef\n  } = _ref;\n  let {\n    enabled = true,\n    escapeKey = true,\n    outsidePress: unstable_outsidePress = true,\n    outsidePressEvent = 'pointerdown',\n    referencePress = false,\n    referencePressEvent = 'pointerdown',\n    ancestorScroll = false,\n    bubbles = true\n  } = _temp === void 0 ? {} : _temp;\n  const tree = useFloatingTree();\n  const nested = useFloatingParentNodeId() != null;\n  const outsidePressFn = useEvent(typeof unstable_outsidePress === 'function' ? unstable_outsidePress : () => false);\n  const outsidePress = typeof unstable_outsidePress === 'function' ? outsidePressFn : unstable_outsidePress;\n  const insideReactTreeRef = React.useRef(false);\n  const {\n    escapeKeyBubbles,\n    outsidePressBubbles\n  } = normalizeBubblesProp(bubbles);\n  React.useEffect(() => {\n    if (!open || !enabled) {\n      return;\n    }\n    dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;\n    dataRef.current.__outsidePressBubbles = outsidePressBubbles;\n    function onKeyDown(event) {\n      if (event.key === 'Escape') {\n        const children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];\n        if (children.length > 0) {\n          let shouldDismiss = true;\n          children.forEach(child => {\n            var _child$context;\n            if ((_child$context = child.context) != null && _child$context.open && !child.context.dataRef.current.__escapeKeyBubbles) {\n              shouldDismiss = false;\n              return;\n            }\n          });\n          if (!shouldDismiss) {\n            return;\n          }\n        }\n        events.emit('dismiss', {\n          type: 'escapeKey',\n          data: {\n            returnFocus: {\n              preventScroll: false\n            }\n          }\n        });\n        onOpenChange(false);\n      }\n    }\n    function onOutsidePress(event) {\n      // Given developers can stop the propagation of the synthetic event,\n      // we can only be confident with a positive value.\n      const insideReactTree = insideReactTreeRef.current;\n      insideReactTreeRef.current = false;\n      if (insideReactTree) {\n        return;\n      }\n      if (typeof outsidePress === 'function' && !outsidePress(event)) {\n        return;\n      }\n      const target = getTarget(event);\n\n      // Check if the click occurred on the scrollbar\n      if (isHTMLElement(target) && floating) {\n        const win = floating.ownerDocument.defaultView || window;\n        const canScrollX = target.scrollWidth > target.clientWidth;\n        const canScrollY = target.scrollHeight > target.clientHeight;\n        let xCond = canScrollY && event.offsetX > target.clientWidth;\n\n        // In some browsers it is possible to change the <body> (or window)\n        // scrollbar to the left side, but is very rare and is difficult to\n        // check for. Plus, for modal dialogs with backdrops, it is more\n        // important that the backdrop is checked but not so much the window.\n        if (canScrollY) {\n          const isRTL = win.getComputedStyle(target).direction === 'rtl';\n          if (isRTL) {\n            xCond = event.offsetX <= target.offsetWidth - target.clientWidth;\n          }\n        }\n        if (xCond || canScrollX && event.offsetY > target.clientHeight) {\n          return;\n        }\n      }\n      const targetIsInsideChildren = tree && getChildren(tree.nodesRef.current, nodeId).some(node => {\n        var _node$context;\n        return isEventTargetWithin(event, (_node$context = node.context) == null ? void 0 : _node$context.elements.floating);\n      });\n      if (isEventTargetWithin(event, floating) || isEventTargetWithin(event, domReference) || targetIsInsideChildren) {\n        return;\n      }\n      const children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];\n      if (children.length > 0) {\n        let shouldDismiss = true;\n        children.forEach(child => {\n          var _child$context2;\n          if ((_child$context2 = child.context) != null && _child$context2.open && !child.context.dataRef.current.__outsidePressBubbles) {\n            shouldDismiss = false;\n            return;\n          }\n        });\n        if (!shouldDismiss) {\n          return;\n        }\n      }\n      events.emit('dismiss', {\n        type: 'outsidePress',\n        data: {\n          returnFocus: nested ? {\n            preventScroll: true\n          } : isVirtualClick(event) || isVirtualPointerEvent(event)\n        }\n      });\n      onOpenChange(false);\n    }\n    function onScroll() {\n      onOpenChange(false);\n    }\n    const doc = getDocument(floating);\n    escapeKey && doc.addEventListener('keydown', onKeyDown);\n    outsidePress && doc.addEventListener(outsidePressEvent, onOutsidePress);\n    let ancestors = [];\n    if (ancestorScroll) {\n      if (isElement(domReference)) {\n        ancestors = getOverflowAncestors(domReference);\n      }\n      if (isElement(floating)) {\n        ancestors = ancestors.concat(getOverflowAncestors(floating));\n      }\n      if (!isElement(reference) && reference && reference.contextElement) {\n        ancestors = ancestors.concat(getOverflowAncestors(reference.contextElement));\n      }\n    }\n\n    // Ignore the visual viewport for scrolling dismissal (allow pinch-zoom)\n    ancestors = ancestors.filter(ancestor => {\n      var _doc$defaultView;\n      return ancestor !== ((_doc$defaultView = doc.defaultView) == null ? void 0 : _doc$defaultView.visualViewport);\n    });\n    ancestors.forEach(ancestor => {\n      ancestor.addEventListener('scroll', onScroll, {\n        passive: true\n      });\n    });\n    return () => {\n      escapeKey && doc.removeEventListener('keydown', onKeyDown);\n      outsidePress && doc.removeEventListener(outsidePressEvent, onOutsidePress);\n      ancestors.forEach(ancestor => {\n        ancestor.removeEventListener('scroll', onScroll);\n      });\n    };\n  }, [dataRef, floating, domReference, reference, escapeKey, outsidePress, outsidePressEvent, events, tree, nodeId, open, onOpenChange, ancestorScroll, enabled, escapeKeyBubbles, outsidePressBubbles, nested]);\n  React.useEffect(() => {\n    insideReactTreeRef.current = false;\n  }, [outsidePress, outsidePressEvent]);\n  return React.useMemo(() => {\n    if (!enabled) {\n      return {};\n    }\n    return {\n      reference: {\n        [bubbleHandlerKeys[referencePressEvent]]: () => {\n          if (referencePress) {\n            events.emit('dismiss', {\n              type: 'referencePress',\n              data: {\n                returnFocus: false\n              }\n            });\n            onOpenChange(false);\n          }\n        }\n      },\n      floating: {\n        [captureHandlerKeys[outsidePressEvent]]: () => {\n          insideReactTreeRef.current = true;\n        }\n      }\n    };\n  }, [enabled, events, referencePress, outsidePressEvent, referencePressEvent, onOpenChange]);\n};\n\n/**\n * Opens the floating element while the reference element has focus, like CSS\n * `:focus`.\n * @see https://floating-ui.com/docs/useFocus\n */\nconst useFocus = function (_ref, _temp) {\n  let {\n    open,\n    onOpenChange,\n    dataRef,\n    events,\n    refs,\n    elements: {\n      floating,\n      domReference\n    }\n  } = _ref;\n  let {\n    enabled = true,\n    keyboardOnly = true\n  } = _temp === void 0 ? {} : _temp;\n  const pointerTypeRef = React.useRef('');\n  const blockFocusRef = React.useRef(false);\n  const timeoutRef = React.useRef();\n  React.useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n    const doc = getDocument(floating);\n    const win = doc.defaultView || window;\n\n    // If the reference was focused and the user left the tab/window, and the\n    // floating element was not open, the focus should be blocked when they\n    // return to the tab/window.\n    function onBlur() {\n      if (!open && isHTMLElement(domReference) && domReference === activeElement$1(getDocument(domReference))) {\n        blockFocusRef.current = true;\n      }\n    }\n    win.addEventListener('blur', onBlur);\n    return () => {\n      win.removeEventListener('blur', onBlur);\n    };\n  }, [floating, domReference, open, enabled]);\n  React.useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n    function onDismiss(payload) {\n      if (payload.type === 'referencePress' || payload.type === 'escapeKey') {\n        blockFocusRef.current = true;\n      }\n    }\n    events.on('dismiss', onDismiss);\n    return () => {\n      events.off('dismiss', onDismiss);\n    };\n  }, [events, enabled]);\n  React.useEffect(() => {\n    return () => {\n      clearTimeout(timeoutRef.current);\n    };\n  }, []);\n  return React.useMemo(() => {\n    if (!enabled) {\n      return {};\n    }\n    return {\n      reference: {\n        onPointerDown(_ref2) {\n          let {\n            pointerType\n          } = _ref2;\n          pointerTypeRef.current = pointerType;\n          blockFocusRef.current = !!(pointerType && keyboardOnly);\n        },\n        onMouseLeave() {\n          blockFocusRef.current = false;\n        },\n        onFocus(event) {\n          var _dataRef$current$open;\n          if (blockFocusRef.current) {\n            return;\n          }\n\n          // Dismiss with click should ignore the subsequent `focus` trigger,\n          // but only if the click originated inside the reference element.\n          if (event.type === 'focus' && ((_dataRef$current$open = dataRef.current.openEvent) == null ? void 0 : _dataRef$current$open.type) === 'mousedown' && dataRef.current.openEvent && isEventTargetWithin(dataRef.current.openEvent, domReference)) {\n            return;\n          }\n          dataRef.current.openEvent = event.nativeEvent;\n          onOpenChange(true);\n        },\n        onBlur(event) {\n          blockFocusRef.current = false;\n          const relatedTarget = event.relatedTarget;\n\n          // Hit the non-modal focus management portal guard. Focus will be\n          // moved into the floating element immediately after.\n          const movedToFocusGuard = isElement(relatedTarget) && relatedTarget.hasAttribute('data-floating-ui-focus-guard') && relatedTarget.getAttribute('data-type') === 'outside';\n\n          // Wait for the window blur listener to fire.\n          timeoutRef.current = setTimeout(() => {\n            // When focusing the reference element (e.g. regular click), then\n            // clicking into the floating element, prevent it from hiding.\n            // Note: it must be focusable, e.g. `tabindex=\"-1\"`.\n            if (contains(refs.floating.current, relatedTarget) || contains(domReference, relatedTarget) || movedToFocusGuard) {\n              return;\n            }\n            onOpenChange(false);\n          });\n        }\n      }\n    };\n  }, [enabled, keyboardOnly, domReference, refs, dataRef, onOpenChange]);\n};\n\nlet isPreventScrollSupported = false;\nconst ARROW_UP = 'ArrowUp';\nconst ARROW_DOWN = 'ArrowDown';\nconst ARROW_LEFT = 'ArrowLeft';\nconst ARROW_RIGHT = 'ArrowRight';\nfunction isDifferentRow(index, cols, prevRow) {\n  return Math.floor(index / cols) !== prevRow;\n}\nfunction isIndexOutOfBounds(listRef, index) {\n  return index < 0 || index >= listRef.current.length;\n}\nfunction findNonDisabledIndex(listRef, _temp) {\n  let {\n    startingIndex = -1,\n    decrement = false,\n    disabledIndices,\n    amount = 1\n  } = _temp === void 0 ? {} : _temp;\n  const list = listRef.current;\n  let index = startingIndex;\n  do {\n    var _list$index, _list$index2;\n    index = index + (decrement ? -amount : amount);\n  } while (index >= 0 && index <= list.length - 1 && (disabledIndices ? disabledIndices.includes(index) : list[index] == null || ((_list$index = list[index]) == null ? void 0 : _list$index.hasAttribute('disabled')) || ((_list$index2 = list[index]) == null ? void 0 : _list$index2.getAttribute('aria-disabled')) === 'true'));\n  return index;\n}\nfunction doSwitch(orientation, vertical, horizontal) {\n  switch (orientation) {\n    case 'vertical':\n      return vertical;\n    case 'horizontal':\n      return horizontal;\n    default:\n      return vertical || horizontal;\n  }\n}\nfunction isMainOrientationKey(key, orientation) {\n  const vertical = key === ARROW_UP || key === ARROW_DOWN;\n  const horizontal = key === ARROW_LEFT || key === ARROW_RIGHT;\n  return doSwitch(orientation, vertical, horizontal);\n}\nfunction isMainOrientationToEndKey(key, orientation, rtl) {\n  const vertical = key === ARROW_DOWN;\n  const horizontal = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;\n  return doSwitch(orientation, vertical, horizontal) || key === 'Enter' || key == ' ' || key === '';\n}\nfunction isCrossOrientationOpenKey(key, orientation, rtl) {\n  const vertical = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;\n  const horizontal = key === ARROW_DOWN;\n  return doSwitch(orientation, vertical, horizontal);\n}\nfunction isCrossOrientationCloseKey(key, orientation, rtl) {\n  const vertical = rtl ? key === ARROW_RIGHT : key === ARROW_LEFT;\n  const horizontal = key === ARROW_UP;\n  return doSwitch(orientation, vertical, horizontal);\n}\nfunction getMinIndex(listRef, disabledIndices) {\n  return findNonDisabledIndex(listRef, {\n    disabledIndices\n  });\n}\nfunction getMaxIndex(listRef, disabledIndices) {\n  return findNonDisabledIndex(listRef, {\n    decrement: true,\n    startingIndex: listRef.current.length,\n    disabledIndices\n  });\n}\n/**\n * Adds arrow key-based navigation of a list of items, either using real DOM\n * focus or virtual focus.\n * @see https://floating-ui.com/docs/useListNavigation\n */\nconst useListNavigation = function (_ref, _temp2) {\n  let {\n    open,\n    onOpenChange,\n    refs,\n    elements: {\n      domReference\n    }\n  } = _ref;\n  let {\n    listRef,\n    activeIndex,\n    onNavigate: unstable_onNavigate = () => {},\n    enabled = true,\n    selectedIndex = null,\n    allowEscape = false,\n    loop = false,\n    nested = false,\n    rtl = false,\n    virtual = false,\n    focusItemOnOpen = 'auto',\n    focusItemOnHover = true,\n    openOnArrowKeyDown = true,\n    disabledIndices = undefined,\n    orientation = 'vertical',\n    cols = 1,\n    scrollItemIntoView = true\n  } = _temp2 === void 0 ? {\n    listRef: {\n      current: []\n    },\n    activeIndex: null,\n    onNavigate: () => {}\n  } : _temp2;\n  if (process.env.NODE_ENV !== \"production\") {\n    if (allowEscape) {\n      if (!loop) {\n        console.warn(['Floating UI: `useListNavigation` looping must be enabled to allow', 'escaping.'].join(' '));\n      }\n      if (!virtual) {\n        console.warn(['Floating UI: `useListNavigation` must be virtual to allow', 'escaping.'].join(' '));\n      }\n    }\n    if (orientation === 'vertical' && cols > 1) {\n      console.warn(['Floating UI: In grid list navigation mode (`cols` > 1), the', '`orientation` should be either \"horizontal\" or \"both\".'].join(' '));\n    }\n  }\n  const parentId = useFloatingParentNodeId();\n  const tree = useFloatingTree();\n  const onNavigate = useEvent(unstable_onNavigate);\n  const focusItemOnOpenRef = React.useRef(focusItemOnOpen);\n  const indexRef = React.useRef(selectedIndex != null ? selectedIndex : -1);\n  const keyRef = React.useRef(null);\n  const isPointerModalityRef = React.useRef(true);\n  const previousOnNavigateRef = React.useRef(onNavigate);\n  const previousOpenRef = React.useRef(open);\n  const forceSyncFocus = React.useRef(false);\n  const forceScrollIntoViewRef = React.useRef(false);\n  const disabledIndicesRef = useLatestRef(disabledIndices);\n  const latestOpenRef = useLatestRef(open);\n  const scrollItemIntoViewRef = useLatestRef(scrollItemIntoView);\n  const [activeId, setActiveId] = React.useState();\n  const focusItem = React.useCallback(function (listRef, indexRef, forceScrollIntoView) {\n    if (forceScrollIntoView === void 0) {\n      forceScrollIntoView = false;\n    }\n    const item = listRef.current[indexRef.current];\n    if (virtual) {\n      setActiveId(item == null ? void 0 : item.id);\n    } else {\n      enqueueFocus(item, {\n        preventScroll: true,\n        // Mac Safari does not move the virtual cursor unless the focus call\n        // is sync. However, for the very first focus call, we need to wait\n        // for the position to be ready in order to prevent unwanted\n        // scrolling. This means the virtual cursor will not move to the first\n        // item when first opening the floating element, but will on\n        // subsequent calls. `preventScroll` is supported in modern Safari,\n        // so we can use that instead.\n        // iOS Safari must be async or the first item will not be focused.\n        sync: isMac() && isSafari() ? isPreventScrollSupported || forceSyncFocus.current : false\n      });\n    }\n    requestAnimationFrame(() => {\n      const scrollIntoViewOptions = scrollItemIntoViewRef.current;\n      const shouldScrollIntoView = scrollIntoViewOptions && item && (forceScrollIntoView || !isPointerModalityRef.current);\n      if (shouldScrollIntoView) {\n        // JSDOM doesn't support `.scrollIntoView()` but it's widely supported\n        // by all browsers.\n        item.scrollIntoView == null ? void 0 : item.scrollIntoView(typeof scrollIntoViewOptions === 'boolean' ? {\n          block: 'nearest',\n          inline: 'nearest'\n        } : scrollIntoViewOptions);\n      }\n    });\n  }, [virtual, scrollItemIntoViewRef]);\n  index(() => {\n    document.createElement('div').focus({\n      get preventScroll() {\n        isPreventScrollSupported = true;\n        return false;\n      }\n    });\n  }, []);\n\n  // Sync `selectedIndex` to be the `activeIndex` upon opening the floating\n  // element. Also, reset `activeIndex` upon closing the floating element.\n  index(() => {\n    if (!enabled) {\n      return;\n    }\n    if (open) {\n      if (focusItemOnOpenRef.current && selectedIndex != null) {\n        // Regardless of the pointer modality, we want to ensure the selected\n        // item comes into view when the floating element is opened.\n        forceScrollIntoViewRef.current = true;\n        onNavigate(selectedIndex);\n      }\n    } else if (previousOpenRef.current) {\n      // Since the user can specify `onNavigate` conditionally\n      // (onNavigate: open ? setActiveIndex : setSelectedIndex),\n      // we store and call the previous function.\n      indexRef.current = -1;\n      previousOnNavigateRef.current(null);\n    }\n  }, [enabled, open, selectedIndex, onNavigate]);\n\n  // Sync `activeIndex` to be the focused item while the floating element is\n  // open.\n  index(() => {\n    if (!enabled) {\n      return;\n    }\n    if (open) {\n      if (activeIndex == null) {\n        forceSyncFocus.current = false;\n        if (selectedIndex != null) {\n          return;\n        }\n\n        // Reset while the floating element was open (e.g. the list changed).\n        if (previousOpenRef.current) {\n          indexRef.current = -1;\n          focusItem(listRef, indexRef);\n        }\n\n        // Initial sync.\n        if (!previousOpenRef.current && focusItemOnOpenRef.current && (keyRef.current != null || focusItemOnOpenRef.current === true && keyRef.current == null)) {\n          indexRef.current = keyRef.current == null || isMainOrientationToEndKey(keyRef.current, orientation, rtl) || nested ? getMinIndex(listRef, disabledIndicesRef.current) : getMaxIndex(listRef, disabledIndicesRef.current);\n          onNavigate(indexRef.current);\n        }\n      } else if (!isIndexOutOfBounds(listRef, activeIndex)) {\n        indexRef.current = activeIndex;\n        focusItem(listRef, indexRef, forceScrollIntoViewRef.current);\n        forceScrollIntoViewRef.current = false;\n      }\n    }\n  }, [enabled, open, activeIndex, selectedIndex, nested, listRef, orientation, rtl, onNavigate, focusItem, disabledIndicesRef]);\n\n  // Ensure the parent floating element has focus when a nested child closes\n  // to allow arrow key navigation to work after the pointer leaves the child.\n  index(() => {\n    if (!enabled) {\n      return;\n    }\n    if (previousOpenRef.current && !open) {\n      var _tree$nodesRef$curren, _tree$nodesRef$curren2;\n      const parentFloating = tree == null ? void 0 : (_tree$nodesRef$curren = tree.nodesRef.current.find(node => node.id === parentId)) == null ? void 0 : (_tree$nodesRef$curren2 = _tree$nodesRef$curren.context) == null ? void 0 : _tree$nodesRef$curren2.elements.floating;\n      if (parentFloating && !contains(parentFloating, activeElement$1(getDocument(parentFloating)))) {\n        parentFloating.focus({\n          preventScroll: true\n        });\n      }\n    }\n  }, [enabled, open, tree, parentId]);\n  index(() => {\n    keyRef.current = null;\n    previousOnNavigateRef.current = onNavigate;\n    previousOpenRef.current = open;\n  });\n  const hasActiveIndex = activeIndex != null;\n  const item = React.useMemo(() => {\n    function syncCurrentTarget(currentTarget) {\n      if (!open) return;\n      const index = listRef.current.indexOf(currentTarget);\n      if (index !== -1) {\n        onNavigate(index);\n      }\n    }\n    const props = {\n      onFocus(_ref2) {\n        let {\n          currentTarget\n        } = _ref2;\n        syncCurrentTarget(currentTarget);\n      },\n      onClick: _ref3 => {\n        let {\n          currentTarget\n        } = _ref3;\n        return currentTarget.focus({\n          preventScroll: true\n        });\n      },\n      // Safari\n      ...(focusItemOnHover && {\n        onMouseMove(_ref4) {\n          let {\n            currentTarget\n          } = _ref4;\n          syncCurrentTarget(currentTarget);\n        },\n        onPointerLeave() {\n          if (!isPointerModalityRef.current) {\n            return;\n          }\n          indexRef.current = -1;\n          focusItem(listRef, indexRef);\n\n          // Virtual cursor with VoiceOver on iOS needs this to be flushed\n          // synchronously or there is a glitch that prevents nested\n          // submenus from being accessible.\n          flushSync(() => onNavigate(null));\n          if (!virtual) {\n            var _refs$floating$curren;\n            // This also needs to be sync to prevent fast mouse movements\n            // from leaving behind a stale active item when landing on a\n            // disabled button item.\n            (_refs$floating$curren = refs.floating.current) == null ? void 0 : _refs$floating$curren.focus({\n              preventScroll: true\n            });\n          }\n        }\n      })\n    };\n    return props;\n  }, [open, refs, focusItem, focusItemOnHover, listRef, onNavigate, virtual]);\n  return React.useMemo(() => {\n    if (!enabled) {\n      return {};\n    }\n    const disabledIndices = disabledIndicesRef.current;\n    function onKeyDown(event) {\n      isPointerModalityRef.current = false;\n      forceSyncFocus.current = true;\n\n      // If the floating element is animating out, ignore navigation. Otherwise,\n      // the `activeIndex` gets set to 0 despite not being open so the next time\n      // the user ArrowDowns, the first item won't be focused.\n      if (!latestOpenRef.current && event.currentTarget === refs.floating.current) {\n        return;\n      }\n      if (nested && isCrossOrientationCloseKey(event.key, orientation, rtl)) {\n        stopEvent(event);\n        onOpenChange(false);\n        if (isHTMLElement(domReference)) {\n          domReference.focus();\n        }\n        return;\n      }\n      const currentIndex = indexRef.current;\n      const minIndex = getMinIndex(listRef, disabledIndices);\n      const maxIndex = getMaxIndex(listRef, disabledIndices);\n      if (event.key === 'Home') {\n        indexRef.current = minIndex;\n        onNavigate(indexRef.current);\n      }\n      if (event.key === 'End') {\n        indexRef.current = maxIndex;\n        onNavigate(indexRef.current);\n      }\n\n      // Grid navigation.\n      if (cols > 1) {\n        const prevIndex = indexRef.current;\n        if (event.key === ARROW_UP) {\n          stopEvent(event);\n          if (prevIndex === -1) {\n            indexRef.current = maxIndex;\n          } else {\n            indexRef.current = findNonDisabledIndex(listRef, {\n              startingIndex: prevIndex,\n              amount: cols,\n              decrement: true,\n              disabledIndices\n            });\n            if (loop && (prevIndex - cols < minIndex || indexRef.current < 0)) {\n              const col = prevIndex % cols;\n              const maxCol = maxIndex % cols;\n              const offset = maxIndex - (maxCol - col);\n              if (maxCol === col) {\n                indexRef.current = maxIndex;\n              } else {\n                indexRef.current = maxCol > col ? offset : offset - cols;\n              }\n            }\n          }\n          if (isIndexOutOfBounds(listRef, indexRef.current)) {\n            indexRef.current = prevIndex;\n          }\n          onNavigate(indexRef.current);\n        }\n        if (event.key === ARROW_DOWN) {\n          stopEvent(event);\n          if (prevIndex === -1) {\n            indexRef.current = minIndex;\n          } else {\n            indexRef.current = findNonDisabledIndex(listRef, {\n              startingIndex: prevIndex,\n              amount: cols,\n              disabledIndices\n            });\n            if (loop && prevIndex + cols > maxIndex) {\n              indexRef.current = findNonDisabledIndex(listRef, {\n                startingIndex: prevIndex % cols - cols,\n                amount: cols,\n                disabledIndices\n              });\n            }\n          }\n          if (isIndexOutOfBounds(listRef, indexRef.current)) {\n            indexRef.current = prevIndex;\n          }\n          onNavigate(indexRef.current);\n        }\n\n        // Remains on the same row/column.\n        if (orientation === 'both') {\n          const prevRow = Math.floor(prevIndex / cols);\n          if (event.key === ARROW_RIGHT) {\n            stopEvent(event);\n            if (prevIndex % cols !== cols - 1) {\n              indexRef.current = findNonDisabledIndex(listRef, {\n                startingIndex: prevIndex,\n                disabledIndices\n              });\n              if (loop && isDifferentRow(indexRef.current, cols, prevRow)) {\n                indexRef.current = findNonDisabledIndex(listRef, {\n                  startingIndex: prevIndex - prevIndex % cols - 1,\n                  disabledIndices\n                });\n              }\n            } else if (loop) {\n              indexRef.current = findNonDisabledIndex(listRef, {\n                startingIndex: prevIndex - prevIndex % cols - 1,\n                disabledIndices\n              });\n            }\n            if (isDifferentRow(indexRef.current, cols, prevRow)) {\n              indexRef.current = prevIndex;\n            }\n          }\n          if (event.key === ARROW_LEFT) {\n            stopEvent(event);\n            if (prevIndex % cols !== 0) {\n              indexRef.current = findNonDisabledIndex(listRef, {\n                startingIndex: prevIndex,\n                disabledIndices,\n                decrement: true\n              });\n              if (loop && isDifferentRow(indexRef.current, cols, prevRow)) {\n                indexRef.current = findNonDisabledIndex(listRef, {\n                  startingIndex: prevIndex + (cols - prevIndex % cols),\n                  decrement: true,\n                  disabledIndices\n                });\n              }\n            } else if (loop) {\n              indexRef.current = findNonDisabledIndex(listRef, {\n                startingIndex: prevIndex + (cols - prevIndex % cols),\n                decrement: true,\n                disabledIndices\n              });\n            }\n            if (isDifferentRow(indexRef.current, cols, prevRow)) {\n              indexRef.current = prevIndex;\n            }\n          }\n          const lastRow = Math.floor(maxIndex / cols) === prevRow;\n          if (isIndexOutOfBounds(listRef, indexRef.current)) {\n            if (loop && lastRow) {\n              indexRef.current = event.key === ARROW_LEFT ? maxIndex : findNonDisabledIndex(listRef, {\n                startingIndex: prevIndex - prevIndex % cols - 1,\n                disabledIndices\n              });\n            } else {\n              indexRef.current = prevIndex;\n            }\n          }\n          onNavigate(indexRef.current);\n          return;\n        }\n      }\n      if (isMainOrientationKey(event.key, orientation)) {\n        stopEvent(event);\n\n        // Reset the index if no item is focused.\n        if (open && !virtual && activeElement$1(event.currentTarget.ownerDocument) === event.currentTarget) {\n          indexRef.current = isMainOrientationToEndKey(event.key, orientation, rtl) ? minIndex : maxIndex;\n          onNavigate(indexRef.current);\n          return;\n        }\n        if (isMainOrientationToEndKey(event.key, orientation, rtl)) {\n          if (loop) {\n            indexRef.current = currentIndex >= maxIndex ? allowEscape && currentIndex !== listRef.current.length ? -1 : minIndex : findNonDisabledIndex(listRef, {\n              startingIndex: currentIndex,\n              disabledIndices\n            });\n          } else {\n            indexRef.current = Math.min(maxIndex, findNonDisabledIndex(listRef, {\n              startingIndex: currentIndex,\n              disabledIndices\n            }));\n          }\n        } else {\n          if (loop) {\n            indexRef.current = currentIndex <= minIndex ? allowEscape && currentIndex !== -1 ? listRef.current.length : maxIndex : findNonDisabledIndex(listRef, {\n              startingIndex: currentIndex,\n              decrement: true,\n              disabledIndices\n            });\n          } else {\n            indexRef.current = Math.max(minIndex, findNonDisabledIndex(listRef, {\n              startingIndex: currentIndex,\n              decrement: true,\n              disabledIndices\n            }));\n          }\n        }\n        if (isIndexOutOfBounds(listRef, indexRef.current)) {\n          onNavigate(null);\n        } else {\n          onNavigate(indexRef.current);\n        }\n      }\n    }\n    function checkVirtualMouse(event) {\n      if (focusItemOnOpen === 'auto' && isVirtualClick(event.nativeEvent)) {\n        focusItemOnOpenRef.current = true;\n      }\n    }\n    function checkVirtualPointer(event) {\n      // `pointerdown` fires first, reset the state then perform the checks.\n      focusItemOnOpenRef.current = focusItemOnOpen;\n      if (focusItemOnOpen === 'auto' && isVirtualPointerEvent(event.nativeEvent)) {\n        focusItemOnOpenRef.current = true;\n      }\n    }\n    const ariaActiveDescendantProp = virtual && open && hasActiveIndex && {\n      'aria-activedescendant': activeId\n    };\n    return {\n      reference: {\n        ...ariaActiveDescendantProp,\n        onKeyDown(event) {\n          isPointerModalityRef.current = false;\n          const isArrowKey = event.key.indexOf('Arrow') === 0;\n          if (virtual && open) {\n            return onKeyDown(event);\n          }\n\n          // If a floating element should not open on arrow key down, avoid\n          // setting `activeIndex` while it's closed.\n          if (!open && !openOnArrowKeyDown && isArrowKey) {\n            return;\n          }\n          const isNavigationKey = isArrowKey || event.key === 'Enter' || event.key === ' ' || event.key === '';\n          if (isNavigationKey) {\n            keyRef.current = event.key;\n          }\n          if (nested) {\n            if (isCrossOrientationOpenKey(event.key, orientation, rtl)) {\n              stopEvent(event);\n              if (open) {\n                indexRef.current = getMinIndex(listRef, disabledIndices);\n                onNavigate(indexRef.current);\n              } else {\n                onOpenChange(true);\n              }\n            }\n            return;\n          }\n          if (isMainOrientationKey(event.key, orientation)) {\n            if (selectedIndex != null) {\n              indexRef.current = selectedIndex;\n            }\n            stopEvent(event);\n            if (!open && openOnArrowKeyDown) {\n              onOpenChange(true);\n            } else {\n              onKeyDown(event);\n            }\n            if (open) {\n              onNavigate(indexRef.current);\n            }\n          }\n        },\n        onFocus() {\n          if (open) {\n            onNavigate(null);\n          }\n        },\n        onPointerDown: checkVirtualPointer,\n        onMouseDown: checkVirtualMouse,\n        onClick: checkVirtualMouse\n      },\n      floating: {\n        'aria-orientation': orientation === 'both' ? undefined : orientation,\n        ...ariaActiveDescendantProp,\n        onKeyDown,\n        onPointerMove() {\n          isPointerModalityRef.current = true;\n        }\n      },\n      item\n    };\n  }, [domReference, refs, activeId, disabledIndicesRef, latestOpenRef, listRef, enabled, orientation, rtl, virtual, open, hasActiveIndex, nested, selectedIndex, openOnArrowKeyDown, allowEscape, cols, loop, focusItemOnOpen, onNavigate, onOpenChange, item]);\n};\n\n/**\n * Merges an array of refs into a single memoized callback ref or `null`.\n * @see https://floating-ui.com/docs/useMergeRefs\n */\nfunction useMergeRefs(refs) {\n  return React.useMemo(() => {\n    if (refs.every(ref => ref == null)) {\n      return null;\n    }\n    return value => {\n      refs.forEach(ref => {\n        if (typeof ref === 'function') {\n          ref(value);\n        } else if (ref != null) {\n          ref.current = value;\n        }\n      });\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, refs);\n}\n\n/**\n * Adds base screen reader props to the reference and floating elements for a\n * given floating element `role`.\n * @see https://floating-ui.com/docs/useRole\n */\nconst useRole = function (_ref, _temp) {\n  let {\n    open\n  } = _ref;\n  let {\n    enabled = true,\n    role = 'dialog'\n  } = _temp === void 0 ? {} : _temp;\n  const rootId = useId();\n  const referenceId = useId();\n  return React.useMemo(() => {\n    const floatingProps = {\n      id: rootId,\n      role\n    };\n    if (!enabled) {\n      return {};\n    }\n    if (role === 'tooltip') {\n      return {\n        reference: {\n          'aria-describedby': open ? rootId : undefined\n        },\n        floating: floatingProps\n      };\n    }\n    return {\n      reference: {\n        'aria-expanded': open ? 'true' : 'false',\n        'aria-haspopup': role === 'alertdialog' ? 'dialog' : role,\n        'aria-controls': open ? rootId : undefined,\n        ...(role === 'listbox' && {\n          role: 'combobox'\n        }),\n        ...(role === 'menu' && {\n          id: referenceId\n        })\n      },\n      floating: {\n        ...floatingProps,\n        ...(role === 'menu' && {\n          'aria-labelledby': referenceId\n        })\n      }\n    };\n  }, [enabled, role, open, rootId, referenceId]);\n};\n\n// Converts a JS style key like `backgroundColor` to a CSS transition-property\n// like `background-color`.\nconst camelCaseToKebabCase = str => str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($, ofs) => (ofs ? '-' : '') + $.toLowerCase());\nfunction useDelayUnmount(open, durationMs) {\n  const [isMounted, setIsMounted] = React.useState(open);\n  if (open && !isMounted) {\n    setIsMounted(true);\n  }\n  React.useEffect(() => {\n    if (!open) {\n      const timeout = setTimeout(() => setIsMounted(false), durationMs);\n      return () => clearTimeout(timeout);\n    }\n  }, [open, durationMs]);\n  return isMounted;\n}\n/**\n * Provides a status string to apply CSS transitions to a floating element,\n * correctly handling placement-aware transitions.\n * @see https://floating-ui.com/docs/useTransition#usetransitionstatus\n */\nfunction useTransitionStatus(_ref, _temp) {\n  let {\n    open,\n    elements: {\n      floating\n    }\n  } = _ref;\n  let {\n    duration = 250\n  } = _temp === void 0 ? {} : _temp;\n  const isNumberDuration = typeof duration === 'number';\n  const closeDuration = (isNumberDuration ? duration : duration.close) || 0;\n  const [initiated, setInitiated] = React.useState(false);\n  const [status, setStatus] = React.useState('unmounted');\n  const isMounted = useDelayUnmount(open, closeDuration);\n\n  // `initiated` check prevents this `setState` call from breaking\n  // <FloatingPortal />. This call is necessary to ensure subsequent opens\n  // after the initial one allows the correct side animation to play when the\n  // placement has changed.\n  index(() => {\n    if (initiated && !isMounted) {\n      setStatus('unmounted');\n    }\n  }, [initiated, isMounted]);\n  index(() => {\n    if (!floating) return;\n    if (open) {\n      setStatus('initial');\n      const frame = requestAnimationFrame(() => {\n        setStatus('open');\n      });\n      return () => {\n        cancelAnimationFrame(frame);\n      };\n    } else {\n      setInitiated(true);\n      setStatus('close');\n    }\n  }, [open, floating]);\n  return {\n    isMounted,\n    status\n  };\n}\n/**\n * Provides styles to apply CSS transitions to a floating element, correctly\n * handling placement-aware transitions. Wrapper around `useTransitionStatus`.\n * @see https://floating-ui.com/docs/useTransition#usetransitionstyles\n */\nfunction useTransitionStyles(context, _temp2) {\n  let {\n    initial: unstable_initial = {\n      opacity: 0\n    },\n    open: unstable_open,\n    close: unstable_close,\n    common: unstable_common,\n    duration = 250\n  } = _temp2 === void 0 ? {} : _temp2;\n  const placement = context.placement;\n  const side = placement.split('-')[0];\n  const [styles, setStyles] = React.useState({});\n  const {\n    isMounted,\n    status\n  } = useTransitionStatus(context, {\n    duration\n  });\n  const initialRef = useLatestRef(unstable_initial);\n  const openRef = useLatestRef(unstable_open);\n  const closeRef = useLatestRef(unstable_close);\n  const commonRef = useLatestRef(unstable_common);\n  const isNumberDuration = typeof duration === 'number';\n  const openDuration = (isNumberDuration ? duration : duration.open) || 0;\n  const closeDuration = (isNumberDuration ? duration : duration.close) || 0;\n  index(() => {\n    const fnArgs = {\n      side,\n      placement\n    };\n    const initial = initialRef.current;\n    const close = closeRef.current;\n    const open = openRef.current;\n    const common = commonRef.current;\n    const initialStyles = typeof initial === 'function' ? initial(fnArgs) : initial;\n    const closeStyles = typeof close === 'function' ? close(fnArgs) : close;\n    const commonStyles = typeof common === 'function' ? common(fnArgs) : common;\n    const openStyles = (typeof open === 'function' ? open(fnArgs) : open) || Object.keys(initialStyles).reduce((acc, key) => {\n      acc[key] = '';\n      return acc;\n    }, {});\n    if (status === 'initial' || status === 'unmounted') {\n      setStyles(styles => ({\n        transitionProperty: styles.transitionProperty,\n        ...commonStyles,\n        ...initialStyles\n      }));\n    }\n    if (status === 'open') {\n      setStyles({\n        transitionProperty: Object.keys(openStyles).map(camelCaseToKebabCase).join(','),\n        transitionDuration: openDuration + \"ms\",\n        ...commonStyles,\n        ...openStyles\n      });\n    }\n    if (status === 'close') {\n      const styles = closeStyles || initialStyles;\n      setStyles({\n        transitionProperty: Object.keys(styles).map(camelCaseToKebabCase).join(','),\n        transitionDuration: closeDuration + \"ms\",\n        ...commonStyles,\n        ...styles\n      });\n    }\n  }, [side, placement, closeDuration, closeRef, initialRef, openRef, commonRef, openDuration, status]);\n  return {\n    isMounted,\n    styles\n  };\n}\n\n/**\n * Provides a matching callback that can be used to focus an item as the user\n * types, often used in tandem with `useListNavigation()`.\n * @see https://floating-ui.com/docs/useTypeahead\n */\nconst useTypeahead = function (_ref, _temp) {\n  var _ref2;\n  let {\n    open,\n    dataRef,\n    refs\n  } = _ref;\n  let {\n    listRef,\n    activeIndex,\n    onMatch: unstable_onMatch = () => {},\n    enabled = true,\n    findMatch = null,\n    resetMs = 1000,\n    ignoreKeys = [],\n    selectedIndex = null\n  } = _temp === void 0 ? {\n    listRef: {\n      current: []\n    },\n    activeIndex: null\n  } : _temp;\n  const timeoutIdRef = React.useRef();\n  const stringRef = React.useRef('');\n  const prevIndexRef = React.useRef((_ref2 = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref2 : -1);\n  const matchIndexRef = React.useRef(null);\n  const onMatch = useEvent(unstable_onMatch);\n  const findMatchRef = useLatestRef(findMatch);\n  const ignoreKeysRef = useLatestRef(ignoreKeys);\n  index(() => {\n    if (open) {\n      clearTimeout(timeoutIdRef.current);\n      matchIndexRef.current = null;\n      stringRef.current = '';\n    }\n  }, [open]);\n  index(() => {\n    // Sync arrow key navigation but not typeahead navigation.\n    if (open && stringRef.current === '') {\n      var _ref3;\n      prevIndexRef.current = (_ref3 = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref3 : -1;\n    }\n  }, [open, selectedIndex, activeIndex]);\n  return React.useMemo(() => {\n    if (!enabled) {\n      return {};\n    }\n    function onKeyDown(event) {\n      var _refs$floating$curren;\n      // Correctly scope nested non-portalled floating elements. Since the nested\n      // floating element is inside of the another, we find the closest role\n      // that indicates the floating element scope.\n      const target = getTarget(event.nativeEvent);\n      if (isElement(target) && (activeElement$1(getDocument(target)) !== event.currentTarget ? (_refs$floating$curren = refs.floating.current) != null && _refs$floating$curren.contains(target) ? target.closest('[role=\"dialog\"],[role=\"menu\"],[role=\"listbox\"],[role=\"tree\"],[role=\"grid\"]') !== event.currentTarget : false : !event.currentTarget.contains(target))) {\n        return;\n      }\n      if (stringRef.current.length > 0 && stringRef.current[0] !== ' ') {\n        dataRef.current.typing = true;\n        if (event.key === ' ') {\n          stopEvent(event);\n        }\n      }\n      const listContent = listRef.current;\n      if (listContent == null || ignoreKeysRef.current.includes(event.key) ||\n      // Character key.\n      event.key.length !== 1 ||\n      // Modifier key.\n      event.ctrlKey || event.metaKey || event.altKey) {\n        return;\n      }\n\n      // Bail out if the list contains a word like \"llama\" or \"aaron\". TODO:\n      // allow it in this case, too.\n      const allowRapidSuccessionOfFirstLetter = listContent.every(text => {\n        var _text$, _text$2;\n        return text ? ((_text$ = text[0]) == null ? void 0 : _text$.toLocaleLowerCase()) !== ((_text$2 = text[1]) == null ? void 0 : _text$2.toLocaleLowerCase()) : true;\n      });\n\n      // Allows the user to cycle through items that start with the same letter\n      // in rapid succession.\n      if (allowRapidSuccessionOfFirstLetter && stringRef.current === event.key) {\n        stringRef.current = '';\n        prevIndexRef.current = matchIndexRef.current;\n      }\n      stringRef.current += event.key;\n      clearTimeout(timeoutIdRef.current);\n      timeoutIdRef.current = setTimeout(() => {\n        stringRef.current = '';\n        prevIndexRef.current = matchIndexRef.current;\n        dataRef.current.typing = false;\n      }, resetMs);\n      const prevIndex = prevIndexRef.current;\n      const orderedList = [...listContent.slice((prevIndex || 0) + 1), ...listContent.slice(0, (prevIndex || 0) + 1)];\n      const str = findMatchRef.current ? findMatchRef.current(orderedList, stringRef.current) : orderedList.find(text => (text == null ? void 0 : text.toLocaleLowerCase().indexOf(stringRef.current.toLocaleLowerCase())) === 0);\n      const index = str ? listContent.indexOf(str) : -1;\n      if (index !== -1) {\n        onMatch(index);\n        matchIndexRef.current = index;\n      }\n    }\n    return {\n      reference: {\n        onKeyDown\n      },\n      floating: {\n        onKeyDown\n      }\n    };\n  }, [enabled, dataRef, listRef, resetMs, ignoreKeysRef, findMatchRef, onMatch, refs]);\n};\n\nfunction getArgsWithCustomFloatingHeight(state, height) {\n  return {\n    ...state,\n    rects: {\n      ...state.rects,\n      floating: {\n        ...state.rects.floating,\n        height\n      }\n    }\n  };\n}\n/**\n * Positions the floating element such that an inner element inside\n * of it is anchored to the reference element.\n * @see https://floating-ui.com/docs/inner\n */\nconst inner = props => ({\n  name: 'inner',\n  options: props,\n  async fn(state) {\n    const {\n      listRef,\n      overflowRef,\n      onFallbackChange,\n      offset: innerOffset = 0,\n      index = 0,\n      minItemsVisible = 4,\n      referenceOverflowThreshold = 0,\n      scrollRef,\n      ...detectOverflowOptions\n    } = props;\n    const {\n      rects,\n      elements: {\n        floating\n      }\n    } = state;\n    const item = listRef.current[index];\n    if (process.env.NODE_ENV !== \"production\") {\n      if (!state.placement.startsWith('bottom')) {\n        console.warn(['Floating UI: `placement` side must be \"bottom\" when using the', '`inner` middleware.'].join(' '));\n      }\n    }\n    if (!item) {\n      return {};\n    }\n    const nextArgs = {\n      ...state,\n      ...(await offset(-item.offsetTop - rects.reference.height / 2 - item.offsetHeight / 2 - innerOffset).fn(state))\n    };\n    const el = (scrollRef == null ? void 0 : scrollRef.current) || floating;\n    const overflow = await detectOverflow(getArgsWithCustomFloatingHeight(nextArgs, el.scrollHeight), detectOverflowOptions);\n    const refOverflow = await detectOverflow(nextArgs, {\n      ...detectOverflowOptions,\n      elementContext: 'reference'\n    });\n    const diffY = Math.max(0, overflow.top);\n    const nextY = nextArgs.y + diffY;\n    const maxHeight = Math.max(0, el.scrollHeight - diffY - Math.max(0, overflow.bottom));\n    el.style.maxHeight = maxHeight + \"px\";\n    el.scrollTop = diffY;\n\n    // There is not enough space, fallback to standard anchored positioning\n    if (onFallbackChange) {\n      if (el.offsetHeight < item.offsetHeight * Math.min(minItemsVisible, listRef.current.length - 1) - 1 || refOverflow.top >= -referenceOverflowThreshold || refOverflow.bottom >= -referenceOverflowThreshold) {\n        flushSync(() => onFallbackChange(true));\n      } else {\n        flushSync(() => onFallbackChange(false));\n      }\n    }\n    if (overflowRef) {\n      overflowRef.current = await detectOverflow(getArgsWithCustomFloatingHeight({\n        ...nextArgs,\n        y: nextY\n      }, el.offsetHeight), detectOverflowOptions);\n    }\n    return {\n      y: nextY\n    };\n  }\n});\n/**\n * Changes the `inner` middleware's `offset` upon a `wheel` event to\n * expand the floating element's height, revealing more list items.\n * @see https://floating-ui.com/docs/inner\n */\nconst useInnerOffset = (_ref, _ref2) => {\n  let {\n    open,\n    elements\n  } = _ref;\n  let {\n    enabled = true,\n    overflowRef,\n    scrollRef,\n    onChange: unstable_onChange\n  } = _ref2;\n  const onChange = useEvent(unstable_onChange);\n  const controlledScrollingRef = React.useRef(false);\n  const prevScrollTopRef = React.useRef(null);\n  const initialOverflowRef = React.useRef(null);\n  React.useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n    function onWheel(e) {\n      if (e.ctrlKey || !el || overflowRef.current == null) {\n        return;\n      }\n      const dY = e.deltaY;\n      const isAtTop = overflowRef.current.top >= -0.5;\n      const isAtBottom = overflowRef.current.bottom >= -0.5;\n      const remainingScroll = el.scrollHeight - el.clientHeight;\n      const sign = dY < 0 ? -1 : 1;\n      const method = dY < 0 ? 'max' : 'min';\n      if (el.scrollHeight <= el.clientHeight) {\n        return;\n      }\n      if (!isAtTop && dY > 0 || !isAtBottom && dY < 0) {\n        e.preventDefault();\n        flushSync(() => {\n          onChange(d => d + Math[method](dY, remainingScroll * sign));\n        });\n      } else if (/firefox/i.test(getUserAgent())) {\n        // Needed to propagate scrolling during momentum scrolling phase once\n        // it gets limited by the boundary. UX improvement, not critical.\n        el.scrollTop += dY;\n      }\n    }\n    const el = (scrollRef == null ? void 0 : scrollRef.current) || elements.floating;\n    if (open && el) {\n      el.addEventListener('wheel', onWheel);\n\n      // Wait for the position to be ready.\n      requestAnimationFrame(() => {\n        prevScrollTopRef.current = el.scrollTop;\n        if (overflowRef.current != null) {\n          initialOverflowRef.current = {\n            ...overflowRef.current\n          };\n        }\n      });\n      return () => {\n        prevScrollTopRef.current = null;\n        initialOverflowRef.current = null;\n        el.removeEventListener('wheel', onWheel);\n      };\n    }\n  }, [enabled, open, elements.floating, overflowRef, scrollRef, onChange]);\n  return React.useMemo(() => {\n    if (!enabled) {\n      return {};\n    }\n    return {\n      floating: {\n        onKeyDown() {\n          controlledScrollingRef.current = true;\n        },\n        onWheel() {\n          controlledScrollingRef.current = false;\n        },\n        onPointerMove() {\n          controlledScrollingRef.current = false;\n        },\n        onScroll() {\n          const el = (scrollRef == null ? void 0 : scrollRef.current) || elements.floating;\n          if (!overflowRef.current || !el || !controlledScrollingRef.current) {\n            return;\n          }\n          if (prevScrollTopRef.current !== null) {\n            const scrollDiff = el.scrollTop - prevScrollTopRef.current;\n            if (overflowRef.current.bottom < -0.5 && scrollDiff < -1 || overflowRef.current.top < -0.5 && scrollDiff > 1) {\n              flushSync(() => onChange(d => d + scrollDiff));\n            }\n          }\n\n          // [Firefox] Wait for the height change to have been applied.\n          requestAnimationFrame(() => {\n            prevScrollTopRef.current = el.scrollTop;\n          });\n        }\n      }\n    };\n  }, [enabled, overflowRef, elements.floating, scrollRef, onChange]);\n};\n\nfunction isPointInPolygon(point, polygon) {\n  const [x, y] = point;\n  let isInside = false;\n  const length = polygon.length;\n  for (let i = 0, j = length - 1; i < length; j = i++) {\n    const [xi, yi] = polygon[i] || [0, 0];\n    const [xj, yj] = polygon[j] || [0, 0];\n    const intersect = yi >= y !== yj >= y && x <= (xj - xi) * (y - yi) / (yj - yi) + xi;\n    if (intersect) {\n      isInside = !isInside;\n    }\n  }\n  return isInside;\n}\nfunction isInside(point, rect) {\n  return point[0] >= rect.x && point[0] <= rect.x + rect.width && point[1] >= rect.y && point[1] <= rect.y + rect.height;\n}\nfunction safePolygon(_temp) {\n  let {\n    restMs = 0,\n    buffer = 0.5,\n    blockPointerEvents = false\n  } = _temp === void 0 ? {} : _temp;\n  let timeoutId;\n  let isInsideRect = false;\n  let hasLanded = false;\n  const fn = _ref => {\n    let {\n      x,\n      y,\n      placement,\n      elements,\n      onClose,\n      nodeId,\n      tree\n    } = _ref;\n    return function onMouseMove(event) {\n      function close() {\n        clearTimeout(timeoutId);\n        onClose();\n      }\n      clearTimeout(timeoutId);\n      if (!elements.domReference || !elements.floating || placement == null || x == null || y == null) {\n        return;\n      }\n      const {\n        clientX,\n        clientY\n      } = event;\n      const clientPoint = [clientX, clientY];\n      const target = getTarget(event);\n      const isLeave = event.type === 'mouseleave';\n      const isOverFloatingEl = contains(elements.floating, target);\n      const isOverReferenceEl = contains(elements.domReference, target);\n      const refRect = elements.domReference.getBoundingClientRect();\n      const rect = elements.floating.getBoundingClientRect();\n      const side = placement.split('-')[0];\n      const cursorLeaveFromRight = x > rect.right - rect.width / 2;\n      const cursorLeaveFromBottom = y > rect.bottom - rect.height / 2;\n      const isOverReferenceRect = isInside(clientPoint, refRect);\n      if (isOverFloatingEl) {\n        hasLanded = true;\n        if (!isLeave) {\n          return;\n        }\n      }\n      if (isOverReferenceEl) {\n        hasLanded = false;\n      }\n      if (isOverReferenceEl && !isLeave) {\n        hasLanded = true;\n        return;\n      }\n\n      // Prevent overlapping floating element from being stuck in an open-close\n      // loop: https://github.com/floating-ui/floating-ui/issues/1910\n      if (isLeave && isElement(event.relatedTarget) && contains(elements.floating, event.relatedTarget)) {\n        return;\n      }\n\n      // If any nested child is open, abort.\n      if (tree && getChildren(tree.nodesRef.current, nodeId).some(_ref2 => {\n        let {\n          context\n        } = _ref2;\n        return context == null ? void 0 : context.open;\n      })) {\n        return;\n      }\n\n      // If the pointer is leaving from the opposite side, the \"buffer\" logic\n      // creates a point where the floating element remains open, but should be\n      // ignored.\n      // A constant of 1 handles floating point rounding errors.\n      if (side === 'top' && y >= refRect.bottom - 1 || side === 'bottom' && y <= refRect.top + 1 || side === 'left' && x >= refRect.right - 1 || side === 'right' && x <= refRect.left + 1) {\n        return close();\n      }\n\n      // Ignore when the cursor is within the rectangular trough between the\n      // two elements. Since the triangle is created from the cursor point,\n      // which can start beyond the ref element's edge, traversing back and\n      // forth from the ref to the floating element can cause it to close. This\n      // ensures it always remains open in that case.\n      let rectPoly = [];\n      switch (side) {\n        case 'top':\n          rectPoly = [[rect.left, refRect.top + 1], [rect.left, rect.bottom - 1], [rect.right, rect.bottom - 1], [rect.right, refRect.top + 1]];\n          isInsideRect = clientX >= rect.left && clientX <= rect.right && clientY >= rect.top && clientY <= refRect.top + 1;\n          break;\n        case 'bottom':\n          rectPoly = [[rect.left, rect.top + 1], [rect.left, refRect.bottom - 1], [rect.right, refRect.bottom - 1], [rect.right, rect.top + 1]];\n          isInsideRect = clientX >= rect.left && clientX <= rect.right && clientY >= refRect.bottom - 1 && clientY <= rect.bottom;\n          break;\n        case 'left':\n          rectPoly = [[rect.right - 1, rect.bottom], [rect.right - 1, rect.top], [refRect.left + 1, rect.top], [refRect.left + 1, rect.bottom]];\n          isInsideRect = clientX >= rect.left && clientX <= refRect.left + 1 && clientY >= rect.top && clientY <= rect.bottom;\n          break;\n        case 'right':\n          rectPoly = [[refRect.right - 1, rect.bottom], [refRect.right - 1, rect.top], [rect.left + 1, rect.top], [rect.left + 1, rect.bottom]];\n          isInsideRect = clientX >= refRect.right - 1 && clientX <= rect.right && clientY >= rect.top && clientY <= rect.bottom;\n          break;\n      }\n      function getPolygon(_ref3) {\n        let [x, y] = _ref3;\n        const isFloatingWider = rect.width > refRect.width;\n        const isFloatingTaller = rect.height > refRect.height;\n        switch (side) {\n          case 'top':\n            {\n              const cursorPointOne = [isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y + buffer + 1];\n              const cursorPointTwo = [isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y + buffer + 1];\n              const commonPoints = [[rect.left, cursorLeaveFromRight ? rect.bottom - buffer : isFloatingWider ? rect.bottom - buffer : rect.top], [rect.right, cursorLeaveFromRight ? isFloatingWider ? rect.bottom - buffer : rect.top : rect.bottom - buffer]];\n              return [cursorPointOne, cursorPointTwo, ...commonPoints];\n            }\n          case 'bottom':\n            {\n              const cursorPointOne = [isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y - buffer];\n              const cursorPointTwo = [isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y - buffer];\n              const commonPoints = [[rect.left, cursorLeaveFromRight ? rect.top + buffer : isFloatingWider ? rect.top + buffer : rect.bottom], [rect.right, cursorLeaveFromRight ? isFloatingWider ? rect.top + buffer : rect.bottom : rect.top + buffer]];\n              return [cursorPointOne, cursorPointTwo, ...commonPoints];\n            }\n          case 'left':\n            {\n              const cursorPointOne = [x + buffer + 1, isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const cursorPointTwo = [x + buffer + 1, isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const commonPoints = [[cursorLeaveFromBottom ? rect.right - buffer : isFloatingTaller ? rect.right - buffer : rect.left, rect.top], [cursorLeaveFromBottom ? isFloatingTaller ? rect.right - buffer : rect.left : rect.right - buffer, rect.bottom]];\n              return [...commonPoints, cursorPointOne, cursorPointTwo];\n            }\n          case 'right':\n            {\n              const cursorPointOne = [x - buffer, isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const cursorPointTwo = [x - buffer, isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const commonPoints = [[cursorLeaveFromBottom ? rect.left + buffer : isFloatingTaller ? rect.left + buffer : rect.right, rect.top], [cursorLeaveFromBottom ? isFloatingTaller ? rect.left + buffer : rect.right : rect.left + buffer, rect.bottom]];\n              return [cursorPointOne, cursorPointTwo, ...commonPoints];\n            }\n        }\n      }\n      const poly = isInsideRect ? rectPoly : getPolygon([x, y]);\n      if (isInsideRect) {\n        return;\n      } else if (hasLanded && !isOverReferenceRect) {\n        return close();\n      }\n      if (!isPointInPolygon([clientX, clientY], poly)) {\n        close();\n      } else if (restMs && !hasLanded) {\n        timeoutId = setTimeout(close, restMs);\n      }\n    };\n  };\n  fn.__options = {\n    blockPointerEvents\n  };\n  return fn;\n}\n\n/**\n * Provides data to position a floating element and context to add interactions.\n * @see https://floating-ui.com/docs/react\n */\nfunction useFloating(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    open = false,\n    onOpenChange: unstable_onOpenChange,\n    nodeId\n  } = options;\n  const position = useFloating$1(options);\n  const tree = useFloatingTree();\n  const domReferenceRef = React.useRef(null);\n  const dataRef = React.useRef({});\n  const events = React.useState(() => createPubSub())[0];\n  const [domReference, setDomReference] = React.useState(null);\n  const setPositionReference = React.useCallback(node => {\n    const positionReference = isElement(node) ? {\n      getBoundingClientRect: () => node.getBoundingClientRect(),\n      contextElement: node\n    } : node;\n    position.refs.setReference(positionReference);\n  }, [position.refs]);\n  const setReference = React.useCallback(node => {\n    if (isElement(node) || node === null) {\n      domReferenceRef.current = node;\n      setDomReference(node);\n    }\n\n    // Backwards-compatibility for passing a virtual element to `reference`\n    // after it has set the DOM reference.\n    if (isElement(position.refs.reference.current) || position.refs.reference.current === null ||\n    // Don't allow setting virtual elements using the old technique back to\n    // `null` to support `positionReference` + an unstable `reference`\n    // callback ref.\n    node !== null && !isElement(node)) {\n      position.refs.setReference(node);\n    }\n  }, [position.refs]);\n  const refs = React.useMemo(() => ({\n    ...position.refs,\n    setReference,\n    setPositionReference,\n    domReference: domReferenceRef\n  }), [position.refs, setReference, setPositionReference]);\n  const elements = React.useMemo(() => ({\n    ...position.elements,\n    domReference: domReference\n  }), [position.elements, domReference]);\n  const onOpenChange = useEvent(unstable_onOpenChange);\n  const context = React.useMemo(() => ({\n    ...position,\n    refs,\n    elements,\n    dataRef,\n    nodeId,\n    events,\n    open,\n    onOpenChange\n  }), [position, nodeId, events, open, onOpenChange, refs, elements]);\n  index(() => {\n    const node = tree == null ? void 0 : tree.nodesRef.current.find(node => node.id === nodeId);\n    if (node) {\n      node.context = context;\n    }\n  });\n  return React.useMemo(() => ({\n    ...position,\n    context,\n    refs,\n    reference: setReference,\n    positionReference: setPositionReference\n  }), [position, refs, context, setReference, setPositionReference]);\n}\n\nfunction mergeProps(userProps, propsList, elementKey) {\n  const map = new Map();\n  return {\n    ...(elementKey === 'floating' && {\n      tabIndex: -1\n    }),\n    ...userProps,\n    ...propsList.map(value => value ? value[elementKey] : null).concat(userProps).reduce((acc, props) => {\n      if (!props) {\n        return acc;\n      }\n      Object.entries(props).forEach(_ref => {\n        let [key, value] = _ref;\n        if (key.indexOf('on') === 0) {\n          if (!map.has(key)) {\n            map.set(key, []);\n          }\n          if (typeof value === 'function') {\n            var _map$get;\n            (_map$get = map.get(key)) == null ? void 0 : _map$get.push(value);\n            acc[key] = function () {\n              var _map$get2;\n              for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n                args[_key] = arguments[_key];\n              }\n              (_map$get2 = map.get(key)) == null ? void 0 : _map$get2.forEach(fn => fn(...args));\n            };\n          }\n        } else {\n          acc[key] = value;\n        }\n      });\n      return acc;\n    }, {})\n  };\n}\nconst useInteractions = function (propsList) {\n  if (propsList === void 0) {\n    propsList = [];\n  }\n  // The dependencies are a dynamic array, so we can't use the linter's\n  // suggestion to add it to the deps array.\n  const deps = propsList;\n  const getReferenceProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'reference'),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  deps);\n  const getFloatingProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'floating'),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  deps);\n  const getItemProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'item'),\n  // Granularly check for `item` changes, because the `getItemProps` getter\n  // should be as referentially stable as possible since it may be passed as\n  // a prop to many components. All `item` key values must therefore be\n  // memoized.\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  propsList.map(key => key == null ? void 0 : key.item));\n  return React.useMemo(() => ({\n    getReferenceProps,\n    getFloatingProps,\n    getItemProps\n  }), [getReferenceProps, getFloatingProps, getItemProps]);\n};\n\nexport { FloatingDelayGroup, FloatingFocusManager, FloatingNode, FloatingOverlay, FloatingPortal, FloatingTree, inner, safePolygon, useClick, useDelayGroup, useDelayGroupContext, useDismiss, useFloating, useFloatingNodeId, useFloatingParentNodeId, useFloatingPortalNode, useFloatingTree, useFocus, useHover, useId, useInnerOffset, useInteractions, useListNavigation, useMergeRefs, useRole, useTransitionStatus, useTransitionStyles, useTypeahead };\n","'use client';\n\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nconst _excluded = [\"className\", \"id\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport composeClasses from '@mui/utils/composeClasses';\nimport Typography from '../Typography';\nimport styled from '../styles/styled';\nimport { useDefaultProps } from '../DefaultPropsProvider';\nimport { getDialogTitleUtilityClass } from './dialogTitleClasses';\nimport DialogContext from '../Dialog/DialogContext';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst useUtilityClasses = ownerState => {\n  const {\n    classes\n  } = ownerState;\n  const slots = {\n    root: ['root']\n  };\n  return composeClasses(slots, getDialogTitleUtilityClass, classes);\n};\nconst DialogTitleRoot = styled(Typography, {\n  name: 'MuiDialogTitle',\n  slot: 'Root',\n  overridesResolver: (props, styles) => styles.root\n})({\n  padding: '16px 24px',\n  flex: '0 0 auto'\n});\nconst DialogTitle = /*#__PURE__*/React.forwardRef(function DialogTitle(inProps, ref) {\n  const props = useDefaultProps({\n    props: inProps,\n    name: 'MuiDialogTitle'\n  });\n  const {\n      className,\n      id: idProp\n    } = props,\n    other = _objectWithoutPropertiesLoose(props, _excluded);\n  const ownerState = props;\n  const classes = useUtilityClasses(ownerState);\n  const {\n    titleId = idProp\n  } = React.useContext(DialogContext);\n  return /*#__PURE__*/_jsx(DialogTitleRoot, _extends({\n    component: \"h2\",\n    className: clsx(classes.root, className),\n    ownerState: ownerState,\n    ref: ref,\n    variant: \"h6\",\n    id: idProp != null ? idProp : titleId\n  }, other));\n});\nprocess.env.NODE_ENV !== \"production\" ? DialogTitle.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * The content of the component.\n   */\n  children: PropTypes.node,\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n  /**\n   * @ignore\n   */\n  id: PropTypes.string,\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])\n} : void 0;\nexport default DialogTitle;","/**\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: rawValue.mainAxis || 0,\n    crossAxis: rawValue.crossAxis || 0,\n    alignmentAxis: rawValue.alignmentAxis\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          enabled: {\n            [mainAxis]: checkMainAxis,\n            [crossAxis]: checkCrossAxis\n          }\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      var _state$middlewareData, _state$middlewareData2;\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 ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) {\n        availableWidth = maximumClippingWidth;\n      }\n      if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) {\n        availableHeight = 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, getDocumentElement, isTopLayer, getNodeName, isOverflowElement, getNodeScroll, 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\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  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,\n    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y\n  };\n}\n\nfunction getClientRects(element) {\n  return Array.from(element.getClientRects());\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\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      ...clippingAncestor,\n      x: clippingAncestor.x - visualOffsets.x,\n      y: clippingAncestor.y - visualOffsets.y\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  let htmlX = 0;\n  let htmlY = 0;\n  if (documentElement && !isOffsetParentAnElement && !isFixed) {\n    const htmlRect = documentElement.getBoundingClientRect();\n    htmlY = htmlRect.top + scroll.scrollTop;\n    htmlX = htmlRect.left + scroll.scrollLeft -\n    // RTL <body> scrollbar.\n    getWindowScrollBarX(documentElement, htmlRect);\n  }\n  const x = rect.left + scroll.scrollLeft - offsets.x - htmlX;\n  const y = rect.top + scroll.scrollTop - offsets.y - htmlY;\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":["arrow","options","element","padding","name","fn","args","value","Object","prototype","hasOwnProperty","call","current","index","document","useLayoutEffect","useEffect","deepEqual","a","b","toString","length","i","keys","Array","isArray","key","$$typeof","useLatestRef","ref","useFloating","placement","strategy","middleware","platform","whileElementsMounted","open","data","setData","x","y","middlewareData","isPositioned","latestMiddleware","setLatestMiddleware","referenceRef","floatingRef","dataRef","whileElementsMountedRef","platformRef","reference","_setReference","floating","_setFloating","setReference","node","setFloating","update","config","then","fullData","isMountedRef","refs","elements","candidateSelectors","candidateSelector","join","NoElement","Element","matches","msMatchesSelector","webkitMatchesSelector","getRootNode","_element$getRootNode","ownerDocument","isInert","lookUp","_node$getAttribute","inertAtt","getAttribute","parentNode","getCandidates","el","includeContainer","filter","candidates","slice","apply","querySelectorAll","unshift","getCandidatesIteratively","elementsToCheck","from","shift","tagName","assigned","assignedElements","nestedCandidates","children","flatten","push","scopeParent","includes","shadowRoot","getShadowRoot","validShadowRoot","shadowRootFilter","_nestedCandidates","hasTabIndex","isNaN","parseInt","getTabIndex","Error","tabIndex","test","_node$getAttribute2","attValue","isContentEditable","sortOrderedTabbables","documentOrder","isInput","isNonTabbableRadio","type","isRadio","radioSet","radioScope","form","queryRadios","window","CSS","escape","err","console","error","message","checked","nodes","getCheckedRadio","isTabbableRadio","isZeroArea","_node$getBoundingClie","getBoundingClientRect","width","height","isHidden","_ref","displayCheck","getComputedStyle","visibility","nodeUnderDetails","parentElement","originalNode","rootNode","assignedSlot","host","_nodeRoot","_nodeRootHost","_nodeRootHost$ownerDo","_node$ownerDocument","nodeRoot","nodeRootHost","attached","contains","_nodeRoot2","_nodeRootHost2","_nodeRootHost2$ownerD","isNodeAttached","getClientRects","isNodeMatchingSelectorFocusable","disabled","isHiddenInput","some","child","isDetailsWithSummary","item","isDisabledFromFieldset","isNodeMatchingSelectorTabbable","isValidShadowRootTabbable","shadowHostNode","sortByOrder","regularTabbables","orderedTabbables","forEach","isScope","candidateTabindex","getSortOrderTabIndex","content","sort","reduce","acc","sortable","concat","container","bind","serverHandoffComplete","count","genId","useId","id","setId","undefined","createPubSub","map","Map","emit","event","_map$get","get","handler","on","listener","set","off","l","FloatingNodeContext","FloatingTreeContext","useFloatingParentNodeId","_React$useContext","useFloatingTree","getDocument","getPlatform","uaData","navigator","userAgentData","getUserAgent","brands","brand","version","userAgent","getWindow","defaultView","isElement","isHTMLElement","HTMLElement","isVirtualClick","mozInputSource","isTrusted","androidRe","pointerType","buttons","detail","isVirtualPointerEvent","pressure","isSafari","vendor","isMac","toLowerCase","startsWith","maxTouchPoints","isMouseLikePointerType","strict","values","useRef","safePolygonIdentifier","getDelay","prop","useHover","context","_temp","enabled","delay","handleClose","mouseOnly","restMs","move","onOpenChange","events","domReference","tree","parentId","handleCloseRef","delayRef","pointerTypeRef","timeoutRef","handlerRef","restTimeoutRef","blockMouseMoveRef","performedPointerEventsMutationRef","unbindMouseMoveRef","isHoverOpen","_dataRef$current$open","openEvent","onDismiss","clearTimeout","onLeave","html","documentElement","addEventListener","removeEventListener","closeWithDelay","runElseBranch","closeDelay","setTimeout","cleanupMouseMoveHandler","clearPointerEvents","body","style","pointerEvents","removeAttribute","onScrollMouseLeave","onMouseEnter","once","onMouseLeave","isClickLikeOpenEvent","openDelay","doc","clientX","clientY","onClose","_handleCloseRef$curre","__options","blockPointerEvents","setAttribute","_tree$nodesRef$curren","_tree$nodesRef$curren2","parentFloating","nodesRef","find","setPointerRef","onPointerDown","onPointerEnter","onMouseMove","returnFocus","_extends","assign","target","arguments","source","this","activeElement$1","activeElement","_activeElement","_activeElement$shadow","parent","ShadowRoot","next","getChildren","allChildren","_node$context","currentChildren","_currentChildren","n","_node$context2","getTarget","composedPath","isTypeableElement","getTabbableOptions","ResizeObserver","getTabbableIn","direction","allTabbable","reverse","activeIndex","indexOf","getNextTabbable","getPreviousTabbable","isOutsideEvent","containerElement","currentTarget","relatedTarget","disableFocusInside","dataset","tabindex","enableFocusInside","useSafeInsertionEffect","useEvent","callback","_len","_key","HIDDEN_STYLES","border","clip","margin","overflow","position","whiteSpace","top","left","timeoutId","setActiveElementOnTab","FocusGuard","props","onFocus","role","setRole","result","isTabFocus","persist","PortalContext","FloatingPortal","root","preserveTabOrder","portalNode","portalEl","setPortalEl","uniqueId","portalContext","usePortalContext","getElementById","newPortalEl","createElement","appendChild","removeChild","useFloatingPortalNode","focusManagerState","setFocusManagerState","beforeOutsideRef","afterOutsideRef","beforeInsideRef","afterInsideRef","shouldRenderGuards","modal","Provider","_beforeInsideRef$curr","focus","prevTabbable","createPortal","_afterInsideRef$curre","nextTabbable","closeOnFocusOut","isButtonTarget","isSpaceIgnored","useClick","eventOption","toggle","ignoreMouse","keyboardHandlers","onMouseDown","button","preventDefault","nativeEvent","onClick","__syncReturnFocus","onKeyDown","onKeyUp","isEventTargetWithin","e","bubbleHandlerKeys","pointerdown","mousedown","click","captureHandlerKeys","useDismiss","nodeId","escapeKey","outsidePress","unstable_outsidePress","outsidePressEvent","referencePress","referencePressEvent","ancestorScroll","bubbles","nested","outsidePressFn","insideReactTreeRef","escapeKeyBubbles","outsidePressBubbles","_bubbles$escapeKey","_bubbles$outsidePress","normalizeBubblesProp","shouldDismiss","_child$context","__escapeKeyBubbles","preventScroll","onOutsidePress","insideReactTree","win","canScrollX","scrollWidth","clientWidth","canScrollY","scrollHeight","clientHeight","xCond","offsetX","offsetWidth","offsetY","targetIsInsideChildren","_child$context2","__outsidePressBubbles","onScroll","ancestors","contextElement","ancestor","_doc$defaultView","visualViewport","passive","useFocus","keyboardOnly","blockFocusRef","onBlur","payload","_ref2","movedToFocusGuard","hasAttribute","useRole","rootId","referenceId","floatingProps","unstable_onOpenChange","domReferenceRef","setDomReference","setPositionReference","positionReference","mergeProps","userProps","propsList","elementKey","entries","has","_map$get2","useInteractions","deps","getReferenceProps","getFloatingProps","getItemProps","_excluded","DialogTitleRoot","slot","overridesResolver","styles","flex","DialogTitle","inProps","className","idProp","other","ownerState","classes","useUtilityClasses","titleId","component","variant","Math","min","max","round","floor","createCoords","v","oppositeSideMap","right","bottom","oppositeAlignmentMap","start","end","clamp","param","split","axis","getAxisLength","getAlignmentAxis","replace","alignment","getOppositePlacement","side","expandPaddingObject","rect","computeCoordsFromPlacement","rtl","sideAxis","alignmentAxis","alignLength","isVertical","commonX","commonY","commonAlign","coords","async","detectOverflow","state","_await$platform$isEle","rects","boundary","rootBoundary","elementContext","altBoundary","paddingObject","clippingClientRect","getClippingRect","getDocumentElement","offsetParent","getOffsetParent","offsetScale","getScale","elementClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","getCssDimensions","css","parseFloat","hasOffset","offsetHeight","shouldFallback","$","unwrapElement","domElement","Number","isFinite","noOffsets","getVisualOffsets","offsetLeft","offsetTop","includeScale","isFixedStrategy","clientRect","scale","visualOffsets","isFixed","floatingOffsetParent","shouldAddVisualOffsets","offsetWin","currentWin","currentIFrame","iframeScale","iframeRect","clientLeft","paddingLeft","clientTop","paddingTop","getWindowScrollBarX","leftScroll","scrollLeft","getClientRectFromClippingAncestor","clippingAncestor","visualViewportBased","getViewportRect","scroll","scrollTop","getDocumentRect","getInnerBoundingClientRect","hasFixedPositionAncestor","stopNode","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsets","offsetRect","htmlX","htmlY","htmlRect","isStaticPositioned","getTrueOffsetParent","polyfill","rawOffsetParent","svgOffsetParent","topLayer","elementClippingAncestors","cache","cachedResult","currentContainingBlockComputedStyle","elementIsFixed","currentNode","computedStyle","currentNodeIsContaining","getClippingElementAncestors","_c","clippingAncestors","firstClippingAncestor","clippingRect","accRect","getElementRects","getOffsetParentFn","getDimensionsFn","getDimensions","floatingDimensions","isRTL","autoUpdate","ancestorResize","elementResize","layoutShift","IntersectionObserver","animationFrame","referenceEl","cleanupIo","onMove","io","cleanup","_io","disconnect","refresh","skip","threshold","rootMargin","isFirstUpdate","handleObserve","ratio","intersectionRatio","observe","observeMove","frameId","reobserveFrame","resizeObserver","firstEntry","unobserve","cancelAnimationFrame","requestAnimationFrame","_resizeObserver","prevRefRect","frameLoop","nextRefRect","_resizeObserver2","_middlewareData$offse","_middlewareData$arrow","diffCoords","mainAxisMulti","crossAxisMulti","rawValue","mainAxis","crossAxis","convertValueToCoords","offset","alignmentOffset","checkMainAxis","checkCrossAxis","limiter","detectOverflowOptions","mainAxisCoord","crossAxisCoord","maxSide","limitedCoords","_middlewareData$flip","initialPlacement","fallbackPlacements","specifiedFallbackPlacements","fallbackStrategy","fallbackAxisSideDirection","flipAlignment","initialSideAxis","isBasePlacement","oppositePlacement","getExpandedPlacements","hasFallbackAxisSideDirection","list","isStart","lr","rl","tb","bt","getSideList","getOppositeAxisPlacements","placements","overflows","overflowsData","flip","sides","mainAlignmentSide","every","_middlewareData$flip2","_overflowsData$filter","nextIndex","nextPlacement","reset","resetPlacement","d","_overflowsData$filter2","currentSideAxis","_state$middlewareData","_state$middlewareData2","isYAxis","heightSide","widthSide","maximumClippingHeight","maximumClippingWidth","overflowAvailableHeight","overflowAvailableWidth","noShift","availableHeight","availableWidth","xMin","xMax","yMin","yMax","nextDimensions","arrowDimensions","minProp","maxProp","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","centerToReference","largestPossiblePadding","minPadding","maxPadding","min$1","center","shouldAddOffset","centerOffset","mergedOptions","platformWithCache","validMiddleware","Boolean","statefulPlacement","resetCount","nextX","nextY","computePosition","hasWindow","getNodeName","isNode","nodeName","Node","isShadowRoot","isOverflowElement","overflowX","overflowY","display","isTableElement","isTopLayer","selector","isContainingBlock","elementOrCss","webkit","isWebKit","transform","perspective","containerType","backdropFilter","willChange","contain","getContainingBlock","getParentNode","isLastTraversableNode","supports","getNodeScroll","scrollX","scrollY","getNearestOverflowAncestor","getOverflowAncestors","traverseIframes","_node$ownerDocument2","scrollableAncestor","isBody","frameElement","getFrameElement","getPrototypeOf"],"sourceRoot":""}