{"version":3,"file":"26770aaf-49c43cc009c021f1ca36.js","mappings":"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","sources":["webpack://iwhi-join-web/./node_modules/@floating-ui/react/dist/floating-ui.react.esm.js"],"sourcesContent":["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 { 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};\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}\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}\nvar index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\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__*/React.createElement(FloatingListContext.Provider, {\n    value: React.useMemo(() => ({\n      register,\n      unregister,\n      map,\n      elementsRef,\n      labelsRef\n    }), [register, unregister, map, elementsRef, labelsRef])\n  }, children);\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}\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__*/React.createElement(\"div\", computedProps);\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__*/React.createElement(CompositeContext.Provider, {\n    value: contextValue\n  }, /*#__PURE__*/React.createElement(FloatingList, {\n    elementsRef: elementsRef\n  }, renderJsx(render, computedProps)));\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});\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\nlet serverHandoffComplete = false;\nlet count = 0;\nconst genId = () =>\n// 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;\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__*/React.createElement(\"svg\", _extends({}, 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  }), computedStrokeWidth > 0 && /*#__PURE__*/React.createElement(\"path\", {\n    clipPath: \"url(#\" + clipPathId + \")\",\n    fill: \"none\",\n    stroke: stroke\n    // Account for the stroke on the fill path rendered below.\n    ,\n\n    strokeWidth: computedStrokeWidth + (d ? 0 : 1),\n    d: dValue\n  }), /*#__PURE__*/React.createElement(\"path\", {\n    stroke: computedStrokeWidth && !d ? rest.fill : 'none',\n    d: dValue\n  }), /*#__PURE__*/React.createElement(\"clipPath\", {\n    id: clipPathId\n  }, /*#__PURE__*/React.createElement(\"rect\", {\n    x: -halfStrokeWidth,\n    y: halfStrokeWidth * (isCustomShape ? -1 : 1),\n    width: width + computedStrokeWidth,\n    height: width\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}\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    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__*/React.createElement(FloatingNodeContext.Provider, {\n    value: React.useMemo(() => ({\n      id,\n      parentId\n    }), [id, parentId])\n  }, children);\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__*/React.createElement(FloatingTreeContext.Provider, {\n    value: React.useMemo(() => ({\n      nodesRef,\n      addNode,\n      removeNode,\n      events\n    }), [addNode, removeNode, events])\n  }, children);\n}\nfunction createAttribute(name) {\n  return \"data-floating-ui-\" + name;\n}\nfunction useLatestRef(value) {\n  const ref = useRef(value);\n  index(() => {\n    ref.current = value;\n  });\n  return ref;\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}\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__*/React.createElement(FloatingDelayGroupContext.Provider, {\n    value: React.useMemo(() => ({\n      ...state,\n      setState,\n      setCurrentId\n    }), [state, setCurrentId])\n  }, children);\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}\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}\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}\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 counterValue = (counterMap.get(node) || 0) + 1;\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 counterValue = (counterMap.get(element) || 0) - 1;\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}\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\n// See Diego Haz's Sandbox for making this logic work well on Safari/iOS:\n// https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/FocusTrap.tsx\n\nconst HIDDEN_STYLES = {\n  border: 0,\n  clip: 'rect(0 0 0 0)',\n  height: '1px',\n  margin: '-1px',\n  overflow: 'hidden',\n  padding: 0,\n  position: 'fixed',\n  whiteSpace: 'nowrap',\n  width: '1px',\n  top: 0,\n  left: 0\n};\nlet 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__*/React.createElement(\"span\", _extends({}, props, restProps));\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__*/React.createElement(PortalContext.Provider, {\n    value: React.useMemo(() => ({\n      preserveTabOrder,\n      beforeOutsideRef,\n      afterOutsideRef,\n      beforeInsideRef,\n      afterInsideRef,\n      portalNode,\n      setFocusManagerState\n    }), [preserveTabOrder, portalNode])\n  }, shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"outside\",\n    ref: beforeOutsideRef,\n    onFocus: event => {\n      if (isOutsideEvent(event, portalNode)) {\n        var _beforeInsideRef$curr;\n        (_beforeInsideRef$curr = beforeInsideRef.current) == null || _beforeInsideRef$curr.focus();\n      } else {\n        const prevTabbable = getPreviousTabbable() || (focusManagerState == null ? void 0 : focusManagerState.refs.domReference.current);\n        prevTabbable == null || prevTabbable.focus();\n      }\n    }\n  }), shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(\"span\", {\n    \"aria-owns\": portalNode.id,\n    style: HIDDEN_STYLES\n  }), portalNode && /*#__PURE__*/ReactDOM.createPortal(children, portalNode), shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"outside\",\n    ref: afterOutsideRef,\n    onFocus: event => {\n      if (isOutsideEvent(event, portalNode)) {\n        var _afterInsideRef$curre;\n        (_afterInsideRef$curre = afterInsideRef.current) == null || _afterInsideRef$curre.focus();\n      } else {\n        const nextTabbable = getNextTabbable() || (focusManagerState == null ? void 0 : focusManagerState.refs.domReference.current);\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}\nconst usePortalContext = () => React.useContext(PortalContext);\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}\nconst LIST_LIMIT = 20;\nlet previouslyFocusedElements = [];\nfunction addPreviouslyFocusedElement(element) {\n  previouslyFocusedElements = previouslyFocusedElements.filter(el => el.isConnected);\n  let tabbableEl = element;\n  if (!tabbableEl || getNodeName(tabbableEl) === 'body') return;\n  if (!isTabbable(tabbableEl, getTabbableOptions())) {\n    const tabbableChild = tabbable(tabbableEl, getTabbableOptions())[0];\n    if (tabbableChild) {\n      tabbableEl = tabbableChild;\n    }\n  }\n  previouslyFocusedElements.push(tabbableEl);\n  if (previouslyFocusedElements.length > LIST_LIMIT) {\n    previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);\n  }\n}\nfunction getPreviouslyFocusedElement() {\n  return previouslyFocusedElements.slice().reverse().find(el => el.isConnected);\n}\nconst VisuallyHiddenDismiss = /*#__PURE__*/React.forwardRef(function VisuallyHiddenDismiss(props, ref) {\n  return /*#__PURE__*/React.createElement(\"button\", _extends({}, props, {\n    type: \"button\",\n    ref: ref,\n    tabIndex: -1,\n    style: HIDDEN_STYLES\n  }));\n});\n/**\n * Provides focus management for the floating element.\n * @see https://floating-ui.com/docs/FloatingFocusManager\n */\nfunction FloatingFocusManager(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  } = props;\n  const {\n    open,\n    refs,\n    nodeId,\n    onOpenChange,\n    events,\n    dataRef,\n    floatingId,\n    elements: {\n      domReference,\n      floating\n    }\n  } = context;\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 guards = supportsInert() ? _guards : true;\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 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;\n          return ((_node$context3 = node.context) == null ? void 0 : _node$context3.elements.floating) === relatedTarget || ((_node$context4 = node.context) == null ? void 0 : _node$context4.elements.domReference) === relatedTarget;\n        })));\n\n        // 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, nodeId, tree, portalContext, onOpenChange, closeOnFocusOut, restoreFocus, getTabbableContent, isUntrappedTypeableCombobox]);\n  React.useEffect(() => {\n    var _portalContext$portal;\n    if (disabled) 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    if (floating) {\n      const insideElements = [floating, ...portalNodes, startDismissButtonRef.current, endDismissButtonRef.current, orderRef.current.includes('reference') || isUntrappedTypeableCombobox ? domReference : null].filter(x => x != null);\n      const cleanup = modal || isUntrappedTypeableCombobox ? markOthers(insideElements, guards, !guards) : markOthers(insideElements);\n      return () => {\n        cleanup();\n      };\n    }\n  }, [disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, guards]);\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' && refs.domReference.current) {\n        addPreviouslyFocusedElement(refs.domReference.current);\n      }\n      if (reason === 'hover' && 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, nodeId).some(node => {\n        var _node$context5;\n        return contains((_node$context5 = node.context) == null ? void 0 : _node$context5.elements.floating, activeEl);\n      });\n      const shouldFocusReference = isFocusInsideFloatingTree || openEvent && ['click', 'mousedown'].includes(openEvent.type);\n      if (shouldFocusReference && refs.domReference.current) {\n        addPreviouslyFocusedElement(refs.domReference.current);\n      }\n      const returnElement = getReturnElement();\n      queueMicrotask(() => {\n        if (\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n        returnFocusRef.current && !preventReturnFocusRef.current && isHTMLElement(returnElement) && (\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        returnElement !== activeEl && activeEl !== doc.body ? isFocusInsideFloatingTree : true)) {\n          returnElement.focus({\n            preventScroll: preventReturnFocusScroll\n          });\n        }\n        fallbackEl.remove();\n      });\n    };\n  }, [disabled, floating, floatingFocusElement, returnFocusRef, dataRef, refs, events, tree, nodeId, isInsidePortal, domReference]);\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      refs\n    });\n    return () => {\n      portalContext.setFocusManagerState(null);\n    };\n  }, [disabled, portalContext, modal, open, onOpenChange, refs, closeOnFocusOut]);\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 !== refs.domReference.current && 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, refs, orderRef, getTabbableContent, ignoreInitialFocus]);\n  function renderDismissButton(location) {\n    if (disabled || !visuallyHiddenDismiss || !modal) {\n      return null;\n    }\n    return /*#__PURE__*/React.createElement(VisuallyHiddenDismiss, {\n      ref: location === 'start' ? startDismissButtonRef : endDismissButtonRef,\n      onClick: event => onOpenChange(false, event.nativeEvent)\n    }, typeof visuallyHiddenDismiss === 'string' ? visuallyHiddenDismiss : 'Dismiss');\n  }\n  const shouldRenderGuards = !disabled && guards && (modal ? !isUntrappedTypeableCombobox : true) && (isInsidePortal || modal);\n  return /*#__PURE__*/React.createElement(React.Fragment, null, shouldRenderGuards && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"inside\",\n    ref: portalContext == null ? void 0 : portalContext.beforeInsideRef,\n    onFocus: event => {\n      if (modal) {\n        const els = getTabbableElements();\n        enqueueFocus(order[0] === 'reference' ? els[0] : els[els.length - 1]);\n      } else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {\n        preventReturnFocusRef.current = false;\n        if (isOutsideEvent(event, portalContext.portalNode)) {\n          const nextTabbable = getNextTabbable() || domReference;\n          nextTabbable == null || 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__*/React.createElement(FocusGuard, {\n    \"data-type\": \"inside\",\n    ref: portalContext == null ? void 0 : portalContext.afterInsideRef,\n    onFocus: event => {\n      if (modal) {\n        enqueueFocus(getTabbableElements()[0]);\n      } else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {\n        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}\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__*/React.createElement(\"div\", _extends({\n    ref: ref\n  }, rest, {\n    style: {\n      position: 'fixed',\n      overflow: 'auto',\n      top: 0,\n      right: 0,\n      bottom: 0,\n      left: 0,\n      ...rest.style\n    }\n  }));\n});\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}\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}\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      // In Firefox, `target.scrollWidth > target.clientWidth` for inline\n      // elements.\n      const canScrollX = target.clientWidth > 0 && target.scrollWidth > target.clientWidth;\n      const canScrollY = target.clientHeight > 0 && target.scrollHeight > target.clientHeight;\n      let xCond = canScrollY && event.offsetX > target.clientWidth;\n\n      // In some browsers it is possible to change the <body> (or window)\n      // scrollbar to the left side, but is very rare and is difficult to\n      // check for. Plus, for modal dialogs with backdrops, it is more\n      // important that the backdrop is checked but not so much the window.\n      if (canScrollY) {\n        const isRTL = getComputedStyle(target).direction === 'rtl';\n        if (isRTL) {\n          xCond = event.offsetX <= target.offsetWidth - target.clientWidth;\n        }\n      }\n      if (xCond || canScrollX && event.offsetY > target.clientHeight) {\n        return;\n      }\n    }\n    const 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    [bubbleHandlerKeys[referencePressEvent]]: event => {\n      if (referencePress) {\n        onOpenChange(false, event.nativeEvent, 'reference-press');\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}\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}\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}\nlet isPreventScrollSupported = false;\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(unstable_onNavigate);\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 forceSyncFocus = React.useRef(false);\n  const forceScrollIntoViewRef = React.useRef(false);\n  const disabledIndicesRef = useLatestRef(disabledIndices);\n  const latestOpenRef = useLatestRef(open);\n  const scrollItemIntoViewRef = useLatestRef(scrollItemIntoView);\n  const selectedIndexRef = useLatestRef(selectedIndex);\n  const [activeId, setActiveId] = React.useState();\n  const [virtualId, setVirtualId] = React.useState();\n  const focusItem = useEffectEvent(function (listRef, indexRef, forceScrollIntoView) {\n    if (forceScrollIntoView === void 0) {\n      forceScrollIntoView = false;\n    }\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          preventScroll: true,\n          // Mac Safari does not move the virtual cursor unless the focus call\n          // is sync. However, for the very first focus call, we need to wait\n          // for the position to be ready in order to prevent unwanted\n          // scrolling. This means the virtual cursor will not move to the first\n          // item when first opening the floating element, but will on\n          // subsequent calls. `preventScroll` is supported in modern Safari,\n          // so we can use that instead.\n          // iOS Safari must be async or the first item will not be focused.\n          sync: isMac() && isSafari() ? isPreventScrollSupported || forceSyncFocus.current : false\n        });\n      }\n    }\n    const initialItem = listRef.current[indexRef.current];\n    if (initialItem) {\n      runFocus(initialItem);\n    }\n    requestAnimationFrame(() => {\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 && (forceScrollIntoView || !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  index(() => {\n    document.createElement('div').focus({\n      get preventScroll() {\n        isPreventScrollSupported = true;\n        return false;\n      }\n    });\n  }, []);\n\n  // Sync `selectedIndex` to be the `activeIndex` upon opening the floating\n  // element. Also, reset `activeIndex` upon closing the floating element.\n  index(() => {\n    if (!enabled) 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(selectedIndex);\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(null);\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 && elements.floating) {\n      if (activeIndex == null) {\n        forceSyncFocus.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(listRef, indexRef);\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(indexRef.current);\n            }\n          };\n          waitForListPopulated();\n        }\n      } else if (!isIndexOutOfBounds(listRef, activeIndex)) {\n        indexRef.current = activeIndex;\n        focusItem(listRef, indexRef, forceScrollIntoViewRef.current);\n        forceScrollIntoViewRef.current = false;\n      }\n    }\n  }, [enabled, open, 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    previousMountedRef.current = !!elements.floating;\n  });\n  index(() => {\n    if (!open) {\n      keyRef.current = null;\n    }\n  }, [open]);\n  index(() => {\n    previousOpenRef.current = open;\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) {\n        onNavigate(index);\n      }\n    }\n    const props = {\n      onFocus(_ref) {\n        let {\n          currentTarget\n        } = _ref;\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          syncCurrentTarget(currentTarget);\n        },\n        onPointerLeave(_ref4) {\n          let {\n            pointerType\n          } = _ref4;\n          if (!isPointerModalityRef.current || pointerType === 'touch') {\n            return;\n          }\n          indexRef.current = -1;\n          focusItem(listRef, indexRef);\n          onNavigate(null);\n          if (!virtual) {\n            enqueueFocus(floatingFocusElementRef.current, {\n              preventScroll: true\n            });\n          }\n        }\n      })\n    };\n    return props;\n  }, [open, floatingFocusElementRef, focusItem, focusItemOnHover, listRef, onNavigate, virtual]);\n  const commonOnKeyDown = useEffectEvent(event => {\n    isPointerModalityRef.current = false;\n    forceSyncFocus.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(indexRef.current);\n      }\n      if (event.key === 'End') {\n        stopEvent(event);\n        indexRef.current = maxIndex;\n        onNavigate(indexRef.current);\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(indexRef.current);\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(indexRef.current);\n        return;\n      }\n      if (isMainOrientationToEndKey(event.key, orientation, rtl)) {\n        if (loop) {\n          indexRef.current = currentIndex >= maxIndex ? allowEscape && currentIndex !== listRef.current.length ? -1 : minIndex : findNonDisabledIndex(listRef, {\n            startingIndex: currentIndex,\n            disabledIndices\n          });\n        } else {\n          indexRef.current = Math.min(maxIndex, findNonDisabledIndex(listRef, {\n            startingIndex: currentIndex,\n            disabledIndices\n          }));\n        }\n      } else {\n        if (loop) {\n          indexRef.current = currentIndex <= minIndex ? allowEscape && currentIndex !== -1 ? listRef.current.length : maxIndex : findNonDisabledIndex(listRef, {\n            startingIndex: currentIndex,\n            decrement: true,\n            disabledIndices\n          });\n        } else {\n          indexRef.current = Math.max(minIndex, findNonDisabledIndex(listRef, {\n            startingIndex: currentIndex,\n            decrement: true,\n            disabledIndices\n          }));\n        }\n      }\n      if (isIndexOutOfBounds(listRef, indexRef.current)) {\n        onNavigate(null);\n      } else {\n        onNavigate(indexRef.current);\n      }\n    }\n  });\n  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      ...(!isTypeableCombobox(elements.domReference) && ariaActiveDescendantProp),\n      onKeyDown: commonOnKeyDown,\n      onPointerMove() {\n        isPointerModalityRef.current = true;\n      }\n    };\n  }, [ariaActiveDescendantProp, commonOnKeyDown, elements.domReference, orientation]);\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(indexRef.current);\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(indexRef.current);\n          }\n        }\n      },\n      onFocus() {\n        if (open && !virtual) {\n          onNavigate(null);\n        }\n      },\n      onPointerDown: 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}\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}\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 */\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 */\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}\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}\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 };"],"names":["useMergeRefs","refs","every","ref","value","forEach","current","SafeReact","useSafeInsertionEffect","useInsertionEffect","fn","useEffectEvent","callback","_len","arguments","length","args","Array","_key","ARROW_UP","ARROW_DOWN","ARROW_LEFT","ARROW_RIGHT","isDifferentRow","index","cols","prevRow","Math","floor","isIndexOutOfBounds","listRef","getMinIndex","disabledIndices","findNonDisabledIndex","getMaxIndex","decrement","startingIndex","_temp","amount","list","isDisabled","getGridNavigatedIndex","elementsRef","_ref","event","orientation","loop","rtl","minIndex","maxIndex","prevIndex","stopEvent","stop","nextIndex","key","col","maxCol","offset","lastRow","buildCellMap","sizes","dense","cellMap","startIndex","_ref2","width","height","itemPlaced","targetCells","i","j","push","cell","getCellIndexOfCorner","corner","firstCellIndex","indexOf","sizeItem","lastIndexOf","getCellIndices","indices","flatMap","cellIndex","includes","element","hasAttribute","getAttribute","document","useLayoutEffect","useEffect","sortByDocumentPosition","a","b","position","compareDocumentPosition","Node","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_PRECEDING","DOCUMENT_POSITION_CONTAINS","FloatingListContext","register","unregister","map","Map","FloatingList","props","children","labelsRef","setMap","node","prevMap","set","delete","newMap","from","keys","sort","map1","map2","size","entries","get","areMapsEqual","Provider","useListItem","label","index$1","setIndex","componentRef","_node$textContent","isLabelDefined","undefined","textContent","renderJsx","render","computedProps","CompositeContext","activeIndex","onNavigate","horizontalKeys","verticalKeys","allKeys","Composite","forwardedRef","externalActiveIndex","externalSetActiveIndex","itemSizes","domProps","internalActiveIndex","internalSetActiveIndex","renderElementProps","contextValue","isGrid","onKeyDown","e","horizontalEndKey","horizontalStartKey","minGridIndex","findIndex","maxGridIndex","reduce","foundIndex","maybeNextIndex","itemIndex","_","toEndKeys","horizontal","vertical","both","toStartKeys","preventedKeys","_elementsRef$current$","stopPropagation","preventDefault","focus","handleKeyDown","CompositeItem","mergedRef","isActive","tabIndex","onFocus","_extends","Object","assign","bind","target","source","prototype","hasOwnProperty","call","apply","this","serverHandoffComplete","count","genId","random","toString","slice","useId","id","setId","FloatingArrow","context","placement","elements","floating","middlewareData","arrow","shift","tipRadius","strokeWidth","staticOffset","stroke","d","style","transform","restStyle","rest","clipPathId","isRTL","setIsRTL","direction","side","alignment","split","isVerticalSide","computedStaticOffset","x","y","computedStrokeWidth","halfStrokeWidth","svgX","svgY","isCustomShape","yOffsetProp","xOffsetProp","arrowX","arrowY","dValue","rotation","top","left","bottom","right","viewBox","pointerEvents","filter","t","join","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","name","useLatestRef","useRef","safePolygonIdentifier","getDelay","prop","pointerType","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","type","openEvent","clearTimeout","onLeave","html","documentElement","addEventListener","removeEventListener","closeWithDelay","runElseBranch","reason","closeDelay","window","setTimeout","cleanupMouseMoveHandler","clearPointerEvents","body","removeAttribute","isClickLikeOpenEvent","domReference","_elements$floating","onScrollMouseLeave","onMouseEnter","once","onMouseLeave","_elements$floating2","openDelay","doc","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","state","prev","next","initialCurrentIdRef","useDelayGroup","options","floatingId","optionId","groupContext","close","unset","timeout","rafId","enqueueFocus","el","preventScroll","cancelPrevious","sync","cancelAnimationFrame","exec","requestAnimationFrame","getChildren","nodes","allChildren","_node$context","currentChildren","_currentChildren","some","_node$context2","concat","counterMap","WeakMap","uncontrolledElementsSet","WeakSet","markerMap","lockCount$1","supportsInert","HTMLElement","unwrapHost","host","parentNode","correctElements","parent","targets","contains","correctedTarget","markOthers","avoidElements","ariaHidden","inert","uncorrectedAvoidElements","markerName","controlAttribute","elementsToKeep","Set","elementsToStop","hiddenElements","markerCounter","keep","has","add","deep","attr","alreadyHidden","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","padding","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","_afterInsideRef$curre","nextTabbable","closeOnFocusOut","FOCUSABLE_ATTRIBUTE","getFloatingFocusElement","floatingElement","querySelector","LIST_LIMIT","previouslyFocusedElements","addPreviouslyFocusedElement","isConnected","tabbableEl","isTabbable","tabbableChild","getPreviouslyFocusedElement","VisuallyHiddenDismiss","FloatingFocusManager","disabled","order","guards","_guards","initialFocus","returnFocus","restoreFocus","visuallyHiddenDismiss","nodeId","ignoreInitialFocus","isUntrappedTypeableCombobox","orderRef","initialFocusRef","returnFocusRef","startDismissButtonRef","endDismissButtonRef","preventReturnFocusRef","isPointerDownRef","tabbableIndexRef","isInsidePortal","floatingFocusElement","getTabbableContent","getTabbableElements","content","Boolean","flat","renderDismissButton","location","onClick","els","shiftKey","handleFocusIn","tabbableIndex","handleFocusOutside","handlePointerDown","movedToUnrelatedNode","_nodes$find","allAncestors","currentParentId","currentNode","getAncestors","_node$context3","_node$context4","prevTabbableIndex","tabbableContent","nodeToFocus","_portalContext$portal","portalNodes","insideElements","cleanup","previouslyFocusedElement","focusableElements","initialFocusValue","elToFocus","focusAlreadyInsideFloatingEl","preventReturnFocusScroll","nested","fallbackEl","insertAdjacentElement","activeEl","isFocusInsideFloatingTree","_node$context5","returnElement","MutationObserver","handleMutation","observer","observe","childList","subtree","attributes","disconnect","_portalContext$before","_portalContext$afterO","lockCount","FloatingOverlay","lockScroll","isIOS","test","bodyStyle","paddingProp","round","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","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","_dataRef$current$floa","shouldDismiss","child","_child$context","__escapeKeyBubbles","closeOnEscapeKeyDownCapture","_getTarget2","_getTarget","closeOnPressOutside","_dataRef$current$floa2","insideReactTree","endedOrStartedInside","inertSelector","markers","targetRootAncestor","nextParent","marker","canScrollX","scrollWidth","canScrollY","clientHeight","scrollHeight","xCond","offsetWidth","targetIsInsideChildren","_child$context2","__outsidePressBubbles","closeOnPressOutsideCapture","_getTarget4","_getTarget3","compositionTimeout","onScroll","handleCompositionStart","handleCompositionEnd","ancestors","ancestor","_doc$defaultView","defaultView","passive","onMouseUp","useFloatingRootContext","onOpenChangeProp","elementsProp","positionReference","useFloating","internalRootContext","rootContext","computedElements","_domReference","setDomReference","_setPositionReference","domReferenceRef","computedPositionReference","useFocus","visibleOnly","blockFocusRef","keyboardModalityRef","onBlur","Error","matches","movedToFocusGuard","ownerDocument","ACTIVE_KEY","SELECTED_KEY","mergeProps","userProps","propsList","elementKey","isItem","domUserProps","__","validProps","propsOrGetProps","acc","val","useInteractions","referenceDeps","floatingDeps","itemDeps","item","getReferenceProps","getFloatingProps","getItemProps","isPreventScrollSupported","doSwitch","isMainOrientationKey","isMainOrientationToEndKey","isCrossOrientationCloseKey","useListNavigation","unstable_onNavigate","selectedIndex","allowEscape","virtual","focusItemOnOpen","focusItemOnHover","openOnArrowKeyDown","scrollItemIntoView","virtualItemRef","floatingFocusElementRef","typeableComboboxReference","focusItemOnOpenRef","indexRef","keyRef","isPointerModalityRef","previousOnNavigateRef","previousMountedRef","previousOpenRef","forceSyncFocus","forceScrollIntoViewRef","disabledIndicesRef","latestOpenRef","scrollItemIntoViewRef","selectedIndexRef","activeId","setActiveId","virtualId","setVirtualId","focusItem","forceScrollIntoView","runFocus","initialItem","waitedItem","scrollIntoViewOptions","scrollIntoView","block","inline","runs","waitForListPopulated","treeContainsActiveEl","handleVirtualFocus","hasActiveIndex","syncCurrentTarget","_ref3","onPointerLeave","_ref4","commonOnKeyDown","which","currentIndex","min","max","ariaActiveDescendantProp","onPointerMove","checkVirtualMouse","isArrowKey","startsWith","isHomeOrEndKey","isMoveKey","isCrossOpenKey","isCrossOrientationOpenKey","isCrossCloseKey","isMainKey","isNavigationKey","trim","rootNode","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","toLowerCase","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","initialStyles","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","overflowRef","onFallbackChange","innerOffset","minItemsVisible","referenceOverflowThreshold","scrollRef","detectOverflowOptions","scrollEl","clientTop","floatingIsBordered","scrollElIsBordered","floatingIsScrollEl","nextArgs","offsetHeight","refOverflow","elementContext","diffY","nextY","maxHeight","v","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"],"sourceRoot":""}