{"version":3,"file":"26770aaf-21b7c5dd9ae2e6b525fa.js","mappings":"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","sources":["webpack://keolis-web-passenger/./node_modules/@floating-ui/react/dist/floating-ui.react.esm.js"],"sourcesContent":["import _asyncToGenerator from \"/home/keoadmin/agent/_work/122/s/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js\";\nimport _defineProperty from \"/home/keoadmin/agent/_work/122/s/node_modules/@babel/runtime/helpers/esm/defineProperty.js\";\nimport _toConsumableArray from \"/home/keoadmin/agent/_work/122/s/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js\";\nimport _objectWithoutProperties from \"/home/keoadmin/agent/_work/122/s/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js\";\nimport _slicedToArray from \"/home/keoadmin/agent/_work/122/s/node_modules/@babel/runtime/helpers/esm/slicedToArray.js\";\nvar _excluded = [\"render\", \"orientation\", \"loop\", \"cols\", \"disabledIndices\", \"activeIndex\", \"onNavigate\", \"itemSizes\", \"dense\"],\n  _excluded2 = [\"render\"],\n  _excluded3 = [\"transform\"],\n  _excluded4 = [\"context\", \"width\", \"height\", \"tipRadius\", \"strokeWidth\", \"staticOffset\", \"stroke\", \"d\", \"style\"],\n  _excluded5 = [\"lockScroll\"],\n  _excluded6 = [\"listRef\", \"overflowRef\", \"onFallbackChange\", \"offset\", \"index\", \"minItemsVisible\", \"referenceOverflowThreshold\", \"scrollRef\"];\nimport _regeneratorRuntime from \"/home/keoadmin/agent/_work/122/s/node_modules/@babel/runtime/regenerator/index.js\";\nfunction _toPropertyKey(t) { var i = _toPrimitive(t, \"string\"); return \"symbol\" == typeof i ? i : String(i); }\nfunction _toPrimitive(t, r) { if (\"object\" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || \"default\"); if (\"object\" != typeof i) return i; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (\"string\" === r ? String : Number)(t); }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\nimport \"core-js/modules/es.array.flat-map.js\";\nimport \"core-js/modules/es.array.unscopables.flat-map.js\";\nimport \"core-js/modules/es.array.sort.js\";\nimport \"core-js/modules/es.array.flat.js\";\nimport \"core-js/modules/es.array.unscopables.flat.js\";\nimport * 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 } from '@floating-ui/utils';\nimport { platform, 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';\nimport { isElement, isHTMLElement, getNodeName, getWindow, isLastTraversableNode, getParentNode, getComputedStyle } from '@floating-ui/utils/dom';\nimport { tabbable } from 'tabbable';\nimport { createPortal, flushSync } from '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  // biome-ignore lint/correctness/useExhaustiveDependencies: intentional\n  return React.useMemo(function () {\n    if (refs.every(function (ref) {\n      return ref == null;\n    })) {\n      return null;\n    }\n    return function (value) {\n      refs.forEach(function (ref) {\n        if (typeof ref === 'function') {\n          ref(value);\n        } else if (ref != null) {\n          ref.current = value;\n        }\n      });\n    };\n  }, refs);\n}\n\n// `toString()` prevents bundlers from trying to `import { useInsertionEffect } from 'react'`\nvar useInsertionEffect = React[/*#__PURE__*/'useInsertionEffect'.toString()];\nvar useSafeInsertionEffect = useInsertionEffect || function (fn) {\n  return fn();\n};\nfunction useEffectEvent(callback) {\n  var ref = React.useRef(function () {\n    if (process.env.NODE_ENV !== \"production\") {\n      throw new Error('Cannot call an event handler while rendering.');\n    }\n  });\n  useSafeInsertionEffect(function () {\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.apply(ref, args);\n  }, []);\n}\nvar ARROW_UP = 'ArrowUp';\nvar ARROW_DOWN = 'ArrowDown';\nvar ARROW_LEFT = 'ArrowLeft';\nvar 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: disabledIndices\n  });\n}\nfunction getMaxIndex(listRef, disabledIndices) {\n  return findNonDisabledIndex(listRef, {\n    decrement: true,\n    startingIndex: listRef.current.length,\n    disabledIndices: disabledIndices\n  });\n}\nfunction findNonDisabledIndex(listRef, _temp) {\n  var _ref5 = _temp === void 0 ? {} : _temp,\n    _ref5$startingIndex = _ref5.startingIndex,\n    startingIndex = _ref5$startingIndex === void 0 ? -1 : _ref5$startingIndex,\n    _ref5$decrement = _ref5.decrement,\n    decrement = _ref5$decrement === void 0 ? false : _ref5$decrement,\n    disabledIndices = _ref5.disabledIndices,\n    _ref5$amount = _ref5.amount,\n    amount = _ref5$amount === void 0 ? 1 : _ref5$amount;\n  var list = listRef.current;\n  var isDisabledIndex = disabledIndices ? function (index) {\n    return disabledIndices.includes(index);\n  } : function (index) {\n    var element = list[index];\n    return element == null || element.hasAttribute('disabled') || element.getAttribute('aria-disabled') === 'true';\n  };\n  var index = startingIndex;\n  do {\n    index += decrement ? -amount : amount;\n  } while (index >= 0 && index <= list.length - 1 && isDisabledIndex(index));\n  return index;\n}\nfunction getGridNavigatedIndex(elementsRef, _ref) {\n  var event = _ref.event,\n    orientation = _ref.orientation,\n    loop = _ref.loop,\n    cols = _ref.cols,\n    disabledIndices = _ref.disabledIndices,\n    minIndex = _ref.minIndex,\n    maxIndex = _ref.maxIndex,\n    prevIndex = _ref.prevIndex,\n    _ref$stopEvent = _ref.stopEvent,\n    stop = _ref$stopEvent === void 0 ? false : _ref$stopEvent;\n  var 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: disabledIndices\n      });\n      if (loop && (prevIndex - cols < minIndex || nextIndex < 0)) {\n        var col = prevIndex % cols;\n        var maxCol = maxIndex % cols;\n        var _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: disabledIndices\n      });\n      if (loop && prevIndex + cols > maxIndex) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex % cols - cols,\n          amount: cols,\n          disabledIndices: 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    var prevRow = floor(prevIndex / cols);\n    if (event.key === ARROW_RIGHT) {\n      stop && stopEvent(event);\n      if (prevIndex % cols !== cols - 1) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex,\n          disabledIndices: disabledIndices\n        });\n        if (loop && isDifferentRow(nextIndex, cols, prevRow)) {\n          nextIndex = findNonDisabledIndex(elementsRef, {\n            startingIndex: prevIndex - prevIndex % cols - 1,\n            disabledIndices: disabledIndices\n          });\n        }\n      } else if (loop) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex - prevIndex % cols - 1,\n          disabledIndices: disabledIndices\n        });\n      }\n      if (isDifferentRow(nextIndex, cols, prevRow)) {\n        nextIndex = prevIndex;\n      }\n    }\n    if (event.key === ARROW_LEFT) {\n      stop && stopEvent(event);\n      if (prevIndex % cols !== 0) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex,\n          disabledIndices: disabledIndices,\n          decrement: true\n        });\n        if (loop && isDifferentRow(nextIndex, cols, prevRow)) {\n          nextIndex = findNonDisabledIndex(elementsRef, {\n            startingIndex: prevIndex + (cols - prevIndex % cols),\n            decrement: true,\n            disabledIndices: disabledIndices\n          });\n        }\n      } else if (loop) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex + (cols - prevIndex % cols),\n          decrement: true,\n          disabledIndices: disabledIndices\n        });\n      }\n      if (isDifferentRow(nextIndex, cols, prevRow)) {\n        nextIndex = prevIndex;\n      }\n    }\n    var lastRow = floor(maxIndex / cols) === prevRow;\n    if (isIndexOutOfBounds(elementsRef, nextIndex)) {\n      if (loop && lastRow) {\n        nextIndex = event.key === ARROW_LEFT ? maxIndex : findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex - prevIndex % cols - 1,\n          disabledIndices: 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  var cellMap = [];\n  var startIndex = 0;\n  sizes.forEach(function (_ref2, index) {\n    var width = _ref2.width,\n      height = _ref2.height;\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    var itemPlaced = false;\n    if (dense) {\n      startIndex = 0;\n    }\n    while (!itemPlaced) {\n      var targetCells = [];\n      for (var i = 0; i < width; i++) {\n        for (var j = 0; j < height; j++) {\n          targetCells.push(startIndex + i + j * cols);\n        }\n      }\n      if (startIndex % cols + width <= cols && targetCells.every(function (cell) {\n        return cellMap[cell] == null;\n      })) {\n        targetCells.forEach(function (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 [].concat(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  var firstCellIndex = cellMap.indexOf(index);\n  switch (corner) {\n    case 'tl':\n      return firstCellIndex;\n    case 'tr':\n      return firstCellIndex + sizes[index].width - 1;\n    case 'bl':\n      return firstCellIndex + (sizes[index].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(function (index, cellIndex) {\n    return indices.includes(index) ? [cellIndex] : [];\n  });\n}\nvar rafId = 0;\nfunction enqueueFocus(el, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  var _options = options,\n    _options$preventScrol = _options.preventScroll,\n    preventScroll = _options$preventScrol === void 0 ? false : _options$preventScrol,\n    _options$cancelPrevio = _options.cancelPrevious,\n    cancelPrevious = _options$cancelPrevio === void 0 ? true : _options$cancelPrevio,\n    _options$sync = _options.sync,\n    sync = _options$sync === void 0 ? false : _options$sync;\n  cancelPrevious && cancelAnimationFrame(rafId);\n  var exec = function exec() {\n    return el == null ? void 0 : el.focus({\n      preventScroll: preventScroll\n    });\n  };\n  if (sync) {\n    exec();\n  } else {\n    rafId = requestAnimationFrame(exec);\n  }\n}\nvar index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\nfunction sortByDocumentPosition(a, b) {\n  var 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  var _iterator = _createForOfIteratorHelper(map1.entries()),\n    _step;\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var _step$value = _slicedToArray(_step.value, 2),\n        key = _step$value[0],\n        value = _step$value[1];\n      if (value !== map2.get(key)) {\n        return false;\n      }\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n  return true;\n}\nvar FloatingListContext = /*#__PURE__*/React.createContext({\n  register: function register() {},\n  unregister: function 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(_ref) {\n  var children = _ref.children,\n    elementsRef = _ref.elementsRef,\n    labelsRef = _ref.labelsRef;\n  var _React$useState = React.useState(function () {\n      return new Map();\n    }),\n    _React$useState2 = _slicedToArray(_React$useState, 2),\n    map = _React$useState2[0],\n    setMap = _React$useState2[1];\n  var register = React.useCallback(function (node) {\n    setMap(function (prevMap) {\n      return new Map(prevMap).set(node, null);\n    });\n  }, []);\n  var unregister = React.useCallback(function (node) {\n    setMap(function (prevMap) {\n      var map = new Map(prevMap);\n      map.delete(node);\n      return map;\n    });\n  }, []);\n  index(function () {\n    var newMap = new Map(map);\n    var nodes = Array.from(newMap.keys()).sort(sortByDocumentPosition);\n    nodes.forEach(function (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(function () {\n      return {\n        register: register,\n        unregister: unregister,\n        map: map,\n        elementsRef: elementsRef,\n        labelsRef: labelsRef\n      };\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(_temp) {\n  var _ref6 = _temp === void 0 ? {} : _temp,\n    label = _ref6.label;\n  var _React$useState3 = React.useState(null),\n    _React$useState4 = _slicedToArray(_React$useState3, 2),\n    index$1 = _React$useState4[0],\n    setIndex = _React$useState4[1];\n  var componentRef = React.useRef(null);\n  var _React$useContext2 = React.useContext(FloatingListContext),\n    register = _React$useContext2.register,\n    unregister = _React$useContext2.unregister,\n    map = _React$useContext2.map,\n    elementsRef = _React$useContext2.elementsRef,\n    labelsRef = _React$useContext2.labelsRef;\n  var ref = React.useCallback(function (node) {\n    componentRef.current = node;\n    if (index$1 !== null) {\n      elementsRef.current[index$1] = node;\n      if (labelsRef) {\n        var _node$textContent;\n        var 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(function () {\n    var node = componentRef.current;\n    if (node) {\n      register(node);\n      return function () {\n        unregister(node);\n      };\n    }\n  }, [register, unregister]);\n  index(function () {\n    var index = componentRef.current ? map.get(componentRef.current) : null;\n    if (index != null) {\n      setIndex(index);\n    }\n  }, [map]);\n  return React.useMemo(function () {\n    return {\n      ref: ref,\n      index: index$1 == null ? -1 : index$1\n    };\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}\nvar CompositeContext = /*#__PURE__*/React.createContext({\n  activeIndex: 0,\n  onNavigate: function onNavigate() {}\n});\nvar horizontalKeys = [ARROW_LEFT, ARROW_RIGHT];\nvar verticalKeys = [ARROW_UP, ARROW_DOWN];\nvar allKeys = [].concat(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 */\nvar Composite = /*#__PURE__*/React.forwardRef(function Composite(_ref, forwardedRef) {\n  var render = _ref.render,\n    _ref$orientation = _ref.orientation,\n    orientation = _ref$orientation === void 0 ? 'both' : _ref$orientation,\n    _ref$loop = _ref.loop,\n    loop = _ref$loop === void 0 ? true : _ref$loop,\n    _ref$cols = _ref.cols,\n    cols = _ref$cols === void 0 ? 1 : _ref$cols,\n    _ref$disabledIndices = _ref.disabledIndices,\n    disabledIndices = _ref$disabledIndices === void 0 ? [] : _ref$disabledIndices,\n    externalActiveIndex = _ref.activeIndex,\n    externalSetActiveIndex = _ref.onNavigate,\n    itemSizes = _ref.itemSizes,\n    _ref$dense = _ref.dense,\n    dense = _ref$dense === void 0 ? false : _ref$dense,\n    props = _objectWithoutProperties(_ref, _excluded);\n  var _React$useState5 = React.useState(0),\n    _React$useState6 = _slicedToArray(_React$useState5, 2),\n    internalActiveIndex = _React$useState6[0],\n    internalSetActiveIndex = _React$useState6[1];\n  var activeIndex = externalActiveIndex != null ? externalActiveIndex : internalActiveIndex;\n  var onNavigate = useEffectEvent(externalSetActiveIndex != null ? externalSetActiveIndex : internalSetActiveIndex);\n  var elementsRef = React.useRef([]);\n  var renderElementProps = render && typeof render !== 'function' ? render.props : {};\n  var contextValue = React.useMemo(function () {\n    return {\n      activeIndex: activeIndex,\n      onNavigate: onNavigate\n    };\n  }, [activeIndex, onNavigate]);\n  var isGrid = cols > 1;\n  function handleKeyDown(event) {\n    if (!allKeys.includes(event.key)) return;\n    var nextIndex = activeIndex;\n    if (isGrid) {\n      var sizes = itemSizes || Array.from({\n        length: elementsRef.current.length\n      }, function () {\n        return {\n          width: 1,\n          height: 1\n        };\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      var cellMap = buildCellMap(sizes, cols, dense);\n      var minGridIndex = cellMap.findIndex(function (index) {\n        return index != null && !disabledIndices.includes(index);\n      });\n      // last enabled index\n      var maxGridIndex = cellMap.reduce(function (foundIndex, index, cellIndex) {\n        return index != null && !(disabledIndices != null && disabledIndices.includes(index)) ? cellIndex : foundIndex;\n      }, -1);\n      nextIndex = cellMap[getGridNavigatedIndex({\n        current: cellMap.map(function (itemIndex) {\n          return itemIndex ? elementsRef.current[itemIndex] : null;\n        })\n      }, {\n        event: event,\n        orientation: orientation,\n        loop: loop,\n        cols: cols,\n        // treat undefined (empty grid spaces) as disabled indices so we\n        // don't end up in them\n        disabledIndices: getCellIndices([].concat(_toConsumableArray(disabledIndices), [undefined]), cellMap),\n        minIndex: minGridIndex,\n        maxIndex: maxGridIndex,\n        prevIndex: getCellIndexOfCorner(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 === ARROW_RIGHT ? 'tr' : 'tl')\n      })]; // navigated cell will never be nullish\n    }\n    var minIndex = getMinIndex(elementsRef, disabledIndices);\n    var maxIndex = getMaxIndex(elementsRef, disabledIndices);\n    var toEndKeys = {\n      horizontal: [ARROW_RIGHT],\n      vertical: [ARROW_DOWN],\n      both: [ARROW_RIGHT, ARROW_DOWN]\n    }[orientation];\n    var toStartKeys = {\n      horizontal: [ARROW_LEFT],\n      vertical: [ARROW_UP],\n      both: [ARROW_LEFT, ARROW_UP]\n    }[orientation];\n    var preventedKeys = isGrid ? allKeys : {\n      horizontal: horizontalKeys,\n      vertical: verticalKeys,\n      both: allKeys\n    }[orientation];\n    if (nextIndex === activeIndex && [].concat(_toConsumableArray(toEndKeys), _toConsumableArray(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: disabledIndices\n        });\n      }\n    }\n    if (nextIndex !== activeIndex && !isIndexOutOfBounds(elementsRef, nextIndex)) {\n      event.stopPropagation();\n      if (preventedKeys.includes(event.key)) {\n        event.preventDefault();\n      }\n      onNavigate(nextIndex);\n\n      // Wait for FocusManager `returnFocus` to execute.\n      queueMicrotask(function () {\n        enqueueFocus(elementsRef.current[nextIndex]);\n      });\n    }\n  }\n  var computedProps = _objectSpread(_objectSpread(_objectSpread({}, props), renderElementProps), {}, {\n    ref: forwardedRef,\n    'aria-orientation': orientation === 'both' ? undefined : orientation,\n    onKeyDown: function onKeyDown(e) {\n      props.onKeyDown == null || props.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 */\nvar CompositeItem = /*#__PURE__*/React.forwardRef(function CompositeItem(_ref2, forwardedRef) {\n  var render = _ref2.render,\n    props = _objectWithoutProperties(_ref2, _excluded2);\n  var renderElementProps = render && typeof render !== 'function' ? render.props : {};\n  var _React$useContext3 = React.useContext(CompositeContext),\n    activeIndex = _React$useContext3.activeIndex,\n    onNavigate = _React$useContext3.onNavigate;\n  var _useListItem = useListItem(),\n    ref = _useListItem.ref,\n    index = _useListItem.index;\n  var mergedRef = useMergeRefs([ref, forwardedRef, renderElementProps.ref]);\n  var isActive = activeIndex === index;\n  var computedProps = _objectSpread(_objectSpread(_objectSpread({}, props), renderElementProps), {}, {\n    ref: mergedRef,\n    tabIndex: isActive ? 0 : -1,\n    'data-active': isActive ? '' : undefined,\n    onFocus: function onFocus(e) {\n      props.onFocus == null || props.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}\nvar serverHandoffComplete = false;\nvar count = 0;\nvar genId = function genId() {\n  return \"floating-ui-\" + count++;\n};\nfunction useFloatingId() {\n  var _React$useState7 = React.useState(function () {\n      return serverHandoffComplete ? genId() : undefined;\n    }),\n    _React$useState8 = _slicedToArray(_React$useState7, 2),\n    id = _React$useState8[0],\n    setId = _React$useState8[1];\n\n  // biome-ignore lint/correctness/useExhaustiveDependencies: intentional\n  index(function () {\n    if (id == null) {\n      setId(genId());\n    }\n  }, []);\n  React.useEffect(function () {\n    if (!serverHandoffComplete) {\n      serverHandoffComplete = true;\n    }\n  }, []);\n  return id;\n}\n\n// `toString()` prevents bundlers from trying to `import { useId } from 'react'`\nvar useReactId = React[/*#__PURE__*/'useId'.toString()];\n\n/**\n * Uses React 18's built-in `useId()` when available, or falls back to a\n * slightly less performant (requiring a double render) implementation for\n * earlier React versions.\n * @see https://floating-ui.com/docs/react-utils#useid\n */\nvar useId = useReactId || useFloatingId;\n\n/**\n * Renders a pointing arrow triangle.\n * @see https://floating-ui.com/docs/FloatingArrow\n */\nvar FloatingArrow = /*#__PURE__*/React.forwardRef(function FloatingArrow(_ref, ref) {\n  var _ref$context = _ref.context,\n    placement = _ref$context.placement,\n    floating = _ref$context.elements.floating,\n    arrow = _ref$context.middlewareData.arrow,\n    _ref$width = _ref.width,\n    width = _ref$width === void 0 ? 14 : _ref$width,\n    _ref$height = _ref.height,\n    height = _ref$height === void 0 ? 7 : _ref$height,\n    _ref$tipRadius = _ref.tipRadius,\n    tipRadius = _ref$tipRadius === void 0 ? 0 : _ref$tipRadius,\n    _ref$strokeWidth = _ref.strokeWidth,\n    strokeWidth = _ref$strokeWidth === void 0 ? 0 : _ref$strokeWidth,\n    staticOffset = _ref.staticOffset,\n    stroke = _ref.stroke,\n    d = _ref.d,\n    _ref$style = _ref.style,\n    _ref$style2 = _ref$style === void 0 ? {} : _ref$style,\n    transform = _ref$style2.transform,\n    restStyle = _objectWithoutProperties(_ref$style2, _excluded3),\n    rest = _objectWithoutProperties(_ref, _excluded4);\n  if (process.env.NODE_ENV !== \"production\") {\n    if (!ref) {\n      console.warn('Floating UI: The `ref` prop is required for the `FloatingArrow`', 'component.');\n    }\n  }\n  var clipPathId = useId();\n  if (!floating) {\n    return null;\n  }\n\n  // Strokes must be double the border width, this ensures the stroke's width\n  // works as you'd expect.\n  strokeWidth *= 2;\n  var halfStrokeWidth = strokeWidth / 2;\n  var svgX = width / 2 * (tipRadius / -8 + 1);\n  var svgY = height / 2 * tipRadius / 4;\n  var _placement$split = placement.split('-'),\n    _placement$split2 = _slicedToArray(_placement$split, 2),\n    side = _placement$split2[0],\n    alignment = _placement$split2[1];\n  var isRTL = platform.isRTL(floating);\n  var isCustomShape = !!d;\n  var isVerticalSide = side === 'top' || side === 'bottom';\n  var yOffsetProp = staticOffset && alignment === 'end' ? 'bottom' : 'top';\n  var xOffsetProp = staticOffset && alignment === 'end' ? 'right' : 'left';\n  if (staticOffset && isRTL) {\n    xOffsetProp = alignment === 'end' ? 'left' : 'right';\n  }\n  var arrowX = (arrow == null ? void 0 : arrow.x) != null ? staticOffset || arrow.x : '';\n  var arrowY = (arrow == null ? void 0 : arrow.y) != null ? staticOffset || arrow.y : '';\n  var dValue = d ||\n  // biome-ignore lint/style/useTemplate: readability\n  'M0,0' + (\" H\" + width) + (\" L\" + (width - svgX) + \",\" + (height - svgY)) + (\" Q\" + width / 2 + \",\" + height + \" \" + svgX + \",\" + (height - svgY)) + ' Z';\n  var 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 + strokeWidth,\n    height: width,\n    viewBox: \"0 0 \" + width + \" \" + (height > width ? height : width),\n    style: _objectSpread(_defineProperty(_defineProperty(_defineProperty(_defineProperty({\n      position: 'absolute',\n      pointerEvents: 'none'\n    }, xOffsetProp, arrowX), yOffsetProp, arrowY), side, isVerticalSide || isCustomShape ? '100%' : \"calc(100% - \" + strokeWidth / 2 + \"px)\"), \"transform\", \"\" + rotation + (transform != null ? transform : '')), restStyle)\n  }), strokeWidth > 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: strokeWidth + (d ? 0 : 1),\n    d: dValue\n  }), /*#__PURE__*/React.createElement(\"path\", {\n    stroke: strokeWidth && !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 + strokeWidth,\n    height: width\n  })));\n});\nfunction createPubSub() {\n  var map = new Map();\n  return {\n    emit: function emit(event, data) {\n      var _map$get;\n      (_map$get = map.get(event)) == null || _map$get.forEach(function (handler) {\n        return handler(data);\n      });\n    },\n    on: function on(event, listener) {\n      map.set(event, [].concat(_toConsumableArray(map.get(event) || []), [listener]));\n    },\n    off: function off(event, listener) {\n      var _map$get2;\n      map.set(event, ((_map$get2 = map.get(event)) == null ? void 0 : _map$get2.filter(function (l) {\n        return l !== listener;\n      })) || []);\n    }\n  };\n}\nvar FloatingNodeContext = /*#__PURE__*/React.createContext(null);\nvar 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 */\nvar useFloatingParentNodeId = function 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 */\nvar useFloatingTree = function useFloatingTree() {\n  return React.useContext(FloatingTreeContext);\n};\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  var id = useId();\n  var tree = useFloatingTree();\n  var reactParentId = useFloatingParentNodeId();\n  var parentId = customParentId || reactParentId;\n  index(function () {\n    var node = {\n      id: id,\n      parentId: parentId\n    };\n    tree == null || tree.addNode(node);\n    return function () {\n      tree == null || tree.removeNode(node);\n    };\n  }, [tree, id, parentId]);\n  return id;\n}\n\n/**\n * Provides parent node context for nested floating elements.\n * @see https://floating-ui.com/docs/FloatingTree\n */\nfunction FloatingNode(_ref) {\n  var children = _ref.children,\n    id = _ref.id;\n  var parentId = useFloatingParentNodeId();\n  return /*#__PURE__*/React.createElement(FloatingNodeContext.Provider, {\n    value: React.useMemo(function () {\n      return {\n        id: id,\n        parentId: parentId\n      };\n    }, [id, parentId])\n  }, children);\n}\n\n/**\n * Provides context for nested floating elements when they are not children of\n * each other on the DOM.\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(_ref2) {\n  var children = _ref2.children;\n  var nodesRef = React.useRef([]);\n  var addNode = React.useCallback(function (node) {\n    nodesRef.current = [].concat(_toConsumableArray(nodesRef.current), [node]);\n  }, []);\n  var removeNode = React.useCallback(function (node) {\n    nodesRef.current = nodesRef.current.filter(function (n) {\n      return n !== node;\n    });\n  }, []);\n  var events = React.useState(function () {\n    return createPubSub();\n  })[0];\n  return /*#__PURE__*/React.createElement(FloatingTreeContext.Provider, {\n    value: React.useMemo(function () {\n      return {\n        nodesRef: nodesRef,\n        addNode: addNode,\n        removeNode: removeNode,\n        events: events\n      };\n    }, [addNode, removeNode, events])\n  }, children);\n}\nfunction createAttribute(name) {\n  return \"data-floating-ui-\" + name;\n}\nfunction useLatestRef(value) {\n  var ref = useRef(value);\n  index(function () {\n    ref.current = value;\n  });\n  return ref;\n}\nvar 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  var open = context.open,\n    onOpenChange = context.onOpenChange,\n    dataRef = context.dataRef,\n    events = context.events,\n    _context$elements = context.elements,\n    domReference = _context$elements.domReference,\n    floating = _context$elements.floating,\n    refs = context.refs;\n  var _props = props,\n    _props$enabled = _props.enabled,\n    enabled = _props$enabled === void 0 ? true : _props$enabled,\n    _props$delay = _props.delay,\n    delay = _props$delay === void 0 ? 0 : _props$delay,\n    _props$handleClose = _props.handleClose,\n    handleClose = _props$handleClose === void 0 ? null : _props$handleClose,\n    _props$mouseOnly = _props.mouseOnly,\n    mouseOnly = _props$mouseOnly === void 0 ? false : _props$mouseOnly,\n    _props$restMs = _props.restMs,\n    restMs = _props$restMs === void 0 ? 0 : _props$restMs,\n    _props$move = _props.move,\n    move = _props$move === void 0 ? true : _props$move;\n  var tree = useFloatingTree();\n  var parentId = useFloatingParentNodeId();\n  var handleCloseRef = useLatestRef(handleClose);\n  var delayRef = useLatestRef(delay);\n  var pointerTypeRef = React.useRef();\n  var timeoutRef = React.useRef();\n  var handlerRef = React.useRef();\n  var restTimeoutRef = React.useRef();\n  var blockMouseMoveRef = React.useRef(true);\n  var performedPointerEventsMutationRef = React.useRef(false);\n  var unbindMouseMoveRef = React.useRef(function () {});\n  var isHoverOpen = React.useCallback(function () {\n    var _dataRef$current$open;\n    var 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(function () {\n    if (!enabled) {\n      return;\n    }\n    function onOpenChange(_ref) {\n      var open = _ref.open;\n      if (!open) {\n        clearTimeout(timeoutRef.current);\n        clearTimeout(restTimeoutRef.current);\n        blockMouseMoveRef.current = true;\n      }\n    }\n    events.on('openchange', onOpenChange);\n    return function () {\n      events.off('openchange', onOpenChange);\n    };\n  }, [enabled, events]);\n  React.useEffect(function () {\n    if (!enabled || !handleCloseRef.current || !open) {\n      return;\n    }\n    function onLeave(event) {\n      if (isHoverOpen()) {\n        onOpenChange(false, event, 'hover');\n      }\n    }\n    var html = getDocument(floating).documentElement;\n    html.addEventListener('mouseleave', onLeave);\n    return function () {\n      html.removeEventListener('mouseleave', onLeave);\n    };\n  }, [floating, open, onOpenChange, enabled, handleCloseRef, isHoverOpen]);\n  var 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    var closeDelay = getDelay(delayRef.current, 'close', pointerTypeRef.current);\n    if (closeDelay && !handlerRef.current) {\n      clearTimeout(timeoutRef.current);\n      timeoutRef.current = setTimeout(function () {\n        return onOpenChange(false, event, reason);\n      }, closeDelay);\n    } else if (runElseBranch) {\n      clearTimeout(timeoutRef.current);\n      onOpenChange(false, event, reason);\n    }\n  }, [delayRef, onOpenChange]);\n  var cleanupMouseMoveHandler = React.useCallback(function () {\n    unbindMouseMoveRef.current();\n    handlerRef.current = undefined;\n  }, []);\n  var clearPointerEvents = React.useCallback(function () {\n    if (performedPointerEventsMutationRef.current) {\n      var body = getDocument(refs.floating.current).body;\n      body.style.pointerEvents = '';\n      body.removeAttribute(safePolygonIdentifier);\n      performedPointerEventsMutationRef.current = false;\n    }\n  }, [refs]);\n\n  // Registering the mouse events on the reference directly to bypass React's\n  // delegation system. If the cursor was on a disabled element and then entered\n  // the reference (no gap), `mouseenter` doesn't fire in the delegation system.\n  React.useEffect(function () {\n    if (!enabled) {\n      return;\n    }\n    function isClickLikeOpenEvent() {\n      return dataRef.current.openEvent ? ['click', 'mousedown'].includes(dataRef.current.openEvent.type) : false;\n    }\n    function onMouseEnter(event) {\n      clearTimeout(timeoutRef.current);\n      blockMouseMoveRef.current = false;\n      if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current) || restMs > 0 && getDelay(delayRef.current, 'open') === 0) {\n        return;\n      }\n      var openDelay = getDelay(delayRef.current, 'open', pointerTypeRef.current);\n      if (openDelay) {\n        timeoutRef.current = setTimeout(function () {\n          onOpenChange(true, event, 'hover');\n        }, openDelay);\n      } else {\n        onOpenChange(true, event, 'hover');\n      }\n    }\n    function onMouseLeave(event) {\n      if (isClickLikeOpenEvent()) {\n        return;\n      }\n      unbindMouseMoveRef.current();\n      var doc = getDocument(floating);\n      clearTimeout(restTimeoutRef.current);\n      if (handleCloseRef.current) {\n        // Prevent clearing `onScrollMouseLeave` timeout.\n        if (!open) {\n          clearTimeout(timeoutRef.current);\n        }\n        handlerRef.current = handleCloseRef.current(_objectSpread(_objectSpread({}, context), {}, {\n          tree: tree,\n          x: event.clientX,\n          y: event.clientY,\n          onClose: function onClose() {\n            clearPointerEvents();\n            cleanupMouseMoveHandler();\n            closeWithDelay(event, true, 'safe-polygon');\n          }\n        }));\n        var handler = handlerRef.current;\n        doc.addEventListener('mousemove', handler);\n        unbindMouseMoveRef.current = function () {\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      var shouldClose = pointerTypeRef.current === 'touch' ? !contains(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()) {\n        return;\n      }\n      handleCloseRef.current == null || handleCloseRef.current(_objectSpread(_objectSpread({}, context), {}, {\n        tree: tree,\n        x: event.clientX,\n        y: event.clientY,\n        onClose: function onClose() {\n          clearPointerEvents();\n          cleanupMouseMoveHandler();\n          closeWithDelay(event);\n        }\n      }))(event);\n    }\n    if (isElement(domReference)) {\n      var ref = domReference;\n      open && ref.addEventListener('mouseleave', onScrollMouseLeave);\n      floating == null || 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 function () {\n        open && ref.removeEventListener('mouseleave', onScrollMouseLeave);\n        floating == null || floating.removeEventListener('mouseleave', onScrollMouseLeave);\n        move && ref.removeEventListener('mousemove', onMouseEnter);\n        ref.removeEventListener('mouseenter', onMouseEnter);\n        ref.removeEventListener('mouseleave', onMouseLeave);\n      };\n    }\n  }, [domReference, floating, enabled, context, mouseOnly, restMs, move, closeWithDelay, cleanupMouseMoveHandler, clearPointerEvents, onOpenChange, open, tree, delayRef, handleCloseRef, dataRef]);\n\n  // Block pointer-events of every element other than the reference and floating\n  // while the floating element is open and has a `handleClose` handler. Also\n  // handles nested floating elements.\n  // https://github.com/floating-ui/floating-ui/issues/1722\n  index(function () {\n    var _handleCloseRef$curre;\n    if (!enabled) {\n      return;\n    }\n    if (open && (_handleCloseRef$curre = handleCloseRef.current) != null && _handleCloseRef$curre.__options.blockPointerEvents && isHoverOpen()) {\n      var body = getDocument(floating).body;\n      body.setAttribute(safePolygonIdentifier, '');\n      body.style.pointerEvents = 'none';\n      performedPointerEventsMutationRef.current = true;\n      if (isElement(domReference) && floating) {\n        var _tree$nodesRef$curren;\n        var ref = domReference;\n        var parentFloating = tree == null || (_tree$nodesRef$curren = tree.nodesRef.current.find(function (node) {\n          return node.id === parentId;\n        })) == 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        ref.style.pointerEvents = 'auto';\n        floating.style.pointerEvents = 'auto';\n        return function () {\n          ref.style.pointerEvents = '';\n          floating.style.pointerEvents = '';\n        };\n      }\n    }\n  }, [enabled, open, parentId, floating, domReference, tree, handleCloseRef, isHoverOpen]);\n  index(function () {\n    if (!open) {\n      pointerTypeRef.current = undefined;\n      cleanupMouseMoveHandler();\n      clearPointerEvents();\n    }\n  }, [open, cleanupMouseMoveHandler, clearPointerEvents]);\n\n  // biome-ignore lint/correctness/useExhaustiveDependencies: intentional\n  React.useEffect(function () {\n    return function () {\n      cleanupMouseMoveHandler();\n      clearTimeout(timeoutRef.current);\n      clearTimeout(restTimeoutRef.current);\n      clearPointerEvents();\n    };\n  }, [enabled, domReference, cleanupMouseMoveHandler, clearPointerEvents]);\n  return React.useMemo(function () {\n    if (!enabled) {\n      return {};\n    }\n    function setPointerRef(event) {\n      pointerTypeRef.current = event.pointerType;\n    }\n    return {\n      reference: {\n        onPointerDown: setPointerRef,\n        onPointerEnter: setPointerRef,\n        onMouseMove: function onMouseMove(event) {\n          if (open || restMs === 0) {\n            return;\n          }\n          clearTimeout(restTimeoutRef.current);\n          restTimeoutRef.current = setTimeout(function () {\n            if (!blockMouseMoveRef.current) {\n              onOpenChange(true, event.nativeEvent, 'hover');\n            }\n          }, restMs);\n        }\n      },\n      floating: {\n        onMouseEnter: function onMouseEnter() {\n          clearTimeout(timeoutRef.current);\n        },\n        onMouseLeave: function onMouseLeave(event) {\n          closeWithDelay(event.nativeEvent, false);\n        }\n      }\n    };\n  }, [enabled, restMs, open, onOpenChange, closeWithDelay]);\n}\nvar FloatingDelayGroupContext = /*#__PURE__*/React.createContext({\n  delay: 0,\n  initialDelay: 0,\n  timeoutMs: 0,\n  currentId: null,\n  setCurrentId: function setCurrentId() {},\n  setState: function setState() {},\n  isInstantPhase: false\n});\nvar useDelayGroupContext = function useDelayGroupContext() {\n  return React.useContext(FloatingDelayGroupContext);\n};\n/**\n * Provides context for a group of floating elements that should share a\n * `delay`.\n * @see https://floating-ui.com/docs/FloatingDelayGroup\n */\nvar FloatingDelayGroup = function FloatingDelayGroup(_ref) {\n  var children = _ref.children,\n    delay = _ref.delay,\n    _ref$timeoutMs = _ref.timeoutMs,\n    timeoutMs = _ref$timeoutMs === void 0 ? 0 : _ref$timeoutMs;\n  var _React$useReducer = React.useReducer(function (prev, next) {\n      return _objectSpread(_objectSpread({}, prev), next);\n    }, {\n      delay: delay,\n      timeoutMs: timeoutMs,\n      initialDelay: delay,\n      currentId: null,\n      isInstantPhase: false\n    }),\n    _React$useReducer2 = _slicedToArray(_React$useReducer, 2),\n    state = _React$useReducer2[0],\n    setState = _React$useReducer2[1];\n  var initialCurrentIdRef = React.useRef(null);\n  var setCurrentId = React.useCallback(function (currentId) {\n    setState({\n      currentId: currentId\n    });\n  }, []);\n  index(function () {\n    if (state.currentId) {\n      if (initialCurrentIdRef.current === null) {\n        initialCurrentIdRef.current = state.currentId;\n      } else {\n        setState({\n          isInstantPhase: true\n        });\n      }\n    } else {\n      setState({\n        isInstantPhase: false\n      });\n      initialCurrentIdRef.current = null;\n    }\n  }, [state.currentId]);\n  return /*#__PURE__*/React.createElement(FloatingDelayGroupContext.Provider, {\n    value: React.useMemo(function () {\n      return _objectSpread(_objectSpread({}, state), {}, {\n        setState: setState,\n        setCurrentId: setCurrentId\n      });\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 */\nvar useDelayGroup = function useDelayGroup(_ref2, _ref3) {\n  var open = _ref2.open,\n    onOpenChange = _ref2.onOpenChange;\n  var id = _ref3.id;\n  var _useDelayGroupContext = useDelayGroupContext(),\n    currentId = _useDelayGroupContext.currentId,\n    setCurrentId = _useDelayGroupContext.setCurrentId,\n    initialDelay = _useDelayGroupContext.initialDelay,\n    setState = _useDelayGroupContext.setState,\n    timeoutMs = _useDelayGroupContext.timeoutMs;\n  index(function () {\n    if (currentId) {\n      setState({\n        delay: {\n          open: 1,\n          close: getDelay(initialDelay, 'close')\n        }\n      });\n      if (currentId !== id) {\n        onOpenChange(false);\n      }\n    }\n  }, [id, onOpenChange, setState, currentId, initialDelay]);\n  index(function () {\n    function unset() {\n      onOpenChange(false);\n      setState({\n        delay: initialDelay,\n        currentId: null\n      });\n    }\n    if (!open && currentId === id) {\n      if (timeoutMs) {\n        var timeout = window.setTimeout(unset, timeoutMs);\n        return function () {\n          clearTimeout(timeout);\n        };\n      }\n      unset();\n    }\n  }, [open, setState, currentId, id, onOpenChange, initialDelay, timeoutMs]);\n  index(function () {\n    if (open) {\n      setCurrentId(id);\n    }\n  }, [open, setCurrentId, id]);\n};\nfunction getAncestors(nodes, id) {\n  var _nodes$find;\n  var allAncestors = [];\n  var currentParentId = (_nodes$find = nodes.find(function (node) {\n    return node.id === id;\n  })) == null ? void 0 : _nodes$find.parentId;\n  while (currentParentId) {\n    var currentNode = nodes.find(function (node) {\n      return node.id === currentParentId;\n    });\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  var allChildren = nodes.filter(function (node) {\n    var _node$context;\n    return node.parentId === id && ((_node$context = node.context) == null ? void 0 : _node$context.open);\n  });\n  var currentChildren = allChildren;\n  while (currentChildren.length) {\n    currentChildren = nodes.filter(function (node) {\n      var _currentChildren;\n      return (_currentChildren = currentChildren) == null ? void 0 : _currentChildren.some(function (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  var deepestNodeId;\n  var maxDepth = -1;\n  function findDeepest(nodeId, depth) {\n    if (depth > maxDepth) {\n      deepestNodeId = nodeId;\n      maxDepth = depth;\n    }\n    var children = getChildren(nodes, nodeId);\n    children.forEach(function (child) {\n      findDeepest(child.id, depth + 1);\n    });\n  }\n  findDeepest(id, 0);\n  return nodes.find(function (node) {\n    return node.id === deepestNodeId;\n  });\n}\n\n// Modified to add conditional `aria-hidden` support:\n// https://github.com/theKashey/aria-hidden/blob/9220c8f4a4fd35f63bee5510a9f41a37264382d4/src/index.ts\nvar counterMap = /*#__PURE__*/new WeakMap();\nvar uncontrolledElementsSet = /*#__PURE__*/new WeakSet();\nvar markerMap = {};\nvar lockCount = 0;\nvar supportsInert = function supportsInert() {\n  return typeof HTMLElement !== 'undefined' && 'inert' in HTMLElement.prototype;\n};\nvar unwrapHost = function unwrapHost(node) {\n  return node && (node.host || unwrapHost(node.parentNode));\n};\nvar correctElements = function correctElements(parent, targets) {\n  return targets.map(function (target) {\n    if (parent.contains(target)) {\n      return target;\n    }\n    var correctedTarget = unwrapHost(target);\n    if (parent.contains(correctedTarget)) {\n      return correctedTarget;\n    }\n    return null;\n  }).filter(function (x) {\n    return x != null;\n  });\n};\nfunction applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, inert) {\n  var markerName = 'data-floating-ui-inert';\n  var controlAttribute = inert ? 'inert' : ariaHidden ? 'aria-hidden' : null;\n  var avoidElements = correctElements(body, uncorrectedAvoidElements);\n  var elementsToKeep = new Set();\n  var elementsToStop = new Set(avoidElements);\n  var hiddenElements = [];\n  if (!markerMap[markerName]) {\n    markerMap[markerName] = new WeakMap();\n  }\n  var 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    Array.prototype.forEach.call(parent.children, function (node) {\n      if (elementsToKeep.has(node)) {\n        deep(node);\n      } else {\n        var _attr = controlAttribute ? node.getAttribute(controlAttribute) : null;\n        var alreadyHidden = _attr !== null && _attr !== 'false';\n        var counterValue = (counterMap.get(node) || 0) + 1;\n        var 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++;\n  return function () {\n    hiddenElements.forEach(function (element) {\n      var counterValue = (counterMap.get(element) || 0) - 1;\n      var 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--;\n    if (!lockCount) {\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  var body = getDocument(avoidElements[0]).body;\n  return applyAttributeToOthers(avoidElements.concat(Array.from(body.querySelectorAll('[aria-live]'))), body, ariaHidden, inert);\n}\nvar getTabbableOptions = function getTabbableOptions() {\n  return {\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  };\n};\nfunction getTabbableIn(container, direction) {\n  var allTabbable = tabbable(container, getTabbableOptions());\n  if (direction === 'prev') {\n    allTabbable.reverse();\n  }\n  var activeIndex = allTabbable.indexOf(activeElement(getDocument(container)));\n  var 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  var containerElement = container || event.currentTarget;\n  var relatedTarget = event.relatedTarget;\n  return !relatedTarget || !contains(containerElement, relatedTarget);\n}\nfunction disableFocusInside(container) {\n  var tabbableElements = tabbable(container, getTabbableOptions());\n  tabbableElements.forEach(function (element) {\n    element.dataset.tabindex = element.getAttribute('tabindex') || '';\n    element.setAttribute('tabindex', '-1');\n  });\n}\nfunction enableFocusInside(container) {\n  var elements = container.querySelectorAll('[data-tabindex]');\n  elements.forEach(function (element) {\n    var tabindex = element.dataset.tabindex;\n    // biome-ignore lint/performance/noDelete: purity\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\nvar 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};\nvar timeoutId;\nfunction setActiveElementOnTab(event) {\n  if (event.key === 'Tab') {\n    event.target;\n    clearTimeout(timeoutId);\n  }\n}\nvar FocusGuard = /*#__PURE__*/React.forwardRef(function FocusGuard(props, ref) {\n  var _React$useState9 = React.useState(),\n    _React$useState10 = _slicedToArray(_React$useState9, 2),\n    role = _React$useState10[0],\n    setRole = _React$useState10[1];\n  index(function () {\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 function () {\n      document.removeEventListener('keydown', setActiveElementOnTab);\n    };\n  }, []);\n  var restProps = _defineProperty(_defineProperty({\n    ref: ref,\n    tabIndex: 0,\n    // Role is only for VoiceOver\n    role: role,\n    'aria-hidden': role ? undefined : true\n  }, createAttribute('focus-guard'), ''), \"style\", HIDDEN_STYLES);\n  return /*#__PURE__*/React.createElement(\"span\", _extends({}, props, restProps));\n});\nvar PortalContext = /*#__PURE__*/React.createContext(null);\nvar attr = /*#__PURE__*/createAttribute('portal');\n\n/**\n * @see https://floating-ui.com/docs/FloatingPortal#usefloatingportalnode\n */\nfunction useFloatingPortalNode(_temp) {\n  var _ref7 = _temp === void 0 ? {} : _temp,\n    id = _ref7.id,\n    root = _ref7.root;\n  var _React$useState11 = React.useState(null),\n    _React$useState12 = _slicedToArray(_React$useState11, 2),\n    portalNode = _React$useState12[0],\n    setPortalNode = _React$useState12[1];\n  var uniqueId = useId();\n  var portalContext = usePortalContext();\n  var portalNodeRef = React.useRef(null);\n  index(function () {\n    return function () {\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(function () {\n        portalNodeRef.current = null;\n      });\n    };\n  }, [portalNode]);\n  index(function () {\n    if (portalNodeRef.current) return;\n    var existingIdRoot = id ? document.getElementById(id) : null;\n    if (!existingIdRoot) return;\n    var 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(function () {\n    if (portalNodeRef.current) return;\n    var container = root || (portalContext == null ? void 0 : portalContext.portalNode);\n    if (container && !isElement(container)) container = container.current;\n    container = container || document.body;\n    var idWrapper = null;\n    if (id) {\n      idWrapper = document.createElement('div');\n      idWrapper.id = id;\n      container.appendChild(idWrapper);\n    }\n    var 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(_ref) {\n  var children = _ref.children,\n    id = _ref.id,\n    _ref$root = _ref.root,\n    root = _ref$root === void 0 ? null : _ref$root,\n    _ref$preserveTabOrder = _ref.preserveTabOrder,\n    preserveTabOrder = _ref$preserveTabOrder === void 0 ? true : _ref$preserveTabOrder;\n  var portalNode = useFloatingPortalNode({\n    id: id,\n    root: root\n  });\n  var _React$useState13 = React.useState(null),\n    _React$useState14 = _slicedToArray(_React$useState13, 2),\n    focusManagerState = _React$useState14[0],\n    setFocusManagerState = _React$useState14[1];\n  var beforeOutsideRef = React.useRef(null);\n  var afterOutsideRef = React.useRef(null);\n  var beforeInsideRef = React.useRef(null);\n  var afterInsideRef = React.useRef(null);\n  var 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(function () {\n    if (!portalNode || !preserveTabOrder || focusManagerState != null && focusManagerState.modal) {\n      return;\n    }\n\n    // Make sure elements inside the portal element are tabbable only when the\n    // portal has already been focused, either by tabbing into a focus trap\n    // element outside or using the mouse.\n    function onFocus(event) {\n      if (portalNode && isOutsideEvent(event)) {\n        var focusing = event.type === 'focusin';\n        var 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 function () {\n      portalNode.removeEventListener('focusin', onFocus, true);\n      portalNode.removeEventListener('focusout', onFocus, true);\n    };\n  }, [portalNode, preserveTabOrder, focusManagerState == null ? void 0 : focusManagerState.modal]);\n  return /*#__PURE__*/React.createElement(PortalContext.Provider, {\n    value: React.useMemo(function () {\n      return {\n        preserveTabOrder: preserveTabOrder,\n        beforeOutsideRef: beforeOutsideRef,\n        afterOutsideRef: afterOutsideRef,\n        beforeInsideRef: beforeInsideRef,\n        afterInsideRef: afterInsideRef,\n        portalNode: portalNode,\n        setFocusManagerState: setFocusManagerState\n      };\n    }, [preserveTabOrder, portalNode])\n  }, shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"outside\",\n    ref: beforeOutsideRef,\n    onFocus: function onFocus(event) {\n      if (isOutsideEvent(event, portalNode)) {\n        var _beforeInsideRef$curr;\n        (_beforeInsideRef$curr = beforeInsideRef.current) == null || _beforeInsideRef$curr.focus();\n      } else {\n        var 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__*/createPortal(children, portalNode), shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"outside\",\n    ref: afterOutsideRef,\n    onFocus: function onFocus(event) {\n      if (isOutsideEvent(event, portalNode)) {\n        var _afterInsideRef$curre;\n        (_afterInsideRef$curre = afterInsideRef.current) == null || _afterInsideRef$curre.focus();\n      } else {\n        var 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));\n      }\n    }\n  }));\n}\nvar usePortalContext = function usePortalContext() {\n  return React.useContext(PortalContext);\n};\nvar LIST_LIMIT = 20;\nvar previouslyFocusedElements = [];\nfunction addPreviouslyFocusedElement(element) {\n  previouslyFocusedElements = previouslyFocusedElements.filter(function (el) {\n    return el.isConnected;\n  });\n  if (element && getNodeName(element) !== 'body') {\n    previouslyFocusedElements.push(element);\n    if (previouslyFocusedElements.length > LIST_LIMIT) {\n      previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);\n    }\n  }\n}\nfunction getPreviouslyFocusedElement() {\n  return previouslyFocusedElements.slice().reverse().find(function (el) {\n    return el.isConnected;\n  });\n}\nvar 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  var context = props.context,\n    children = props.children,\n    _props$disabled = props.disabled,\n    disabled = _props$disabled === void 0 ? false : _props$disabled,\n    _props$order = props.order,\n    order = _props$order === void 0 ? ['content'] : _props$order,\n    _props$guards = props.guards,\n    _guards = _props$guards === void 0 ? true : _props$guards,\n    _props$initialFocus = props.initialFocus,\n    initialFocus = _props$initialFocus === void 0 ? 0 : _props$initialFocus,\n    _props$returnFocus = props.returnFocus,\n    returnFocus = _props$returnFocus === void 0 ? true : _props$returnFocus,\n    _props$modal = props.modal,\n    modal = _props$modal === void 0 ? true : _props$modal,\n    _props$visuallyHidden = props.visuallyHiddenDismiss,\n    visuallyHiddenDismiss = _props$visuallyHidden === void 0 ? false : _props$visuallyHidden,\n    _props$closeOnFocusOu = props.closeOnFocusOut,\n    closeOnFocusOut = _props$closeOnFocusOu === void 0 ? true : _props$closeOnFocusOu;\n  var open = context.open,\n    refs = context.refs,\n    nodeId = context.nodeId,\n    onOpenChange = context.onOpenChange,\n    events = context.events,\n    dataRef = context.dataRef,\n    _context$elements2 = context.elements,\n    domReference = _context$elements2.domReference,\n    floating = _context$elements2.floating;\n  var 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  var isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;\n\n  // Force the guards to be rendered if the `inert` attribute is not supported.\n  var guards = supportsInert() ? _guards : true;\n  var orderRef = useLatestRef(order);\n  var initialFocusRef = useLatestRef(initialFocus);\n  var returnFocusRef = useLatestRef(returnFocus);\n  var tree = useFloatingTree();\n  var portalContext = usePortalContext();\n  var startDismissButtonRef = React.useRef(null);\n  var endDismissButtonRef = React.useRef(null);\n  var preventReturnFocusRef = React.useRef(false);\n  var isPointerDownRef = React.useRef(false);\n  var isInsidePortal = portalContext != null;\n  var getTabbableContent = React.useCallback(function (container) {\n    if (container === void 0) {\n      container = floating;\n    }\n    return container ? tabbable(container, getTabbableOptions()) : [];\n  }, [floating]);\n  var getTabbableElements = React.useCallback(function (container) {\n    var content = getTabbableContent(container);\n    return orderRef.current.map(function (type) {\n      if (domReference && type === 'reference') {\n        return domReference;\n      }\n      if (floating && type === 'floating') {\n        return floating;\n      }\n      return content;\n    }).filter(Boolean).flat();\n  }, [domReference, floating, orderRef, getTabbableContent]);\n  React.useEffect(function () {\n    if (disabled || !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(floating, activeElement(getDocument(floating))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) {\n          stopEvent(event);\n        }\n        var els = getTabbableElements();\n        var target = getTarget(event);\n        if (orderRef.current[0] === 'reference' && target === domReference) {\n          stopEvent(event);\n          if (event.shiftKey) {\n            enqueueFocus(els[els.length - 1]);\n          } else {\n            enqueueFocus(els[1]);\n          }\n        }\n        if (orderRef.current[1] === 'floating' && target === floating && event.shiftKey) {\n          stopEvent(event);\n          enqueueFocus(els[0]);\n        }\n      }\n    }\n    var doc = getDocument(floating);\n    doc.addEventListener('keydown', onKeyDown);\n    return function () {\n      doc.removeEventListener('keydown', onKeyDown);\n    };\n  }, [disabled, domReference, floating, modal, orderRef, isUntrappedTypeableCombobox, getTabbableContent, getTabbableElements]);\n  React.useEffect(function () {\n    if (disabled || !closeOnFocusOut) return;\n\n    // In Safari, buttons lose focus when pressing them.\n    function handlePointerDown() {\n      isPointerDownRef.current = true;\n      setTimeout(function () {\n        isPointerDownRef.current = false;\n      });\n    }\n    function handleFocusOutside(event) {\n      var relatedTarget = event.relatedTarget;\n      queueMicrotask(function () {\n        var 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(function (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(function (node) {\n          var _node$context3, _node$context4;\n          return ((_node$context3 = node.context) == null ? void 0 : _node$context3.elements.floating) === relatedTarget || ((_node$context4 = node.context) == null ? void 0 : _node$context4.elements.domReference) === relatedTarget;\n        })));\n\n        // Focus did not move inside the floating tree, and there are no tabbable\n        // portal guards to handle closing.\n        if (relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current &&\n        // Fix React 18 Strict Mode returnFocus due to double rendering.\n        relatedTarget !== getPreviouslyFocusedElement()) {\n          preventReturnFocusRef.current = true;\n          onOpenChange(false, event);\n        }\n      });\n    }\n    if (floating && isHTMLElement(domReference)) {\n      domReference.addEventListener('focusout', handleFocusOutside);\n      domReference.addEventListener('pointerdown', handlePointerDown);\n      !modal && floating.addEventListener('focusout', handleFocusOutside);\n      return function () {\n        domReference.removeEventListener('focusout', handleFocusOutside);\n        domReference.removeEventListener('pointerdown', handlePointerDown);\n        !modal && floating.removeEventListener('focusout', handleFocusOutside);\n      };\n    }\n  }, [disabled, domReference, floating, modal, nodeId, tree, portalContext, onOpenChange, closeOnFocusOut]);\n  React.useEffect(function () {\n    var _portalContext$portal;\n    if (disabled) return;\n\n    // Don't hide portals nested within the parent portal.\n    var portalNodes = Array.from((portalContext == null || (_portalContext$portal = portalContext.portalNode) == null ? void 0 : _portalContext$portal.querySelectorAll(\"[\" + createAttribute('portal') + \"]\")) || []);\n    if (floating) {\n      var insideElements = [floating].concat(portalNodes, [startDismissButtonRef.current, endDismissButtonRef.current, orderRef.current.includes('reference') || isUntrappedTypeableCombobox ? domReference : null]).filter(function (x) {\n        return x != null;\n      });\n      var cleanup = modal || isUntrappedTypeableCombobox ? markOthers(insideElements, guards, !guards) : markOthers(insideElements);\n      return function () {\n        cleanup();\n      };\n    }\n  }, [disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, guards]);\n  index(function () {\n    if (disabled || !floating) return;\n    var doc = getDocument(floating);\n    var previouslyFocusedElement = activeElement(doc);\n\n    // Wait for any layout effect state setters to execute to set `tabIndex`.\n    queueMicrotask(function () {\n      var focusableElements = getTabbableElements(floating);\n      var initialFocusValue = initialFocusRef.current;\n      var elToFocus = (typeof initialFocusValue === 'number' ? focusableElements[initialFocusValue] : initialFocusValue.current) || floating;\n      var focusAlreadyInsideFloatingEl = contains(floating, previouslyFocusedElement);\n      if (!ignoreInitialFocus && !focusAlreadyInsideFloatingEl && open) {\n        enqueueFocus(elToFocus, {\n          preventScroll: elToFocus === floating\n        });\n      }\n    });\n  }, [disabled, open, floating, ignoreInitialFocus, getTabbableElements, initialFocusRef]);\n  index(function () {\n    if (disabled || !floating) return;\n    var preventReturnFocusScroll = false;\n    var doc = getDocument(floating);\n    var previouslyFocusedElement = activeElement(doc);\n    var contextData = dataRef.current;\n    addPreviouslyFocusedElement(previouslyFocusedElement);\n\n    // Dismissing via outside press should always ignore `returnFocus` to\n    // prevent unwanted scrolling.\n    function onOpenChange(_ref) {\n      var reason = _ref.reason,\n        event = _ref.event,\n        nested = _ref.nested;\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    return function () {\n      events.off('openchange', onOpenChange);\n      var activeEl = activeElement(doc);\n      var isFocusInsideFloatingTree = contains(floating, activeEl) || tree && getChildren(tree.nodesRef.current, nodeId).some(function (node) {\n        var _node$context5;\n        return contains((_node$context5 = node.context) == null ? void 0 : _node$context5.elements.floating, activeEl);\n      });\n      var shouldFocusReference = isFocusInsideFloatingTree || contextData.openEvent && ['click', 'mousedown'].includes(contextData.openEvent.type);\n      if (shouldFocusReference && refs.domReference.current) {\n        addPreviouslyFocusedElement(refs.domReference.current);\n      }\n      var returnElement = getPreviouslyFocusedElement();\n      if (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        enqueueFocus(returnElement, {\n          // When dismissing nested floating elements, by the time the rAF has\n          // executed, the menus will all have been unmounted. When they try\n          // to get focused, the calls get ignored — leaving the root\n          // reference focused as desired.\n          cancelPrevious: false,\n          preventScroll: preventReturnFocusScroll\n        });\n      }\n    };\n  }, [disabled, floating, returnFocusRef, dataRef, refs, events, tree, nodeId]);\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(function () {\n    if (disabled || !portalContext) return;\n    portalContext.setFocusManagerState({\n      modal: modal,\n      closeOnFocusOut: closeOnFocusOut,\n      open: open,\n      onOpenChange: onOpenChange,\n      refs: refs\n    });\n    return function () {\n      portalContext.setFocusManagerState(null);\n    };\n  }, [disabled, portalContext, modal, open, onOpenChange, refs, closeOnFocusOut]);\n  index(function () {\n    if (disabled || !floating || typeof MutationObserver !== 'function' || ignoreInitialFocus) {\n      return;\n    }\n    var handleMutation = function handleMutation() {\n      var tabIndex = floating.getAttribute('tabindex');\n      if (orderRef.current.includes('floating') || activeElement(getDocument(floating)) !== refs.domReference.current && getTabbableContent().length === 0) {\n        if (tabIndex !== '0') {\n          floating.setAttribute('tabindex', '0');\n        }\n      } else if (tabIndex !== '-1') {\n        floating.setAttribute('tabindex', '-1');\n      }\n    };\n    handleMutation();\n    var observer = new MutationObserver(handleMutation);\n    observer.observe(floating, {\n      childList: true,\n      subtree: true,\n      attributes: true\n    });\n    return function () {\n      observer.disconnect();\n    };\n  }, [disabled, floating, 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: function onClick(event) {\n        return onOpenChange(false, event.nativeEvent);\n      }\n    }, typeof visuallyHiddenDismiss === 'string' ? visuallyHiddenDismiss : 'Dismiss');\n  }\n  var shouldRenderGuards = !disabled && guards && (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: function onFocus(event) {\n      if (modal) {\n        var 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          var 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: function 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          var 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}\nvar activeLocks = /*#__PURE__*/new Set();\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 */\nvar FloatingOverlay = /*#__PURE__*/React.forwardRef(function FloatingOverlay(_ref, ref) {\n  var _ref$lockScroll = _ref.lockScroll,\n    lockScroll = _ref$lockScroll === void 0 ? false : _ref$lockScroll,\n    rest = _objectWithoutProperties(_ref, _excluded5);\n  var lockId = useId();\n  index(function () {\n    if (!lockScroll) return;\n    activeLocks.add(lockId);\n    var isIOS = /iP(hone|ad|od)|iOS/.test(getPlatform());\n    var bodyStyle = document.body.style;\n    // RTL <body> scrollbar\n    var scrollbarX = Math.round(document.documentElement.getBoundingClientRect().left) + document.documentElement.scrollLeft;\n    var paddingProp = scrollbarX ? 'paddingLeft' : 'paddingRight';\n    var scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;\n    var scrollX = bodyStyle.left ? parseFloat(bodyStyle.left) : window.pageXOffset;\n    var scrollY = bodyStyle.top ? parseFloat(bodyStyle.top) : window.pageYOffset;\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      var offsetLeft = ((_window$visualViewpor = window.visualViewport) == null ? void 0 : _window$visualViewpor.offsetLeft) || 0;\n      var 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 function () {\n      activeLocks.delete(lockId);\n      if (activeLocks.size === 0) {\n        Object.assign(bodyStyle, _defineProperty({\n          overflow: ''\n        }, paddingProp, ''));\n        if (isIOS) {\n          Object.assign(bodyStyle, {\n            position: '',\n            top: '',\n            left: '',\n            right: ''\n          });\n          window.scrollTo(scrollX, scrollY);\n        }\n      }\n    };\n  }, [lockId, lockScroll]);\n  return /*#__PURE__*/React.createElement(\"div\", _extends({\n    ref: ref\n  }, rest, {\n    style: _objectSpread({\n      position: 'fixed',\n      overflow: 'auto',\n      top: 0,\n      right: 0,\n      bottom: 0,\n      left: 0\n    }, rest.style)\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  var open = context.open,\n    onOpenChange = context.onOpenChange,\n    dataRef = context.dataRef,\n    domReference = context.elements.domReference;\n  var _props2 = props,\n    _props2$enabled = _props2.enabled,\n    enabled = _props2$enabled === void 0 ? true : _props2$enabled,\n    _props2$event = _props2.event,\n    eventOption = _props2$event === void 0 ? 'click' : _props2$event,\n    _props2$toggle = _props2.toggle,\n    toggle = _props2$toggle === void 0 ? true : _props2$toggle,\n    _props2$ignoreMouse = _props2.ignoreMouse,\n    ignoreMouse = _props2$ignoreMouse === void 0 ? false : _props2$ignoreMouse,\n    _props2$keyboardHandl = _props2.keyboardHandlers,\n    keyboardHandlers = _props2$keyboardHandl === void 0 ? true : _props2$keyboardHandl;\n  var pointerTypeRef = React.useRef();\n  var didKeyDownRef = React.useRef(false);\n  return React.useMemo(function () {\n    if (!enabled) return {};\n    return {\n      reference: {\n        onPointerDown: function onPointerDown(event) {\n          pointerTypeRef.current = event.pointerType;\n        },\n        onMouseDown: function onMouseDown(event) {\n          // Ignore all buttons except for the \"main\" button.\n          // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button\n          if (event.button !== 0) {\n            return;\n          }\n          if (isMouseLikePointerType(pointerTypeRef.current, true) && ignoreMouse) {\n            return;\n          }\n          if (eventOption === 'click') {\n            return;\n          }\n          if (open && toggle && (dataRef.current.openEvent ? 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: function onClick(event) {\n          if (eventOption === 'mousedown' && pointerTypeRef.current) {\n            pointerTypeRef.current = undefined;\n            return;\n          }\n          if (isMouseLikePointerType(pointerTypeRef.current, true) && ignoreMouse) {\n            return;\n          }\n          if (open && toggle && (dataRef.current.openEvent ? dataRef.current.openEvent.type === 'click' : true)) {\n            onOpenChange(false, event.nativeEvent, 'click');\n          } else {\n            onOpenChange(true, event.nativeEvent, 'click');\n          }\n        },\n        onKeyDown: function 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: function 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      }\n    };\n  }, [enabled, dataRef, eventOption, ignoreMouse, keyboardHandlers, domReference, toggle, open, onOpenChange]);\n}\nfunction createVirtualElement(domRef, data) {\n  var offsetX = null;\n  var offsetY = null;\n  var isAutoUpdateEvent = false;\n  return {\n    contextElement: domRef.current || undefined,\n    getBoundingClientRect: function getBoundingClientRect() {\n      var _domRef$current, _data$dataRef$current;\n      var domRect = ((_domRef$current = domRef.current) == null ? void 0 : _domRef$current.getBoundingClientRect()) || {\n        width: 0,\n        height: 0,\n        x: 0,\n        y: 0\n      };\n      var isXAxis = data.axis === 'x' || data.axis === 'both';\n      var isYAxis = data.axis === 'y' || data.axis === 'both';\n      var canTrackCursorOnAutoUpdate = ['mouseenter', 'mousemove'].includes(((_data$dataRef$current = data.dataRef.current.openEvent) == null ? void 0 : _data$dataRef$current.type) || '') && data.pointerType !== 'touch';\n      var width = domRect.width;\n      var height = domRect.height;\n      var x = domRect.x;\n      var 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: width,\n        height: height,\n        x: x,\n        y: 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  var open = context.open,\n    refs = context.refs,\n    dataRef = context.dataRef,\n    floating = context.elements.floating;\n  var _props3 = props,\n    _props3$enabled = _props3.enabled,\n    enabled = _props3$enabled === void 0 ? true : _props3$enabled,\n    _props3$axis = _props3.axis,\n    axis = _props3$axis === void 0 ? 'both' : _props3$axis,\n    _props3$x = _props3.x,\n    x = _props3$x === void 0 ? null : _props3$x,\n    _props3$y = _props3.y,\n    y = _props3$y === void 0 ? null : _props3$y;\n  var initialRef = React.useRef(false);\n  var cleanupListenerRef = React.useRef(null);\n  var _React$useState15 = React.useState(),\n    _React$useState16 = _slicedToArray(_React$useState15, 2),\n    pointerType = _React$useState16[0],\n    setPointerType = _React$useState16[1];\n  var _React$useState17 = React.useState([]),\n    _React$useState18 = _slicedToArray(_React$useState17, 2),\n    reactive = _React$useState18[0],\n    setReactive = _React$useState18[1];\n  var setReference = useEffectEvent(function (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(refs.domReference, {\n      x: x,\n      y: y,\n      axis: axis,\n      dataRef: dataRef,\n      pointerType: pointerType\n    }));\n  });\n  var handleReferenceEnterOrMove = useEffectEvent(function (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  var openCheck = isMouseLikePointerType(pointerType) ? floating : open;\n  var addListener = React.useCallback(function () {\n    // Explicitly specified `x`/`y` coordinates shouldn't add a listener.\n    if (!openCheck || !enabled || x != null || y != null) return;\n    var win = getWindow(refs.floating.current);\n    function handleMouseMove(event) {\n      var target = getTarget(event);\n      if (!contains(refs.floating.current, 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      var cleanup = function cleanup() {\n        win.removeEventListener('mousemove', handleMouseMove);\n        cleanupListenerRef.current = null;\n      };\n      cleanupListenerRef.current = cleanup;\n      return cleanup;\n    }\n    refs.setPositionReference(refs.domReference.current);\n  }, [dataRef, enabled, openCheck, refs, setReference, x, y]);\n\n  // biome-ignore lint/correctness/useExhaustiveDependencies: intentionally specifying `reactive`\n  React.useEffect(function () {\n    return addListener();\n  }, [addListener, reactive]);\n  React.useEffect(function () {\n    if (enabled && !floating) {\n      initialRef.current = false;\n    }\n  }, [enabled, floating]);\n  React.useEffect(function () {\n    if (!enabled && open) {\n      initialRef.current = true;\n    }\n  }, [enabled, open]);\n  index(function () {\n    if (enabled && (x != null || y != null)) {\n      initialRef.current = false;\n      setReference(x, y);\n    }\n  }, [enabled, x, y, setReference]);\n  return React.useMemo(function () {\n    if (!enabled) return {};\n    function setPointerTypeRef(_ref) {\n      var pointerType = _ref.pointerType;\n      setPointerType(pointerType);\n    }\n    return {\n      reference: {\n        onPointerDown: setPointerTypeRef,\n        onPointerEnter: setPointerTypeRef,\n        onMouseMove: handleReferenceEnterOrMove,\n        onMouseEnter: handleReferenceEnterOrMove\n      }\n    };\n  }, [enabled, handleReferenceEnterOrMove]);\n}\nvar bubbleHandlerKeys = {\n  pointerdown: 'onPointerDown',\n  mousedown: 'onMouseDown',\n  click: 'onClick'\n};\nvar captureHandlerKeys = {\n  pointerdown: 'onPointerDownCapture',\n  mousedown: 'onMouseDownCapture',\n  click: 'onClickCapture'\n};\nvar normalizeProp = function 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  var open = context.open,\n    onOpenChange = context.onOpenChange,\n    nodeId = context.nodeId,\n    _context$elements3 = context.elements,\n    reference = _context$elements3.reference,\n    domReference = _context$elements3.domReference,\n    floating = _context$elements3.floating,\n    dataRef = context.dataRef;\n  var _props4 = props,\n    _props4$enabled = _props4.enabled,\n    enabled = _props4$enabled === void 0 ? true : _props4$enabled,\n    _props4$escapeKey = _props4.escapeKey,\n    escapeKey = _props4$escapeKey === void 0 ? true : _props4$escapeKey,\n    _props4$outsidePress = _props4.outsidePress,\n    unstable_outsidePress = _props4$outsidePress === void 0 ? true : _props4$outsidePress,\n    _props4$outsidePressE = _props4.outsidePressEvent,\n    outsidePressEvent = _props4$outsidePressE === void 0 ? 'pointerdown' : _props4$outsidePressE,\n    _props4$referencePres = _props4.referencePress,\n    referencePress = _props4$referencePres === void 0 ? false : _props4$referencePres,\n    _props4$referencePres2 = _props4.referencePressEvent,\n    referencePressEvent = _props4$referencePres2 === void 0 ? 'pointerdown' : _props4$referencePres2,\n    _props4$ancestorScrol = _props4.ancestorScroll,\n    ancestorScroll = _props4$ancestorScrol === void 0 ? false : _props4$ancestorScrol,\n    bubbles = _props4.bubbles,\n    capture = _props4.capture;\n  var tree = useFloatingTree();\n  var outsidePressFn = useEffectEvent(typeof unstable_outsidePress === 'function' ? unstable_outsidePress : function () {\n    return false;\n  });\n  var outsidePress = typeof unstable_outsidePress === 'function' ? outsidePressFn : unstable_outsidePress;\n  var insideReactTreeRef = React.useRef(false);\n  var endedOrStartedInsideRef = React.useRef(false);\n  var _normalizeProp = normalizeProp(bubbles),\n    escapeKeyBubbles = _normalizeProp.escapeKey,\n    outsidePressBubbles = _normalizeProp.outsidePress;\n  var _normalizeProp2 = normalizeProp(capture),\n    escapeKeyCapture = _normalizeProp2.escapeKey,\n    outsidePressCapture = _normalizeProp2.outsidePress;\n  var closeOnEscapeKeyDown = useEffectEvent(function (event) {\n    if (!open || !enabled || !escapeKey || event.key !== 'Escape') {\n      return;\n    }\n    var children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];\n    if (!escapeKeyBubbles) {\n      event.stopPropagation();\n      if (children.length > 0) {\n        var shouldDismiss = true;\n        children.forEach(function (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  var closeOnEscapeKeyDownCapture = useEffectEvent(function (event) {\n    var _getTarget2;\n    var callback = function 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  var closeOnPressOutside = useEffectEvent(function (event) {\n    // Given developers can stop the propagation of the synthetic event,\n    // we can only be confident with a positive value.\n    var 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    var 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    var target = getTarget(event);\n    var inertSelector = \"[\" + createAttribute('inert') + \"]\";\n    var markers = getDocument(floating).querySelectorAll(inertSelector);\n    var targetRootAncestor = isElement(target) ? target : null;\n    while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {\n      var 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, 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(function (marker) {\n      return !contains(targetRootAncestor, marker);\n    })) {\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      var canScrollX = target.clientWidth > 0 && target.scrollWidth > target.clientWidth;\n      var canScrollY = target.clientHeight > 0 && target.scrollHeight > target.clientHeight;\n      var 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        var 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    var targetIsInsideChildren = tree && getChildren(tree.nodesRef.current, nodeId).some(function (node) {\n      var _node$context;\n      return isEventTargetWithin(event, (_node$context = node.context) == null ? void 0 : _node$context.elements.floating);\n    });\n    if (isEventTargetWithin(event, floating) || isEventTargetWithin(event, domReference) || targetIsInsideChildren) {\n      return;\n    }\n    var children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];\n    if (children.length > 0) {\n      var shouldDismiss = true;\n      children.forEach(function (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  var closeOnPressOutsideCapture = useEffectEvent(function (event) {\n    var _getTarget4;\n    var callback = function 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(function () {\n    if (!open || !enabled) {\n      return;\n    }\n    dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;\n    dataRef.current.__outsidePressBubbles = outsidePressBubbles;\n    function onScroll(event) {\n      onOpenChange(false, event, 'ancestor-scroll');\n    }\n    var doc = getDocument(floating);\n    escapeKey && doc.addEventListener('keydown', escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);\n    outsidePress && doc.addEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);\n    var ancestors = [];\n    if (ancestorScroll) {\n      if (isElement(domReference)) {\n        ancestors = getOverflowAncestors(domReference);\n      }\n      if (isElement(floating)) {\n        ancestors = ancestors.concat(getOverflowAncestors(floating));\n      }\n      if (!isElement(reference) && reference && reference.contextElement) {\n        ancestors = ancestors.concat(getOverflowAncestors(reference.contextElement));\n      }\n    }\n\n    // Ignore the visual viewport for scrolling dismissal (allow pinch-zoom)\n    ancestors = ancestors.filter(function (ancestor) {\n      var _doc$defaultView;\n      return ancestor !== ((_doc$defaultView = doc.defaultView) == null ? void 0 : _doc$defaultView.visualViewport);\n    });\n    ancestors.forEach(function (ancestor) {\n      ancestor.addEventListener('scroll', onScroll, {\n        passive: true\n      });\n    });\n    return function () {\n      escapeKey && doc.removeEventListener('keydown', escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);\n      outsidePress && doc.removeEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);\n      ancestors.forEach(function (ancestor) {\n        ancestor.removeEventListener('scroll', onScroll);\n      });\n    };\n  }, [dataRef, floating, domReference, reference, escapeKey, outsidePress, outsidePressEvent, open, onOpenChange, ancestorScroll, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, escapeKeyCapture, closeOnEscapeKeyDownCapture, closeOnPressOutside, outsidePressCapture, closeOnPressOutsideCapture]);\n\n  // biome-ignore lint/correctness/useExhaustiveDependencies: intentional\n  React.useEffect(function () {\n    insideReactTreeRef.current = false;\n  }, [outsidePress, outsidePressEvent]);\n  return React.useMemo(function () {\n    if (!enabled) {\n      return {};\n    }\n    return {\n      reference: _defineProperty({\n        onKeyDown: closeOnEscapeKeyDown\n      }, bubbleHandlerKeys[referencePressEvent], function (event) {\n        if (referencePress) {\n          onOpenChange(false, event.nativeEvent, 'reference-press');\n        }\n      }),\n      floating: _defineProperty({\n        onKeyDown: closeOnEscapeKeyDown,\n        onMouseDown: function onMouseDown() {\n          endedOrStartedInsideRef.current = true;\n        },\n        onMouseUp: function onMouseUp() {\n          endedOrStartedInsideRef.current = true;\n        }\n      }, captureHandlerKeys[outsidePressEvent], function () {\n        insideReactTreeRef.current = true;\n      })\n    };\n  }, [enabled, referencePress, outsidePressEvent, referencePressEvent, onOpenChange, closeOnEscapeKeyDown]);\n}\nvar devMessageSet;\nif (process.env.NODE_ENV !== \"production\") {\n  devMessageSet = /*#__PURE__*/new Set();\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  var _options$elements2;\n  if (options === void 0) {\n    options = {};\n  }\n  var _options2 = options,\n    _options2$open = _options2.open,\n    open = _options2$open === void 0 ? false : _options2$open,\n    unstable_onOpenChange = _options2.onOpenChange,\n    nodeId = _options2.nodeId;\n  if (process.env.NODE_ENV !== \"production\") {\n    var _options$elements;\n    var err = 'Floating UI: Cannot pass a virtual element to the ' + '`elements.reference` option, as it must be a real DOM element. ' + 'Use `refs.setPositionReference` instead.';\n    if ((_options$elements = options.elements) != null && _options$elements.reference && !isElement(options.elements.reference)) {\n      var _devMessageSet;\n      if (!((_devMessageSet = devMessageSet) != null && _devMessageSet.has(err))) {\n        var _devMessageSet2;\n        (_devMessageSet2 = devMessageSet) == null || _devMessageSet2.add(err);\n        console.error(err);\n      }\n    }\n  }\n  var _React$useState19 = React.useState(null),\n    _React$useState20 = _slicedToArray(_React$useState19, 2),\n    _domReference = _React$useState20[0],\n    setDomReference = _React$useState20[1];\n  var domReference = ((_options$elements2 = options.elements) == null ? void 0 : _options$elements2.reference) || _domReference;\n  var position = useFloating$1(options);\n  var tree = useFloatingTree();\n  var nested = useFloatingParentNodeId() != null;\n  var onOpenChange = useEffectEvent(function (open, event, reason) {\n    if (open) {\n      dataRef.current.openEvent = event;\n    }\n    events.emit('openchange', {\n      open: open,\n      event: event,\n      reason: reason,\n      nested: nested\n    });\n    unstable_onOpenChange == null || unstable_onOpenChange(open, event, reason);\n  });\n  var domReferenceRef = React.useRef(null);\n  var dataRef = React.useRef({});\n  var events = React.useState(function () {\n    return createPubSub();\n  })[0];\n  var floatingId = useId();\n  var setPositionReference = React.useCallback(function (node) {\n    var positionReference = isElement(node) ? {\n      getBoundingClientRect: function getBoundingClientRect() {\n        return node.getBoundingClientRect();\n      },\n      contextElement: node\n    } : node;\n    position.refs.setReference(positionReference);\n  }, [position.refs]);\n  var setReference = React.useCallback(function (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  var refs = React.useMemo(function () {\n    return _objectSpread(_objectSpread({}, position.refs), {}, {\n      setReference: setReference,\n      setPositionReference: setPositionReference,\n      domReference: domReferenceRef\n    });\n  }, [position.refs, setReference, setPositionReference]);\n  var elements = React.useMemo(function () {\n    return _objectSpread(_objectSpread({}, position.elements), {}, {\n      domReference: domReference\n    });\n  }, [position.elements, domReference]);\n  var context = React.useMemo(function () {\n    return _objectSpread(_objectSpread({}, position), {}, {\n      refs: refs,\n      elements: elements,\n      dataRef: dataRef,\n      nodeId: nodeId,\n      floatingId: floatingId,\n      events: events,\n      open: open,\n      onOpenChange: onOpenChange\n    });\n  }, [position, nodeId, floatingId, events, open, onOpenChange, refs, elements]);\n  index(function () {\n    var node = tree == null ? void 0 : tree.nodesRef.current.find(function (node) {\n      return node.id === nodeId;\n    });\n    if (node) {\n      node.context = context;\n    }\n  });\n  return React.useMemo(function () {\n    return _objectSpread(_objectSpread({}, position), {}, {\n      context: context,\n      refs: refs,\n      elements: elements\n    });\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  var open = context.open,\n    onOpenChange = context.onOpenChange,\n    events = context.events,\n    refs = context.refs,\n    domReference = context.elements.domReference;\n  var _props5 = props,\n    _props5$enabled = _props5.enabled,\n    enabled = _props5$enabled === void 0 ? true : _props5$enabled,\n    _props5$visibleOnly = _props5.visibleOnly,\n    visibleOnly = _props5$visibleOnly === void 0 ? true : _props5$visibleOnly;\n  var blockFocusRef = React.useRef(false);\n  var timeoutRef = React.useRef();\n  var keyboardModalityRef = React.useRef(true);\n  React.useEffect(function () {\n    if (!enabled) {\n      return;\n    }\n    var win = getWindow(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(domReference) && domReference === activeElement(getDocument(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 function () {\n      win.removeEventListener('blur', onBlur);\n      win.removeEventListener('keydown', onKeyDown, true);\n    };\n  }, [domReference, open, enabled]);\n  React.useEffect(function () {\n    if (!enabled) {\n      return;\n    }\n    function onOpenChange(_ref) {\n      var reason = _ref.reason;\n      if (reason === 'reference-press' || reason === 'escape-key') {\n        blockFocusRef.current = true;\n      }\n    }\n    events.on('openchange', onOpenChange);\n    return function () {\n      events.off('openchange', onOpenChange);\n    };\n  }, [events, enabled]);\n  React.useEffect(function () {\n    return function () {\n      clearTimeout(timeoutRef.current);\n    };\n  }, []);\n  return React.useMemo(function () {\n    if (!enabled) {\n      return {};\n    }\n    return {\n      reference: {\n        onPointerDown: function onPointerDown(event) {\n          if (isVirtualPointerEvent(event.nativeEvent)) return;\n          keyboardModalityRef.current = false;\n        },\n        onMouseLeave: function onMouseLeave() {\n          blockFocusRef.current = false;\n        },\n        onFocus: function onFocus(event) {\n          if (blockFocusRef.current) return;\n          var 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: function onBlur(event) {\n          blockFocusRef.current = false;\n          var relatedTarget = event.relatedTarget;\n\n          // Hit the non-modal focus management portal guard. Focus will be\n          // moved into the floating element immediately after.\n          var 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(function () {\n            var activeEl = activeElement(domReference ? domReference.ownerDocument : document);\n\n            // Focus left the page, keep it open.\n            if (!relatedTarget && activeEl === 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(refs.floating.current, activeEl) || contains(domReference, activeEl) || movedToFocusGuard) {\n              return;\n            }\n            onOpenChange(false, event.nativeEvent, 'focus');\n          });\n        }\n      }\n    };\n  }, [enabled, visibleOnly, domReference, refs, onOpenChange]);\n}\nvar ACTIVE_KEY = 'active';\nvar SELECTED_KEY = 'selected';\nfunction mergeProps(userProps, propsList, elementKey) {\n  var map = new Map();\n  var isItem = elementKey === 'item';\n  var domUserProps = userProps;\n  if (isItem && userProps) {\n    var _ = userProps[ACTIVE_KEY],\n      __ = userProps[SELECTED_KEY],\n      validProps = _objectWithoutProperties(userProps, [ACTIVE_KEY, SELECTED_KEY].map(_toPropertyKey));\n    domUserProps = validProps;\n  }\n  return _objectSpread(_objectSpread(_objectSpread({}, elementKey === 'floating' && {\n    tabIndex: -1\n  }), domUserProps), propsList.map(function (value) {\n    var propsOrGetProps = value ? value[elementKey] : null;\n    if (typeof propsOrGetProps === 'function') {\n      return userProps ? propsOrGetProps(userProps) : null;\n    }\n    return propsOrGetProps;\n  }).concat(userProps).reduce(function (acc, props) {\n    if (!props) {\n      return acc;\n    }\n    Object.entries(props).forEach(function (_ref) {\n      var _ref8 = _slicedToArray(_ref, 2),\n        key = _ref8[0],\n        value = _ref8[1];\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(function (fn) {\n              return fn.apply(void 0, args);\n            }).find(function (val) {\n              return val !== undefined;\n            });\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  // The dependencies are a dynamic array, so we can't use the linter's\n  // suggestion to add it to the deps array.\n  var deps = propsList;\n\n  // biome-ignore lint/correctness/useExhaustiveDependencies: intentional\n  var getReferenceProps = React.useCallback(function (userProps) {\n    return mergeProps(userProps, propsList, 'reference');\n  }, deps);\n\n  // biome-ignore lint/correctness/useExhaustiveDependencies: intentional\n  var getFloatingProps = React.useCallback(function (userProps) {\n    return mergeProps(userProps, propsList, 'floating');\n  }, deps);\n\n  // biome-ignore lint/correctness/useExhaustiveDependencies: intentional\n  var getItemProps = React.useCallback(function (userProps) {\n    return mergeProps(userProps, propsList, 'item');\n  },\n  // Granularly check for `item` changes, because the `getItemProps` getter\n  // should be as referentially stable as possible since it may be passed as\n  // a prop to many components. All `item` key values must therefore be\n  // memoized.\n  propsList.map(function (key) {\n    return key == null ? void 0 : key.item;\n  }));\n  return React.useMemo(function () {\n    return {\n      getReferenceProps: getReferenceProps,\n      getFloatingProps: getFloatingProps,\n      getItemProps: getItemProps\n    };\n  }, [getReferenceProps, getFloatingProps, getItemProps]);\n}\nvar 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  var vertical = key === ARROW_UP || key === ARROW_DOWN;\n  var horizontal = key === ARROW_LEFT || key === ARROW_RIGHT;\n  return doSwitch(orientation, vertical, horizontal);\n}\nfunction isMainOrientationToEndKey(key, orientation, rtl) {\n  var vertical = key === ARROW_DOWN;\n  var 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  var vertical = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;\n  var horizontal = key === ARROW_DOWN;\n  return doSwitch(orientation, vertical, horizontal);\n}\nfunction isCrossOrientationCloseKey(key, orientation, rtl) {\n  var vertical = rtl ? key === ARROW_RIGHT : key === ARROW_LEFT;\n  var 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  var open = context.open,\n    onOpenChange = context.onOpenChange,\n    refs = context.refs,\n    _context$elements4 = context.elements,\n    domReference = _context$elements4.domReference,\n    floating = _context$elements4.floating;\n  var listRef = props.listRef,\n    activeIndex = props.activeIndex,\n    _props$onNavigate = props.onNavigate,\n    unstable_onNavigate = _props$onNavigate === void 0 ? function () {} : _props$onNavigate,\n    _props$enabled2 = props.enabled,\n    enabled = _props$enabled2 === void 0 ? true : _props$enabled2,\n    _props$selectedIndex = props.selectedIndex,\n    selectedIndex = _props$selectedIndex === void 0 ? null : _props$selectedIndex,\n    _props$allowEscape = props.allowEscape,\n    allowEscape = _props$allowEscape === void 0 ? false : _props$allowEscape,\n    _props$loop = props.loop,\n    loop = _props$loop === void 0 ? false : _props$loop,\n    _props$nested = props.nested,\n    nested = _props$nested === void 0 ? false : _props$nested,\n    _props$rtl = props.rtl,\n    rtl = _props$rtl === void 0 ? false : _props$rtl,\n    _props$virtual = props.virtual,\n    virtual = _props$virtual === void 0 ? false : _props$virtual,\n    _props$focusItemOnOpe = props.focusItemOnOpen,\n    focusItemOnOpen = _props$focusItemOnOpe === void 0 ? 'auto' : _props$focusItemOnOpe,\n    _props$focusItemOnHov = props.focusItemOnHover,\n    focusItemOnHover = _props$focusItemOnHov === void 0 ? true : _props$focusItemOnHov,\n    _props$openOnArrowKey = props.openOnArrowKeyDown,\n    openOnArrowKeyDown = _props$openOnArrowKey === void 0 ? true : _props$openOnArrowKey,\n    _props$disabledIndice = props.disabledIndices,\n    disabledIndices = _props$disabledIndice === void 0 ? undefined : _props$disabledIndice,\n    _props$orientation = props.orientation,\n    orientation = _props$orientation === void 0 ? 'vertical' : _props$orientation,\n    _props$cols = props.cols,\n    cols = _props$cols === void 0 ? 1 : _props$cols,\n    _props$scrollItemInto = props.scrollItemIntoView,\n    scrollItemIntoView = _props$scrollItemInto === void 0 ? true : _props$scrollItemInto,\n    virtualItemRef = props.virtualItemRef,\n    itemSizes = props.itemSizes,\n    _props$dense = props.dense,\n    dense = _props$dense === void 0 ? false : _props$dense;\n  if (process.env.NODE_ENV !== \"production\") {\n    if (allowEscape) {\n      if (!loop) {\n        console.warn(['Floating UI: `useListNavigation` looping must be enabled to allow', 'escaping.'].join(' '));\n      }\n      if (!virtual) {\n        console.warn(['Floating UI: `useListNavigation` must be virtual to allow', 'escaping.'].join(' '));\n      }\n    }\n    if (orientation === 'vertical' && cols > 1) {\n      console.warn(['Floating UI: In grid list navigation mode (`cols` > 1), the', '`orientation` should be either \"horizontal\" or \"both\".'].join(' '));\n    }\n  }\n  var parentId = useFloatingParentNodeId();\n  var tree = useFloatingTree();\n  var onNavigate = useEffectEvent(unstable_onNavigate);\n  var focusItemOnOpenRef = React.useRef(focusItemOnOpen);\n  var indexRef = React.useRef(selectedIndex != null ? selectedIndex : -1);\n  var keyRef = React.useRef(null);\n  var isPointerModalityRef = React.useRef(true);\n  var previousOnNavigateRef = React.useRef(onNavigate);\n  var previousMountedRef = React.useRef(!!floating);\n  var forceSyncFocus = React.useRef(false);\n  var forceScrollIntoViewRef = React.useRef(false);\n  var disabledIndicesRef = useLatestRef(disabledIndices);\n  var latestOpenRef = useLatestRef(open);\n  var scrollItemIntoViewRef = useLatestRef(scrollItemIntoView);\n  var _React$useState21 = React.useState(),\n    _React$useState22 = _slicedToArray(_React$useState21, 2),\n    activeId = _React$useState22[0],\n    setActiveId = _React$useState22[1];\n  var _React$useState23 = React.useState(),\n    _React$useState24 = _slicedToArray(_React$useState23, 2),\n    virtualId = _React$useState24[0],\n    setVirtualId = _React$useState24[1];\n  var focusItem = useEffectEvent(function (listRef, indexRef, forceScrollIntoView) {\n    if (forceScrollIntoView === void 0) {\n      forceScrollIntoView = false;\n    }\n    var item = listRef.current[indexRef.current];\n    if (!item) return;\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    requestAnimationFrame(function () {\n      var scrollIntoViewOptions = scrollItemIntoViewRef.current;\n      var shouldScrollIntoView = scrollIntoViewOptions && item && (forceScrollIntoView || !isPointerModalityRef.current);\n      if (shouldScrollIntoView) {\n        // JSDOM doesn't support `.scrollIntoView()` but it's widely supported\n        // by all browsers.\n        item.scrollIntoView == null || item.scrollIntoView(typeof scrollIntoViewOptions === 'boolean' ? {\n          block: 'nearest',\n          inline: 'nearest'\n        } : scrollIntoViewOptions);\n      }\n    });\n  });\n  index(function () {\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(function () {\n    if (!enabled) {\n      return;\n    }\n    if (open && 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, floating, selectedIndex, onNavigate]);\n\n  // Sync `activeIndex` to be the focused item while the floating element is\n  // open.\n  index(function () {\n    if (!enabled) {\n      return;\n    }\n    if (open && floating) {\n      if (activeIndex == null) {\n        forceSyncFocus.current = false;\n        if (selectedIndex != null) {\n          return;\n        }\n\n        // Reset while the floating element was open (e.g. the list changed).\n        if (previousMountedRef.current) {\n          indexRef.current = -1;\n          focusItem(listRef, indexRef);\n        }\n\n        // Initial sync.\n        if (!previousMountedRef.current && focusItemOnOpenRef.current && (keyRef.current != null || focusItemOnOpenRef.current === true && keyRef.current == null)) {\n          var runs = 0;\n          var waitForListPopulated = function 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                var 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, floating, activeIndex, selectedIndex, nested, listRef, orientation, rtl, onNavigate, focusItem, disabledIndicesRef]);\n\n  // Ensure the parent floating element has focus when a nested child closes\n  // to allow arrow key navigation to work after the pointer leaves the child.\n  index(function () {\n    var _nodes$find;\n    if (!enabled || floating || !tree || virtual || !previousMountedRef.current) {\n      return;\n    }\n    var nodes = tree.nodesRef.current;\n    var parent = (_nodes$find = nodes.find(function (node) {\n      return node.id === parentId;\n    })) == null || (_nodes$find = _nodes$find.context) == null ? void 0 : _nodes$find.elements.floating;\n    var activeEl = activeElement(getDocument(floating));\n    var treeContainsActiveEl = nodes.some(function (node) {\n      return node.context && contains(node.context.elements.floating, activeEl);\n    });\n    if (parent && !treeContainsActiveEl && isPointerModalityRef.current) {\n      parent.focus({\n        preventScroll: true\n      });\n    }\n  }, [enabled, floating, tree, parentId, virtual]);\n  index(function () {\n    if (!enabled || !tree || !virtual || 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 function () {\n      tree.events.off('virtualfocus', handleVirtualFocus);\n    };\n  }, [enabled, tree, virtual, parentId, virtualItemRef]);\n  index(function () {\n    previousOnNavigateRef.current = onNavigate;\n    previousMountedRef.current = !!floating;\n  });\n  index(function () {\n    if (!open) {\n      keyRef.current = null;\n    }\n  }, [open]);\n  var hasActiveIndex = activeIndex != null;\n  var item = React.useMemo(function () {\n    function syncCurrentTarget(currentTarget) {\n      if (!open) return;\n      var index = listRef.current.indexOf(currentTarget);\n      if (index !== -1) {\n        onNavigate(index);\n      }\n    }\n    var props = _objectSpread({\n      onFocus: function onFocus(_ref) {\n        var currentTarget = _ref.currentTarget;\n        syncCurrentTarget(currentTarget);\n      },\n      onClick: function onClick(_ref2) {\n        var currentTarget = _ref2.currentTarget;\n        return currentTarget.focus({\n          preventScroll: true\n        });\n      }\n    }, focusItemOnHover && {\n      onMouseMove: function onMouseMove(_ref3) {\n        var currentTarget = _ref3.currentTarget;\n        syncCurrentTarget(currentTarget);\n      },\n      onPointerLeave: function onPointerLeave(_ref4) {\n        var pointerType = _ref4.pointerType;\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(refs.floating.current, {\n            preventScroll: true\n          });\n        }\n      }\n    });\n    return props;\n  }, [open, refs, focusItem, focusItemOnHover, listRef, onNavigate, virtual]);\n  return React.useMemo(function () {\n    if (!enabled) {\n      return {};\n    }\n    var disabledIndices = disabledIndicesRef.current;\n    function _onKeyDown(event) {\n      isPointerModalityRef.current = false;\n      forceSyncFocus.current = true;\n\n      // If the floating element is animating out, ignore navigation. Otherwise,\n      // the `activeIndex` gets set to 0 despite not being open so the next time\n      // the user ArrowDowns, the first item won't be focused.\n      if (!latestOpenRef.current && event.currentTarget === refs.floating.current) {\n        return;\n      }\n      if (nested && isCrossOrientationCloseKey(event.key, orientation, rtl)) {\n        stopEvent(event);\n        onOpenChange(false, event.nativeEvent, 'list-navigation');\n        if (isHTMLElement(domReference) && !virtual) {\n          domReference.focus();\n        }\n        return;\n      }\n      var currentIndex = indexRef.current;\n      var minIndex = getMinIndex(listRef, disabledIndices);\n      var maxIndex = getMaxIndex(listRef, disabledIndices);\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      // Grid navigation.\n      if (cols > 1) {\n        var sizes = itemSizes || Array.from({\n          length: listRef.current.length\n        }, function () {\n          return {\n            width: 1,\n            height: 1\n          };\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        var cellMap = buildCellMap(sizes, cols, dense);\n        var minGridIndex = cellMap.findIndex(function (index) {\n          return index != null && !(disabledIndices != null && disabledIndices.includes(index));\n        });\n        // last enabled index\n        var maxGridIndex = cellMap.reduce(function (foundIndex, index, cellIndex) {\n          return index != null && !(disabledIndices != null && disabledIndices.includes(index)) ? cellIndex : foundIndex;\n        }, -1);\n        indexRef.current = cellMap[getGridNavigatedIndex({\n          current: cellMap.map(function (itemIndex) {\n            return itemIndex != null ? listRef.current[itemIndex] : null;\n          })\n        }, {\n          event: event,\n          orientation: orientation,\n          loop: loop,\n          cols: cols,\n          // treat undefined (empty grid spaces) as disabled indices so we\n          // don't end up in them\n          disabledIndices: getCellIndices([].concat(_toConsumableArray(disabledIndices || []), [undefined]), cellMap),\n          minIndex: minGridIndex,\n          maxIndex: maxGridIndex,\n          prevIndex: getCellIndexOfCorner(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 === ARROW_RIGHT ? 'tr' : 'tl'),\n          stopEvent: true\n        })]; // navigated cell will never be nullish\n\n        onNavigate(indexRef.current);\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: disabledIndices\n            });\n          } else {\n            indexRef.current = Math.min(maxIndex, findNonDisabledIndex(listRef, {\n              startingIndex: currentIndex,\n              disabledIndices: 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: disabledIndices\n            });\n          } else {\n            indexRef.current = Math.max(minIndex, findNonDisabledIndex(listRef, {\n              startingIndex: currentIndex,\n              decrement: true,\n              disabledIndices: disabledIndices\n            }));\n          }\n        }\n        if (isIndexOutOfBounds(listRef, indexRef.current)) {\n          onNavigate(null);\n        } else {\n          onNavigate(indexRef.current);\n        }\n      }\n    }\n    function checkVirtualMouse(event) {\n      if (focusItemOnOpen === 'auto' && isVirtualClick(event.nativeEvent)) {\n        focusItemOnOpenRef.current = true;\n      }\n    }\n    function checkVirtualPointer(event) {\n      // `pointerdown` fires first, reset the state then perform the checks.\n      focusItemOnOpenRef.current = focusItemOnOpen;\n      if (focusItemOnOpen === 'auto' && isVirtualPointerEvent(event.nativeEvent)) {\n        focusItemOnOpenRef.current = true;\n      }\n    }\n    var ariaActiveDescendantProp = virtual && open && hasActiveIndex && {\n      'aria-activedescendant': virtualId || activeId\n    };\n    var activeItem = listRef.current.find(function (item) {\n      return (item == null ? void 0 : item.id) === activeId;\n    });\n    return {\n      reference: _objectSpread(_objectSpread({}, ariaActiveDescendantProp), {}, {\n        onKeyDown: function onKeyDown(event) {\n          isPointerModalityRef.current = false;\n          var isArrowKey = event.key.indexOf('Arrow') === 0;\n          var isCrossOpenKey = isCrossOrientationOpenKey(event.key, orientation, rtl);\n          var isCrossCloseKey = isCrossOrientationCloseKey(event.key, orientation, rtl);\n          var isMainKey = isMainOrientationKey(event.key, orientation);\n          var isNavigationKey = (nested ? isCrossOpenKey : isMainKey) || event.key === 'Enter' || event.key.trim() === '';\n          if (virtual && open) {\n            var rootNode = tree == null ? void 0 : tree.nodesRef.current.find(function (node) {\n              return node.parentId == null;\n            });\n            var deepestNode = tree && rootNode ? getDeepestNode(tree.nodesRef.current, rootNode.id) : null;\n            if (isArrowKey && deepestNode && virtualItemRef) {\n              var eventObject = new KeyboardEvent('keydown', {\n                key: event.key,\n                bubbles: true\n              });\n              if (isCrossOpenKey || isCrossCloseKey) {\n                var _deepestNode$context, _deepestNode$context2;\n                var isCurrentTarget = ((_deepestNode$context = deepestNode.context) == null ? void 0 : _deepestNode$context.elements.domReference) === event.currentTarget;\n                var dispatchItem = isCrossCloseKey && !isCurrentTarget ? (_deepestNode$context2 = deepestNode.context) == null ? void 0 : _deepestNode$context2.elements.domReference : isCrossOpenKey ? activeItem : null;\n                if (dispatchItem) {\n                  stopEvent(event);\n                  dispatchItem.dispatchEvent(eventObject);\n                  setVirtualId(undefined);\n                }\n              }\n              if (isMainKey && 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 _onKeyDown(event);\n          }\n\n          // If a floating element should not open on arrow key down, avoid\n          // setting `activeIndex` while it's closed.\n          if (!open && !openOnArrowKeyDown && isArrowKey) {\n            return;\n          }\n          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, disabledIndices);\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              _onKeyDown(event);\n            }\n            if (open) {\n              onNavigate(indexRef.current);\n            }\n          }\n        },\n        onFocus: function onFocus() {\n          if (open) {\n            onNavigate(null);\n          }\n        },\n        onPointerDown: checkVirtualPointer,\n        onMouseDown: checkVirtualMouse,\n        onClick: checkVirtualMouse\n      }),\n      floating: _objectSpread(_objectSpread({\n        'aria-orientation': orientation === 'both' ? undefined : orientation\n      }, !isTypeableCombobox(domReference) && ariaActiveDescendantProp), {}, {\n        onKeyDown: _onKeyDown,\n        onPointerMove: function onPointerMove() {\n          isPointerModalityRef.current = true;\n        }\n      }),\n      item: item\n    };\n  }, [domReference, refs, activeId, virtualId, disabledIndicesRef, latestOpenRef, listRef, enabled, orientation, rtl, virtual, open, hasActiveIndex, nested, selectedIndex, openOnArrowKeyDown, allowEscape, cols, loop, focusItemOnOpen, onNavigate, onOpenChange, item, tree, virtualItemRef, itemSizes, dense]);\n}\nvar 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  var open = context.open,\n    floatingId = context.floatingId;\n  var _props6 = props,\n    _props6$enabled = _props6.enabled,\n    enabled = _props6$enabled === void 0 ? true : _props6$enabled,\n    _props6$role = _props6.role,\n    role = _props6$role === void 0 ? 'dialog' : _props6$role;\n  var ariaRole = (_componentRoleToAriaR = componentRoleToAriaRoleMap.get(role)) != null ? _componentRoleToAriaR : role;\n  var referenceId = useId();\n  var parentId = useFloatingParentNodeId();\n  var isNested = parentId != null;\n  return React.useMemo(function () {\n    if (!enabled) return {};\n    var floatingProps = _objectSpread({\n      id: floatingId\n    }, ariaRole && {\n      role: ariaRole\n    });\n    if (ariaRole === 'tooltip' || role === 'label') {\n      return {\n        reference: _defineProperty({}, \"aria-\" + (role === 'label' ? 'labelledby' : 'describedby'), open ? floatingId : undefined),\n        floating: floatingProps\n      };\n    }\n    return {\n      reference: _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({\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      }), ariaRole === 'menu' && {\n        id: referenceId\n      }), ariaRole === 'menu' && isNested && {\n        role: 'menuitem'\n      }), role === 'select' && {\n        'aria-autocomplete': 'none'\n      }), role === 'combobox' && {\n        'aria-autocomplete': 'list'\n      }),\n      floating: _objectSpread(_objectSpread({}, floatingProps), ariaRole === 'menu' && {\n        'aria-labelledby': referenceId\n      }),\n      item: function item(_ref) {\n        var active = _ref.active,\n          selected = _ref.selected;\n        var commonProps = _objectSpread({\n          role: 'option'\n        }, active && {\n          id: floatingId + \"-option\"\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 _objectSpread(_objectSpread({}, commonProps), {}, {\n              'aria-selected': active && selected\n            });\n          case 'combobox':\n            {\n              return _objectSpread(_objectSpread({}, commonProps), active && {\n                'aria-selected': true\n              });\n            }\n        }\n        return {};\n      }\n    };\n  }, [enabled, role, ariaRole, open, floatingId, referenceId, isNested]);\n}\n\n// Converts a JS style key like `backgroundColor` to a CSS transition-property\n// like `background-color`.\nvar camelCaseToKebabCase = function camelCaseToKebabCase(str) {\n  return str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, function ($, ofs) {\n    return (ofs ? '-' : '') + $.toLowerCase();\n  });\n};\nfunction execWithArgsOrReturn(valueOrFn, args) {\n  return typeof valueOrFn === 'function' ? valueOrFn(args) : valueOrFn;\n}\nfunction useDelayUnmount(open, durationMs) {\n  var _React$useState25 = React.useState(open),\n    _React$useState26 = _slicedToArray(_React$useState25, 2),\n    isMounted = _React$useState26[0],\n    setIsMounted = _React$useState26[1];\n  if (open && !isMounted) {\n    setIsMounted(true);\n  }\n  React.useEffect(function () {\n    if (!open) {\n      var timeout = setTimeout(function () {\n        return setIsMounted(false);\n      }, durationMs);\n      return function () {\n        return clearTimeout(timeout);\n      };\n    }\n  }, [open, durationMs]);\n  return isMounted;\n}\n/**\n * Provides a status string to apply CSS transitions to a floating element,\n * correctly handling placement-aware transitions.\n * @see https://floating-ui.com/docs/useTransition#usetransitionstatus\n */\nfunction useTransitionStatus(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  var open = context.open,\n    floating = context.elements.floating;\n  var _props7 = props,\n    _props7$duration = _props7.duration,\n    duration = _props7$duration === void 0 ? 250 : _props7$duration;\n  var isNumberDuration = typeof duration === 'number';\n  var closeDuration = (isNumberDuration ? duration : duration.close) || 0;\n  var _React$useState27 = React.useState(false),\n    _React$useState28 = _slicedToArray(_React$useState27, 2),\n    initiated = _React$useState28[0],\n    setInitiated = _React$useState28[1];\n  var _React$useState29 = React.useState('unmounted'),\n    _React$useState30 = _slicedToArray(_React$useState29, 2),\n    status = _React$useState30[0],\n    setStatus = _React$useState30[1];\n  var isMounted = useDelayUnmount(open, closeDuration);\n\n  // `initiated` check prevents this `setState` call from breaking\n  // <FloatingPortal />. This call is necessary to ensure subsequent opens\n  // after the initial one allows the correct side animation to play when the\n  // placement has changed.\n  index(function () {\n    if (initiated && !isMounted) {\n      setStatus('unmounted');\n    }\n  }, [initiated, isMounted]);\n  index(function () {\n    if (!floating) return;\n    if (open) {\n      setStatus('initial');\n      var frame = requestAnimationFrame(function () {\n        setStatus('open');\n      });\n      return function () {\n        cancelAnimationFrame(frame);\n      };\n    }\n    setInitiated(true);\n    setStatus('close');\n  }, [open, floating]);\n  return {\n    isMounted: isMounted,\n    status: 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  var _props8 = props,\n    _props8$initial = _props8.initial,\n    unstable_initial = _props8$initial === void 0 ? {\n      opacity: 0\n    } : _props8$initial,\n    unstable_open = _props8.open,\n    unstable_close = _props8.close,\n    unstable_common = _props8.common,\n    _props8$duration = _props8.duration,\n    duration = _props8$duration === void 0 ? 250 : _props8$duration;\n  var placement = context.placement;\n  var side = placement.split('-')[0];\n  var fnArgs = React.useMemo(function () {\n    return {\n      side: side,\n      placement: placement\n    };\n  }, [side, placement]);\n  var isNumberDuration = typeof duration === 'number';\n  var openDuration = (isNumberDuration ? duration : duration.open) || 0;\n  var closeDuration = (isNumberDuration ? duration : duration.close) || 0;\n  var _React$useState31 = React.useState(function () {\n      return _objectSpread(_objectSpread({}, execWithArgsOrReturn(unstable_common, fnArgs)), execWithArgsOrReturn(unstable_initial, fnArgs));\n    }),\n    _React$useState32 = _slicedToArray(_React$useState31, 2),\n    styles = _React$useState32[0],\n    setStyles = _React$useState32[1];\n  var _useTransitionStatus = useTransitionStatus(context, {\n      duration: duration\n    }),\n    isMounted = _useTransitionStatus.isMounted,\n    status = _useTransitionStatus.status;\n  var initialRef = useLatestRef(unstable_initial);\n  var openRef = useLatestRef(unstable_open);\n  var closeRef = useLatestRef(unstable_close);\n  var commonRef = useLatestRef(unstable_common);\n  index(function () {\n    var initialStyles = execWithArgsOrReturn(initialRef.current, fnArgs);\n    var closeStyles = execWithArgsOrReturn(closeRef.current, fnArgs);\n    var commonStyles = execWithArgsOrReturn(commonRef.current, fnArgs);\n    var openStyles = execWithArgsOrReturn(openRef.current, fnArgs) || Object.keys(initialStyles).reduce(function (acc, key) {\n      acc[key] = '';\n      return acc;\n    }, {});\n    if (status === 'initial') {\n      setStyles(function (styles) {\n        return _objectSpread(_objectSpread({\n          transitionProperty: styles.transitionProperty\n        }, commonStyles), initialStyles);\n      });\n    }\n    if (status === 'open') {\n      setStyles(_objectSpread(_objectSpread({\n        transitionProperty: Object.keys(openStyles).map(camelCaseToKebabCase).join(','),\n        transitionDuration: openDuration + \"ms\"\n      }, commonStyles), openStyles));\n    }\n    if (status === 'close') {\n      var _styles = closeStyles || initialStyles;\n      setStyles(_objectSpread(_objectSpread({\n        transitionProperty: Object.keys(_styles).map(camelCaseToKebabCase).join(','),\n        transitionDuration: closeDuration + \"ms\"\n      }, commonStyles), _styles));\n    }\n  }, [closeDuration, closeRef, initialRef, openRef, commonRef, openDuration, status, fnArgs]);\n  return {\n    isMounted: isMounted,\n    styles: 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  var open = context.open,\n    dataRef = context.dataRef;\n  var listRef = props.listRef,\n    activeIndex = props.activeIndex,\n    unstable_onMatch = props.onMatch,\n    unstable_onTypingChange = props.onTypingChange,\n    _props$enabled3 = props.enabled,\n    enabled = _props$enabled3 === void 0 ? true : _props$enabled3,\n    _props$findMatch = props.findMatch,\n    findMatch = _props$findMatch === void 0 ? null : _props$findMatch,\n    _props$resetMs = props.resetMs,\n    resetMs = _props$resetMs === void 0 ? 750 : _props$resetMs,\n    _props$ignoreKeys = props.ignoreKeys,\n    ignoreKeys = _props$ignoreKeys === void 0 ? [] : _props$ignoreKeys,\n    _props$selectedIndex2 = props.selectedIndex,\n    selectedIndex = _props$selectedIndex2 === void 0 ? null : _props$selectedIndex2;\n  var timeoutIdRef = React.useRef();\n  var stringRef = React.useRef('');\n  var prevIndexRef = React.useRef((_ref = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref : -1);\n  var matchIndexRef = React.useRef(null);\n  var onMatch = useEffectEvent(unstable_onMatch);\n  var onTypingChange = useEffectEvent(unstable_onTypingChange);\n  var findMatchRef = useLatestRef(findMatch);\n  var ignoreKeysRef = useLatestRef(ignoreKeys);\n  index(function () {\n    if (open) {\n      clearTimeout(timeoutIdRef.current);\n      matchIndexRef.current = null;\n      stringRef.current = '';\n    }\n  }, [open]);\n  index(function () {\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  return React.useMemo(function () {\n    if (!enabled) {\n      return {};\n    }\n    function setTypingChange(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    function getMatchingIndex(list, orderedList, string) {\n      var str = findMatchRef.current ? findMatchRef.current(orderedList, string) : orderedList.find(function (text) {\n        return (text == null ? void 0 : text.toLocaleLowerCase().indexOf(string.toLocaleLowerCase())) === 0;\n      });\n      return str ? list.indexOf(str) : -1;\n    }\n    function onKeyDown(event) {\n      var 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      var allowRapidSuccessionOfFirstLetter = listContent.every(function (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(function () {\n        stringRef.current = '';\n        prevIndexRef.current = matchIndexRef.current;\n        setTypingChange(false);\n      }, resetMs);\n      var prevIndex = prevIndexRef.current;\n      var index = getMatchingIndex(listContent, [].concat(_toConsumableArray(listContent.slice((prevIndex || 0) + 1)), _toConsumableArray(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    return {\n      reference: {\n        onKeyDown: onKeyDown\n      },\n      floating: {\n        onKeyDown: onKeyDown,\n        onKeyUp: function onKeyUp(event) {\n          if (event.key === ' ') {\n            setTypingChange(false);\n          }\n        }\n      }\n    };\n  }, [enabled, open, dataRef, listRef, resetMs, ignoreKeysRef, findMatchRef, onMatch, onTypingChange]);\n}\nfunction getArgsWithCustomFloatingHeight(state, height) {\n  return _objectSpread(_objectSpread({}, state), {}, {\n    rects: _objectSpread(_objectSpread({}, state.rects), {}, {\n      floating: _objectSpread(_objectSpread({}, state.rects.floating), {}, {\n        height: height\n      })\n    })\n  });\n}\n/**\n * Positions the floating element such that an inner element inside\n * of it is anchored to the reference element.\n * @see https://floating-ui.com/docs/inner\n */\nvar inner = function inner(props) {\n  return {\n    name: 'inner',\n    options: props,\n    fn: function fn(state) {\n      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {\n        var listRef, overflowRef, onFallbackChange, _props$offset, innerOffset, _props$index, index, _props$minItemsVisibl, minItemsVisible, _props$referenceOverf, referenceOverflowThreshold, scrollRef, detectOverflowOptions, rects, floating, item, nextArgs, el, overflow, refOverflow, diffY, nextY, maxHeight;\n        return _regeneratorRuntime.wrap(function _callee$(_context) {\n          while (1) switch (_context.prev = _context.next) {\n            case 0:\n              listRef = props.listRef, overflowRef = props.overflowRef, onFallbackChange = props.onFallbackChange, _props$offset = props.offset, innerOffset = _props$offset === void 0 ? 0 : _props$offset, _props$index = props.index, index = _props$index === void 0 ? 0 : _props$index, _props$minItemsVisibl = props.minItemsVisible, minItemsVisible = _props$minItemsVisibl === void 0 ? 4 : _props$minItemsVisibl, _props$referenceOverf = props.referenceOverflowThreshold, referenceOverflowThreshold = _props$referenceOverf === void 0 ? 0 : _props$referenceOverf, scrollRef = props.scrollRef, detectOverflowOptions = _objectWithoutProperties(props, _excluded6);\n              rects = state.rects, floating = state.elements.floating;\n              item = listRef.current[index];\n              if (process.env.NODE_ENV !== \"production\") {\n                if (!state.placement.startsWith('bottom')) {\n                  console.warn(['Floating UI: `placement` side must be \"bottom\" when using the', '`inner` middleware.'].join(' '));\n                }\n              }\n              if (item) {\n                _context.next = 6;\n                break;\n              }\n              return _context.abrupt(\"return\", {});\n            case 6:\n              _context.t0 = _objectSpread;\n              _context.t1 = _objectSpread({}, state);\n              _context.next = 10;\n              return offset(-item.offsetTop - floating.clientTop - rects.reference.height / 2 - item.offsetHeight / 2 - innerOffset).fn(state);\n            case 10:\n              _context.t2 = _context.sent;\n              nextArgs = (0, _context.t0)(_context.t1, _context.t2);\n              el = (scrollRef == null ? void 0 : scrollRef.current) || floating;\n              _context.next = 15;\n              return detectOverflow(getArgsWithCustomFloatingHeight(nextArgs, el.scrollHeight), detectOverflowOptions);\n            case 15:\n              overflow = _context.sent;\n              _context.next = 18;\n              return detectOverflow(nextArgs, _objectSpread(_objectSpread({}, detectOverflowOptions), {}, {\n                elementContext: 'reference'\n              }));\n            case 18:\n              refOverflow = _context.sent;\n              diffY = Math.max(0, overflow.top);\n              nextY = nextArgs.y + diffY;\n              maxHeight = Math.max(0, el.scrollHeight - diffY - Math.max(0, overflow.bottom));\n              el.style.maxHeight = maxHeight + \"px\";\n              el.scrollTop = diffY;\n\n              // There is not enough space, fallback to standard anchored positioning\n              if (onFallbackChange) {\n                if (el.offsetHeight < item.offsetHeight * Math.min(minItemsVisible, listRef.current.length - 1) - 1 || refOverflow.top >= -referenceOverflowThreshold || refOverflow.bottom >= -referenceOverflowThreshold) {\n                  flushSync(function () {\n                    return onFallbackChange(true);\n                  });\n                } else {\n                  flushSync(function () {\n                    return onFallbackChange(false);\n                  });\n                }\n              }\n              if (!overflowRef) {\n                _context.next = 29;\n                break;\n              }\n              _context.next = 28;\n              return detectOverflow(getArgsWithCustomFloatingHeight(_objectSpread(_objectSpread({}, nextArgs), {}, {\n                y: nextY\n              }), el.offsetHeight), detectOverflowOptions);\n            case 28:\n              overflowRef.current = _context.sent;\n            case 29:\n              return _context.abrupt(\"return\", {\n                y: nextY\n              });\n            case 30:\n            case \"end\":\n              return _context.stop();\n          }\n        }, _callee);\n      }))();\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  var open = context.open,\n    elements = context.elements;\n  var _props$enabled4 = props.enabled,\n    enabled = _props$enabled4 === void 0 ? true : _props$enabled4,\n    overflowRef = props.overflowRef,\n    scrollRef = props.scrollRef,\n    unstable_onChange = props.onChange;\n  var onChange = useEffectEvent(unstable_onChange);\n  var controlledScrollingRef = React.useRef(false);\n  var prevScrollTopRef = React.useRef(null);\n  var initialOverflowRef = React.useRef(null);\n  React.useEffect(function () {\n    if (!enabled) {\n      return;\n    }\n    function onWheel(e) {\n      if (e.ctrlKey || !el || overflowRef.current == null) {\n        return;\n      }\n      var dY = e.deltaY;\n      var isAtTop = overflowRef.current.top >= -0.5;\n      var isAtBottom = overflowRef.current.bottom >= -0.5;\n      var remainingScroll = el.scrollHeight - el.clientHeight;\n      var sign = dY < 0 ? -1 : 1;\n      var method = dY < 0 ? 'max' : 'min';\n      if (el.scrollHeight <= el.clientHeight) {\n        return;\n      }\n      if (!isAtTop && dY > 0 || !isAtBottom && dY < 0) {\n        e.preventDefault();\n        flushSync(function () {\n          onChange(function (d) {\n            return d + Math[method](dY, remainingScroll * sign);\n          });\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    var 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(function () {\n        prevScrollTopRef.current = el.scrollTop;\n        if (overflowRef.current != null) {\n          initialOverflowRef.current = _objectSpread({}, overflowRef.current);\n        }\n      });\n      return function () {\n        prevScrollTopRef.current = null;\n        initialOverflowRef.current = null;\n        el.removeEventListener('wheel', onWheel);\n      };\n    }\n  }, [enabled, open, elements.floating, overflowRef, scrollRef, onChange]);\n  return React.useMemo(function () {\n    if (!enabled) {\n      return {};\n    }\n    return {\n      floating: {\n        onKeyDown: function onKeyDown() {\n          controlledScrollingRef.current = true;\n        },\n        onWheel: function onWheel() {\n          controlledScrollingRef.current = false;\n        },\n        onPointerMove: function onPointerMove() {\n          controlledScrollingRef.current = false;\n        },\n        onScroll: function onScroll() {\n          var 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            var scrollDiff = el.scrollTop - prevScrollTopRef.current;\n            if (overflowRef.current.bottom < -0.5 && scrollDiff < -1 || overflowRef.current.top < -0.5 && scrollDiff > 1) {\n              flushSync(function () {\n                return onChange(function (d) {\n                  return d + scrollDiff;\n                });\n              });\n            }\n          }\n\n          // [Firefox] Wait for the height change to have been applied.\n          requestAnimationFrame(function () {\n            prevScrollTopRef.current = el.scrollTop;\n          });\n        }\n      }\n    };\n  }, [enabled, overflowRef, elements.floating, scrollRef, onChange]);\n}\nfunction isPointInPolygon(point, polygon) {\n  var _point = _slicedToArray(point, 2),\n    x = _point[0],\n    y = _point[1];\n  var isInside = false;\n  var length = polygon.length;\n  for (var i = 0, j = length - 1; i < length; j = i++) {\n    var _ref9 = polygon[i] || [0, 0],\n      _ref10 = _slicedToArray(_ref9, 2),\n      xi = _ref10[0],\n      yi = _ref10[1];\n    var _ref11 = polygon[j] || [0, 0],\n      _ref12 = _slicedToArray(_ref11, 2),\n      xj = _ref12[0],\n      yj = _ref12[1];\n    var 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  var _options3 = options,\n    _options3$buffer = _options3.buffer,\n    buffer = _options3$buffer === void 0 ? 0.5 : _options3$buffer,\n    _options3$blockPointe = _options3.blockPointerEvents,\n    blockPointerEvents = _options3$blockPointe === void 0 ? false : _options3$blockPointe,\n    _options3$requireInte = _options3.requireIntent,\n    requireIntent = _options3$requireInte === void 0 ? true : _options3$requireInte;\n  var timeoutId;\n  var hasLanded = false;\n  var lastX = null;\n  var lastY = null;\n  var lastCursorTime = performance.now();\n  function getCursorSpeed(x, y) {\n    var currentTime = performance.now();\n    var 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    var deltaX = x - lastX;\n    var deltaY = y - lastY;\n    var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);\n    var speed = distance / elapsedTime; // px / ms\n\n    lastX = x;\n    lastY = y;\n    lastCursorTime = currentTime;\n    return speed;\n  }\n  var fn = function fn(_ref) {\n    var x = _ref.x,\n      y = _ref.y,\n      placement = _ref.placement,\n      elements = _ref.elements,\n      onClose = _ref.onClose,\n      nodeId = _ref.nodeId,\n      tree = _ref.tree;\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      var clientX = event.clientX,\n        clientY = event.clientY;\n      var clientPoint = [clientX, clientY];\n      var target = getTarget(event);\n      var isLeave = event.type === 'mouseleave';\n      var isOverFloatingEl = contains(elements.floating, target);\n      var isOverReferenceEl = contains(elements.domReference, target);\n      var refRect = elements.domReference.getBoundingClientRect();\n      var rect = elements.floating.getBoundingClientRect();\n      var side = placement.split('-')[0];\n      var cursorLeaveFromRight = x > rect.right - rect.width / 2;\n      var cursorLeaveFromBottom = y > rect.bottom - rect.height / 2;\n      var isOverReferenceRect = isInside(clientPoint, refRect);\n      var isFloatingWider = rect.width > refRect.width;\n      var isFloatingTaller = rect.height > refRect.height;\n      var left = (isFloatingWider ? refRect : rect).left;\n      var right = (isFloatingWider ? refRect : rect).right;\n      var top = (isFloatingTaller ? refRect : rect).top;\n      var 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(function (_ref2) {\n        var context = _ref2.context;\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      var 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        var _ref13 = _slicedToArray(_ref3, 2),\n          x = _ref13[0],\n          y = _ref13[1];\n        switch (side) {\n          case 'top':\n            {\n              var cursorPointOne = [isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y + buffer + 1];\n              var cursorPointTwo = [isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y + buffer + 1];\n              var 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].concat(commonPoints);\n            }\n          case 'bottom':\n            {\n              var _cursorPointOne = [isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y - buffer];\n              var _cursorPointTwo = [isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y - buffer];\n              var _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].concat(_commonPoints);\n            }\n          case 'left':\n            {\n              var _cursorPointOne2 = [x + buffer + 1, isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              var _cursorPointTwo2 = [x + buffer + 1, isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              var _commonPoints2 = [[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 [].concat(_commonPoints2, [_cursorPointOne2, _cursorPointTwo2]);\n            }\n          case 'right':\n            {\n              var _cursorPointOne3 = [x - buffer, isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              var _cursorPointTwo3 = [x - buffer, isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              var _commonPoints3 = [[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 [_cursorPointOne3, _cursorPointTwo3].concat(_commonPoints3);\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        var cursorSpeed = getCursorSpeed(event.clientX, event.clientY);\n        var 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: 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, useFloatingTree, useFocus, useHover, useId, useInnerOffset, useInteractions, useListItem, useListNavigation, useMergeRefs, useRole, useTransitionStatus, useTransitionStyles, useTypeahead };"],"names":["_excluded","_excluded2","_excluded3","_excluded4","_excluded5","_excluded6","_toPropertyKey","t","i","r","e","Symbol","toPrimitive","call","TypeError","String","Number","_toPrimitive","ownKeys","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","getOwnPropertyDescriptors","defineProperties","defineProperty","_createForOfIteratorHelper","allowArrayLike","it","iterator","Array","isArray","minLen","_arrayLikeToArray","n","prototype","toString","slice","constructor","name","from","test","_unsupportedIterableToArray","F","s","done","value","_e","f","err","normalCompletion","didErr","step","next","_e2","return","arr","len","arr2","useMergeRefs","refs","every","ref","current","useSafeInsertionEffect","fn","useEffectEvent","callback","_len","args","_key","ARROW_UP","ARROW_DOWN","ARROW_LEFT","ARROW_RIGHT","isDifferentRow","index","cols","prevRow","Math","floor","isIndexOutOfBounds","listRef","getMinIndex","disabledIndices","findNonDisabledIndex","getMaxIndex","decrement","startingIndex","_temp","_ref5","_ref5$startingIndex","_ref5$decrement","_ref5$amount","amount","list","isDisabledIndex","includes","element","hasAttribute","getAttribute","getGridNavigatedIndex","elementsRef","_ref","event","orientation","loop","minIndex","maxIndex","prevIndex","_ref$stopEvent","stopEvent","stop","nextIndex","key","col","maxCol","_offset","lastRow","buildCellMap","sizes","dense","cellMap","startIndex","_ref2","width","height","itemPlaced","targetCells","j","cell","concat","getCellIndexOfCorner","corner","firstCellIndex","indexOf","lastIndexOf","getCellIndices","indices","flatMap","cellIndex","rafId","enqueueFocus","el","options","_options","_options$preventScrol","preventScroll","_options$cancelPrevio","cancelPrevious","_options$sync","sync","cancelAnimationFrame","exec","focus","requestAnimationFrame","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","children","labelsRef","_React$useState","_React$useState2","setMap","node","prevMap","set","delete","newMap","sort","map1","map2","size","_step","_iterator","entries","_step$value","get","areMapsEqual","Provider","useListItem","label","_React$useState3","_React$useState4","index$1","setIndex","componentRef","_React$useContext2","_node$textContent","isLabelDefined","undefined","textContent","renderJsx","render","computedProps","CompositeContext","activeIndex","onNavigate","horizontalKeys","verticalKeys","allKeys","Composite","forwardedRef","_ref$orientation","_ref$loop","_ref$cols","_ref$disabledIndices","externalActiveIndex","externalSetActiveIndex","itemSizes","_ref$dense","props","_React$useState5","_React$useState6","internalActiveIndex","internalSetActiveIndex","renderElementProps","contextValue","isGrid","onKeyDown","minGridIndex","findIndex","maxGridIndex","reduce","foundIndex","itemIndex","toEndKeys","horizontal","vertical","both","toStartKeys","preventedKeys","stopPropagation","preventDefault","queueMicrotask","handleKeyDown","CompositeItem","_React$useContext3","_useListItem","mergedRef","isActive","tabIndex","onFocus","_extends","assign","bind","target","source","hasOwnProperty","this","serverHandoffComplete","count","genId","useId","_React$useState7","_React$useState8","id","setId","FloatingArrow","_ref$context","context","placement","floating","elements","arrow","middlewareData","_ref$width","_ref$height","_ref$tipRadius","tipRadius","_ref$strokeWidth","strokeWidth","staticOffset","stroke","d","_ref$style","style","_ref$style2","transform","restStyle","rest","clipPathId","halfStrokeWidth","svgX","svgY","_placement$split","split","_placement$split2","side","alignment","isRTL","isCustomShape","isVerticalSide","yOffsetProp","xOffsetProp","arrowX","x","arrowY","y","dValue","rotation","top","left","bottom","right","viewBox","pointerEvents","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","events","createAttribute","useLatestRef","useRef","safePolygonIdentifier","getDelay","prop","pointerType","useHover","open","onOpenChange","dataRef","_context$elements","domReference","_props","_props$enabled","enabled","_props$delay","delay","_props$handleClose","handleClose","_props$mouseOnly","mouseOnly","_props$restMs","restMs","_props$move","move","handleCloseRef","delayRef","pointerTypeRef","timeoutRef","handlerRef","restTimeoutRef","blockMouseMoveRef","performedPointerEventsMutationRef","unbindMouseMoveRef","isHoverOpen","_dataRef$current$open","type","openEvent","clearTimeout","html","documentElement","addEventListener","onLeave","removeEventListener","closeWithDelay","runElseBranch","reason","closeDelay","setTimeout","cleanupMouseMoveHandler","clearPointerEvents","body","removeAttribute","onScrollMouseLeave","onMouseEnter","once","onMouseLeave","isClickLikeOpenEvent","openDelay","doc","clientX","clientY","onClose","relatedTarget","_handleCloseRef$curre","__options","blockPointerEvents","setAttribute","_tree$nodesRef$curren","parentFloating","find","setPointerRef","reference","onPointerDown","onPointerEnter","onMouseMove","nativeEvent","FloatingDelayGroupContext","initialDelay","timeoutMs","currentId","setCurrentId","setState","isInstantPhase","useDelayGroupContext","FloatingDelayGroup","_ref$timeoutMs","_React$useReducer","prev","_React$useReducer2","state","initialCurrentIdRef","useDelayGroup","_ref3","_useDelayGroupContext","close","unset","timeout","window","getChildren","nodes","allChildren","_node$context","currentChildren","_currentChildren","some","_node$context2","counterMap","WeakMap","uncontrolledElementsSet","WeakSet","markerMap","lockCount","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","direction","allTabbable","reverse","getNextTabbable","getPreviousTabbable","isOutsideEvent","containerElement","currentTarget","disableFocusInside","dataset","tabindex","enableFocusInside","HIDDEN_STYLES","border","clip","margin","overflow","padding","whiteSpace","setActiveElementOnTab","timeoutId","FocusGuard","_React$useState9","_React$useState10","role","setRole","restProps","PortalContext","attr","useFloatingPortalNode","_ref7","root","_React$useState11","_React$useState12","portalNode","setPortalNode","uniqueId","portalContext","usePortalContext","portalNodeRef","remove","existingIdRoot","getElementById","subRoot","createElement","appendChild","idWrapper","FloatingPortal","_ref$root","_ref$preserveTabOrder","preserveTabOrder","_React$useState13","_React$useState14","focusManagerState","setFocusManagerState","beforeOutsideRef","afterOutsideRef","beforeInsideRef","afterInsideRef","shouldRenderGuards","modal","_beforeInsideRef$curr","prevTabbable","createPortal","_afterInsideRef$curre","nextTabbable","closeOnFocusOut","LIST_LIMIT","previouslyFocusedElements","addPreviouslyFocusedElement","isConnected","getPreviouslyFocusedElement","VisuallyHiddenDismiss","FloatingFocusManager","_props$disabled","disabled","_props$order","order","_props$guards","guards","_guards","_props$initialFocus","initialFocus","_props$returnFocus","returnFocus","_props$modal","_props$visuallyHidden","visuallyHiddenDismiss","_props$closeOnFocusOu","nodeId","_context$elements2","ignoreInitialFocus","isUntrappedTypeableCombobox","orderRef","initialFocusRef","returnFocusRef","startDismissButtonRef","endDismissButtonRef","preventReturnFocusRef","isPointerDownRef","isInsidePortal","getTabbableContent","getTabbableElements","content","Boolean","flat","renderDismissButton","location","onClick","els","shiftKey","handleFocusOutside","handlePointerDown","movedToUnrelatedNode","_nodes$find","allAncestors","currentParentId","currentNode","getAncestors","_node$context3","_node$context4","_portalContext$portal","portalNodes","insideElements","cleanup","previouslyFocusedElement","focusableElements","initialFocusValue","elToFocus","focusAlreadyInsideFloatingEl","preventReturnFocusScroll","contextData","activeEl","isFocusInsideFloatingTree","_node$context5","returnElement","nested","MutationObserver","handleMutation","observer","observe","childList","subtree","attributes","disconnect","_portalContext$before","_portalContext$afterO","activeLocks","FloatingOverlay","_ref$lockScroll","lockScroll","lockId","isIOS","bodyStyle","paddingProp","round","getBoundingClientRect","scrollLeft","scrollbarWidth","innerWidth","clientWidth","scrollX","parseFloat","pageXOffset","scrollY","pageYOffset","_window$visualViewpor","_window$visualViewpor2","offsetLeft","visualViewport","offsetTop","scrollTo","isButtonTarget","tagName","isSpaceIgnored","useClick","_props2","_props2$enabled","_props2$event","eventOption","_props2$toggle","toggle","_props2$ignoreMouse","ignoreMouse","_props2$keyboardHandl","keyboardHandlers","didKeyDownRef","onMouseDown","button","defaultPrevented","onKeyUp","isMouseBasedEvent","useClientPoint","_props3","_props3$enabled","_props3$axis","axis","_props3$x","_props3$y","initialRef","cleanupListenerRef","_React$useState15","_React$useState16","setPointerType","_React$useState17","_React$useState18","reactive","setReactive","setReference","domRef","offsetX","offsetY","isAutoUpdateEvent","setPositionReference","contextElement","_domRef$current","_data$dataRef$current","domRect","isXAxis","isYAxis","canTrackCursorOnAutoUpdate","handleReferenceEnterOrMove","openCheck","addListener","win","handleMouseMove","setPointerTypeRef","bubbleHandlerKeys","pointerdown","mousedown","click","captureHandlerKeys","normalizeProp","normalizable","_normalizable$escapeK","_normalizable$outside","escapeKey","outsidePress","useDismiss","_context$elements3","_props4","_props4$enabled","_props4$escapeKey","_props4$outsidePress","unstable_outsidePress","_props4$outsidePressE","outsidePressEvent","_props4$referencePres","referencePress","_props4$referencePres2","referencePressEvent","_props4$ancestorScrol","ancestorScroll","bubbles","capture","outsidePressFn","insideReactTreeRef","endedOrStartedInsideRef","_normalizeProp","escapeKeyBubbles","outsidePressBubbles","_normalizeProp2","escapeKeyCapture","outsidePressCapture","closeOnEscapeKeyDown","shouldDismiss","child","_child$context","__escapeKeyBubbles","closeOnEscapeKeyDownCapture","_getTarget2","_getTarget","closeOnPressOutside","insideReactTree","endedOrStartedInside","inertSelector","markers","targetRootAncestor","nextParent","marker","canScrollX","scrollWidth","canScrollY","clientHeight","scrollHeight","xCond","offsetWidth","targetIsInsideChildren","_child$context2","__outsidePressBubbles","closeOnPressOutsideCapture","_getTarget4","_getTarget3","ancestors","ancestor","_doc$defaultView","defaultView","onScroll","passive","onMouseUp","useFloating","_options$elements2","_options2","_options2$open","unstable_onOpenChange","_React$useState19","_React$useState20","_domReference","setDomReference","domReferenceRef","floatingId","positionReference","useFocus","_props5","_props5$enabled","_props5$visibleOnly","visibleOnly","blockFocusRef","keyboardModalityRef","onBlur","Error","matches","movedToFocusGuard","ownerDocument","ACTIVE_KEY","SELECTED_KEY","mergeProps","userProps","propsList","elementKey","isItem","domUserProps","propsOrGetProps","acc","_ref8","val","useInteractions","deps","getReferenceProps","getFloatingProps","getItemProps","item","isPreventScrollSupported","doSwitch","isMainOrientationKey","isMainOrientationToEndKey","rtl","isCrossOrientationCloseKey","useListNavigation","_context$elements4","_props$onNavigate","unstable_onNavigate","_props$enabled2","_props$selectedIndex","selectedIndex","_props$allowEscape","allowEscape","_props$loop","_props$nested","_props$rtl","_props$virtual","virtual","_props$focusItemOnOpe","focusItemOnOpen","_props$focusItemOnHov","focusItemOnHover","_props$openOnArrowKey","openOnArrowKeyDown","_props$disabledIndice","_props$orientation","_props$cols","_props$scrollItemInto","scrollItemIntoView","virtualItemRef","_props$dense","focusItemOnOpenRef","indexRef","keyRef","isPointerModalityRef","previousOnNavigateRef","previousMountedRef","forceSyncFocus","forceScrollIntoViewRef","disabledIndicesRef","latestOpenRef","scrollItemIntoViewRef","_React$useState21","_React$useState22","activeId","setActiveId","_React$useState23","_React$useState24","virtualId","setVirtualId","focusItem","forceScrollIntoView","scrollIntoViewOptions","scrollIntoView","block","inline","runs","waitForListPopulated","treeContainsActiveEl","handleVirtualFocus","hasActiveIndex","syncCurrentTarget","onPointerLeave","_ref4","_onKeyDown","currentIndex","min","max","checkVirtualMouse","ariaActiveDescendantProp","activeItem","deepestNodeId","maxDepth","isArrowKey","isCrossOpenKey","isCrossOrientationOpenKey","isCrossCloseKey","isMainKey","isNavigationKey","trim","rootNode","deepestNode","findDeepest","depth","_deepestNode$context$","eventObject","KeyboardEvent","_deepestNode$context","_deepestNode$context2","isCurrentTarget","dispatchItem","dispatchEvent","onPointerMove","componentRoleToAriaRoleMap","useRole","_componentRoleToAriaR","_props6","_props6$enabled","_props6$role","ariaRole","referenceId","isNested","floatingProps","active","selected","commonProps","camelCaseToKebabCase","str","replace","$","ofs","toLowerCase","execWithArgsOrReturn","valueOrFn","useTransitionStatus","_props7$duration","duration","closeDuration","_React$useState27","_React$useState28","initiated","setInitiated","_React$useState29","_React$useState30","status","setStatus","isMounted","durationMs","_React$useState25","_React$useState26","setIsMounted","useDelayUnmount","frame","useTransitionStyles","_props8","_props8$initial","initial","unstable_initial","opacity","unstable_open","unstable_close","unstable_common","common","_props8$duration","fnArgs","isNumberDuration","openDuration","_React$useState31","_React$useState32","styles","setStyles","_useTransitionStatus","openRef","closeRef","commonRef","initialStyles","closeStyles","commonStyles","openStyles","transitionProperty","join","transitionDuration","_styles","useTypeahead","unstable_onMatch","onMatch","unstable_onTypingChange","onTypingChange","_props$enabled3","_props$findMatch","findMatch","_props$resetMs","resetMs","_props$ignoreKeys","ignoreKeys","_props$selectedIndex2","timeoutIdRef","stringRef","prevIndexRef","matchIndexRef","findMatchRef","ignoreKeysRef","setTypingChange","typing","getMatchingIndex","orderedList","string","text","toLocaleLowerCase","listContent","ctrlKey","metaKey","altKey","_text$","_text$2","getArgsWithCustomFloatingHeight","rects","inner","_callee","overflowRef","onFallbackChange","_props$offset","innerOffset","_props$index","_props$minItemsVisibl","minItemsVisible","_props$referenceOverf","referenceOverflowThreshold","scrollRef","detectOverflowOptions","nextArgs","refOverflow","diffY","nextY","maxHeight","_context","offset","abrupt","t0","t1","clientTop","offsetHeight","t2","sent","elementContext","scrollTop","flushSync","useInnerOffset","_props$enabled4","onChange","controlledScrollingRef","prevScrollTopRef","initialOverflowRef","onWheel","dY","deltaY","isAtTop","isAtBottom","remainingScroll","sign","method","scrollDiff","isPointInPolygon","point","polygon","_point","isInside","_ref9","_ref10","xi","yi","_ref11","_ref12","xj","yj","safePolygon","_options3","_options3$buffer","buffer","_options3$blockPointe","_options3$requireInte","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","_ref13","cursorPointOne","cursorPointTwo","commonPoints","_cursorPointOne","_cursorPointTwo","_commonPoints","_cursorPointOne2","_cursorPointTwo2","_commonPoints2","_cursorPointOne3","_cursorPointTwo3","_commonPoints3","getPolygon"],"sourceRoot":""}