{"version":3,"file":"static/js/vendors-77ff0bac.aa8341e6.js","mappings":"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","sources":["../node_modules/@floating-ui/react/dist/floating-ui.react.utils.mjs","../node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs","../node_modules/@floating-ui/react/dist/floating-ui.react.esm.js","../node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs","../node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs"],"sourcesContent":["import { isShadowRoot, isHTMLElement } from '@floating-ui/utils/dom';\n\nfunction activeElement(doc) {\n  let activeElement = doc.activeElement;\n  while (((_activeElement = activeElement) == null || (_activeElement = _activeElement.shadowRoot) == null ? void 0 : _activeElement.activeElement) != null) {\n    var _activeElement;\n    activeElement = activeElement.shadowRoot.activeElement;\n  }\n  return activeElement;\n}\nfunction contains(parent, child) {\n  if (!parent || !child) {\n    return false;\n  }\n  const rootNode = child.getRootNode == null ? void 0 : child.getRootNode();\n\n  // First, attempt with faster native method\n  if (parent.contains(child)) {\n    return true;\n  }\n\n  // then fallback to custom implementation with Shadow DOM support\n  if (rootNode && isShadowRoot(rootNode)) {\n    let next = child;\n    while (next) {\n      if (parent === next) {\n        return true;\n      }\n      // @ts-ignore\n      next = next.parentNode || next.host;\n    }\n  }\n\n  // Give up, the result is false\n  return false;\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\n// License: https://github.com/adobe/react-spectrum/blob/b35d5c02fe900badccd0cf1a8f23bb593419f238/packages/@react-aria/utils/src/isVirtualEvent.ts\nfunction isVirtualClick(event) {\n  // FIXME: Firefox is now emitting a deprecation warning for `mozInputSource`.\n  // Try to find a workaround for this. `react-aria` source still has the check.\n  if (event.mozInputSource === 0 && event.isTrusted) {\n    return true;\n  }\n  if (isAndroid() && event.pointerType) {\n    return event.type === 'click' && event.buttons === 1;\n  }\n  return event.detail === 0 && !event.pointerType;\n}\nfunction isVirtualPointerEvent(event) {\n  if (isJSDOM()) return false;\n  return !isAndroid() && event.width === 0 && event.height === 0 || isAndroid() && 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 && event.pointerType === 'touch';\n}\nfunction isSafari() {\n  // Chrome DevTools does not complain about navigator.vendor\n  return /apple/i.test(navigator.vendor);\n}\nfunction isAndroid() {\n  const re = /android/i;\n  return re.test(getPlatform()) || re.test(getUserAgent());\n}\nfunction isMac() {\n  return getPlatform().toLowerCase().startsWith('mac') && !navigator.maxTouchPoints;\n}\nfunction isJSDOM() {\n  return getUserAgent().includes('jsdom/');\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}\nfunction isReactEvent(event) {\n  return 'nativeEvent' in event;\n}\nfunction isRootElement(element) {\n  return element.matches('html,body');\n}\nfunction getDocument(node) {\n  return (node == null ? void 0 : node.ownerDocument) || document;\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}\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}\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}\nfunction stopEvent(event) {\n  event.preventDefault();\n  event.stopPropagation();\n}\nfunction isTypeableCombobox(element) {\n  if (!element) return false;\n  return element.getAttribute('role') === 'combobox' && isTypeableElement(element);\n}\n\nexport { TYPEABLE_SELECTOR, activeElement, contains, getDocument, getPlatform, getTarget, getUserAgent, isAndroid, isEventTargetWithin, isJSDOM, isMac, isMouseLikePointerType, isReactEvent, isRootElement, isSafari, isTypeableCombobox, isTypeableElement, isVirtualClick, isVirtualPointerEvent, stopEvent };\n","import { computePosition, arrow as arrow$2, offset as offset$1, shift as shift$1, limitShift as limitShift$1, flip as flip$1, size as size$1, autoPlacement as autoPlacement$1, hide as hide$1, inline as inline$1 } from '@floating-ui/dom';\nexport { autoUpdate, computePosition, detectOverflow, getOverflowAncestors, platform } from '@floating-ui/dom';\nimport * as React from 'react';\nimport { useLayoutEffect, useEffect } from 'react';\nimport * as ReactDOM from 'react-dom';\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;\n  let i;\n  let 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 (!{}.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 getDPR(element) {\n  if (typeof window === 'undefined') {\n    return 1;\n  }\n  const win = element.ownerDocument.defaultView || window;\n  return win.devicePixelRatio || 1;\n}\n\nfunction roundByDPR(element, value) {\n  const dpr = getDPR(element);\n  return Math.round(value * dpr) / dpr;\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/useFloating\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    elements: {\n      reference: externalReference,\n      floating: externalFloating\n    } = {},\n    transform = true,\n    whileElementsMounted,\n    open\n  } = options;\n  const [data, setData] = React.useState({\n    x: 0,\n    y: 0,\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 [_reference, _setReference] = React.useState(null);\n  const [_floating, _setFloating] = React.useState(null);\n  const setReference = React.useCallback(node => {\n    if (node !== referenceRef.current) {\n      referenceRef.current = node;\n      _setReference(node);\n    }\n  }, []);\n  const setFloating = React.useCallback(node => {\n    if (node !== floatingRef.current) {\n      floatingRef.current = node;\n      _setFloating(node);\n    }\n  }, []);\n  const referenceEl = externalReference || _reference;\n  const floatingEl = externalFloating || _floating;\n  const referenceRef = React.useRef(null);\n  const floatingRef = React.useRef(null);\n  const dataRef = React.useRef(data);\n  const hasWhileElementsMounted = whileElementsMounted != null;\n  const whileElementsMountedRef = useLatestRef(whileElementsMounted);\n  const platformRef = useLatestRef(platform);\n  const openRef = useLatestRef(open);\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        // The floating element's position may be recomputed while it's closed\n        // but still mounted (such as when transitioning out). To ensure\n        // `isPositioned` will be `false` initially on the next open, avoid\n        // setting it to `true` when `open === false` (must be specified).\n        isPositioned: openRef.current !== false\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, openRef]);\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 (referenceEl) referenceRef.current = referenceEl;\n    if (floatingEl) floatingRef.current = floatingEl;\n    if (referenceEl && floatingEl) {\n      if (whileElementsMountedRef.current) {\n        return whileElementsMountedRef.current(referenceEl, floatingEl, update);\n      }\n      update();\n    }\n  }, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);\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: referenceEl,\n    floating: floatingEl\n  }), [referenceEl, floatingEl]);\n  const floatingStyles = React.useMemo(() => {\n    const initialStyles = {\n      position: strategy,\n      left: 0,\n      top: 0\n    };\n    if (!elements.floating) {\n      return initialStyles;\n    }\n    const x = roundByDPR(elements.floating, data.x);\n    const y = roundByDPR(elements.floating, data.y);\n    if (transform) {\n      return {\n        ...initialStyles,\n        transform: \"translate(\" + x + \"px, \" + y + \"px)\",\n        ...(getDPR(elements.floating) >= 1.5 && {\n          willChange: 'transform'\n        })\n      };\n    }\n    return {\n      position: strategy,\n      left: x,\n      top: y\n    };\n  }, [strategy, transform, elements.floating, data.x, data.y]);\n  return React.useMemo(() => ({\n    ...data,\n    update,\n    refs,\n    elements,\n    floatingStyles\n  }), [data, update, refs, elements, floatingStyles]);\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 * This wraps the core `arrow` middleware to allow React refs as the element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow$1 = options => {\n  function isRef(value) {\n    return {}.hasOwnProperty.call(value, 'current');\n  }\n  return {\n    name: 'arrow',\n    options,\n    fn(state) {\n      const {\n        element,\n        padding\n      } = typeof options === 'function' ? options(state) : options;\n      if (element && isRef(element)) {\n        if (element.current != null) {\n          return arrow$2({\n            element: element.current,\n            padding\n          }).fn(state);\n        }\n        return {};\n      }\n      if (element) {\n        return arrow$2({\n          element,\n          padding\n        }).fn(state);\n      }\n      return {};\n    }\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 = (options, deps) => ({\n  ...offset$1(options),\n  options: [options, deps]\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 = (options, deps) => ({\n  ...shift$1(options),\n  options: [options, deps]\n});\n\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = (options, deps) => ({\n  ...limitShift$1(options),\n  options: [options, deps]\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 = (options, deps) => ({\n  ...flip$1(options),\n  options: [options, deps]\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 = (options, deps) => ({\n  ...size$1(options),\n  options: [options, deps]\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 = (options, deps) => ({\n  ...autoPlacement$1(options),\n  options: [options, deps]\n});\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 = (options, deps) => ({\n  ...hide$1(options),\n  options: [options, deps]\n});\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 = (options, deps) => ({\n  ...inline$1(options),\n  options: [options, deps]\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 * 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, deps) => ({\n  ...arrow$1(options),\n  options: [options, deps]\n});\n\nexport { arrow, autoPlacement, flip, hide, inline, limitShift, offset, shift, size, useFloating };\n","import * as React from 'react';\nimport { useLayoutEffect, useEffect, useRef } from 'react';\nimport { stopEvent, getDocument, isMouseLikePointerType, contains, activeElement, isSafari, isTypeableCombobox, isVirtualClick, isVirtualPointerEvent, getTarget, getPlatform, isTypeableElement, isReactEvent, isRootElement, isEventTargetWithin, isMac, getUserAgent } from '@floating-ui/react/utils';\nimport { floor, evaluate, max, min, round } from '@floating-ui/utils';\nimport { jsx, jsxs, Fragment } from 'react/jsx-runtime';\nimport { getComputedStyle, isElement, getNodeName, isHTMLElement, getWindow, isLastTraversableNode, getParentNode, isWebKit } from '@floating-ui/utils/dom';\nimport { tabbable, isTabbable } from 'tabbable';\nimport * as ReactDOM from 'react-dom';\nimport { getOverflowAncestors, useFloating as useFloating$1, offset, detectOverflow } 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\n/**\n * Merges an array of refs into a single memoized callback ref or `null`.\n * @see https://floating-ui.com/docs/react-utils#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// https://github.com/mui/material-ui/issues/41190#issuecomment-2040873379\nconst SafeReact = {\n  ...React\n};\n\nconst useInsertionEffect = SafeReact.useInsertionEffect;\nconst useSafeInsertionEffect = useInsertionEffect || (fn => fn());\nfunction useEffectEvent(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\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 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}\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    index += decrement ? -amount : amount;\n  } while (index >= 0 && index <= list.length - 1 && isDisabled(list, index, disabledIndices));\n  return index;\n}\nfunction getGridNavigatedIndex(elementsRef, _ref) {\n  let {\n    event,\n    orientation,\n    loop,\n    rtl,\n    cols,\n    disabledIndices,\n    minIndex,\n    maxIndex,\n    prevIndex,\n    stopEvent: stop = false\n  } = _ref;\n  let nextIndex = prevIndex;\n  if (event.key === ARROW_UP) {\n    stop && stopEvent(event);\n    if (prevIndex === -1) {\n      nextIndex = maxIndex;\n    } else {\n      nextIndex = findNonDisabledIndex(elementsRef, {\n        startingIndex: nextIndex,\n        amount: cols,\n        decrement: true,\n        disabledIndices\n      });\n      if (loop && (prevIndex - cols < minIndex || nextIndex < 0)) {\n        const col = prevIndex % cols;\n        const maxCol = maxIndex % cols;\n        const offset = maxIndex - (maxCol - col);\n        if (maxCol === col) {\n          nextIndex = maxIndex;\n        } else {\n          nextIndex = maxCol > col ? offset : offset - cols;\n        }\n      }\n    }\n    if (isIndexOutOfBounds(elementsRef, nextIndex)) {\n      nextIndex = prevIndex;\n    }\n  }\n  if (event.key === ARROW_DOWN) {\n    stop && stopEvent(event);\n    if (prevIndex === -1) {\n      nextIndex = minIndex;\n    } else {\n      nextIndex = findNonDisabledIndex(elementsRef, {\n        startingIndex: prevIndex,\n        amount: cols,\n        disabledIndices\n      });\n      if (loop && prevIndex + cols > maxIndex) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex % cols - cols,\n          amount: cols,\n          disabledIndices\n        });\n      }\n    }\n    if (isIndexOutOfBounds(elementsRef, nextIndex)) {\n      nextIndex = prevIndex;\n    }\n  }\n\n  // Remains on the same row/column.\n  if (orientation === 'both') {\n    const prevRow = floor(prevIndex / cols);\n    if (event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT)) {\n      stop && stopEvent(event);\n      if (prevIndex % cols !== cols - 1) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex,\n          disabledIndices\n        });\n        if (loop && isDifferentRow(nextIndex, cols, prevRow)) {\n          nextIndex = findNonDisabledIndex(elementsRef, {\n            startingIndex: prevIndex - prevIndex % cols - 1,\n            disabledIndices\n          });\n        }\n      } else if (loop) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex - prevIndex % cols - 1,\n          disabledIndices\n        });\n      }\n      if (isDifferentRow(nextIndex, cols, prevRow)) {\n        nextIndex = prevIndex;\n      }\n    }\n    if (event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT)) {\n      stop && stopEvent(event);\n      if (prevIndex % cols !== 0) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex,\n          decrement: true,\n          disabledIndices\n        });\n        if (loop && isDifferentRow(nextIndex, cols, prevRow)) {\n          nextIndex = findNonDisabledIndex(elementsRef, {\n            startingIndex: prevIndex + (cols - prevIndex % cols),\n            decrement: true,\n            disabledIndices\n          });\n        }\n      } else if (loop) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex + (cols - prevIndex % cols),\n          decrement: true,\n          disabledIndices\n        });\n      }\n      if (isDifferentRow(nextIndex, cols, prevRow)) {\n        nextIndex = prevIndex;\n      }\n    }\n    const lastRow = floor(maxIndex / cols) === prevRow;\n    if (isIndexOutOfBounds(elementsRef, nextIndex)) {\n      if (loop && lastRow) {\n        nextIndex = event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT) ? maxIndex : findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex - prevIndex % cols - 1,\n          disabledIndices\n        });\n      } else {\n        nextIndex = prevIndex;\n      }\n    }\n  }\n  return nextIndex;\n}\n\n/** For each cell index, gets the item index that occupies that cell */\nfunction buildCellMap(sizes, cols, dense) {\n  const cellMap = [];\n  let startIndex = 0;\n  sizes.forEach((_ref2, index) => {\n    let {\n      width,\n      height\n    } = _ref2;\n    if (width > cols) {\n      if (process.env.NODE_ENV !== \"production\") {\n        throw new Error(\"[Floating UI]: Invalid grid - item width at index \" + index + \" is greater than grid columns\");\n      }\n    }\n    let itemPlaced = false;\n    if (dense) {\n      startIndex = 0;\n    }\n    while (!itemPlaced) {\n      const targetCells = [];\n      for (let i = 0; i < width; i++) {\n        for (let j = 0; j < height; j++) {\n          targetCells.push(startIndex + i + j * cols);\n        }\n      }\n      if (startIndex % cols + width <= cols && targetCells.every(cell => cellMap[cell] == null)) {\n        targetCells.forEach(cell => {\n          cellMap[cell] = index;\n        });\n        itemPlaced = true;\n      } else {\n        startIndex++;\n      }\n    }\n  });\n\n  // convert into a non-sparse array\n  return [...cellMap];\n}\n\n/** Gets cell index of an item's corner or -1 when index is -1. */\nfunction getCellIndexOfCorner(index, sizes, cellMap, cols, corner) {\n  if (index === -1) return -1;\n  const firstCellIndex = cellMap.indexOf(index);\n  const sizeItem = sizes[index];\n  switch (corner) {\n    case 'tl':\n      return firstCellIndex;\n    case 'tr':\n      if (!sizeItem) {\n        return firstCellIndex;\n      }\n      return firstCellIndex + sizeItem.width - 1;\n    case 'bl':\n      if (!sizeItem) {\n        return firstCellIndex;\n      }\n      return firstCellIndex + (sizeItem.height - 1) * cols;\n    case 'br':\n      return cellMap.lastIndexOf(index);\n  }\n}\n\n/** Gets all cell indices that correspond to the specified indices */\nfunction getCellIndices(indices, cellMap) {\n  return cellMap.flatMap((index, cellIndex) => indices.includes(index) ? [cellIndex] : []);\n}\nfunction isDisabled(list, index, disabledIndices) {\n  if (disabledIndices) {\n    return disabledIndices.includes(index);\n  }\n  const element = list[index];\n  return element == null || element.hasAttribute('disabled') || element.getAttribute('aria-disabled') === 'true';\n}\n\nvar index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\n\nfunction sortByDocumentPosition(a, b) {\n  const position = a.compareDocumentPosition(b);\n  if (position & Node.DOCUMENT_POSITION_FOLLOWING || position & Node.DOCUMENT_POSITION_CONTAINED_BY) {\n    return -1;\n  }\n  if (position & Node.DOCUMENT_POSITION_PRECEDING || position & Node.DOCUMENT_POSITION_CONTAINS) {\n    return 1;\n  }\n  return 0;\n}\nfunction areMapsEqual(map1, map2) {\n  if (map1.size !== map2.size) {\n    return false;\n  }\n  for (const [key, value] of map1.entries()) {\n    if (value !== map2.get(key)) {\n      return false;\n    }\n  }\n  return true;\n}\nconst FloatingListContext = /*#__PURE__*/React.createContext({\n  register: () => {},\n  unregister: () => {},\n  map: /*#__PURE__*/new Map(),\n  elementsRef: {\n    current: []\n  }\n});\n/**\n * Provides context for a list of items within the floating element.\n * @see https://floating-ui.com/docs/FloatingList\n */\nfunction FloatingList(props) {\n  const {\n    children,\n    elementsRef,\n    labelsRef\n  } = props;\n  const [map, setMap] = React.useState(() => new Map());\n  const register = React.useCallback(node => {\n    setMap(prevMap => new Map(prevMap).set(node, null));\n  }, []);\n  const unregister = React.useCallback(node => {\n    setMap(prevMap => {\n      const map = new Map(prevMap);\n      map.delete(node);\n      return map;\n    });\n  }, []);\n  index(() => {\n    const newMap = new Map(map);\n    const nodes = Array.from(newMap.keys()).sort(sortByDocumentPosition);\n    nodes.forEach((node, index) => {\n      newMap.set(node, index);\n    });\n    if (!areMapsEqual(map, newMap)) {\n      setMap(newMap);\n    }\n  }, [map]);\n  return /*#__PURE__*/jsx(FloatingListContext.Provider, {\n    value: React.useMemo(() => ({\n      register,\n      unregister,\n      map,\n      elementsRef,\n      labelsRef\n    }), [register, unregister, map, elementsRef, labelsRef]),\n    children: children\n  });\n}\n/**\n * Used to register a list item and its index (DOM position) in the\n * `FloatingList`.\n * @see https://floating-ui.com/docs/FloatingList#uselistitem\n */\nfunction useListItem(props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    label\n  } = props;\n  const {\n    register,\n    unregister,\n    map,\n    elementsRef,\n    labelsRef\n  } = React.useContext(FloatingListContext);\n  const [index$1, setIndex] = React.useState(null);\n  const componentRef = React.useRef(null);\n  const ref = React.useCallback(node => {\n    componentRef.current = node;\n    if (index$1 !== null) {\n      elementsRef.current[index$1] = node;\n      if (labelsRef) {\n        var _node$textContent;\n        const isLabelDefined = label !== undefined;\n        labelsRef.current[index$1] = isLabelDefined ? label : (_node$textContent = node == null ? void 0 : node.textContent) != null ? _node$textContent : null;\n      }\n    }\n  }, [index$1, elementsRef, labelsRef, label]);\n  index(() => {\n    const node = componentRef.current;\n    if (node) {\n      register(node);\n      return () => {\n        unregister(node);\n      };\n    }\n  }, [register, unregister]);\n  index(() => {\n    const index = componentRef.current ? map.get(componentRef.current) : null;\n    if (index != null) {\n      setIndex(index);\n    }\n  }, [map]);\n  return React.useMemo(() => ({\n    ref,\n    index: index$1 == null ? -1 : index$1\n  }), [index$1, ref]);\n}\n\nfunction renderJsx(render, computedProps) {\n  if (typeof render === 'function') {\n    return render(computedProps);\n  }\n  if (render) {\n    return /*#__PURE__*/React.cloneElement(render, computedProps);\n  }\n  return /*#__PURE__*/jsx(\"div\", {\n    ...computedProps\n  });\n}\nconst CompositeContext = /*#__PURE__*/React.createContext({\n  activeIndex: 0,\n  onNavigate: () => {}\n});\nconst horizontalKeys = [ARROW_LEFT, ARROW_RIGHT];\nconst verticalKeys = [ARROW_UP, ARROW_DOWN];\nconst allKeys = [...horizontalKeys, ...verticalKeys];\n\n/**\n * Creates a single tab stop whose items are navigated by arrow keys, which\n * provides list navigation outside of floating element contexts.\n *\n * This is useful to enable navigation of a list of items that aren’t part of a\n * floating element. A menubar is an example of a composite, with each reference\n * element being an item.\n * @see https://floating-ui.com/docs/Composite\n */\nconst Composite = /*#__PURE__*/React.forwardRef(function Composite(props, forwardedRef) {\n  const {\n    render,\n    orientation = 'both',\n    loop = true,\n    rtl = false,\n    cols = 1,\n    disabledIndices,\n    activeIndex: externalActiveIndex,\n    onNavigate: externalSetActiveIndex,\n    itemSizes,\n    dense = false,\n    ...domProps\n  } = props;\n  const [internalActiveIndex, internalSetActiveIndex] = React.useState(0);\n  const activeIndex = externalActiveIndex != null ? externalActiveIndex : internalActiveIndex;\n  const onNavigate = useEffectEvent(externalSetActiveIndex != null ? externalSetActiveIndex : internalSetActiveIndex);\n  const elementsRef = React.useRef([]);\n  const renderElementProps = render && typeof render !== 'function' ? render.props : {};\n  const contextValue = React.useMemo(() => ({\n    activeIndex,\n    onNavigate\n  }), [activeIndex, onNavigate]);\n  const isGrid = cols > 1;\n  function handleKeyDown(event) {\n    if (!allKeys.includes(event.key)) return;\n    let nextIndex = activeIndex;\n    const minIndex = getMinIndex(elementsRef, disabledIndices);\n    const maxIndex = getMaxIndex(elementsRef, disabledIndices);\n    const horizontalEndKey = rtl ? ARROW_LEFT : ARROW_RIGHT;\n    const horizontalStartKey = rtl ? ARROW_RIGHT : ARROW_LEFT;\n    if (isGrid) {\n      const sizes = itemSizes || Array.from({\n        length: elementsRef.current.length\n      }, () => ({\n        width: 1,\n        height: 1\n      }));\n      // To calculate movements on the grid, we use hypothetical cell indices\n      // as if every item was 1x1, then convert back to real indices.\n      const cellMap = buildCellMap(sizes, cols, dense);\n      const minGridIndex = cellMap.findIndex(index => index != null && !isDisabled(elementsRef.current, index, disabledIndices));\n      // last enabled index\n      const maxGridIndex = cellMap.reduce((foundIndex, index, cellIndex) => index != null && !isDisabled(elementsRef.current, index, disabledIndices) ? cellIndex : foundIndex, -1);\n      const maybeNextIndex = cellMap[getGridNavigatedIndex({\n        current: cellMap.map(itemIndex => itemIndex ? elementsRef.current[itemIndex] : null)\n      }, {\n        event,\n        orientation,\n        loop,\n        rtl,\n        cols,\n        // treat undefined (empty grid spaces) as disabled indices so we\n        // don't end up in them\n        disabledIndices: getCellIndices([...(disabledIndices || elementsRef.current.map((_, index) => isDisabled(elementsRef.current, index) ? index : undefined)), undefined], cellMap),\n        minIndex: minGridIndex,\n        maxIndex: maxGridIndex,\n        prevIndex: getCellIndexOfCorner(activeIndex > maxIndex ? minIndex : activeIndex, sizes, cellMap, cols,\n        // use a corner matching the edge closest to the direction we're\n        // moving in so we don't end up in the same item. Prefer\n        // top/left over bottom/right.\n        event.key === ARROW_DOWN ? 'bl' : event.key === horizontalEndKey ? 'tr' : 'tl')\n      })];\n      if (maybeNextIndex != null) {\n        nextIndex = maybeNextIndex;\n      }\n    }\n    const toEndKeys = {\n      horizontal: [horizontalEndKey],\n      vertical: [ARROW_DOWN],\n      both: [horizontalEndKey, ARROW_DOWN]\n    }[orientation];\n    const toStartKeys = {\n      horizontal: [horizontalStartKey],\n      vertical: [ARROW_UP],\n      both: [horizontalStartKey, ARROW_UP]\n    }[orientation];\n    const preventedKeys = isGrid ? allKeys : {\n      horizontal: horizontalKeys,\n      vertical: verticalKeys,\n      both: allKeys\n    }[orientation];\n    if (nextIndex === activeIndex && [...toEndKeys, ...toStartKeys].includes(event.key)) {\n      if (loop && nextIndex === maxIndex && toEndKeys.includes(event.key)) {\n        nextIndex = minIndex;\n      } else if (loop && nextIndex === minIndex && toStartKeys.includes(event.key)) {\n        nextIndex = maxIndex;\n      } else {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: nextIndex,\n          decrement: toStartKeys.includes(event.key),\n          disabledIndices\n        });\n      }\n    }\n    if (nextIndex !== activeIndex && !isIndexOutOfBounds(elementsRef, nextIndex)) {\n      var _elementsRef$current$;\n      event.stopPropagation();\n      if (preventedKeys.includes(event.key)) {\n        event.preventDefault();\n      }\n      onNavigate(nextIndex);\n      (_elementsRef$current$ = elementsRef.current[nextIndex]) == null || _elementsRef$current$.focus();\n    }\n  }\n  const computedProps = {\n    ...domProps,\n    ...renderElementProps,\n    ref: forwardedRef,\n    'aria-orientation': orientation === 'both' ? undefined : orientation,\n    onKeyDown(e) {\n      domProps.onKeyDown == null || domProps.onKeyDown(e);\n      renderElementProps.onKeyDown == null || renderElementProps.onKeyDown(e);\n      handleKeyDown(e);\n    }\n  };\n  return /*#__PURE__*/jsx(CompositeContext.Provider, {\n    value: contextValue,\n    children: /*#__PURE__*/jsx(FloatingList, {\n      elementsRef: elementsRef,\n      children: renderJsx(render, computedProps)\n    })\n  });\n});\n/**\n * @see https://floating-ui.com/docs/Composite\n */\nconst CompositeItem = /*#__PURE__*/React.forwardRef(function CompositeItem(props, forwardedRef) {\n  const {\n    render,\n    ...domProps\n  } = props;\n  const renderElementProps = render && typeof render !== 'function' ? render.props : {};\n  const {\n    activeIndex,\n    onNavigate\n  } = React.useContext(CompositeContext);\n  const {\n    ref,\n    index\n  } = useListItem();\n  const mergedRef = useMergeRefs([ref, forwardedRef, renderElementProps.ref]);\n  const isActive = activeIndex === index;\n  const computedProps = {\n    ...domProps,\n    ...renderElementProps,\n    ref: mergedRef,\n    tabIndex: isActive ? 0 : -1,\n    'data-active': isActive ? '' : undefined,\n    onFocus(e) {\n      domProps.onFocus == null || domProps.onFocus(e);\n      renderElementProps.onFocus == null || renderElementProps.onFocus(e);\n      onNavigate(index);\n    }\n  };\n  return renderJsx(render, computedProps);\n});\n\nlet serverHandoffComplete = false;\nlet count = 0;\nconst genId = () => // Ensure the id is unique with multiple independent versions of Floating UI\n// on <React 18\n\"floating-ui-\" + Math.random().toString(36).slice(2, 6) + 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    serverHandoffComplete = true;\n  }, []);\n  return id;\n}\nconst useReactId = SafeReact.useId;\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/react-utils#useid\n */\nconst useId = useReactId || useFloatingId;\n\nlet devMessageSet;\nif (process.env.NODE_ENV !== \"production\") {\n  devMessageSet = /*#__PURE__*/new Set();\n}\nfunction warn() {\n  var _devMessageSet;\n  for (var _len = arguments.length, messages = new Array(_len), _key = 0; _key < _len; _key++) {\n    messages[_key] = arguments[_key];\n  }\n  const message = \"Floating UI: \" + messages.join(' ');\n  if (!((_devMessageSet = devMessageSet) != null && _devMessageSet.has(message))) {\n    var _devMessageSet2;\n    (_devMessageSet2 = devMessageSet) == null || _devMessageSet2.add(message);\n    console.warn(message);\n  }\n}\nfunction error() {\n  var _devMessageSet3;\n  for (var _len2 = arguments.length, messages = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n    messages[_key2] = arguments[_key2];\n  }\n  const message = \"Floating UI: \" + messages.join(' ');\n  if (!((_devMessageSet3 = devMessageSet) != null && _devMessageSet3.has(message))) {\n    var _devMessageSet4;\n    (_devMessageSet4 = devMessageSet) == null || _devMessageSet4.add(message);\n    console.error(message);\n  }\n}\n\n/**\n * Renders a pointing arrow triangle.\n * @see https://floating-ui.com/docs/FloatingArrow\n */\nconst FloatingArrow = /*#__PURE__*/React.forwardRef(function FloatingArrow(props, ref) {\n  const {\n    context: {\n      placement,\n      elements: {\n        floating\n      },\n      middlewareData: {\n        arrow,\n        shift\n      }\n    },\n    width = 14,\n    height = 7,\n    tipRadius = 0,\n    strokeWidth = 0,\n    staticOffset,\n    stroke,\n    d,\n    style: {\n      transform,\n      ...restStyle\n    } = {},\n    ...rest\n  } = props;\n  if (process.env.NODE_ENV !== \"production\") {\n    if (!ref) {\n      warn('The `ref` prop is required for `FloatingArrow`.');\n    }\n  }\n  const clipPathId = useId();\n  const [isRTL, setIsRTL] = React.useState(false);\n\n  // https://github.com/floating-ui/floating-ui/issues/2932\n  index(() => {\n    if (!floating) return;\n    const isRTL = getComputedStyle(floating).direction === 'rtl';\n    if (isRTL) {\n      setIsRTL(true);\n    }\n  }, [floating]);\n  if (!floating) {\n    return null;\n  }\n  const [side, alignment] = placement.split('-');\n  const isVerticalSide = side === 'top' || side === 'bottom';\n  let computedStaticOffset = staticOffset;\n  if (isVerticalSide && shift != null && shift.x || !isVerticalSide && shift != null && shift.y) {\n    computedStaticOffset = null;\n  }\n\n  // Strokes must be double the border width, this ensures the stroke's width\n  // works as you'd expect.\n  const computedStrokeWidth = strokeWidth * 2;\n  const halfStrokeWidth = computedStrokeWidth / 2;\n  const svgX = width / 2 * (tipRadius / -8 + 1);\n  const svgY = height / 2 * tipRadius / 4;\n  const isCustomShape = !!d;\n  const yOffsetProp = computedStaticOffset && alignment === 'end' ? 'bottom' : 'top';\n  let xOffsetProp = computedStaticOffset && alignment === 'end' ? 'right' : 'left';\n  if (computedStaticOffset && isRTL) {\n    xOffsetProp = alignment === 'end' ? 'left' : 'right';\n  }\n  const arrowX = (arrow == null ? void 0 : arrow.x) != null ? computedStaticOffset || arrow.x : '';\n  const arrowY = (arrow == null ? void 0 : arrow.y) != null ? computedStaticOffset || arrow.y : '';\n  const dValue = d || 'M0,0' + (\" H\" + width) + (\" L\" + (width - svgX) + \",\" + (height - svgY)) + (\" Q\" + width / 2 + \",\" + height + \" \" + svgX + \",\" + (height - svgY)) + ' Z';\n  const rotation = {\n    top: isCustomShape ? 'rotate(180deg)' : '',\n    left: isCustomShape ? 'rotate(90deg)' : 'rotate(-90deg)',\n    bottom: isCustomShape ? '' : 'rotate(180deg)',\n    right: isCustomShape ? 'rotate(-90deg)' : 'rotate(90deg)'\n  }[side];\n  return /*#__PURE__*/jsxs(\"svg\", {\n    ...rest,\n    \"aria-hidden\": true,\n    ref: ref,\n    width: isCustomShape ? width : width + computedStrokeWidth,\n    height: width,\n    viewBox: \"0 0 \" + width + \" \" + (height > width ? height : width),\n    style: {\n      position: 'absolute',\n      pointerEvents: 'none',\n      [xOffsetProp]: arrowX,\n      [yOffsetProp]: arrowY,\n      [side]: isVerticalSide || isCustomShape ? '100%' : \"calc(100% - \" + computedStrokeWidth / 2 + \"px)\",\n      transform: [rotation, transform].filter(t => !!t).join(' '),\n      ...restStyle\n    },\n    children: [computedStrokeWidth > 0 && /*#__PURE__*/jsx(\"path\", {\n      clipPath: \"url(#\" + clipPathId + \")\",\n      fill: \"none\",\n      stroke: stroke\n      // Account for the stroke on the fill path rendered below.\n      ,\n      strokeWidth: computedStrokeWidth + (d ? 0 : 1),\n      d: dValue\n    }), /*#__PURE__*/jsx(\"path\", {\n      stroke: computedStrokeWidth && !d ? rest.fill : 'none',\n      d: dValue\n    }), /*#__PURE__*/jsx(\"clipPath\", {\n      id: clipPathId,\n      children: /*#__PURE__*/jsx(\"rect\", {\n        x: -halfStrokeWidth,\n        y: halfStrokeWidth * (isCustomShape ? -1 : 1),\n        width: width + computedStrokeWidth,\n        height: width\n      })\n    })]\n  });\n});\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 || _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      var _map$get2;\n      map.set(event, ((_map$get2 = map.get(event)) == null ? void 0 : _map$get2.filter(l => l !== listener)) || []);\n    }\n  };\n}\n\nconst FloatingNodeContext = /*#__PURE__*/React.createContext(null);\nconst FloatingTreeContext = /*#__PURE__*/React.createContext(null);\n\n/**\n * Returns the parent node id for nested floating elements, if available.\n * Returns `null` for top-level floating elements.\n */\nconst useFloatingParentNodeId = () => {\n  var _React$useContext;\n  return ((_React$useContext = React.useContext(FloatingNodeContext)) == null ? void 0 : _React$useContext.id) || null;\n};\n\n/**\n * Returns the nearest floating tree context, if available.\n */\nconst useFloatingTree = () => React.useContext(FloatingTreeContext);\n\n/**\n * Registers a node into the `FloatingTree`, returning its id.\n * @see https://floating-ui.com/docs/FloatingTree\n */\nfunction useFloatingNodeId(customParentId) {\n  const id = useId();\n  const tree = useFloatingTree();\n  const reactParentId = useFloatingParentNodeId();\n  const parentId = customParentId || reactParentId;\n  index(() => {\n    if (!id) return;\n    const node = {\n      id,\n      parentId\n    };\n    tree == null || tree.addNode(node);\n    return () => {\n      tree == null || tree.removeNode(node);\n    };\n  }, [tree, id, parentId]);\n  return id;\n}\n/**\n * Provides parent node context for nested floating elements.\n * @see https://floating-ui.com/docs/FloatingTree\n */\nfunction FloatingNode(props) {\n  const {\n    children,\n    id\n  } = props;\n  const parentId = useFloatingParentNodeId();\n  return /*#__PURE__*/jsx(FloatingNodeContext.Provider, {\n    value: React.useMemo(() => ({\n      id,\n      parentId\n    }), [id, parentId]),\n    children: children\n  });\n}\n/**\n * Provides context for nested floating elements when they are not children of\n * each other on the DOM.\n * This is not necessary in all cases, except when there must be explicit communication between parent and child floating elements. It is necessary for:\n * - The `bubbles` option in the `useDismiss()` Hook\n * - Nested virtual list navigation\n * - Nested floating elements that each open on hover\n * - Custom communication between parent and child floating elements\n * @see https://floating-ui.com/docs/FloatingTree\n */\nfunction FloatingTree(props) {\n  const {\n    children\n  } = props;\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__*/jsx(FloatingTreeContext.Provider, {\n    value: React.useMemo(() => ({\n      nodesRef,\n      addNode,\n      removeNode,\n      events\n    }), [addNode, removeNode, events]),\n    children: children\n  });\n}\n\nfunction createAttribute(name) {\n  return \"data-floating-ui-\" + name;\n}\n\nfunction useLatestRef(value) {\n  const ref = useRef(value);\n  index(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n\nconst safePolygonIdentifier = /*#__PURE__*/createAttribute('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 */\nfunction useHover(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    dataRef,\n    events,\n    elements\n  } = context;\n  const {\n    enabled = true,\n    delay = 0,\n    handleClose = null,\n    mouseOnly = false,\n    restMs = 0,\n    move = true\n  } = props;\n  const tree = useFloatingTree();\n  const parentId = useFloatingParentNodeId();\n  const handleCloseRef = useLatestRef(handleClose);\n  const delayRef = useLatestRef(delay);\n  const openRef = useLatestRef(open);\n  const pointerTypeRef = React.useRef();\n  const timeoutRef = React.useRef(-1);\n  const handlerRef = React.useRef();\n  const restTimeoutRef = React.useRef(-1);\n  const blockMouseMoveRef = React.useRef(true);\n  const performedPointerEventsMutationRef = React.useRef(false);\n  const unbindMouseMoveRef = React.useRef(() => {});\n  const restTimeoutPendingRef = React.useRef(false);\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 closing before opening, clear the delay timeouts to cancel it\n  // from showing.\n  React.useEffect(() => {\n    if (!enabled) return;\n    function onOpenChange(_ref) {\n      let {\n        open\n      } = _ref;\n      if (!open) {\n        clearTimeout(timeoutRef.current);\n        clearTimeout(restTimeoutRef.current);\n        blockMouseMoveRef.current = true;\n        restTimeoutPendingRef.current = false;\n      }\n    }\n    events.on('openchange', onOpenChange);\n    return () => {\n      events.off('openchange', onOpenChange);\n    };\n  }, [enabled, events]);\n  React.useEffect(() => {\n    if (!enabled) return;\n    if (!handleCloseRef.current) return;\n    if (!open) return;\n    function onLeave(event) {\n      if (isHoverOpen()) {\n        onOpenChange(false, event, 'hover');\n      }\n    }\n    const html = getDocument(elements.floating).documentElement;\n    html.addEventListener('mouseleave', onLeave);\n    return () => {\n      html.removeEventListener('mouseleave', onLeave);\n    };\n  }, [elements.floating, open, onOpenChange, enabled, handleCloseRef, isHoverOpen]);\n  const closeWithDelay = React.useCallback(function (event, runElseBranch, reason) {\n    if (runElseBranch === void 0) {\n      runElseBranch = true;\n    }\n    if (reason === void 0) {\n      reason = 'hover';\n    }\n    const closeDelay = getDelay(delayRef.current, 'close', pointerTypeRef.current);\n    if (closeDelay && !handlerRef.current) {\n      clearTimeout(timeoutRef.current);\n      timeoutRef.current = window.setTimeout(() => onOpenChange(false, event, reason), closeDelay);\n    } else if (runElseBranch) {\n      clearTimeout(timeoutRef.current);\n      onOpenChange(false, event, reason);\n    }\n  }, [delayRef, onOpenChange]);\n  const cleanupMouseMoveHandler = useEffectEvent(() => {\n    unbindMouseMoveRef.current();\n    handlerRef.current = undefined;\n  });\n  const clearPointerEvents = useEffectEvent(() => {\n    if (performedPointerEventsMutationRef.current) {\n      const body = getDocument(elements.floating).body;\n      body.style.pointerEvents = '';\n      body.removeAttribute(safePolygonIdentifier);\n      performedPointerEventsMutationRef.current = false;\n    }\n  });\n  const isClickLikeOpenEvent = useEffectEvent(() => {\n    return dataRef.current.openEvent ? ['click', 'mousedown'].includes(dataRef.current.openEvent.type) : false;\n  });\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) return;\n    function onMouseEnter(event) {\n      clearTimeout(timeoutRef.current);\n      blockMouseMoveRef.current = false;\n      if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current) || restMs > 0 && !getDelay(delayRef.current, 'open')) {\n        return;\n      }\n      const openDelay = getDelay(delayRef.current, 'open', pointerTypeRef.current);\n      if (openDelay) {\n        timeoutRef.current = window.setTimeout(() => {\n          if (!openRef.current) {\n            onOpenChange(true, event, 'hover');\n          }\n        }, openDelay);\n      } else if (!open) {\n        onOpenChange(true, event, 'hover');\n      }\n    }\n    function onMouseLeave(event) {\n      if (isClickLikeOpenEvent()) return;\n      unbindMouseMoveRef.current();\n      const doc = getDocument(elements.floating);\n      clearTimeout(restTimeoutRef.current);\n      restTimeoutPendingRef.current = false;\n      if (handleCloseRef.current && dataRef.current.floatingContext) {\n        // Prevent clearing `onScrollMouseLeave` timeout.\n        if (!open) {\n          clearTimeout(timeoutRef.current);\n        }\n        handlerRef.current = handleCloseRef.current({\n          ...dataRef.current.floatingContext,\n          tree,\n          x: event.clientX,\n          y: event.clientY,\n          onClose() {\n            clearPointerEvents();\n            cleanupMouseMoveHandler();\n            if (!isClickLikeOpenEvent()) {\n              closeWithDelay(event, true, 'safe-polygon');\n            }\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\n      // Allow interactivity without `safePolygon` on touch devices. With a\n      // pointer, a short close delay is an alternative, so it should work\n      // consistently.\n      const shouldClose = pointerTypeRef.current === 'touch' ? !contains(elements.floating, event.relatedTarget) : true;\n      if (shouldClose) {\n        closeWithDelay(event);\n      }\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()) return;\n      if (!dataRef.current.floatingContext) return;\n      handleCloseRef.current == null || handleCloseRef.current({\n        ...dataRef.current.floatingContext,\n        tree,\n        x: event.clientX,\n        y: event.clientY,\n        onClose() {\n          clearPointerEvents();\n          cleanupMouseMoveHandler();\n          if (!isClickLikeOpenEvent()) {\n            closeWithDelay(event);\n          }\n        }\n      })(event);\n    }\n    if (isElement(elements.domReference)) {\n      var _elements$floating;\n      const ref = elements.domReference;\n      open && ref.addEventListener('mouseleave', onScrollMouseLeave);\n      (_elements$floating = elements.floating) == null || _elements$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        var _elements$floating2;\n        open && ref.removeEventListener('mouseleave', onScrollMouseLeave);\n        (_elements$floating2 = elements.floating) == null || _elements$floating2.removeEventListener('mouseleave', onScrollMouseLeave);\n        move && ref.removeEventListener('mousemove', onMouseEnter);\n        ref.removeEventListener('mouseenter', onMouseEnter);\n        ref.removeEventListener('mouseleave', onMouseLeave);\n      };\n    }\n  }, [elements, enabled, context, mouseOnly, restMs, move, closeWithDelay, cleanupMouseMoveHandler, clearPointerEvents, onOpenChange, open, openRef, tree, delayRef, handleCloseRef, dataRef, isClickLikeOpenEvent]);\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) return;\n    if (open && (_handleCloseRef$curre = handleCloseRef.current) != null && _handleCloseRef$curre.__options.blockPointerEvents && isHoverOpen()) {\n      performedPointerEventsMutationRef.current = true;\n      const floatingEl = elements.floating;\n      if (isElement(elements.domReference) && floatingEl) {\n        var _tree$nodesRef$curren;\n        const body = getDocument(elements.floating).body;\n        body.setAttribute(safePolygonIdentifier, '');\n        const ref = elements.domReference;\n        const parentFloating = tree == null || (_tree$nodesRef$curren = tree.nodesRef.current.find(node => node.id === parentId)) == null || (_tree$nodesRef$curren = _tree$nodesRef$curren.context) == null ? void 0 : _tree$nodesRef$curren.elements.floating;\n        if (parentFloating) {\n          parentFloating.style.pointerEvents = '';\n        }\n        body.style.pointerEvents = 'none';\n        ref.style.pointerEvents = 'auto';\n        floatingEl.style.pointerEvents = 'auto';\n        return () => {\n          body.style.pointerEvents = '';\n          ref.style.pointerEvents = '';\n          floatingEl.style.pointerEvents = '';\n        };\n      }\n    }\n  }, [enabled, open, parentId, elements, tree, handleCloseRef, isHoverOpen]);\n  index(() => {\n    if (!open) {\n      pointerTypeRef.current = undefined;\n      restTimeoutPendingRef.current = false;\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, elements.domReference, cleanupMouseMoveHandler, clearPointerEvents]);\n  const reference = React.useMemo(() => {\n    function setPointerRef(event) {\n      pointerTypeRef.current = event.pointerType;\n    }\n    return {\n      onPointerDown: setPointerRef,\n      onPointerEnter: setPointerRef,\n      onMouseMove(event) {\n        const {\n          nativeEvent\n        } = event;\n        function handleMouseMove() {\n          if (!blockMouseMoveRef.current && !openRef.current) {\n            onOpenChange(true, nativeEvent, 'hover');\n          }\n        }\n        if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current)) {\n          return;\n        }\n        if (open || restMs === 0) {\n          return;\n        }\n\n        // Ignore insignificant movements to account for tremors.\n        if (restTimeoutPendingRef.current && event.movementX ** 2 + event.movementY ** 2 < 2) {\n          return;\n        }\n        clearTimeout(restTimeoutRef.current);\n        if (pointerTypeRef.current === 'touch') {\n          handleMouseMove();\n        } else {\n          restTimeoutPendingRef.current = true;\n          restTimeoutRef.current = window.setTimeout(handleMouseMove, restMs);\n        }\n      }\n    };\n  }, [mouseOnly, onOpenChange, open, openRef, restMs]);\n  const floating = React.useMemo(() => ({\n    onMouseEnter() {\n      clearTimeout(timeoutRef.current);\n    },\n    onMouseLeave(event) {\n      if (!isClickLikeOpenEvent()) {\n        closeWithDelay(event.nativeEvent, false);\n      }\n    }\n  }), [closeWithDelay, isClickLikeOpenEvent]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating\n  } : {}, [enabled, reference, floating]);\n}\n\nconst NOOP = () => {};\nconst FloatingDelayGroupContext = /*#__PURE__*/React.createContext({\n  delay: 0,\n  initialDelay: 0,\n  timeoutMs: 0,\n  currentId: null,\n  setCurrentId: NOOP,\n  setState: NOOP,\n  isInstantPhase: false\n});\n\n/**\n * @deprecated\n * Use the return value of `useDelayGroup()` instead.\n */\nconst useDelayGroupContext = () => React.useContext(FloatingDelayGroupContext);\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 */\nfunction FloatingDelayGroup(props) {\n  const {\n    children,\n    delay,\n    timeoutMs = 0\n  } = props;\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 if (!state.isInstantPhase) {\n        setState({\n          isInstantPhase: true\n        });\n      }\n    } else {\n      if (state.isInstantPhase) {\n        setState({\n          isInstantPhase: false\n        });\n      }\n      initialCurrentIdRef.current = null;\n    }\n  }, [state.currentId, state.isInstantPhase]);\n  return /*#__PURE__*/jsx(FloatingDelayGroupContext.Provider, {\n    value: React.useMemo(() => ({\n      ...state,\n      setState,\n      setCurrentId\n    }), [state, setCurrentId]),\n    children: children\n  });\n}\n/**\n * Enables grouping when called inside a component that's a child of a\n * `FloatingDelayGroup`.\n * @see https://floating-ui.com/docs/FloatingDelayGroup\n */\nfunction useDelayGroup(context, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    floatingId\n  } = context;\n  const {\n    id: optionId,\n    enabled = true\n  } = options;\n  const id = optionId != null ? optionId : floatingId;\n  const groupContext = useDelayGroupContext();\n  const {\n    currentId,\n    setCurrentId,\n    initialDelay,\n    setState,\n    timeoutMs\n  } = groupContext;\n  index(() => {\n    if (!enabled) return;\n    if (!currentId) return;\n    setState({\n      delay: {\n        open: 1,\n        close: getDelay(initialDelay, 'close')\n      }\n    });\n    if (currentId !== id) {\n      onOpenChange(false);\n    }\n  }, [enabled, id, onOpenChange, setState, currentId, initialDelay]);\n  index(() => {\n    function unset() {\n      onOpenChange(false);\n      setState({\n        delay: initialDelay,\n        currentId: null\n      });\n    }\n    if (!enabled) return;\n    if (!currentId) return;\n    if (!open && currentId === id) {\n      if (timeoutMs) {\n        const timeout = window.setTimeout(unset, timeoutMs);\n        return () => {\n          clearTimeout(timeout);\n        };\n      }\n      unset();\n    }\n  }, [enabled, open, setState, currentId, id, onOpenChange, initialDelay, timeoutMs]);\n  index(() => {\n    if (!enabled) return;\n    if (setCurrentId === NOOP || !open) return;\n    setCurrentId(id);\n  }, [enabled, open, setCurrentId, id]);\n  return groupContext;\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}\nfunction getDeepestNode(nodes, id) {\n  let deepestNodeId;\n  let maxDepth = -1;\n  function findDeepest(nodeId, depth) {\n    if (depth > maxDepth) {\n      deepestNodeId = nodeId;\n      maxDepth = depth;\n    }\n    const children = getChildren(nodes, nodeId);\n    children.forEach(child => {\n      findDeepest(child.id, depth + 1);\n    });\n  }\n  findDeepest(id, 0);\n  return nodes.find(node => node.id === deepestNodeId);\n}\n\n// Modified to add conditional `aria-hidden` support:\n// https://github.com/theKashey/aria-hidden/blob/9220c8f4a4fd35f63bee5510a9f41a37264382d4/src/index.ts\nlet counterMap = /*#__PURE__*/new WeakMap();\nlet uncontrolledElementsSet = /*#__PURE__*/new WeakSet();\nlet markerMap = {};\nlet lockCount$1 = 0;\nconst supportsInert = () => typeof HTMLElement !== 'undefined' && 'inert' in HTMLElement.prototype;\nconst unwrapHost = node => node && (node.host || unwrapHost(node.parentNode));\nconst correctElements = (parent, targets) => targets.map(target => {\n  if (parent.contains(target)) {\n    return target;\n  }\n  const correctedTarget = unwrapHost(target);\n  if (parent.contains(correctedTarget)) {\n    return correctedTarget;\n  }\n  return null;\n}).filter(x => x != null);\nfunction applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, inert) {\n  const markerName = 'data-floating-ui-inert';\n  const controlAttribute = inert ? 'inert' : ariaHidden ? 'aria-hidden' : null;\n  const avoidElements = correctElements(body, uncorrectedAvoidElements);\n  const elementsToKeep = new Set();\n  const elementsToStop = new Set(avoidElements);\n  const hiddenElements = [];\n  if (!markerMap[markerName]) {\n    markerMap[markerName] = new WeakMap();\n  }\n  const markerCounter = markerMap[markerName];\n  avoidElements.forEach(keep);\n  deep(body);\n  elementsToKeep.clear();\n  function keep(el) {\n    if (!el || elementsToKeep.has(el)) {\n      return;\n    }\n    elementsToKeep.add(el);\n    el.parentNode && keep(el.parentNode);\n  }\n  function deep(parent) {\n    if (!parent || elementsToStop.has(parent)) {\n      return;\n    }\n    [].forEach.call(parent.children, node => {\n      if (getNodeName(node) === 'script') return;\n      if (elementsToKeep.has(node)) {\n        deep(node);\n      } else {\n        const attr = controlAttribute ? node.getAttribute(controlAttribute) : null;\n        const alreadyHidden = attr !== null && attr !== 'false';\n        const currentCounterValue = counterMap.get(node) || 0;\n        const counterValue = controlAttribute ? currentCounterValue + 1 : currentCounterValue;\n        const markerValue = (markerCounter.get(node) || 0) + 1;\n        counterMap.set(node, counterValue);\n        markerCounter.set(node, markerValue);\n        hiddenElements.push(node);\n        if (counterValue === 1 && alreadyHidden) {\n          uncontrolledElementsSet.add(node);\n        }\n        if (markerValue === 1) {\n          node.setAttribute(markerName, '');\n        }\n        if (!alreadyHidden && controlAttribute) {\n          node.setAttribute(controlAttribute, 'true');\n        }\n      }\n    });\n  }\n  lockCount$1++;\n  return () => {\n    hiddenElements.forEach(element => {\n      const currentCounterValue = counterMap.get(element) || 0;\n      const counterValue = controlAttribute ? currentCounterValue - 1 : currentCounterValue;\n      const markerValue = (markerCounter.get(element) || 0) - 1;\n      counterMap.set(element, counterValue);\n      markerCounter.set(element, markerValue);\n      if (!counterValue) {\n        if (!uncontrolledElementsSet.has(element) && controlAttribute) {\n          element.removeAttribute(controlAttribute);\n        }\n        uncontrolledElementsSet.delete(element);\n      }\n      if (!markerValue) {\n        element.removeAttribute(markerName);\n      }\n    });\n    lockCount$1--;\n    if (!lockCount$1) {\n      counterMap = new WeakMap();\n      counterMap = new WeakMap();\n      uncontrolledElementsSet = new WeakSet();\n      markerMap = {};\n    }\n  };\n}\nfunction markOthers(avoidElements, ariaHidden, inert) {\n  if (ariaHidden === void 0) {\n    ariaHidden = false;\n  }\n  if (inert === void 0) {\n    inert = false;\n  }\n  const body = getDocument(avoidElements[0]).body;\n  return applyAttributeToOthers(avoidElements.concat(Array.from(body.querySelectorAll('[aria-live]'))), body, ariaHidden, inert);\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(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\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 timeoutId;\nfunction setActiveElementOnTab(event) {\n  if (event.key === 'Tab') {\n    event.target;\n    clearTimeout(timeoutId);\n  }\n}\nconst FocusGuard = /*#__PURE__*/React.forwardRef(function FocusGuard(props, ref) {\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  const restProps = {\n    ref,\n    tabIndex: 0,\n    // Role is only for VoiceOver\n    role,\n    'aria-hidden': role ? undefined : true,\n    [createAttribute('focus-guard')]: '',\n    style: HIDDEN_STYLES\n  };\n  return /*#__PURE__*/jsx(\"span\", {\n    ...props,\n    ...restProps\n  });\n});\n\nconst PortalContext = /*#__PURE__*/React.createContext(null);\nconst attr = /*#__PURE__*/createAttribute('portal');\n/**\n * @see https://floating-ui.com/docs/FloatingPortal#usefloatingportalnode\n */\nfunction useFloatingPortalNode(props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    id,\n    root\n  } = props;\n  const uniqueId = useId();\n  const portalContext = usePortalContext();\n  const [portalNode, setPortalNode] = React.useState(null);\n  const portalNodeRef = React.useRef(null);\n  index(() => {\n    return () => {\n      portalNode == null || portalNode.remove();\n      // Allow the subsequent layout effects to create a new node on updates.\n      // The portal node will still be cleaned up on unmount.\n      // https://github.com/floating-ui/floating-ui/issues/2454\n      queueMicrotask(() => {\n        portalNodeRef.current = null;\n      });\n    };\n  }, [portalNode]);\n  index(() => {\n    // Wait for the uniqueId to be generated before creating the portal node in\n    // React <18 (using `useFloatingId` instead of the native `useId`).\n    // https://github.com/floating-ui/floating-ui/issues/2778\n    if (!uniqueId) return;\n    if (portalNodeRef.current) return;\n    const existingIdRoot = id ? document.getElementById(id) : null;\n    if (!existingIdRoot) return;\n    const subRoot = document.createElement('div');\n    subRoot.id = uniqueId;\n    subRoot.setAttribute(attr, '');\n    existingIdRoot.appendChild(subRoot);\n    portalNodeRef.current = subRoot;\n    setPortalNode(subRoot);\n  }, [id, uniqueId]);\n  index(() => {\n    // Wait for the root to exist before creating the portal node. The root must\n    // be stored in state, not a ref, for this to work reactively.\n    if (root === null) return;\n    if (!uniqueId) return;\n    if (portalNodeRef.current) return;\n    let container = root || (portalContext == null ? void 0 : portalContext.portalNode);\n    if (container && !isElement(container)) container = container.current;\n    container = container || document.body;\n    let idWrapper = null;\n    if (id) {\n      idWrapper = document.createElement('div');\n      idWrapper.id = id;\n      container.appendChild(idWrapper);\n    }\n    const subRoot = document.createElement('div');\n    subRoot.id = uniqueId;\n    subRoot.setAttribute(attr, '');\n    container = idWrapper || container;\n    container.appendChild(subRoot);\n    portalNodeRef.current = subRoot;\n    setPortalNode(subRoot);\n  }, [id, root, uniqueId, portalContext]);\n  return portalNode;\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 * This is necessary to ensure the floating element can appear outside any\n * potential parent containers that cause clipping (such as `overflow: hidden`),\n * while retaining its location in the React tree.\n * @see https://floating-ui.com/docs/FloatingPortal\n */\nfunction FloatingPortal(props) {\n  const {\n    children,\n    id,\n    root,\n    preserveTabOrder = true\n  } = props;\n  const portalNode = useFloatingPortalNode({\n    id,\n    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 modal = focusManagerState == null ? void 0 : focusManagerState.modal;\n  const open = focusManagerState == null ? void 0 : focusManagerState.open;\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 &&\n  // Don't render if unmount is transitioning.\n  focusManagerState.open && preserveTabOrder && !!(root || portalNode);\n\n  // https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/TabbablePortal.tsx\n  React.useEffect(() => {\n    if (!portalNode || !preserveTabOrder || 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, modal]);\n  React.useEffect(() => {\n    if (!portalNode) return;\n    if (open) return;\n    enableFocusInside(portalNode);\n  }, [open, portalNode]);\n  return /*#__PURE__*/jsxs(PortalContext.Provider, {\n    value: React.useMemo(() => ({\n      preserveTabOrder,\n      beforeOutsideRef,\n      afterOutsideRef,\n      beforeInsideRef,\n      afterInsideRef,\n      portalNode,\n      setFocusManagerState\n    }), [preserveTabOrder, portalNode]),\n    children: [shouldRenderGuards && portalNode && /*#__PURE__*/jsx(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 || _beforeInsideRef$curr.focus();\n        } else {\n          const prevTabbable = getPreviousTabbable() || (focusManagerState == null ? void 0 : focusManagerState.domReference);\n          prevTabbable == null || prevTabbable.focus();\n        }\n      }\n    }), shouldRenderGuards && portalNode && /*#__PURE__*/jsx(\"span\", {\n      \"aria-owns\": portalNode.id,\n      style: HIDDEN_STYLES\n    }), portalNode && /*#__PURE__*/ReactDOM.createPortal(children, portalNode), shouldRenderGuards && portalNode && /*#__PURE__*/jsx(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 || _afterInsideRef$curre.focus();\n        } else {\n          const nextTabbable = getNextTabbable() || (focusManagerState == null ? void 0 : focusManagerState.domReference);\n          nextTabbable == null || nextTabbable.focus();\n          (focusManagerState == null ? void 0 : focusManagerState.closeOnFocusOut) && (focusManagerState == null ? void 0 : focusManagerState.onOpenChange(false, event.nativeEvent, 'focus-out'));\n        }\n      }\n    })]\n  });\n}\nconst usePortalContext = () => React.useContext(PortalContext);\n\nconst FOCUSABLE_ATTRIBUTE = 'data-floating-ui-focusable';\nfunction getFloatingFocusElement(floatingElement) {\n  if (!floatingElement) {\n    return null;\n  }\n  // Try to find the element that has `{...getFloatingProps()}` spread on it.\n  // This indicates the floating element is acting as a positioning wrapper, and\n  // so focus should be managed on the child element with the event handlers and\n  // aria props.\n  return floatingElement.hasAttribute(FOCUSABLE_ATTRIBUTE) ? floatingElement : floatingElement.querySelector(\"[\" + FOCUSABLE_ATTRIBUTE + \"]\") || floatingElement;\n}\n\nconst LIST_LIMIT = 20;\nlet previouslyFocusedElements = [];\nfunction addPreviouslyFocusedElement(element) {\n  previouslyFocusedElements = previouslyFocusedElements.filter(el => el.isConnected);\n  if (element && getNodeName(element) !== 'body') {\n    previouslyFocusedElements.push(element);\n    if (previouslyFocusedElements.length > LIST_LIMIT) {\n      previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);\n    }\n  }\n}\nfunction getPreviouslyFocusedElement() {\n  return previouslyFocusedElements.slice().reverse().find(el => el.isConnected);\n}\nfunction getFirstTabbableElement(container) {\n  const tabbableOptions = getTabbableOptions();\n  if (isTabbable(container, tabbableOptions)) {\n    return container;\n  }\n  return tabbable(container, tabbableOptions)[0] || container;\n}\nconst VisuallyHiddenDismiss = /*#__PURE__*/React.forwardRef(function VisuallyHiddenDismiss(props, ref) {\n  return /*#__PURE__*/jsx(\"button\", {\n    ...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(props) {\n  const {\n    context,\n    children,\n    disabled = false,\n    order = ['content'],\n    guards: _guards = true,\n    initialFocus = 0,\n    returnFocus = true,\n    restoreFocus = false,\n    modal = true,\n    visuallyHiddenDismiss = false,\n    closeOnFocusOut = true,\n    outsideElementsInert = false\n  } = props;\n  const {\n    open,\n    onOpenChange,\n    events,\n    dataRef,\n    elements: {\n      domReference,\n      floating\n    }\n  } = context;\n  const getNodeId = useEffectEvent(() => {\n    var _dataRef$current$floa;\n    return (_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.nodeId;\n  });\n  const ignoreInitialFocus = typeof initialFocus === 'number' && initialFocus < 0;\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 isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;\n\n  // Force the guards to be rendered if the `inert` attribute is not supported.\n  const inertSupported = supportsInert();\n  const guards = inertSupported ? _guards : true;\n  const useInert = !guards || inertSupported && outsideElementsInert;\n  const orderRef = useLatestRef(order);\n  const initialFocusRef = useLatestRef(initialFocus);\n  const returnFocusRef = useLatestRef(returnFocus);\n  const tree = useFloatingTree();\n  const portalContext = usePortalContext();\n  const startDismissButtonRef = React.useRef(null);\n  const endDismissButtonRef = React.useRef(null);\n  const preventReturnFocusRef = React.useRef(false);\n  const isPointerDownRef = React.useRef(false);\n  const tabbableIndexRef = React.useRef(-1);\n  const isInsidePortal = portalContext != null;\n  const floatingFocusElement = getFloatingFocusElement(floating);\n  const getTabbableContent = useEffectEvent(function (container) {\n    if (container === void 0) {\n      container = floatingFocusElement;\n    }\n    return container ? tabbable(container, getTabbableOptions()) : [];\n  });\n  const getTabbableElements = useEffectEvent(container => {\n    const content = getTabbableContent(container);\n    return orderRef.current.map(type => {\n      if (domReference && type === 'reference') {\n        return domReference;\n      }\n      if (floatingFocusElement && type === 'floating') {\n        return floatingFocusElement;\n      }\n      return content;\n    }).filter(Boolean).flat();\n  });\n  React.useEffect(() => {\n    if (disabled) return;\n    if (!modal) return;\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 (contains(floatingFocusElement, activeElement(getDocument(floatingFocusElement))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) {\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 === floatingFocusElement && event.shiftKey) {\n          stopEvent(event);\n          enqueueFocus(els[0]);\n        }\n      }\n    }\n    const doc = getDocument(floatingFocusElement);\n    doc.addEventListener('keydown', onKeyDown);\n    return () => {\n      doc.removeEventListener('keydown', onKeyDown);\n    };\n  }, [disabled, domReference, floatingFocusElement, modal, orderRef, isUntrappedTypeableCombobox, getTabbableContent, getTabbableElements]);\n  React.useEffect(() => {\n    if (disabled) return;\n    if (!floating) return;\n    function handleFocusIn(event) {\n      const target = getTarget(event);\n      const tabbableContent = getTabbableContent();\n      const tabbableIndex = tabbableContent.indexOf(target);\n      if (tabbableIndex !== -1) {\n        tabbableIndexRef.current = tabbableIndex;\n      }\n    }\n    floating.addEventListener('focusin', handleFocusIn);\n    return () => {\n      floating.removeEventListener('focusin', handleFocusIn);\n    };\n  }, [disabled, floating, getTabbableContent]);\n  React.useEffect(() => {\n    if (disabled) return;\n    if (!closeOnFocusOut) return;\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      queueMicrotask(() => {\n        const nodeId = getNodeId();\n        const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext == null ? void 0 : portalContext.portalNode, relatedTarget) || relatedTarget != null && relatedTarget.hasAttribute(createAttribute('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, _node$context5;\n          return [(_node$context3 = node.context) == null ? void 0 : _node$context3.elements.floating, getFloatingFocusElement((_node$context4 = node.context) == null ? void 0 : _node$context4.elements.floating)].includes(relatedTarget) || ((_node$context5 = node.context) == null ? void 0 : _node$context5.elements.domReference) === relatedTarget;\n        })));\n\n        // Restore focus to the previous tabbable element index to prevent\n        // focus from being lost outside the floating tree.\n        if (restoreFocus && movedToUnrelatedNode && activeElement(getDocument(floatingFocusElement)) === getDocument(floatingFocusElement).body) {\n          // Let `FloatingPortal` effect knows that focus is still inside the\n          // floating tree.\n          if (isHTMLElement(floatingFocusElement)) {\n            floatingFocusElement.focus();\n          }\n          const prevTabbableIndex = tabbableIndexRef.current;\n          const tabbableContent = getTabbableContent();\n          const nodeToFocus = tabbableContent[prevTabbableIndex] || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;\n          if (isHTMLElement(nodeToFocus)) {\n            nodeToFocus.focus();\n          }\n        }\n\n        // Focus did not move inside the floating tree, and there are no tabbable\n        // portal guards to handle closing.\n        if ((isUntrappedTypeableCombobox ? true : !modal) && relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current &&\n        // Fix React 18 Strict Mode returnFocus due to double rendering.\n        relatedTarget !== getPreviouslyFocusedElement()) {\n          preventReturnFocusRef.current = true;\n          onOpenChange(false, event, 'focus-out');\n        }\n      });\n    }\n    if (floating && isHTMLElement(domReference)) {\n      domReference.addEventListener('focusout', handleFocusOutside);\n      domReference.addEventListener('pointerdown', handlePointerDown);\n      floating.addEventListener('focusout', handleFocusOutside);\n      return () => {\n        domReference.removeEventListener('focusout', handleFocusOutside);\n        domReference.removeEventListener('pointerdown', handlePointerDown);\n        floating.removeEventListener('focusout', handleFocusOutside);\n      };\n    }\n  }, [disabled, domReference, floating, floatingFocusElement, modal, tree, portalContext, onOpenChange, closeOnFocusOut, restoreFocus, getTabbableContent, isUntrappedTypeableCombobox, getNodeId]);\n  const beforeGuardRef = React.useRef(null);\n  const afterGuardRef = React.useRef(null);\n  const mergedBeforeGuardRef = useMergeRefs([beforeGuardRef, portalContext == null ? void 0 : portalContext.beforeInsideRef]);\n  const mergedAfterGuardRef = useMergeRefs([afterGuardRef, portalContext == null ? void 0 : portalContext.afterInsideRef]);\n  React.useEffect(() => {\n    var _portalContext$portal;\n    if (disabled) return;\n    if (!floating) return;\n\n    // Don't hide portals nested within the parent portal.\n    const portalNodes = Array.from((portalContext == null || (_portalContext$portal = portalContext.portalNode) == null ? void 0 : _portalContext$portal.querySelectorAll(\"[\" + createAttribute('portal') + \"]\")) || []);\n    const ancestorFloatingNodes = tree && !modal ? getAncestors(tree == null ? void 0 : tree.nodesRef.current, getNodeId()).map(node => {\n      var _node$context6;\n      return (_node$context6 = node.context) == null ? void 0 : _node$context6.elements.floating;\n    }) : [];\n    const insideElements = [floating, ...portalNodes, ...ancestorFloatingNodes, startDismissButtonRef.current, endDismissButtonRef.current, beforeGuardRef.current, afterGuardRef.current, portalContext == null ? void 0 : portalContext.beforeOutsideRef.current, portalContext == null ? void 0 : portalContext.afterOutsideRef.current, orderRef.current.includes('reference') || isUntrappedTypeableCombobox ? domReference : null].filter(x => x != null);\n    const cleanup = modal || isUntrappedTypeableCombobox ? markOthers(insideElements, !useInert, useInert) : markOthers(insideElements);\n    return () => {\n      cleanup();\n    };\n  }, [disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, guards, useInert, tree, getNodeId]);\n  index(() => {\n    if (disabled || !isHTMLElement(floatingFocusElement)) return;\n    const doc = getDocument(floatingFocusElement);\n    const previouslyFocusedElement = activeElement(doc);\n\n    // Wait for any layout effect state setters to execute to set `tabIndex`.\n    queueMicrotask(() => {\n      const focusableElements = getTabbableElements(floatingFocusElement);\n      const initialFocusValue = initialFocusRef.current;\n      const elToFocus = (typeof initialFocusValue === 'number' ? focusableElements[initialFocusValue] : initialFocusValue.current) || floatingFocusElement;\n      const focusAlreadyInsideFloatingEl = contains(floatingFocusElement, previouslyFocusedElement);\n      if (!ignoreInitialFocus && !focusAlreadyInsideFloatingEl && open) {\n        enqueueFocus(elToFocus, {\n          preventScroll: elToFocus === floatingFocusElement\n        });\n      }\n    });\n  }, [disabled, open, floatingFocusElement, ignoreInitialFocus, getTabbableElements, initialFocusRef]);\n  index(() => {\n    if (disabled || !floatingFocusElement) return;\n    let preventReturnFocusScroll = false;\n    const doc = getDocument(floatingFocusElement);\n    const previouslyFocusedElement = activeElement(doc);\n    const contextData = dataRef.current;\n    let openEvent = contextData.openEvent;\n    addPreviouslyFocusedElement(previouslyFocusedElement);\n\n    // Dismissing via outside press should always ignore `returnFocus` to\n    // prevent unwanted scrolling.\n    function onOpenChange(_ref) {\n      let {\n        open,\n        reason,\n        event,\n        nested\n      } = _ref;\n      if (open) {\n        openEvent = event;\n      }\n      if (reason === 'escape-key' && domReference) {\n        addPreviouslyFocusedElement(domReference);\n      }\n      if (['hover', 'safe-polygon'].includes(reason) && event.type === 'mouseleave') {\n        preventReturnFocusRef.current = true;\n      }\n      if (reason !== 'outside-press') return;\n      if (nested) {\n        preventReturnFocusRef.current = false;\n        preventReturnFocusScroll = true;\n      } else {\n        preventReturnFocusRef.current = !(isVirtualClick(event) || isVirtualPointerEvent(event));\n      }\n    }\n    events.on('openchange', onOpenChange);\n    const fallbackEl = doc.createElement('span');\n    fallbackEl.setAttribute('tabindex', '-1');\n    fallbackEl.setAttribute('aria-hidden', 'true');\n    Object.assign(fallbackEl.style, HIDDEN_STYLES);\n    if (isInsidePortal && domReference) {\n      domReference.insertAdjacentElement('afterend', fallbackEl);\n    }\n    function getReturnElement() {\n      if (typeof returnFocusRef.current === 'boolean') {\n        return getPreviouslyFocusedElement() || fallbackEl;\n      }\n      return returnFocusRef.current.current || fallbackEl;\n    }\n    return () => {\n      events.off('openchange', onOpenChange);\n      const activeEl = activeElement(doc);\n      const isFocusInsideFloatingTree = contains(floating, activeEl) || tree && getChildren(tree.nodesRef.current, getNodeId()).some(node => {\n        var _node$context7;\n        return contains((_node$context7 = node.context) == null ? void 0 : _node$context7.elements.floating, activeEl);\n      });\n      const shouldFocusReference = isFocusInsideFloatingTree || openEvent && ['click', 'mousedown'].includes(openEvent.type);\n      if (shouldFocusReference && domReference) {\n        addPreviouslyFocusedElement(domReference);\n      }\n      const returnElement = getReturnElement();\n      queueMicrotask(() => {\n        // This is `returnElement`, if it's tabbable, or its first tabbable child.\n        const tabbableReturnElement = getFirstTabbableElement(returnElement);\n        if (\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n        returnFocusRef.current && !preventReturnFocusRef.current && isHTMLElement(tabbableReturnElement) && (\n        // If the focus moved somewhere else after mount, avoid returning focus\n        // since it likely entered a different element which should be\n        // respected: https://github.com/floating-ui/floating-ui/issues/2607\n        tabbableReturnElement !== activeEl && activeEl !== doc.body ? isFocusInsideFloatingTree : true)) {\n          tabbableReturnElement.focus({\n            preventScroll: preventReturnFocusScroll\n          });\n        }\n        fallbackEl.remove();\n      });\n    };\n  }, [disabled, floating, floatingFocusElement, returnFocusRef, dataRef, events, tree, isInsidePortal, domReference, getNodeId]);\n  React.useEffect(() => {\n    // The `returnFocus` cleanup behavior is inside a microtask; ensure we\n    // wait for it to complete before resetting the flag.\n    queueMicrotask(() => {\n      preventReturnFocusRef.current = false;\n    });\n  }, [disabled]);\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 (disabled) return;\n    if (!portalContext) return;\n    portalContext.setFocusManagerState({\n      modal,\n      closeOnFocusOut,\n      open,\n      onOpenChange,\n      domReference\n    });\n    return () => {\n      portalContext.setFocusManagerState(null);\n    };\n  }, [disabled, portalContext, modal, open, onOpenChange, closeOnFocusOut, domReference]);\n  index(() => {\n    if (disabled) return;\n    if (!floatingFocusElement) return;\n    if (typeof MutationObserver !== 'function') return;\n    if (ignoreInitialFocus) return;\n    const handleMutation = () => {\n      const tabIndex = floatingFocusElement.getAttribute('tabindex');\n      const tabbableContent = getTabbableContent();\n      const activeEl = activeElement(getDocument(floating));\n      const tabbableIndex = tabbableContent.indexOf(activeEl);\n      if (tabbableIndex !== -1) {\n        tabbableIndexRef.current = tabbableIndex;\n      }\n      if (orderRef.current.includes('floating') || activeEl !== domReference && tabbableContent.length === 0) {\n        if (tabIndex !== '0') {\n          floatingFocusElement.setAttribute('tabindex', '0');\n        }\n      } else if (tabIndex !== '-1') {\n        floatingFocusElement.setAttribute('tabindex', '-1');\n      }\n    };\n    handleMutation();\n    const observer = new MutationObserver(handleMutation);\n    observer.observe(floatingFocusElement, {\n      childList: true,\n      subtree: true,\n      attributes: true\n    });\n    return () => {\n      observer.disconnect();\n    };\n  }, [disabled, floating, floatingFocusElement, domReference, orderRef, getTabbableContent, ignoreInitialFocus]);\n  function renderDismissButton(location) {\n    if (disabled || !visuallyHiddenDismiss || !modal) {\n      return null;\n    }\n    return /*#__PURE__*/jsx(VisuallyHiddenDismiss, {\n      ref: location === 'start' ? startDismissButtonRef : endDismissButtonRef,\n      onClick: event => onOpenChange(false, event.nativeEvent),\n      children: typeof visuallyHiddenDismiss === 'string' ? visuallyHiddenDismiss : 'Dismiss'\n    });\n  }\n  const shouldRenderGuards = !disabled && guards && (modal ? !isUntrappedTypeableCombobox : true) && (isInsidePortal || modal);\n  return /*#__PURE__*/jsxs(Fragment, {\n    children: [shouldRenderGuards && /*#__PURE__*/jsx(FocusGuard, {\n      \"data-type\": \"inside\",\n      ref: mergedBeforeGuardRef,\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 || nextTabbable.focus();\n          } else {\n            var _portalContext$before;\n            (_portalContext$before = portalContext.beforeOutsideRef.current) == null || _portalContext$before.focus();\n          }\n        }\n      }\n    }), !isUntrappedTypeableCombobox && renderDismissButton('start'), children, renderDismissButton('end'), shouldRenderGuards && /*#__PURE__*/jsx(FocusGuard, {\n      \"data-type\": \"inside\",\n      ref: mergedAfterGuardRef,\n      onFocus: event => {\n        if (modal) {\n          enqueueFocus(getTabbableElements()[0]);\n        } else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {\n          if (closeOnFocusOut) {\n            preventReturnFocusRef.current = true;\n          }\n          if (isOutsideEvent(event, portalContext.portalNode)) {\n            const prevTabbable = getPreviousTabbable() || domReference;\n            prevTabbable == null || prevTabbable.focus();\n          } else {\n            var _portalContext$afterO;\n            (_portalContext$afterO = portalContext.afterOutsideRef.current) == null || _portalContext$afterO.focus();\n          }\n        }\n      }\n    })]\n  });\n}\n\nlet lockCount = 0;\nfunction enableScrollLock() {\n  const isIOS = /iP(hone|ad|od)|iOS/.test(getPlatform());\n  const bodyStyle = document.body.style;\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  const scrollX = bodyStyle.left ? parseFloat(bodyStyle.left) : window.scrollX;\n  const scrollY = bodyStyle.top ? parseFloat(bodyStyle.top) : window.scrollY;\n  bodyStyle.overflow = 'hidden';\n  if (scrollbarWidth) {\n    bodyStyle[paddingProp] = scrollbarWidth + \"px\";\n  }\n\n  // Only iOS doesn't respect `overflow: hidden` on document.body, and this\n  // technique has fewer side effects.\n  if (isIOS) {\n    var _window$visualViewpor, _window$visualViewpor2;\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    Object.assign(bodyStyle, {\n      position: 'fixed',\n      top: -(scrollY - Math.floor(offsetTop)) + \"px\",\n      left: -(scrollX - Math.floor(offsetLeft)) + \"px\",\n      right: '0'\n    });\n  }\n  return () => {\n    Object.assign(bodyStyle, {\n      overflow: '',\n      [paddingProp]: ''\n    });\n    if (isIOS) {\n      Object.assign(bodyStyle, {\n        position: '',\n        top: '',\n        left: '',\n        right: ''\n      });\n      window.scrollTo(scrollX, scrollY);\n    }\n  };\n}\nlet cleanup = () => {};\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(props, ref) {\n  const {\n    lockScroll = false,\n    ...rest\n  } = props;\n  index(() => {\n    if (!lockScroll) return;\n    lockCount++;\n    if (lockCount === 1) {\n      cleanup = enableScrollLock();\n    }\n    return () => {\n      lockCount--;\n      if (lockCount === 0) {\n        cleanup();\n      }\n    };\n  }, [lockScroll]);\n  return /*#__PURE__*/jsx(\"div\", {\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 */\nfunction useClick(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    dataRef,\n    elements: {\n      domReference\n    }\n  } = context;\n  const {\n    enabled = true,\n    event: eventOption = 'click',\n    toggle = true,\n    ignoreMouse = false,\n    keyboardHandlers = true,\n    stickIfOpen = true\n  } = props;\n  const pointerTypeRef = React.useRef();\n  const didKeyDownRef = React.useRef(false);\n  const reference = React.useMemo(() => ({\n    onPointerDown(event) {\n      pointerTypeRef.current = event.pointerType;\n    },\n    onMouseDown(event) {\n      const pointerType = pointerTypeRef.current;\n\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) return;\n      if (eventOption === 'click') return;\n      if (isMouseLikePointerType(pointerType, true) && ignoreMouse) return;\n      if (open && toggle && (dataRef.current.openEvent && stickIfOpen ? dataRef.current.openEvent.type === 'mousedown' : true)) {\n        onOpenChange(false, event.nativeEvent, 'click');\n      } else {\n        // Prevent stealing focus from the floating element\n        event.preventDefault();\n        onOpenChange(true, event.nativeEvent, 'click');\n      }\n    },\n    onClick(event) {\n      const pointerType = pointerTypeRef.current;\n      if (eventOption === 'mousedown' && pointerTypeRef.current) {\n        pointerTypeRef.current = undefined;\n        return;\n      }\n      if (isMouseLikePointerType(pointerType, true) && ignoreMouse) return;\n      if (open && toggle && (dataRef.current.openEvent && stickIfOpen ? dataRef.current.openEvent.type === 'click' : true)) {\n        onOpenChange(false, event.nativeEvent, 'click');\n      } else {\n        onOpenChange(true, event.nativeEvent, 'click');\n      }\n    },\n    onKeyDown(event) {\n      pointerTypeRef.current = undefined;\n      if (event.defaultPrevented || !keyboardHandlers || isButtonTarget(event)) {\n        return;\n      }\n      if (event.key === ' ' && !isSpaceIgnored(domReference)) {\n        // Prevent scrolling\n        event.preventDefault();\n        didKeyDownRef.current = true;\n      }\n      if (event.key === 'Enter') {\n        if (open && toggle) {\n          onOpenChange(false, event.nativeEvent, 'click');\n        } else {\n          onOpenChange(true, event.nativeEvent, 'click');\n        }\n      }\n    },\n    onKeyUp(event) {\n      if (event.defaultPrevented || !keyboardHandlers || isButtonTarget(event) || isSpaceIgnored(domReference)) {\n        return;\n      }\n      if (event.key === ' ' && didKeyDownRef.current) {\n        didKeyDownRef.current = false;\n        if (open && toggle) {\n          onOpenChange(false, event.nativeEvent, 'click');\n        } else {\n          onOpenChange(true, event.nativeEvent, 'click');\n        }\n      }\n    }\n  }), [dataRef, domReference, eventOption, ignoreMouse, keyboardHandlers, onOpenChange, open, stickIfOpen, toggle]);\n  return React.useMemo(() => enabled ? {\n    reference\n  } : {}, [enabled, reference]);\n}\n\nfunction createVirtualElement(domElement, data) {\n  let offsetX = null;\n  let offsetY = null;\n  let isAutoUpdateEvent = false;\n  return {\n    contextElement: domElement || undefined,\n    getBoundingClientRect() {\n      var _data$dataRef$current;\n      const domRect = (domElement == null ? void 0 : domElement.getBoundingClientRect()) || {\n        width: 0,\n        height: 0,\n        x: 0,\n        y: 0\n      };\n      const isXAxis = data.axis === 'x' || data.axis === 'both';\n      const isYAxis = data.axis === 'y' || data.axis === 'both';\n      const canTrackCursorOnAutoUpdate = ['mouseenter', 'mousemove'].includes(((_data$dataRef$current = data.dataRef.current.openEvent) == null ? void 0 : _data$dataRef$current.type) || '') && data.pointerType !== 'touch';\n      let width = domRect.width;\n      let height = domRect.height;\n      let x = domRect.x;\n      let y = domRect.y;\n      if (offsetX == null && data.x && isXAxis) {\n        offsetX = domRect.x - data.x;\n      }\n      if (offsetY == null && data.y && isYAxis) {\n        offsetY = domRect.y - data.y;\n      }\n      x -= offsetX || 0;\n      y -= offsetY || 0;\n      width = 0;\n      height = 0;\n      if (!isAutoUpdateEvent || canTrackCursorOnAutoUpdate) {\n        width = data.axis === 'y' ? domRect.width : 0;\n        height = data.axis === 'x' ? domRect.height : 0;\n        x = isXAxis && data.x != null ? data.x : x;\n        y = isYAxis && data.y != null ? data.y : y;\n      } else if (isAutoUpdateEvent && !canTrackCursorOnAutoUpdate) {\n        height = data.axis === 'x' ? domRect.height : height;\n        width = data.axis === 'y' ? domRect.width : width;\n      }\n      isAutoUpdateEvent = true;\n      return {\n        width,\n        height,\n        x,\n        y,\n        top: y,\n        right: x + width,\n        bottom: y + height,\n        left: x\n      };\n    }\n  };\n}\nfunction isMouseBasedEvent(event) {\n  return event != null && event.clientX != null;\n}\n/**\n * Positions the floating element relative to a client point (in the viewport),\n * such as the mouse position. By default, it follows the mouse cursor.\n * @see https://floating-ui.com/docs/useClientPoint\n */\nfunction useClientPoint(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    dataRef,\n    elements: {\n      floating,\n      domReference\n    },\n    refs\n  } = context;\n  const {\n    enabled = true,\n    axis = 'both',\n    x = null,\n    y = null\n  } = props;\n  const initialRef = React.useRef(false);\n  const cleanupListenerRef = React.useRef(null);\n  const [pointerType, setPointerType] = React.useState();\n  const [reactive, setReactive] = React.useState([]);\n  const setReference = useEffectEvent((x, y) => {\n    if (initialRef.current) return;\n\n    // Prevent setting if the open event was not a mouse-like one\n    // (e.g. focus to open, then hover over the reference element).\n    // Only apply if the event exists.\n    if (dataRef.current.openEvent && !isMouseBasedEvent(dataRef.current.openEvent)) {\n      return;\n    }\n    refs.setPositionReference(createVirtualElement(domReference, {\n      x,\n      y,\n      axis,\n      dataRef,\n      pointerType\n    }));\n  });\n  const handleReferenceEnterOrMove = useEffectEvent(event => {\n    if (x != null || y != null) return;\n    if (!open) {\n      setReference(event.clientX, event.clientY);\n    } else if (!cleanupListenerRef.current) {\n      // If there's no cleanup, there's no listener, but we want to ensure\n      // we add the listener if the cursor landed on the floating element and\n      // then back on the reference (i.e. it's interactive).\n      setReactive([]);\n    }\n  });\n\n  // If the pointer is a mouse-like pointer, we want to continue following the\n  // mouse even if the floating element is transitioning out. On touch\n  // devices, this is undesirable because the floating element will move to\n  // the dismissal touch point.\n  const openCheck = isMouseLikePointerType(pointerType) ? floating : open;\n  const addListener = React.useCallback(() => {\n    // Explicitly specified `x`/`y` coordinates shouldn't add a listener.\n    if (!openCheck || !enabled || x != null || y != null) return;\n    const win = getWindow(floating);\n    function handleMouseMove(event) {\n      const target = getTarget(event);\n      if (!contains(floating, target)) {\n        setReference(event.clientX, event.clientY);\n      } else {\n        win.removeEventListener('mousemove', handleMouseMove);\n        cleanupListenerRef.current = null;\n      }\n    }\n    if (!dataRef.current.openEvent || isMouseBasedEvent(dataRef.current.openEvent)) {\n      win.addEventListener('mousemove', handleMouseMove);\n      const cleanup = () => {\n        win.removeEventListener('mousemove', handleMouseMove);\n        cleanupListenerRef.current = null;\n      };\n      cleanupListenerRef.current = cleanup;\n      return cleanup;\n    }\n    refs.setPositionReference(domReference);\n  }, [openCheck, enabled, x, y, floating, dataRef, refs, domReference, setReference]);\n  React.useEffect(() => {\n    return addListener();\n  }, [addListener, reactive]);\n  React.useEffect(() => {\n    if (enabled && !floating) {\n      initialRef.current = false;\n    }\n  }, [enabled, floating]);\n  React.useEffect(() => {\n    if (!enabled && open) {\n      initialRef.current = true;\n    }\n  }, [enabled, open]);\n  index(() => {\n    if (enabled && (x != null || y != null)) {\n      initialRef.current = false;\n      setReference(x, y);\n    }\n  }, [enabled, x, y, setReference]);\n  const reference = React.useMemo(() => {\n    function setPointerTypeRef(_ref) {\n      let {\n        pointerType\n      } = _ref;\n      setPointerType(pointerType);\n    }\n    return {\n      onPointerDown: setPointerTypeRef,\n      onPointerEnter: setPointerTypeRef,\n      onMouseMove: handleReferenceEnterOrMove,\n      onMouseEnter: handleReferenceEnterOrMove\n    };\n  }, [handleReferenceEnterOrMove]);\n  return React.useMemo(() => enabled ? {\n    reference\n  } : {}, [enabled, reference]);\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 normalizeProp = normalizable => {\n  var _normalizable$escapeK, _normalizable$outside;\n  return {\n    escapeKey: typeof normalizable === 'boolean' ? normalizable : (_normalizable$escapeK = normalizable == null ? void 0 : normalizable.escapeKey) != null ? _normalizable$escapeK : false,\n    outsidePress: typeof normalizable === 'boolean' ? normalizable : (_normalizable$outside = normalizable == null ? void 0 : normalizable.outsidePress) != null ? _normalizable$outside : 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 */\nfunction useDismiss(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    elements,\n    dataRef\n  } = context;\n  const {\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,\n    capture\n  } = props;\n  const tree = useFloatingTree();\n  const outsidePressFn = useEffectEvent(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 endedOrStartedInsideRef = React.useRef(false);\n  const {\n    escapeKey: escapeKeyBubbles,\n    outsidePress: outsidePressBubbles\n  } = normalizeProp(bubbles);\n  const {\n    escapeKey: escapeKeyCapture,\n    outsidePress: outsidePressCapture\n  } = normalizeProp(capture);\n  const isComposingRef = React.useRef(false);\n  const closeOnEscapeKeyDown = useEffectEvent(event => {\n    var _dataRef$current$floa;\n    if (!open || !enabled || !escapeKey || event.key !== 'Escape') {\n      return;\n    }\n\n    // Wait until IME is settled. Pressing `Escape` while composing should\n    // close the compose menu, but not the floating element.\n    if (isComposingRef.current) {\n      return;\n    }\n    const nodeId = (_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.nodeId;\n    const children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];\n    if (!escapeKeyBubbles) {\n      event.stopPropagation();\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    }\n    onOpenChange(false, isReactEvent(event) ? event.nativeEvent : event, 'escape-key');\n  });\n  const closeOnEscapeKeyDownCapture = useEffectEvent(event => {\n    var _getTarget2;\n    const callback = () => {\n      var _getTarget;\n      closeOnEscapeKeyDown(event);\n      (_getTarget = getTarget(event)) == null || _getTarget.removeEventListener('keydown', callback);\n    };\n    (_getTarget2 = getTarget(event)) == null || _getTarget2.addEventListener('keydown', callback);\n  });\n  const closeOnPressOutside = useEffectEvent(event => {\n    var _dataRef$current$floa2;\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\n    // When click outside is lazy (`click` event), handle dragging.\n    // Don't close if:\n    // - The click started inside the floating element.\n    // - The click ended inside the floating element.\n    const endedOrStartedInside = endedOrStartedInsideRef.current;\n    endedOrStartedInsideRef.current = false;\n    if (outsidePressEvent === 'click' && endedOrStartedInside) {\n      return;\n    }\n    if (insideReactTree) {\n      return;\n    }\n    if (typeof outsidePress === 'function' && !outsidePress(event)) {\n      return;\n    }\n    const target = getTarget(event);\n    const inertSelector = \"[\" + createAttribute('inert') + \"]\";\n    const markers = getDocument(elements.floating).querySelectorAll(inertSelector);\n    let targetRootAncestor = isElement(target) ? target : null;\n    while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {\n      const nextParent = getParentNode(targetRootAncestor);\n      if (isLastTraversableNode(nextParent) || !isElement(nextParent)) {\n        break;\n      }\n      targetRootAncestor = nextParent;\n    }\n\n    // Check if the click occurred on a third-party element injected after the\n    // floating element rendered.\n    if (markers.length && isElement(target) && !isRootElement(target) &&\n    // Clicked on a direct ancestor (e.g. FloatingOverlay).\n    !contains(target, elements.floating) &&\n    // If the target root element contains none of the markers, then the\n    // element was injected after the floating element rendered.\n    Array.from(markers).every(marker => !contains(targetRootAncestor, marker))) {\n      return;\n    }\n\n    // Check if the click occurred on the scrollbar\n    if (isHTMLElement(target) && floating) {\n      const lastTraversableNode = isLastTraversableNode(target);\n      const style = getComputedStyle(target);\n      const scrollRe = /auto|scroll/;\n      const isScrollableX = lastTraversableNode || scrollRe.test(style.overflowX);\n      const isScrollableY = lastTraversableNode || scrollRe.test(style.overflowY);\n      const canScrollX = isScrollableX && target.clientWidth > 0 && target.scrollWidth > target.clientWidth;\n      const canScrollY = isScrollableY && target.clientHeight > 0 && target.scrollHeight > target.clientHeight;\n      const isRTL = style.direction === 'rtl';\n\n      // Check click position relative to scrollbar.\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      const pressedVerticalScrollbar = canScrollY && (isRTL ? event.offsetX <= target.offsetWidth - target.clientWidth : event.offsetX > target.clientWidth);\n      const pressedHorizontalScrollbar = canScrollX && event.offsetY > target.clientHeight;\n      if (pressedVerticalScrollbar || pressedHorizontalScrollbar) {\n        return;\n      }\n    }\n    const nodeId = (_dataRef$current$floa2 = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa2.nodeId;\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, elements.floating) || isEventTargetWithin(event, elements.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    onOpenChange(false, event, 'outside-press');\n  });\n  const closeOnPressOutsideCapture = useEffectEvent(event => {\n    var _getTarget4;\n    const callback = () => {\n      var _getTarget3;\n      closeOnPressOutside(event);\n      (_getTarget3 = getTarget(event)) == null || _getTarget3.removeEventListener(outsidePressEvent, callback);\n    };\n    (_getTarget4 = getTarget(event)) == null || _getTarget4.addEventListener(outsidePressEvent, callback);\n  });\n  React.useEffect(() => {\n    if (!open || !enabled) {\n      return;\n    }\n    dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;\n    dataRef.current.__outsidePressBubbles = outsidePressBubbles;\n    let compositionTimeout = -1;\n    function onScroll(event) {\n      onOpenChange(false, event, 'ancestor-scroll');\n    }\n    function handleCompositionStart() {\n      window.clearTimeout(compositionTimeout);\n      isComposingRef.current = true;\n    }\n    function handleCompositionEnd() {\n      // Safari fires `compositionend` before `keydown`, so we need to wait\n      // until the next tick to set `isComposing` to `false`.\n      // https://bugs.webkit.org/show_bug.cgi?id=165004\n      compositionTimeout = window.setTimeout(() => {\n        isComposingRef.current = false;\n      },\n      // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.\n      // Only apply to WebKit for the test to remain 0ms.\n      isWebKit() ? 5 : 0);\n    }\n    const doc = getDocument(elements.floating);\n    if (escapeKey) {\n      doc.addEventListener('keydown', escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);\n      doc.addEventListener('compositionstart', handleCompositionStart);\n      doc.addEventListener('compositionend', handleCompositionEnd);\n    }\n    outsidePress && doc.addEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);\n    let ancestors = [];\n    if (ancestorScroll) {\n      if (isElement(elements.domReference)) {\n        ancestors = getOverflowAncestors(elements.domReference);\n      }\n      if (isElement(elements.floating)) {\n        ancestors = ancestors.concat(getOverflowAncestors(elements.floating));\n      }\n      if (!isElement(elements.reference) && elements.reference && elements.reference.contextElement) {\n        ancestors = ancestors.concat(getOverflowAncestors(elements.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      if (escapeKey) {\n        doc.removeEventListener('keydown', escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);\n        doc.removeEventListener('compositionstart', handleCompositionStart);\n        doc.removeEventListener('compositionend', handleCompositionEnd);\n      }\n      outsidePress && doc.removeEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);\n      ancestors.forEach(ancestor => {\n        ancestor.removeEventListener('scroll', onScroll);\n      });\n      window.clearTimeout(compositionTimeout);\n    };\n  }, [dataRef, elements, escapeKey, outsidePress, outsidePressEvent, open, onOpenChange, ancestorScroll, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, escapeKeyCapture, closeOnEscapeKeyDownCapture, closeOnPressOutside, outsidePressCapture, closeOnPressOutsideCapture]);\n  React.useEffect(() => {\n    insideReactTreeRef.current = false;\n  }, [outsidePress, outsidePressEvent]);\n  const reference = React.useMemo(() => ({\n    onKeyDown: closeOnEscapeKeyDown,\n    ...(referencePress && {\n      [bubbleHandlerKeys[referencePressEvent]]: event => {\n        onOpenChange(false, event.nativeEvent, 'reference-press');\n      },\n      ...(referencePressEvent !== 'click' && {\n        onClick(event) {\n          onOpenChange(false, event.nativeEvent, 'reference-press');\n        }\n      })\n    })\n  }), [closeOnEscapeKeyDown, onOpenChange, referencePress, referencePressEvent]);\n  const floating = React.useMemo(() => ({\n    onKeyDown: closeOnEscapeKeyDown,\n    onMouseDown() {\n      endedOrStartedInsideRef.current = true;\n    },\n    onMouseUp() {\n      endedOrStartedInsideRef.current = true;\n    },\n    [captureHandlerKeys[outsidePressEvent]]: () => {\n      insideReactTreeRef.current = true;\n    }\n  }), [closeOnEscapeKeyDown, outsidePressEvent]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating\n  } : {}, [enabled, reference, floating]);\n}\n\nfunction useFloatingRootContext(options) {\n  const {\n    open = false,\n    onOpenChange: onOpenChangeProp,\n    elements: elementsProp\n  } = options;\n  const floatingId = useId();\n  const dataRef = React.useRef({});\n  const [events] = React.useState(() => createPubSub());\n  const nested = useFloatingParentNodeId() != null;\n  if (process.env.NODE_ENV !== \"production\") {\n    const optionDomReference = elementsProp.reference;\n    if (optionDomReference && !isElement(optionDomReference)) {\n      error('Cannot pass a virtual element to the `elements.reference` option,', 'as it must be a real DOM element. Use `refs.setPositionReference()`', 'instead.');\n    }\n  }\n  const [positionReference, setPositionReference] = React.useState(elementsProp.reference);\n  const onOpenChange = useEffectEvent((open, event, reason) => {\n    dataRef.current.openEvent = open ? event : undefined;\n    events.emit('openchange', {\n      open,\n      event,\n      reason,\n      nested\n    });\n    onOpenChangeProp == null || onOpenChangeProp(open, event, reason);\n  });\n  const refs = React.useMemo(() => ({\n    setPositionReference\n  }), []);\n  const elements = React.useMemo(() => ({\n    reference: positionReference || elementsProp.reference || null,\n    floating: elementsProp.floating || null,\n    domReference: elementsProp.reference\n  }), [positionReference, elementsProp.reference, elementsProp.floating]);\n  return React.useMemo(() => ({\n    dataRef,\n    open,\n    onOpenChange,\n    elements,\n    events,\n    floatingId,\n    refs\n  }), [open, onOpenChange, elements, events, floatingId, refs]);\n}\n\n/**\n * Provides data to position a floating element and context to add interactions.\n * @see https://floating-ui.com/docs/useFloating\n */\nfunction useFloating(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    nodeId\n  } = options;\n  const internalRootContext = useFloatingRootContext({\n    ...options,\n    elements: {\n      reference: null,\n      floating: null,\n      ...options.elements\n    }\n  });\n  const rootContext = options.rootContext || internalRootContext;\n  const computedElements = rootContext.elements;\n  const [_domReference, setDomReference] = React.useState(null);\n  const [positionReference, _setPositionReference] = React.useState(null);\n  const optionDomReference = computedElements == null ? void 0 : computedElements.domReference;\n  const domReference = optionDomReference || _domReference;\n  const domReferenceRef = React.useRef(null);\n  const tree = useFloatingTree();\n  index(() => {\n    if (domReference) {\n      domReferenceRef.current = domReference;\n    }\n  }, [domReference]);\n  const position = useFloating$1({\n    ...options,\n    elements: {\n      ...computedElements,\n      ...(positionReference && {\n        reference: positionReference\n      })\n    }\n  });\n  const setPositionReference = React.useCallback(node => {\n    const computedPositionReference = isElement(node) ? {\n      getBoundingClientRect: () => node.getBoundingClientRect(),\n      contextElement: node\n    } : node;\n    // Store the positionReference in state if the DOM reference is specified externally via the\n    // `elements.reference` option. This ensures that it won't be overridden on future renders.\n    _setPositionReference(computedPositionReference);\n    position.refs.setReference(computedPositionReference);\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 context = React.useMemo(() => ({\n    ...position,\n    ...rootContext,\n    refs,\n    elements,\n    nodeId\n  }), [position, refs, elements, nodeId, rootContext]);\n  index(() => {\n    rootContext.dataRef.current.floatingContext = context;\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    elements\n  }), [position, refs, elements, context]);\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 */\nfunction useFocus(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    events,\n    dataRef,\n    elements\n  } = context;\n  const {\n    enabled = true,\n    visibleOnly = true\n  } = props;\n  const blockFocusRef = React.useRef(false);\n  const timeoutRef = React.useRef();\n  const keyboardModalityRef = React.useRef(true);\n  React.useEffect(() => {\n    if (!enabled) return;\n    const win = getWindow(elements.domReference);\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(elements.domReference) && elements.domReference === activeElement(getDocument(elements.domReference))) {\n        blockFocusRef.current = true;\n      }\n    }\n    function onKeyDown() {\n      keyboardModalityRef.current = true;\n    }\n    win.addEventListener('blur', onBlur);\n    win.addEventListener('keydown', onKeyDown, true);\n    return () => {\n      win.removeEventListener('blur', onBlur);\n      win.removeEventListener('keydown', onKeyDown, true);\n    };\n  }, [elements.domReference, open, enabled]);\n  React.useEffect(() => {\n    if (!enabled) return;\n    function onOpenChange(_ref) {\n      let {\n        reason\n      } = _ref;\n      if (reason === 'reference-press' || reason === 'escape-key') {\n        blockFocusRef.current = true;\n      }\n    }\n    events.on('openchange', onOpenChange);\n    return () => {\n      events.off('openchange', onOpenChange);\n    };\n  }, [events, enabled]);\n  React.useEffect(() => {\n    return () => {\n      clearTimeout(timeoutRef.current);\n    };\n  }, []);\n  const reference = React.useMemo(() => ({\n    onPointerDown(event) {\n      if (isVirtualPointerEvent(event.nativeEvent)) return;\n      keyboardModalityRef.current = false;\n    },\n    onMouseLeave() {\n      blockFocusRef.current = false;\n    },\n    onFocus(event) {\n      if (blockFocusRef.current) return;\n      const target = getTarget(event.nativeEvent);\n      if (visibleOnly && isElement(target)) {\n        try {\n          // Mac Safari unreliably matches `:focus-visible` on the reference\n          // if focus was outside the page initially - use the fallback\n          // instead.\n          if (isSafari() && isMac()) throw Error();\n          if (!target.matches(':focus-visible')) return;\n        } catch (e) {\n          // Old browsers will throw an error when using `:focus-visible`.\n          if (!keyboardModalityRef.current && !isTypeableElement(target)) {\n            return;\n          }\n        }\n      }\n      onOpenChange(true, event.nativeEvent, 'focus');\n    },\n    onBlur(event) {\n      blockFocusRef.current = false;\n      const relatedTarget = event.relatedTarget;\n      const nativeEvent = event.nativeEvent;\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(createAttribute('focus-guard')) && relatedTarget.getAttribute('data-type') === 'outside';\n\n      // Wait for the window blur listener to fire.\n      timeoutRef.current = window.setTimeout(() => {\n        var _dataRef$current$floa;\n        const activeEl = activeElement(elements.domReference ? elements.domReference.ownerDocument : document);\n\n        // Focus left the page, keep it open.\n        if (!relatedTarget && activeEl === elements.domReference) return;\n\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        // We can not rely on relatedTarget to point to the correct element\n        // as it will only point to the shadow host of the newly focused element\n        // and not the element that actually has received focus if it is located\n        // inside a shadow root.\n        if (contains((_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.refs.floating.current, activeEl) || contains(elements.domReference, activeEl) || movedToFocusGuard) {\n          return;\n        }\n        onOpenChange(false, nativeEvent, 'focus');\n      });\n    }\n  }), [dataRef, elements.domReference, onOpenChange, visibleOnly]);\n  return React.useMemo(() => enabled ? {\n    reference\n  } : {}, [enabled, reference]);\n}\n\nconst ACTIVE_KEY = 'active';\nconst SELECTED_KEY = 'selected';\nfunction mergeProps(userProps, propsList, elementKey) {\n  const map = new Map();\n  const isItem = elementKey === 'item';\n  let domUserProps = userProps;\n  if (isItem && userProps) {\n    const {\n      [ACTIVE_KEY]: _,\n      [SELECTED_KEY]: __,\n      ...validProps\n    } = userProps;\n    domUserProps = validProps;\n  }\n  return {\n    ...(elementKey === 'floating' && {\n      tabIndex: -1,\n      [FOCUSABLE_ATTRIBUTE]: ''\n    }),\n    ...domUserProps,\n    ...propsList.map(value => {\n      const propsOrGetProps = value ? value[elementKey] : null;\n      if (typeof propsOrGetProps === 'function') {\n        return userProps ? propsOrGetProps(userProps) : null;\n      }\n      return propsOrGetProps;\n    }).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 (isItem && [ACTIVE_KEY, SELECTED_KEY].includes(key)) {\n          return;\n        }\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 || _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              return (_map$get2 = map.get(key)) == null ? void 0 : _map$get2.map(fn => fn(...args)).find(val => val !== undefined);\n            };\n          }\n        } else {\n          acc[key] = value;\n        }\n      });\n      return acc;\n    }, {})\n  };\n}\n/**\n * Merges an array of interaction hooks' props into prop getters, allowing\n * event handler functions to be composed together without overwriting one\n * another.\n * @see https://floating-ui.com/docs/useInteractions\n */\nfunction useInteractions(propsList) {\n  if (propsList === void 0) {\n    propsList = [];\n  }\n  const referenceDeps = propsList.map(key => key == null ? void 0 : key.reference);\n  const floatingDeps = propsList.map(key => key == null ? void 0 : key.floating);\n  const itemDeps = propsList.map(key => key == null ? void 0 : key.item);\n  const getReferenceProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'reference'),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  referenceDeps);\n  const getFloatingProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'floating'),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  floatingDeps);\n  const getItemProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'item'),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  itemDeps);\n  return React.useMemo(() => ({\n    getReferenceProps,\n    getFloatingProps,\n    getItemProps\n  }), [getReferenceProps, getFloatingProps, getItemProps]);\n}\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}\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 */\nfunction useListNavigation(context, props) {\n  const {\n    open,\n    onOpenChange,\n    elements\n  } = context;\n  const {\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    virtualItemRef,\n    itemSizes,\n    dense = false\n  } = props;\n  if (process.env.NODE_ENV !== \"production\") {\n    if (allowEscape) {\n      if (!loop) {\n        warn('`useListNavigation` looping must be enabled to allow escaping.');\n      }\n      if (!virtual) {\n        warn('`useListNavigation` must be virtual to allow escaping.');\n      }\n    }\n    if (orientation === 'vertical' && cols > 1) {\n      warn('In grid list navigation mode (`cols` > 1), the `orientation` should', 'be either \"horizontal\" or \"both\".');\n    }\n  }\n  const floatingFocusElement = getFloatingFocusElement(elements.floating);\n  const floatingFocusElementRef = useLatestRef(floatingFocusElement);\n  const parentId = useFloatingParentNodeId();\n  const tree = useFloatingTree();\n  const onNavigate = useEffectEvent(() => {\n    unstable_onNavigate(indexRef.current === -1 ? null : indexRef.current);\n  });\n  const typeableComboboxReference = isTypeableCombobox(elements.domReference);\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 previousMountedRef = React.useRef(!!elements.floating);\n  const previousOpenRef = React.useRef(open);\n  const forceSyncFocusRef = 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 selectedIndexRef = useLatestRef(selectedIndex);\n  const [activeId, setActiveId] = React.useState();\n  const [virtualId, setVirtualId] = React.useState();\n  const focusItem = useEffectEvent(() => {\n    function runFocus(item) {\n      if (virtual) {\n        setActiveId(item.id);\n        tree == null || tree.events.emit('virtualfocus', item);\n        if (virtualItemRef) {\n          virtualItemRef.current = item;\n        }\n      } else {\n        enqueueFocus(item, {\n          sync: forceSyncFocusRef.current,\n          preventScroll: true\n        });\n      }\n    }\n    const initialItem = listRef.current[indexRef.current];\n    if (initialItem) {\n      runFocus(initialItem);\n    }\n    const scheduler = forceSyncFocusRef.current ? v => v() : requestAnimationFrame;\n    scheduler(() => {\n      const waitedItem = listRef.current[indexRef.current] || initialItem;\n      if (!waitedItem) return;\n      if (!initialItem) {\n        runFocus(waitedItem);\n      }\n      const scrollIntoViewOptions = scrollItemIntoViewRef.current;\n      const shouldScrollIntoView = scrollIntoViewOptions && item && (forceScrollIntoViewRef.current || !isPointerModalityRef.current);\n      if (shouldScrollIntoView) {\n        // JSDOM doesn't support `.scrollIntoView()` but it's widely supported\n        // by all browsers.\n        waitedItem.scrollIntoView == null || waitedItem.scrollIntoView(typeof scrollIntoViewOptions === 'boolean' ? {\n          block: 'nearest',\n          inline: 'nearest'\n        } : scrollIntoViewOptions);\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) return;\n    if (open && elements.floating) {\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        indexRef.current = selectedIndex;\n        onNavigate();\n      }\n    } else if (previousMountedRef.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();\n    }\n  }, [enabled, open, elements.floating, selectedIndex, onNavigate]);\n\n  // Sync `activeIndex` to be the focused item while the floating element is\n  // open.\n  index(() => {\n    if (!enabled) return;\n    if (!open) return;\n    if (!elements.floating) return;\n    if (activeIndex == null) {\n      forceSyncFocusRef.current = false;\n      if (selectedIndexRef.current != null) {\n        return;\n      }\n\n      // Reset while the floating element was open (e.g. the list changed).\n      if (previousMountedRef.current) {\n        indexRef.current = -1;\n        focusItem();\n      }\n\n      // Initial sync.\n      if ((!previousOpenRef.current || !previousMountedRef.current) && focusItemOnOpenRef.current && (keyRef.current != null || focusItemOnOpenRef.current === true && keyRef.current == null)) {\n        let runs = 0;\n        const waitForListPopulated = () => {\n          if (listRef.current[0] == null) {\n            // Avoid letting the browser paint if possible on the first try,\n            // otherwise use rAF. Don't try more than twice, since something\n            // is wrong otherwise.\n            if (runs < 2) {\n              const scheduler = runs ? requestAnimationFrame : queueMicrotask;\n              scheduler(waitForListPopulated);\n            }\n            runs++;\n          } else {\n            indexRef.current = keyRef.current == null || isMainOrientationToEndKey(keyRef.current, orientation, rtl) || nested ? getMinIndex(listRef, disabledIndicesRef.current) : getMaxIndex(listRef, disabledIndicesRef.current);\n            keyRef.current = null;\n            onNavigate();\n          }\n        };\n        waitForListPopulated();\n      }\n    } else if (!isIndexOutOfBounds(listRef, activeIndex)) {\n      indexRef.current = activeIndex;\n      focusItem();\n      forceScrollIntoViewRef.current = false;\n    }\n  }, [enabled, open, elements.floating, activeIndex, selectedIndexRef, 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    var _nodes$find;\n    if (!enabled || elements.floating || !tree || virtual || !previousMountedRef.current) {\n      return;\n    }\n    const nodes = tree.nodesRef.current;\n    const parent = (_nodes$find = nodes.find(node => node.id === parentId)) == null || (_nodes$find = _nodes$find.context) == null ? void 0 : _nodes$find.elements.floating;\n    const activeEl = activeElement(getDocument(elements.floating));\n    const treeContainsActiveEl = nodes.some(node => node.context && contains(node.context.elements.floating, activeEl));\n    if (parent && !treeContainsActiveEl && isPointerModalityRef.current) {\n      parent.focus({\n        preventScroll: true\n      });\n    }\n  }, [enabled, elements.floating, tree, parentId, virtual]);\n  index(() => {\n    if (!enabled) return;\n    if (!tree) return;\n    if (!virtual) return;\n    if (parentId) return;\n    function handleVirtualFocus(item) {\n      setVirtualId(item.id);\n      if (virtualItemRef) {\n        virtualItemRef.current = item;\n      }\n    }\n    tree.events.on('virtualfocus', handleVirtualFocus);\n    return () => {\n      tree.events.off('virtualfocus', handleVirtualFocus);\n    };\n  }, [enabled, tree, virtual, parentId, virtualItemRef]);\n  index(() => {\n    previousOnNavigateRef.current = onNavigate;\n    previousOpenRef.current = open;\n    previousMountedRef.current = !!elements.floating;\n  });\n  index(() => {\n    if (!open) {\n      keyRef.current = null;\n    }\n  }, [open]);\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 && indexRef.current !== index) {\n        indexRef.current = index;\n        onNavigate();\n      }\n    }\n    const props = {\n      onFocus(_ref) {\n        let {\n          currentTarget\n        } = _ref;\n        forceSyncFocusRef.current = true;\n        syncCurrentTarget(currentTarget);\n      },\n      onClick: _ref2 => {\n        let {\n          currentTarget\n        } = _ref2;\n        return currentTarget.focus({\n          preventScroll: true\n        });\n      },\n      // Safari\n      ...(focusItemOnHover && {\n        onMouseMove(_ref3) {\n          let {\n            currentTarget\n          } = _ref3;\n          forceSyncFocusRef.current = true;\n          forceScrollIntoViewRef.current = false;\n          syncCurrentTarget(currentTarget);\n        },\n        onPointerLeave(_ref4) {\n          let {\n            pointerType\n          } = _ref4;\n          if (!isPointerModalityRef.current || pointerType === 'touch') {\n            return;\n          }\n          forceSyncFocusRef.current = true;\n          indexRef.current = -1;\n          onNavigate();\n          if (!virtual) {\n            var _floatingFocusElement;\n            (_floatingFocusElement = floatingFocusElementRef.current) == null || _floatingFocusElement.focus({\n              preventScroll: true\n            });\n          }\n        }\n      })\n    };\n    return props;\n  }, [open, floatingFocusElementRef, focusItemOnHover, listRef, onNavigate, virtual]);\n  const commonOnKeyDown = useEffectEvent(event => {\n    isPointerModalityRef.current = false;\n    forceSyncFocusRef.current = true;\n\n    // When composing a character, Chrome fires ArrowDown twice. Firefox/Safari\n    // don't appear to suffer from this. `event.isComposing` is avoided due to\n    // Safari not supporting it properly (although it's not needed in the first\n    // place for Safari, just avoiding any possible issues).\n    if (event.which === 229) {\n      return;\n    }\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 === floatingFocusElementRef.current) {\n      return;\n    }\n    if (nested && isCrossOrientationCloseKey(event.key, orientation, rtl)) {\n      stopEvent(event);\n      onOpenChange(false, event.nativeEvent, 'list-navigation');\n      if (isHTMLElement(elements.domReference)) {\n        if (virtual) {\n          tree == null || tree.events.emit('virtualfocus', elements.domReference);\n        } else {\n          elements.domReference.focus();\n        }\n      }\n      return;\n    }\n    const currentIndex = indexRef.current;\n    const minIndex = getMinIndex(listRef, disabledIndices);\n    const maxIndex = getMaxIndex(listRef, disabledIndices);\n    if (!typeableComboboxReference) {\n      if (event.key === 'Home') {\n        stopEvent(event);\n        indexRef.current = minIndex;\n        onNavigate();\n      }\n      if (event.key === 'End') {\n        stopEvent(event);\n        indexRef.current = maxIndex;\n        onNavigate();\n      }\n    }\n\n    // Grid navigation.\n    if (cols > 1) {\n      const sizes = itemSizes || Array.from({\n        length: listRef.current.length\n      }, () => ({\n        width: 1,\n        height: 1\n      }));\n      // To calculate movements on the grid, we use hypothetical cell indices\n      // as if every item was 1x1, then convert back to real indices.\n      const cellMap = buildCellMap(sizes, cols, dense);\n      const minGridIndex = cellMap.findIndex(index => index != null && !isDisabled(listRef.current, index, disabledIndices));\n      // last enabled index\n      const maxGridIndex = cellMap.reduce((foundIndex, index, cellIndex) => index != null && !isDisabled(listRef.current, index, disabledIndices) ? cellIndex : foundIndex, -1);\n      const index = cellMap[getGridNavigatedIndex({\n        current: cellMap.map(itemIndex => itemIndex != null ? listRef.current[itemIndex] : null)\n      }, {\n        event,\n        orientation,\n        loop,\n        rtl,\n        cols,\n        // treat undefined (empty grid spaces) as disabled indices so we\n        // don't end up in them\n        disabledIndices: getCellIndices([...(disabledIndices || listRef.current.map((_, index) => isDisabled(listRef.current, index) ? index : undefined)), undefined], cellMap),\n        minIndex: minGridIndex,\n        maxIndex: maxGridIndex,\n        prevIndex: getCellIndexOfCorner(indexRef.current > maxIndex ? minIndex : indexRef.current, sizes, cellMap, cols,\n        // use a corner matching the edge closest to the direction\n        // we're moving in so we don't end up in the same item. Prefer\n        // top/left over bottom/right.\n        event.key === ARROW_DOWN ? 'bl' : event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT) ? 'tr' : 'tl'),\n        stopEvent: true\n      })];\n      if (index != null) {\n        indexRef.current = index;\n        onNavigate();\n      }\n      if (orientation === 'both') {\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(event.currentTarget.ownerDocument) === event.currentTarget) {\n        indexRef.current = isMainOrientationToEndKey(event.key, orientation, rtl) ? minIndex : maxIndex;\n        onNavigate();\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        indexRef.current = -1;\n      }\n      onNavigate();\n    }\n  });\n  const ariaActiveDescendantProp = React.useMemo(() => {\n    return virtual && open && hasActiveIndex && {\n      'aria-activedescendant': virtualId || activeId\n    };\n  }, [virtual, open, hasActiveIndex, virtualId, activeId]);\n  const floating = React.useMemo(() => {\n    return {\n      'aria-orientation': orientation === 'both' ? undefined : orientation,\n      ...(!typeableComboboxReference ? ariaActiveDescendantProp : {}),\n      onKeyDown: commonOnKeyDown,\n      onPointerMove() {\n        isPointerModalityRef.current = true;\n      }\n    };\n  }, [ariaActiveDescendantProp, commonOnKeyDown, orientation, typeableComboboxReference]);\n  const reference = React.useMemo(() => {\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    return {\n      ...ariaActiveDescendantProp,\n      onKeyDown(event) {\n        isPointerModalityRef.current = false;\n        const isArrowKey = event.key.startsWith('Arrow');\n        const isHomeOrEndKey = ['Home', 'End'].includes(event.key);\n        const isMoveKey = isArrowKey || isHomeOrEndKey;\n        const isCrossOpenKey = isCrossOrientationOpenKey(event.key, orientation, rtl);\n        const isCrossCloseKey = isCrossOrientationCloseKey(event.key, orientation, rtl);\n        const isMainKey = isMainOrientationKey(event.key, orientation);\n        const isNavigationKey = (nested ? isCrossOpenKey : isMainKey) || event.key === 'Enter' || event.key.trim() === '';\n        if (virtual && open) {\n          const rootNode = tree == null ? void 0 : tree.nodesRef.current.find(node => node.parentId == null);\n          const deepestNode = tree && rootNode ? getDeepestNode(tree.nodesRef.current, rootNode.id) : null;\n          if (isMoveKey && deepestNode && virtualItemRef) {\n            const eventObject = new KeyboardEvent('keydown', {\n              key: event.key,\n              bubbles: true\n            });\n            if (isCrossOpenKey || isCrossCloseKey) {\n              var _deepestNode$context, _deepestNode$context2;\n              const isCurrentTarget = ((_deepestNode$context = deepestNode.context) == null ? void 0 : _deepestNode$context.elements.domReference) === event.currentTarget;\n              const dispatchItem = isCrossCloseKey && !isCurrentTarget ? (_deepestNode$context2 = deepestNode.context) == null ? void 0 : _deepestNode$context2.elements.domReference : isCrossOpenKey ? listRef.current.find(item => (item == null ? void 0 : item.id) === activeId) : null;\n              if (dispatchItem) {\n                stopEvent(event);\n                dispatchItem.dispatchEvent(eventObject);\n                setVirtualId(undefined);\n              }\n            }\n            if ((isMainKey || isHomeOrEndKey) && deepestNode.context) {\n              if (deepestNode.context.open && deepestNode.parentId && event.currentTarget !== deepestNode.context.elements.domReference) {\n                var _deepestNode$context$;\n                stopEvent(event);\n                (_deepestNode$context$ = deepestNode.context.elements.domReference) == null || _deepestNode$context$.dispatchEvent(eventObject);\n                return;\n              }\n            }\n          }\n          return commonOnKeyDown(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        if (isNavigationKey) {\n          keyRef.current = nested && isMainKey ? null : event.key;\n        }\n        if (nested) {\n          if (isCrossOpenKey) {\n            stopEvent(event);\n            if (open) {\n              indexRef.current = getMinIndex(listRef, disabledIndicesRef.current);\n              onNavigate();\n            } else {\n              onOpenChange(true, event.nativeEvent, 'list-navigation');\n            }\n          }\n          return;\n        }\n        if (isMainKey) {\n          if (selectedIndex != null) {\n            indexRef.current = selectedIndex;\n          }\n          stopEvent(event);\n          if (!open && openOnArrowKeyDown) {\n            onOpenChange(true, event.nativeEvent, 'list-navigation');\n          } else {\n            commonOnKeyDown(event);\n          }\n          if (open) {\n            onNavigate();\n          }\n        }\n      },\n      onFocus() {\n        if (open && !virtual) {\n          indexRef.current = -1;\n          onNavigate();\n        }\n      },\n      onPointerDown: checkVirtualPointer,\n      onPointerEnter: checkVirtualPointer,\n      onMouseDown: checkVirtualMouse,\n      onClick: checkVirtualMouse\n    };\n  }, [activeId, ariaActiveDescendantProp, commonOnKeyDown, disabledIndicesRef, focusItemOnOpen, listRef, nested, onNavigate, onOpenChange, open, openOnArrowKeyDown, orientation, rtl, selectedIndex, tree, virtual, virtualItemRef]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating,\n    item\n  } : {}, [enabled, reference, floating, item]);\n}\n\nconst componentRoleToAriaRoleMap = /*#__PURE__*/new Map([['select', 'listbox'], ['combobox', 'listbox'], ['label', false]]);\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 */\nfunction useRole(context, props) {\n  var _componentRoleToAriaR;\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    floatingId\n  } = context;\n  const {\n    enabled = true,\n    role = 'dialog'\n  } = props;\n  const ariaRole = (_componentRoleToAriaR = componentRoleToAriaRoleMap.get(role)) != null ? _componentRoleToAriaR : role;\n  const referenceId = useId();\n  const parentId = useFloatingParentNodeId();\n  const isNested = parentId != null;\n  const reference = React.useMemo(() => {\n    if (ariaRole === 'tooltip' || role === 'label') {\n      return {\n        [\"aria-\" + (role === 'label' ? 'labelledby' : 'describedby')]: open ? floatingId : undefined\n      };\n    }\n    return {\n      'aria-expanded': open ? 'true' : 'false',\n      'aria-haspopup': ariaRole === 'alertdialog' ? 'dialog' : ariaRole,\n      'aria-controls': open ? floatingId : undefined,\n      ...(ariaRole === 'listbox' && {\n        role: 'combobox'\n      }),\n      ...(ariaRole === 'menu' && {\n        id: referenceId\n      }),\n      ...(ariaRole === 'menu' && isNested && {\n        role: 'menuitem'\n      }),\n      ...(role === 'select' && {\n        'aria-autocomplete': 'none'\n      }),\n      ...(role === 'combobox' && {\n        'aria-autocomplete': 'list'\n      })\n    };\n  }, [ariaRole, floatingId, isNested, open, referenceId, role]);\n  const floating = React.useMemo(() => {\n    const floatingProps = {\n      id: floatingId,\n      ...(ariaRole && {\n        role: ariaRole\n      })\n    };\n    if (ariaRole === 'tooltip' || role === 'label') {\n      return floatingProps;\n    }\n    return {\n      ...floatingProps,\n      ...(ariaRole === 'menu' && {\n        'aria-labelledby': referenceId\n      })\n    };\n  }, [ariaRole, floatingId, referenceId, role]);\n  const item = React.useCallback(_ref => {\n    let {\n      active,\n      selected\n    } = _ref;\n    const commonProps = {\n      role: 'option',\n      ...(active && {\n        id: floatingId + \"-option\"\n      })\n    };\n\n    // For `menu`, we are unable to tell if the item is a `menuitemradio`\n    // or `menuitemcheckbox`. For backwards-compatibility reasons, also\n    // avoid defaulting to `menuitem` as it may overwrite custom role props.\n    switch (role) {\n      case 'select':\n        return {\n          ...commonProps,\n          'aria-selected': active && selected\n        };\n      case 'combobox':\n        {\n          return {\n            ...commonProps,\n            ...(active && {\n              'aria-selected': true\n            })\n          };\n        }\n    }\n    return {};\n  }, [floatingId, role]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating,\n    item\n  } : {}, [enabled, reference, floating, item]);\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 execWithArgsOrReturn(valueOrFn, args) {\n  return typeof valueOrFn === 'function' ? valueOrFn(args) : valueOrFn;\n}\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 && isMounted) {\n      const timeout = setTimeout(() => setIsMounted(false), durationMs);\n      return () => clearTimeout(timeout);\n    }\n  }, [open, isMounted, 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(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    elements: {\n      floating\n    }\n  } = context;\n  const {\n    duration = 250\n  } = props;\n  const isNumberDuration = typeof duration === 'number';\n  const closeDuration = (isNumberDuration ? duration : duration.close) || 0;\n  const [status, setStatus] = React.useState('unmounted');\n  const isMounted = useDelayUnmount(open, closeDuration);\n  if (!isMounted && status === 'close') {\n    setStatus('unmounted');\n  }\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    }\n    setStatus('close');\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, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    initial: unstable_initial = {\n      opacity: 0\n    },\n    open: unstable_open,\n    close: unstable_close,\n    common: unstable_common,\n    duration = 250\n  } = props;\n  const placement = context.placement;\n  const side = placement.split('-')[0];\n  const fnArgs = React.useMemo(() => ({\n    side,\n    placement\n  }), [side, placement]);\n  const isNumberDuration = typeof duration === 'number';\n  const openDuration = (isNumberDuration ? duration : duration.open) || 0;\n  const closeDuration = (isNumberDuration ? duration : duration.close) || 0;\n  const [styles, setStyles] = React.useState(() => ({\n    ...execWithArgsOrReturn(unstable_common, fnArgs),\n    ...execWithArgsOrReturn(unstable_initial, fnArgs)\n  }));\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  index(() => {\n    const initialStyles = execWithArgsOrReturn(initialRef.current, fnArgs);\n    const closeStyles = execWithArgsOrReturn(closeRef.current, fnArgs);\n    const commonStyles = execWithArgsOrReturn(commonRef.current, fnArgs);\n    const openStyles = execWithArgsOrReturn(openRef.current, fnArgs) || Object.keys(initialStyles).reduce((acc, key) => {\n      acc[key] = '';\n      return acc;\n    }, {});\n    if (status === 'initial') {\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  }, [closeDuration, closeRef, initialRef, openRef, commonRef, openDuration, status, fnArgs]);\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 */\nfunction useTypeahead(context, props) {\n  var _ref;\n  const {\n    open,\n    dataRef\n  } = context;\n  const {\n    listRef,\n    activeIndex,\n    onMatch: unstable_onMatch,\n    onTypingChange: unstable_onTypingChange,\n    enabled = true,\n    findMatch = null,\n    resetMs = 750,\n    ignoreKeys = [],\n    selectedIndex = null\n  } = props;\n  const timeoutIdRef = React.useRef();\n  const stringRef = React.useRef('');\n  const prevIndexRef = React.useRef((_ref = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref : -1);\n  const matchIndexRef = React.useRef(null);\n  const onMatch = useEffectEvent(unstable_onMatch);\n  const onTypingChange = useEffectEvent(unstable_onTypingChange);\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 _ref2;\n      prevIndexRef.current = (_ref2 = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref2 : -1;\n    }\n  }, [open, selectedIndex, activeIndex]);\n  const setTypingChange = useEffectEvent(value => {\n    if (value) {\n      if (!dataRef.current.typing) {\n        dataRef.current.typing = value;\n        onTypingChange(value);\n      }\n    } else {\n      if (dataRef.current.typing) {\n        dataRef.current.typing = value;\n        onTypingChange(value);\n      }\n    }\n  });\n  const onKeyDown = useEffectEvent(event => {\n    function getMatchingIndex(list, orderedList, string) {\n      const str = findMatchRef.current ? findMatchRef.current(orderedList, string) : orderedList.find(text => (text == null ? void 0 : text.toLocaleLowerCase().indexOf(string.toLocaleLowerCase())) === 0);\n      return str ? list.indexOf(str) : -1;\n    }\n    const listContent = listRef.current;\n    if (stringRef.current.length > 0 && stringRef.current[0] !== ' ') {\n      if (getMatchingIndex(listContent, listContent, stringRef.current) === -1) {\n        setTypingChange(false);\n      } else if (event.key === ' ') {\n        stopEvent(event);\n      }\n    }\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    if (open && event.key !== ' ') {\n      stopEvent(event);\n      setTypingChange(true);\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      setTypingChange(false);\n    }, resetMs);\n    const prevIndex = prevIndexRef.current;\n    const index = getMatchingIndex(listContent, [...listContent.slice((prevIndex || 0) + 1), ...listContent.slice(0, (prevIndex || 0) + 1)], stringRef.current);\n    if (index !== -1) {\n      onMatch(index);\n      matchIndexRef.current = index;\n    } else if (event.key !== ' ') {\n      stringRef.current = '';\n      setTypingChange(false);\n    }\n  });\n  const reference = React.useMemo(() => ({\n    onKeyDown\n  }), [onKeyDown]);\n  const floating = React.useMemo(() => {\n    return {\n      onKeyDown,\n      onKeyUp(event) {\n        if (event.key === ' ') {\n          setTypingChange(false);\n        }\n      }\n    };\n  }, [onKeyDown, setTypingChange]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating\n  } : {}, [enabled, reference, floating]);\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 of it is\n * anchored to the reference element.\n * @see https://floating-ui.com/docs/inner\n * @deprecated\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    } = evaluate(props, state);\n    const {\n      rects,\n      elements: {\n        floating\n      }\n    } = state;\n    const item = listRef.current[index];\n    const scrollEl = (scrollRef == null ? void 0 : scrollRef.current) || floating;\n\n    // Valid combinations:\n    // 1. Floating element is the scrollRef and has a border (default)\n    // 2. Floating element is not the scrollRef, floating element has a border\n    // 3. Floating element is not the scrollRef, scrollRef has a border\n    // Floating > {...getFloatingProps()} wrapper > scrollRef > items is not\n    // allowed as VoiceOver doesn't work.\n    const clientTop = floating.clientTop || scrollEl.clientTop;\n    const floatingIsBordered = floating.clientTop !== 0;\n    const scrollElIsBordered = scrollEl.clientTop !== 0;\n    const floatingIsScrollEl = floating === scrollEl;\n    if (process.env.NODE_ENV !== \"production\") {\n      if (!state.placement.startsWith('bottom')) {\n        warn('`placement` side must be \"bottom\" when using the `inner`', 'middleware.');\n      }\n    }\n    if (!item) {\n      return {};\n    }\n    const nextArgs = {\n      ...state,\n      ...(await offset(-item.offsetTop - floating.clientTop - rects.reference.height / 2 - item.offsetHeight / 2 - innerOffset).fn(state))\n    };\n    const overflow = await detectOverflow(getArgsWithCustomFloatingHeight(nextArgs, scrollEl.scrollHeight + clientTop + floating.clientTop), detectOverflowOptions);\n    const refOverflow = await detectOverflow(nextArgs, {\n      ...detectOverflowOptions,\n      elementContext: 'reference'\n    });\n    const diffY = max(0, overflow.top);\n    const nextY = nextArgs.y + diffY;\n    const isScrollable = scrollEl.scrollHeight > scrollEl.clientHeight;\n    const rounder = isScrollable ? v => v : round;\n    const maxHeight = rounder(max(0, scrollEl.scrollHeight + (floatingIsBordered && floatingIsScrollEl || scrollElIsBordered ? clientTop * 2 : 0) - diffY - max(0, overflow.bottom)));\n    scrollEl.style.maxHeight = maxHeight + \"px\";\n    scrollEl.scrollTop = diffY;\n\n    // There is not enough space, fallback to standard anchored positioning\n    if (onFallbackChange) {\n      const shouldFallback = scrollEl.offsetHeight < item.offsetHeight * min(minItemsVisible, listRef.current.length) - 1 || refOverflow.top >= -referenceOverflowThreshold || refOverflow.bottom >= -referenceOverflowThreshold;\n      ReactDOM.flushSync(() => onFallbackChange(shouldFallback));\n    }\n    if (overflowRef) {\n      overflowRef.current = await detectOverflow(getArgsWithCustomFloatingHeight({\n        ...nextArgs,\n        y: nextY\n      }, scrollEl.offsetHeight + clientTop + floating.clientTop), 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 * @deprecated\n */\nfunction useInnerOffset(context, props) {\n  const {\n    open,\n    elements\n  } = context;\n  const {\n    enabled = true,\n    overflowRef,\n    scrollRef,\n    onChange: unstable_onChange\n  } = props;\n  const onChange = useEffectEvent(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) return;\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        ReactDOM.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  const floating = React.useMemo(() => ({\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          ReactDOM.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  }), [elements.floating, onChange, overflowRef, scrollRef]);\n  return React.useMemo(() => enabled ? {\n    floating\n  } : {}, [enabled, floating]);\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}\n/**\n * Generates a safe polygon area that the user can traverse without closing the\n * floating element once leaving the reference element.\n * @see https://floating-ui.com/docs/useHover#safepolygon\n */\nfunction safePolygon(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    buffer = 0.5,\n    blockPointerEvents = false,\n    requireIntent = true\n  } = options;\n  let timeoutId;\n  let hasLanded = false;\n  let lastX = null;\n  let lastY = null;\n  let lastCursorTime = performance.now();\n  function getCursorSpeed(x, y) {\n    const currentTime = performance.now();\n    const elapsedTime = currentTime - lastCursorTime;\n    if (lastX === null || lastY === null || elapsedTime === 0) {\n      lastX = x;\n      lastY = y;\n      lastCursorTime = currentTime;\n      return null;\n    }\n    const deltaX = x - lastX;\n    const deltaY = y - lastY;\n    const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);\n    const speed = distance / elapsedTime; // px / ms\n\n    lastX = x;\n    lastY = y;\n    lastCursorTime = currentTime;\n    return speed;\n  }\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      const isFloatingWider = rect.width > refRect.width;\n      const isFloatingTaller = rect.height > refRect.height;\n      const left = (isFloatingWider ? refRect : rect).left;\n      const right = (isFloatingWider ? refRect : rect).right;\n      const top = (isFloatingTaller ? refRect : rect).top;\n      const bottom = (isFloatingTaller ? refRect : rect).bottom;\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 = [[left, refRect.top + 1], [left, rect.bottom - 1], [right, rect.bottom - 1], [right, refRect.top + 1]];\n          break;\n        case 'bottom':\n          rectPoly = [[left, rect.top + 1], [left, refRect.bottom - 1], [right, refRect.bottom - 1], [right, rect.top + 1]];\n          break;\n        case 'left':\n          rectPoly = [[rect.right - 1, bottom], [rect.right - 1, top], [refRect.left + 1, top], [refRect.left + 1, bottom]];\n          break;\n        case 'right':\n          rectPoly = [[refRect.right - 1, bottom], [refRect.right - 1, top], [rect.left + 1, top], [rect.left + 1, bottom]];\n          break;\n      }\n      function getPolygon(_ref3) {\n        let [x, y] = _ref3;\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      if (isPointInPolygon([clientX, clientY], rectPoly)) {\n        return;\n      }\n      if (hasLanded && !isOverReferenceRect) {\n        return close();\n      }\n      if (!isLeave && requireIntent) {\n        const cursorSpeed = getCursorSpeed(event.clientX, event.clientY);\n        const cursorSpeedThreshold = 0.1;\n        if (cursorSpeed !== null && cursorSpeed < cursorSpeedThreshold) {\n          return close();\n        }\n      }\n      if (!isPointInPolygon([clientX, clientY], getPolygon([x, y]))) {\n        close();\n      } else if (!hasLanded && requireIntent) {\n        timeoutId = window.setTimeout(close, 40);\n      }\n    };\n  };\n  fn.__options = {\n    blockPointerEvents\n  };\n  return fn;\n}\n\nexport { Composite, CompositeItem, FloatingArrow, FloatingDelayGroup, FloatingFocusManager, FloatingList, FloatingNode, FloatingOverlay, FloatingPortal, FloatingTree, inner, safePolygon, useClick, useClientPoint, useDelayGroup, useDelayGroupContext, useDismiss, useFloating, useFloatingNodeId, useFloatingParentNodeId, useFloatingPortalNode, useFloatingRootContext, useFloatingTree, useFocus, useHover, useId, useInnerOffset, useInteractions, useListItem, useListNavigation, useMergeRefs, useRole, useTransitionStatus, useTransitionStyles, useTypeahead };\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  // https://drafts.csswg.org/css-transforms-2/#individual-transforms\n  return ['transform', 'translate', 'scale', 'rotate', 'perspective'].some(value => css[value] ? css[value] !== 'none' : false) || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'translate', 'scale', 'rotate', '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","/**\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"],"names":["activeElement","doc","_activeElement","shadowRoot","contains","parent","child","rootNode","getRootNode","isShadowRoot","next","parentNode","host","getPlatform","uaData","navigator","userAgentData","platform","getUserAgent","Array","isArray","brands","map","_ref","brand","version","join","userAgent","isVirtualClick","event","mozInputSource","isTrusted","isAndroid","pointerType","type","buttons","detail","isVirtualPointerEvent","includes","width","height","pressure","isSafari","test","vendor","re","isMouseLikePointerType","strict","values","push","undefined","getDocument","node","ownerDocument","document","isEventTargetWithin","composedPath","e","target","getTarget","TYPEABLE_SELECTOR","isTypeableElement","element","isHTMLElement","matches","stopEvent","preventDefault","stopPropagation","isTypeableCombobox","getAttribute","index","useLayoutEffect","useEffect","deepEqual","a","b","toString","length","i","keys","Object","hasOwnProperty","call","key","$$typeof","getDPR","window","defaultView","devicePixelRatio","roundByDPR","value","dpr","Math","round","useLatestRef","ref","React","current","offset","options","deps","_objectSpread","offset$1","shift","shift$1","limitShift","limitShift$1","flip","flip$1","size","size$1","autoPlacement","autoPlacement$1","hide","hide$1","inline","inline$1","arrow","name","fn","state","padding","arrow$2","arrow$1","useMergeRefs","refs","every","forEach","SafeReact","useSafeInsertionEffect","useInsertionEffect","useEffectEvent","callback","process","_len","arguments","args","_key","ARROW_UP","ARROW_DOWN","ARROW_LEFT","ARROW_RIGHT","isDifferentRow","cols","prevRow","floor","isIndexOutOfBounds","listRef","getMinIndex","disabledIndices","findNonDisabledIndex","getMaxIndex","decrement","startingIndex","_temp","amount","list","isDisabled","getGridNavigatedIndex","elementsRef","orientation","loop","rtl","minIndex","maxIndex","prevIndex","stop","nextIndex","col","maxCol","lastRow","buildCellMap","sizes","dense","cellMap","startIndex","_ref2","itemPlaced","targetCells","j","cell","getCellIndexOfCorner","corner","firstCellIndex","indexOf","sizeItem","lastIndexOf","getCellIndices","indices","flatMap","cellIndex","hasAttribute","sortByDocumentPosition","position","compareDocumentPosition","Node","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_PRECEDING","DOCUMENT_POSITION_CONTAINS","FloatingListContext","register","unregister","Map","FloatingList","props","children","labelsRef","setMap","prevMap","set","delete","newMap","from","sort","map1","map2","entries","get","areMapsEqual","jsx","Provider","useListItem","label","index$1","setIndex","componentRef","_node$textContent","isLabelDefined","textContent","renderJsx","render","computedProps","CompositeContext","activeIndex","onNavigate","horizontalKeys","verticalKeys","allKeys","Composite","forwardedRef","externalActiveIndex","externalSetActiveIndex","itemSizes","domProps","_objectWithoutProperties","_excluded","internalActiveIndex","internalSetActiveIndex","renderElementProps","contextValue","isGrid","onKeyDown","horizontalEndKey","horizontalStartKey","minGridIndex","findIndex","maxGridIndex","reduce","foundIndex","maybeNextIndex","itemIndex","_","toEndKeys","horizontal","vertical","both","toStartKeys","preventedKeys","_elementsRef$current$","focus","handleKeyDown","CompositeItem","_excluded2","mergedRef","isActive","tabIndex","onFocus","serverHandoffComplete","count","genId","random","slice","useId","id","setId","FloatingArrow","context","placement","elements","floating","middlewareData","tipRadius","strokeWidth","staticOffset","stroke","d","style","transform","restStyle","_excluded3","rest","_excluded4","clipPathId","isRTL","setIsRTL","getComputedStyle","direction","side","alignment","split","isVerticalSide","computedStaticOffset","x","y","computedStrokeWidth","halfStrokeWidth","svgX","svgY","isCustomShape","yOffsetProp","xOffsetProp","arrowX","arrowY","dValue","rotation","top","left","bottom","right","jsxs","viewBox","pointerEvents","filter","t","clipPath","fill","createPubSub","emit","data","_map$get","handler","on","listener","off","_map$get2","l","FloatingNodeContext","FloatingTreeContext","useFloatingParentNodeId","_React$useContext","useFloatingTree","useFloatingNodeId","customParentId","tree","reactParentId","parentId","addNode","removeNode","FloatingNode","FloatingTree","nodesRef","n","events","createAttribute","useRef","safePolygonIdentifier","getDelay","prop","useHover","open","onOpenChange","dataRef","enabled","delay","handleClose","mouseOnly","restMs","move","handleCloseRef","delayRef","openRef","pointerTypeRef","timeoutRef","handlerRef","restTimeoutRef","blockMouseMoveRef","performedPointerEventsMutationRef","unbindMouseMoveRef","restTimeoutPendingRef","isHoverOpen","_dataRef$current$open","openEvent","clearTimeout","onLeave","html","documentElement","addEventListener","removeEventListener","closeWithDelay","runElseBranch","reason","closeDelay","setTimeout","cleanupMouseMoveHandler","clearPointerEvents","body","removeAttribute","isClickLikeOpenEvent","isElement","domReference","_elements$floating","onScrollMouseLeave","onMouseEnter","once","onMouseLeave","_elements$floating2","openDelay","floatingContext","clientX","clientY","onClose","relatedTarget","_handleCloseRef$curre","__options","blockPointerEvents","floatingEl","_tree$nodesRef$curren","setAttribute","parentFloating","find","reference","setPointerRef","onPointerDown","onPointerEnter","onMouseMove","nativeEvent","handleMouseMove","movementX","movementY","NOOP","FloatingDelayGroupContext","initialDelay","timeoutMs","currentId","setCurrentId","setState","isInstantPhase","useDelayGroupContext","FloatingDelayGroup","prev","initialCurrentIdRef","useDelayGroup","floatingId","optionId","groupContext","close","unset","timeout","rafId","enqueueFocus","el","preventScroll","cancelPrevious","sync","cancelAnimationFrame","exec","requestAnimationFrame","getAncestors","nodes","_nodes$find","allAncestors","currentParentId","currentNode","concat","getChildren","allChildren","_node$context","currentChildren","_currentChildren","some","_node$context2","counterMap","WeakMap","uncontrolledElementsSet","WeakSet","markerMap","lockCount$1","supportsInert","HTMLElement","prototype","unwrapHost","correctElements","targets","correctedTarget","markOthers","avoidElements","ariaHidden","inert","uncorrectedAvoidElements","markerName","controlAttribute","elementsToKeep","Set","elementsToStop","hiddenElements","markerCounter","keep","has","add","deep","getNodeName","attr","alreadyHidden","currentCounterValue","counterValue","markerValue","clear","applyAttributeToOthers","querySelectorAll","getTabbableOptions","getShadowRoot","displayCheck","ResizeObserver","getTabbableIn","container","allTabbable","tabbable","reverse","getNextTabbable","getPreviousTabbable","isOutsideEvent","containerElement","currentTarget","disableFocusInside","dataset","tabindex","enableFocusInside","HIDDEN_STYLES","border","clip","margin","overflow","whiteSpace","setActiveElementOnTab","timeoutId","FocusGuard","role","setRole","restProps","PortalContext","useFloatingPortalNode","root","uniqueId","portalContext","usePortalContext","portalNode","setPortalNode","portalNodeRef","remove","queueMicrotask","existingIdRoot","getElementById","subRoot","createElement","appendChild","idWrapper","FloatingPortal","preserveTabOrder","focusManagerState","setFocusManagerState","beforeOutsideRef","afterOutsideRef","beforeInsideRef","afterInsideRef","modal","shouldRenderGuards","_beforeInsideRef$curr","prevTabbable","ReactDOM","_afterInsideRef$curre","nextTabbable","closeOnFocusOut","FOCUSABLE_ATTRIBUTE","getFloatingFocusElement","floatingElement","querySelector","LIST_LIMIT","previouslyFocusedElements","addPreviouslyFocusedElement","isConnected","getPreviouslyFocusedElement","VisuallyHiddenDismiss","FloatingFocusManager","disabled","order","guards","_guards","initialFocus","returnFocus","restoreFocus","visuallyHiddenDismiss","outsideElementsInert","getNodeId","_dataRef$current$floa","nodeId","ignoreInitialFocus","isUntrappedTypeableCombobox","inertSupported","useInert","orderRef","initialFocusRef","returnFocusRef","startDismissButtonRef","endDismissButtonRef","preventReturnFocusRef","isPointerDownRef","tabbableIndexRef","isInsidePortal","floatingFocusElement","getTabbableContent","getTabbableElements","content","Boolean","flat","els","shiftKey","handleFocusIn","tabbableIndex","handleFocusOutside","handlePointerDown","movedToUnrelatedNode","_node$context3","_node$context4","_node$context5","prevTabbableIndex","tabbableContent","nodeToFocus","beforeGuardRef","afterGuardRef","mergedBeforeGuardRef","mergedAfterGuardRef","renderDismissButton","location","onClick","_portalContext$portal","portalNodes","ancestorFloatingNodes","_node$context6","insideElements","cleanup","previouslyFocusedElement","focusableElements","initialFocusValue","elToFocus","focusAlreadyInsideFloatingEl","preventReturnFocusScroll","nested","fallbackEl","assign","insertAdjacentElement","activeEl","isFocusInsideFloatingTree","_node$context7","returnElement","tabbableReturnElement","tabbableOptions","isTabbable","getFirstTabbableElement","MutationObserver","handleMutation","observer","observe","childList","subtree","attributes","disconnect","Fragment","_portalContext$before","_portalContext$afterO","lockCount","FloatingOverlay","lockScroll","_excluded5","isIOS","bodyStyle","paddingProp","getBoundingClientRect","scrollLeft","scrollbarWidth","innerWidth","clientWidth","scrollX","parseFloat","scrollY","_window$visualViewpor","_window$visualViewpor2","offsetLeft","visualViewport","offsetTop","scrollTo","enableScrollLock","isButtonTarget","tagName","isSpaceIgnored","useClick","eventOption","toggle","ignoreMouse","keyboardHandlers","stickIfOpen","didKeyDownRef","onMouseDown","button","defaultPrevented","onKeyUp","isMouseBasedEvent","useClientPoint","axis","initialRef","cleanupListenerRef","setPointerType","reactive","setReactive","setReference","setPositionReference","domElement","offsetX","offsetY","isAutoUpdateEvent","contextElement","_data$dataRef$current","domRect","isXAxis","isYAxis","canTrackCursorOnAutoUpdate","createVirtualElement","handleReferenceEnterOrMove","openCheck","addListener","win","getWindow","setPointerTypeRef","bubbleHandlerKeys","pointerdown","mousedown","click","captureHandlerKeys","normalizeProp","normalizable","_normalizable$escapeK","_normalizable$outside","escapeKey","outsidePress","useDismiss","unstable_outsidePress","outsidePressEvent","referencePress","referencePressEvent","ancestorScroll","bubbles","capture","outsidePressFn","insideReactTreeRef","endedOrStartedInsideRef","escapeKeyBubbles","outsidePressBubbles","escapeKeyCapture","outsidePressCapture","isComposingRef","closeOnEscapeKeyDown","shouldDismiss","_child$context","__escapeKeyBubbles","isReactEvent","closeOnEscapeKeyDownCapture","_getTarget2","_getTarget","closeOnPressOutside","_dataRef$current$floa2","insideReactTree","endedOrStartedInside","inertSelector","markers","targetRootAncestor","isLastTraversableNode","nextParent","getParentNode","marker","lastTraversableNode","scrollRe","isScrollableX","overflowX","isScrollableY","overflowY","canScrollX","scrollWidth","canScrollY","clientHeight","scrollHeight","pressedVerticalScrollbar","offsetWidth","pressedHorizontalScrollbar","targetIsInsideChildren","_child$context2","__outsidePressBubbles","closeOnPressOutsideCapture","_getTarget4","_getTarget3","compositionTimeout","onScroll","handleCompositionStart","handleCompositionEnd","isWebKit","ancestors","getOverflowAncestors","ancestor","_doc$defaultView","passive","onMouseUp","useFloatingRootContext","onOpenChangeProp","elementsProp","positionReference","useFloating","internalRootContext","rootContext","computedElements","_domReference","setDomReference","_setPositionReference","domReferenceRef","strategy","middleware","externalReference","externalFloating","whileElementsMounted","setData","isPositioned","latestMiddleware","setLatestMiddleware","_reference","_setReference","_floating","_setFloating","referenceRef","setFloating","floatingRef","referenceEl","hasWhileElementsMounted","whileElementsMountedRef","platformRef","update","config","computePosition","then","fullData","isMountedRef","floatingStyles","initialStyles","willChange","useFloating$1","computedPositionReference","useFocus","visibleOnly","blockFocusRef","keyboardModalityRef","onBlur","toLowerCase","startsWith","maxTouchPoints","Error","movedToFocusGuard","ACTIVE_KEY","SELECTED_KEY","mergeProps","userProps","propsList","elementKey","isItem","domUserProps","__","_toPropertyKey","propsOrGetProps","acc","val","useInteractions","referenceDeps","floatingDeps","itemDeps","item","getReferenceProps","getFloatingProps","getItemProps","doSwitch","isMainOrientationKey","isMainOrientationToEndKey","isCrossOrientationCloseKey","useListNavigation","unstable_onNavigate","selectedIndex","allowEscape","virtual","focusItemOnOpen","focusItemOnHover","openOnArrowKeyDown","scrollItemIntoView","virtualItemRef","floatingFocusElementRef","indexRef","typeableComboboxReference","focusItemOnOpenRef","keyRef","isPointerModalityRef","previousOnNavigateRef","previousMountedRef","previousOpenRef","forceSyncFocusRef","forceScrollIntoViewRef","disabledIndicesRef","latestOpenRef","scrollItemIntoViewRef","selectedIndexRef","activeId","setActiveId","virtualId","setVirtualId","focusItem","runFocus","initialItem","v","waitedItem","scrollIntoViewOptions","scrollIntoView","block","runs","waitForListPopulated","treeContainsActiveEl","handleVirtualFocus","hasActiveIndex","syncCurrentTarget","_ref3","onPointerLeave","_ref4","_floatingFocusElement","commonOnKeyDown","which","currentIndex","min","max","ariaActiveDescendantProp","onPointerMove","checkVirtualMouse","checkVirtualPointer","isArrowKey","isHomeOrEndKey","isMoveKey","isCrossOpenKey","isCrossOrientationOpenKey","isCrossCloseKey","isMainKey","isNavigationKey","trim","deepestNode","deepestNodeId","maxDepth","findDeepest","depth","getDeepestNode","eventObject","KeyboardEvent","_deepestNode$context","_deepestNode$context2","isCurrentTarget","dispatchItem","dispatchEvent","_deepestNode$context$","componentRoleToAriaRoleMap","useRole","_componentRoleToAriaR","ariaRole","referenceId","isNested","floatingProps","active","selected","commonProps","camelCaseToKebabCase","str","replace","$","ofs","execWithArgsOrReturn","valueOrFn","useTransitionStatus","duration","closeDuration","status","setStatus","isMounted","durationMs","setIsMounted","useDelayUnmount","frame","useTransitionStyles","initial","unstable_initial","opacity","unstable_open","unstable_close","common","unstable_common","fnArgs","isNumberDuration","openDuration","styles","setStyles","closeRef","commonRef","closeStyles","commonStyles","openStyles","transitionProperty","transitionDuration","useTypeahead","onMatch","unstable_onMatch","onTypingChange","unstable_onTypingChange","findMatch","resetMs","ignoreKeys","timeoutIdRef","stringRef","prevIndexRef","matchIndexRef","findMatchRef","ignoreKeysRef","setTypingChange","typing","getMatchingIndex","orderedList","string","text","toLocaleLowerCase","listContent","ctrlKey","metaKey","altKey","_text$","_text$2","getArgsWithCustomFloatingHeight","rects","inner","_evaluate","evaluate","overflowRef","onFallbackChange","innerOffset","minItemsVisible","referenceOverflowThreshold","scrollRef","detectOverflowOptions","_excluded6","scrollEl","clientTop","floatingIsBordered","scrollElIsBordered","floatingIsScrollEl","nextArgs","offsetHeight","detectOverflow","refOverflow","elementContext","diffY","nextY","maxHeight","scrollTop","shouldFallback","useInnerOffset","onChange","unstable_onChange","controlledScrollingRef","prevScrollTopRef","initialOverflowRef","onWheel","dY","deltaY","isAtTop","isAtBottom","remainingScroll","sign","method","scrollDiff","isPointInPolygon","point","polygon","isInside","xi","yi","xj","yj","safePolygon","buffer","requireIntent","hasLanded","lastX","lastY","lastCursorTime","performance","now","clientPoint","isLeave","isOverFloatingEl","isOverReferenceEl","refRect","rect","cursorLeaveFromRight","cursorLeaveFromBottom","isOverReferenceRect","isFloatingWider","isFloatingTaller","rectPoly","cursorSpeed","currentTime","elapsedTime","deltaX","distance","sqrt","getCursorSpeed","cursorPointOne","cursorPointTwo","getPolygon","hasWindow","isNode","nodeName","_node$ownerDocument","getDocumentElement","Element","ShadowRoot","isOverflowElement","display","isTableElement","isTopLayer","selector","isContainingBlock","elementOrCss","webkit","css","containerType","backdropFilter","contain","getContainingBlock","CSS","supports","getNodeScroll","result","assignedSlot","getNearestOverflowAncestor","traverseIframes","_node$ownerDocument2","scrollableAncestor","isBody","frameElement","getFrameElement","getPrototypeOf","sides","alignments","placements","createCoords","oppositeSideMap","oppositeAlignmentMap","start","end","clamp","param","getSide","getAlignment","getOppositeAxis","getAxisLength","getSideAxis","getAlignmentAxis","getAlignmentSides","alignmentAxis","mainAlignmentSide","getOppositePlacement","getExpandedPlacements","oppositePlacement","getOppositeAlignmentPlacement","getOppositeAxisPlacements","flipAlignment","isStart","lr","rl","tb","bt","getSideList","getPaddingObject","expandPaddingObject","rectToClientRect"],"sourceRoot":""}