{"version":3,"file":"js/371-e0e2a3366286213f6d83.js","mappings":"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","sources":["webpack://app/./node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs","webpack://app/./node_modules/@floating-ui/react/dist/floating-ui.react.utils.mjs","webpack://app/./node_modules/@floating-ui/react-dom/node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs","webpack://app/./node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs","webpack://app/./node_modules/@floating-ui/react/dist/floating-ui.react.esm.js","webpack://app/./node_modules/lodash.debounce/index.js","webpack://app/./node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs"],"sourcesContent":["function hasWindow() {\n  return typeof window !== 'undefined';\n}\nfunction getNodeName(node) {\n  if (isNode(node)) {\n    return (node.nodeName || '').toLowerCase();\n  }\n  // Mocked nodes in testing environments may not be instances of Node. By\n  // returning `#document` an infinite loop won't occur.\n  // https://github.com/floating-ui/floating-ui/issues/2317\n  return '#document';\n}\nfunction getWindow(node) {\n  var _node$ownerDocument;\n  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;\n}\nfunction getDocumentElement(node) {\n  var _ref;\n  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;\n}\nfunction isNode(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof Node || value instanceof getWindow(value).Node;\n}\nfunction isElement(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof Element || value instanceof getWindow(value).Element;\n}\nfunction isHTMLElement(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;\n}\nfunction isShadowRoot(value) {\n  if (!hasWindow() || typeof ShadowRoot === 'undefined') {\n    return false;\n  }\n  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;\n}\nfunction isOverflowElement(element) {\n  const {\n    overflow,\n    overflowX,\n    overflowY,\n    display\n  } = getComputedStyle(element);\n  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);\n}\nfunction isTableElement(element) {\n  return ['table', 'td', 'th'].includes(getNodeName(element));\n}\nfunction isTopLayer(element) {\n  return [':popover-open', ':modal'].some(selector => {\n    try {\n      return element.matches(selector);\n    } catch (e) {\n      return false;\n    }\n  });\n}\nfunction isContainingBlock(elementOrCss) {\n  const webkit = isWebKit();\n  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));\n}\nfunction getContainingBlock(element) {\n  let currentNode = getParentNode(element);\n  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    if (isContainingBlock(currentNode)) {\n      return currentNode;\n    } else if (isTopLayer(currentNode)) {\n      return null;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  return null;\n}\nfunction isWebKit() {\n  if (typeof CSS === 'undefined' || !CSS.supports) return false;\n  return CSS.supports('-webkit-backdrop-filter', 'none');\n}\nfunction isLastTraversableNode(node) {\n  return ['html', 'body', '#document'].includes(getNodeName(node));\n}\nfunction getComputedStyle(element) {\n  return getWindow(element).getComputedStyle(element);\n}\nfunction getNodeScroll(element) {\n  if (isElement(element)) {\n    return {\n      scrollLeft: element.scrollLeft,\n      scrollTop: element.scrollTop\n    };\n  }\n  return {\n    scrollLeft: element.scrollX,\n    scrollTop: element.scrollY\n  };\n}\nfunction getParentNode(node) {\n  if (getNodeName(node) === 'html') {\n    return node;\n  }\n  const result =\n  // Step into the shadow DOM of the parent of a slotted node.\n  node.assignedSlot ||\n  // DOM Element detected.\n  node.parentNode ||\n  // ShadowRoot detected.\n  isShadowRoot(node) && node.host ||\n  // Fallback.\n  getDocumentElement(node);\n  return isShadowRoot(result) ? result.host : result;\n}\nfunction getNearestOverflowAncestor(node) {\n  const parentNode = getParentNode(node);\n  if (isLastTraversableNode(parentNode)) {\n    return node.ownerDocument ? node.ownerDocument.body : node.body;\n  }\n  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {\n    return parentNode;\n  }\n  return getNearestOverflowAncestor(parentNode);\n}\nfunction getOverflowAncestors(node, list, traverseIframes) {\n  var _node$ownerDocument2;\n  if (list === void 0) {\n    list = [];\n  }\n  if (traverseIframes === void 0) {\n    traverseIframes = true;\n  }\n  const scrollableAncestor = getNearestOverflowAncestor(node);\n  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);\n  const win = getWindow(scrollableAncestor);\n  if (isBody) {\n    const frameElement = getFrameElement(win);\n    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);\n  }\n  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));\n}\nfunction getFrameElement(win) {\n  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;\n}\n\nexport { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isTopLayer, isWebKit };\n","import { isShadowRoot, isHTMLElement } from '@floating-ui/utils/dom';\n\nfunction activeElement(doc) {\n  let activeElement = doc.activeElement;\n  while (((_activeElement = activeElement) == null || (_activeElement = _activeElement.shadowRoot) == null ? void 0 : _activeElement.activeElement) != null) {\n    var _activeElement;\n    activeElement = activeElement.shadowRoot.activeElement;\n  }\n  return activeElement;\n}\nfunction contains(parent, child) {\n  if (!parent || !child) {\n    return false;\n  }\n  const rootNode = child.getRootNode == null ? void 0 : child.getRootNode();\n\n  // First, attempt with faster native method\n  if (parent.contains(child)) {\n    return true;\n  }\n\n  // then fallback to custom implementation with Shadow DOM support\n  if (rootNode && isShadowRoot(rootNode)) {\n    let next = child;\n    while (next) {\n      if (parent === next) {\n        return true;\n      }\n      // @ts-ignore\n      next = next.parentNode || next.host;\n    }\n  }\n\n  // Give up, the result is false\n  return false;\n}\n// Avoid Chrome DevTools blue warning.\nfunction getPlatform() {\n  const uaData = navigator.userAgentData;\n  if (uaData != null && uaData.platform) {\n    return uaData.platform;\n  }\n  return navigator.platform;\n}\nfunction getUserAgent() {\n  const uaData = navigator.userAgentData;\n  if (uaData && Array.isArray(uaData.brands)) {\n    return uaData.brands.map(_ref => {\n      let {\n        brand,\n        version\n      } = _ref;\n      return brand + \"/\" + version;\n    }).join(' ');\n  }\n  return navigator.userAgent;\n}\n\n// License: https://github.com/adobe/react-spectrum/blob/b35d5c02fe900badccd0cf1a8f23bb593419f238/packages/@react-aria/utils/src/isVirtualEvent.ts\nfunction isVirtualClick(event) {\n  // FIXME: Firefox is now emitting a deprecation warning for `mozInputSource`.\n  // Try to find a workaround for this. `react-aria` source still has the check.\n  if (event.mozInputSource === 0 && event.isTrusted) {\n    return true;\n  }\n  if (isAndroid() && event.pointerType) {\n    return event.type === 'click' && event.buttons === 1;\n  }\n  return event.detail === 0 && !event.pointerType;\n}\nfunction isVirtualPointerEvent(event) {\n  if (isJSDOM()) return false;\n  return !isAndroid() && event.width === 0 && event.height === 0 || isAndroid() && event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === 'mouse' ||\n  // iOS VoiceOver returns 0.333• for width/height.\n  event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === 'touch';\n}\nfunction isSafari() {\n  // Chrome DevTools does not complain about navigator.vendor\n  return /apple/i.test(navigator.vendor);\n}\nfunction isAndroid() {\n  const re = /android/i;\n  return re.test(getPlatform()) || re.test(getUserAgent());\n}\nfunction isMac() {\n  return getPlatform().toLowerCase().startsWith('mac') && !navigator.maxTouchPoints;\n}\nfunction isJSDOM() {\n  return getUserAgent().includes('jsdom/');\n}\nfunction isMouseLikePointerType(pointerType, strict) {\n  // On some Linux machines with Chromium, mouse inputs return a `pointerType`\n  // of \"pen\": https://github.com/floating-ui/floating-ui/issues/2015\n  const values = ['mouse', 'pen'];\n  if (!strict) {\n    values.push('', undefined);\n  }\n  return values.includes(pointerType);\n}\nfunction isReactEvent(event) {\n  return 'nativeEvent' in event;\n}\nfunction isRootElement(element) {\n  return element.matches('html,body');\n}\nfunction getDocument(node) {\n  return (node == null ? void 0 : node.ownerDocument) || document;\n}\nfunction isEventTargetWithin(event, node) {\n  if (node == null) {\n    return false;\n  }\n  if ('composedPath' in event) {\n    return event.composedPath().includes(node);\n  }\n\n  // TS thinks `event` is of type never as it assumes all browsers support composedPath, but browsers without shadow dom don't\n  const e = event;\n  return e.target != null && node.contains(e.target);\n}\nfunction getTarget(event) {\n  if ('composedPath' in event) {\n    return event.composedPath()[0];\n  }\n\n  // TS thinks `event` is of type never as it assumes all browsers support\n  // `composedPath()`, but browsers without shadow DOM don't.\n  return event.target;\n}\nconst TYPEABLE_SELECTOR = \"input:not([type='hidden']):not([disabled]),\" + \"[contenteditable]:not([contenteditable='false']),textarea:not([disabled])\";\nfunction isTypeableElement(element) {\n  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);\n}\nfunction stopEvent(event) {\n  event.preventDefault();\n  event.stopPropagation();\n}\nfunction isTypeableCombobox(element) {\n  if (!element) return false;\n  return element.getAttribute('role') === 'combobox' && isTypeableElement(element);\n}\n\nexport { TYPEABLE_SELECTOR, activeElement, contains, getDocument, getPlatform, getTarget, getUserAgent, isAndroid, isEventTargetWithin, isJSDOM, isMac, isMouseLikePointerType, isReactEvent, isRootElement, isSafari, isTypeableCombobox, isTypeableElement, isVirtualClick, isVirtualPointerEvent, stopEvent };\n","import { rectToClientRect, detectOverflow as detectOverflow$1, offset as offset$1, autoPlacement as autoPlacement$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, arrow as arrow$1, inline as inline$1, limitShift as limitShift$1, computePosition as computePosition$1 } from '@floating-ui/core';\nimport { round, createCoords, max, min, floor } from '@floating-ui/utils';\nimport { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getFrameElement, getNodeScroll, getDocumentElement, isTopLayer, getNodeName, isOverflowElement, getOverflowAncestors, getParentNode, isLastTraversableNode, isContainingBlock, isTableElement, getContainingBlock } from '@floating-ui/utils/dom';\nexport { getOverflowAncestors } from '@floating-ui/utils/dom';\n\nfunction getCssDimensions(element) {\n  const css = getComputedStyle(element);\n  // In testing environments, the `width` and `height` properties are empty\n  // strings for SVG elements, returning NaN. Fallback to `0` in this case.\n  let width = parseFloat(css.width) || 0;\n  let height = parseFloat(css.height) || 0;\n  const hasOffset = isHTMLElement(element);\n  const offsetWidth = hasOffset ? element.offsetWidth : width;\n  const offsetHeight = hasOffset ? element.offsetHeight : height;\n  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;\n  if (shouldFallback) {\n    width = offsetWidth;\n    height = offsetHeight;\n  }\n  return {\n    width,\n    height,\n    $: shouldFallback\n  };\n}\n\nfunction unwrapElement(element) {\n  return !isElement(element) ? element.contextElement : element;\n}\n\nfunction getScale(element) {\n  const domElement = unwrapElement(element);\n  if (!isHTMLElement(domElement)) {\n    return createCoords(1);\n  }\n  const rect = domElement.getBoundingClientRect();\n  const {\n    width,\n    height,\n    $\n  } = getCssDimensions(domElement);\n  let x = ($ ? round(rect.width) : rect.width) / width;\n  let y = ($ ? round(rect.height) : rect.height) / height;\n\n  // 0, NaN, or Infinity should always fallback to 1.\n\n  if (!x || !Number.isFinite(x)) {\n    x = 1;\n  }\n  if (!y || !Number.isFinite(y)) {\n    y = 1;\n  }\n  return {\n    x,\n    y\n  };\n}\n\nconst noOffsets = /*#__PURE__*/createCoords(0);\nfunction getVisualOffsets(element) {\n  const win = getWindow(element);\n  if (!isWebKit() || !win.visualViewport) {\n    return noOffsets;\n  }\n  return {\n    x: win.visualViewport.offsetLeft,\n    y: win.visualViewport.offsetTop\n  };\n}\nfunction shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {\n  if (isFixed === void 0) {\n    isFixed = false;\n  }\n  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {\n    return false;\n  }\n  return isFixed;\n}\n\nfunction getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {\n  if (includeScale === void 0) {\n    includeScale = false;\n  }\n  if (isFixedStrategy === void 0) {\n    isFixedStrategy = false;\n  }\n  const clientRect = element.getBoundingClientRect();\n  const domElement = unwrapElement(element);\n  let scale = createCoords(1);\n  if (includeScale) {\n    if (offsetParent) {\n      if (isElement(offsetParent)) {\n        scale = getScale(offsetParent);\n      }\n    } else {\n      scale = getScale(element);\n    }\n  }\n  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);\n  let x = (clientRect.left + visualOffsets.x) / scale.x;\n  let y = (clientRect.top + visualOffsets.y) / scale.y;\n  let width = clientRect.width / scale.x;\n  let height = clientRect.height / scale.y;\n  if (domElement) {\n    const win = getWindow(domElement);\n    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;\n    let currentWin = win;\n    let currentIFrame = getFrameElement(currentWin);\n    while (currentIFrame && offsetParent && offsetWin !== currentWin) {\n      const iframeScale = getScale(currentIFrame);\n      const iframeRect = currentIFrame.getBoundingClientRect();\n      const css = getComputedStyle(currentIFrame);\n      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;\n      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;\n      x *= iframeScale.x;\n      y *= iframeScale.y;\n      width *= iframeScale.x;\n      height *= iframeScale.y;\n      x += left;\n      y += top;\n      currentWin = getWindow(currentIFrame);\n      currentIFrame = getFrameElement(currentWin);\n    }\n  }\n  return rectToClientRect({\n    width,\n    height,\n    x,\n    y\n  });\n}\n\n// If <html> has a CSS width greater than the viewport, then this will be\n// incorrect for RTL.\nfunction getWindowScrollBarX(element, rect) {\n  const leftScroll = getNodeScroll(element).scrollLeft;\n  if (!rect) {\n    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;\n  }\n  return rect.left + leftScroll;\n}\n\nfunction getHTMLOffset(documentElement, scroll, ignoreScrollbarX) {\n  if (ignoreScrollbarX === void 0) {\n    ignoreScrollbarX = false;\n  }\n  const htmlRect = documentElement.getBoundingClientRect();\n  const x = htmlRect.left + scroll.scrollLeft - (ignoreScrollbarX ? 0 :\n  // RTL <body> scrollbar.\n  getWindowScrollBarX(documentElement, htmlRect));\n  const y = htmlRect.top + scroll.scrollTop;\n  return {\n    x,\n    y\n  };\n}\n\nfunction convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {\n  let {\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  } = _ref;\n  const isFixed = strategy === 'fixed';\n  const documentElement = getDocumentElement(offsetParent);\n  const topLayer = elements ? isTopLayer(elements.floating) : false;\n  if (offsetParent === documentElement || topLayer && isFixed) {\n    return rect;\n  }\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  let scale = createCoords(1);\n  const offsets = createCoords(0);\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isHTMLElement(offsetParent)) {\n      const offsetRect = getBoundingClientRect(offsetParent);\n      scale = getScale(offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    }\n  }\n  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll, true) : createCoords(0);\n  return {\n    width: rect.width * scale.x,\n    height: rect.height * scale.y,\n    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,\n    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y\n  };\n}\n\nfunction getClientRects(element) {\n  return Array.from(element.getClientRects());\n}\n\n// Gets the entire size of the scrollable document area, even extending outside\n// of the `<html>` and `<body>` rect bounds if horizontally scrollable.\nfunction getDocumentRect(element) {\n  const html = getDocumentElement(element);\n  const scroll = getNodeScroll(element);\n  const body = element.ownerDocument.body;\n  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);\n  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);\n  let x = -scroll.scrollLeft + getWindowScrollBarX(element);\n  const y = -scroll.scrollTop;\n  if (getComputedStyle(body).direction === 'rtl') {\n    x += max(html.clientWidth, body.clientWidth) - width;\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\nfunction getViewportRect(element, strategy) {\n  const win = getWindow(element);\n  const html = getDocumentElement(element);\n  const visualViewport = win.visualViewport;\n  let width = html.clientWidth;\n  let height = html.clientHeight;\n  let x = 0;\n  let y = 0;\n  if (visualViewport) {\n    width = visualViewport.width;\n    height = visualViewport.height;\n    const visualViewportBased = isWebKit();\n    if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {\n      x = visualViewport.offsetLeft;\n      y = visualViewport.offsetTop;\n    }\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\n// Returns the inner client rect, subtracting scrollbars if present.\nfunction getInnerBoundingClientRect(element, strategy) {\n  const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');\n  const top = clientRect.top + element.clientTop;\n  const left = clientRect.left + element.clientLeft;\n  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);\n  const width = element.clientWidth * scale.x;\n  const height = element.clientHeight * scale.y;\n  const x = left * scale.x;\n  const y = top * scale.y;\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\nfunction getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {\n  let rect;\n  if (clippingAncestor === 'viewport') {\n    rect = getViewportRect(element, strategy);\n  } else if (clippingAncestor === 'document') {\n    rect = getDocumentRect(getDocumentElement(element));\n  } else if (isElement(clippingAncestor)) {\n    rect = getInnerBoundingClientRect(clippingAncestor, strategy);\n  } else {\n    const visualOffsets = getVisualOffsets(element);\n    rect = {\n      x: clippingAncestor.x - visualOffsets.x,\n      y: clippingAncestor.y - visualOffsets.y,\n      width: clippingAncestor.width,\n      height: clippingAncestor.height\n    };\n  }\n  return rectToClientRect(rect);\n}\nfunction hasFixedPositionAncestor(element, stopNode) {\n  const parentNode = getParentNode(element);\n  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {\n    return false;\n  }\n  return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);\n}\n\n// A \"clipping ancestor\" is an `overflow` element with the characteristic of\n// clipping (or hiding) child elements. This returns all clipping ancestors\n// of the given element up the tree.\nfunction getClippingElementAncestors(element, cache) {\n  const cachedResult = cache.get(element);\n  if (cachedResult) {\n    return cachedResult;\n  }\n  let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');\n  let currentContainingBlockComputedStyle = null;\n  const elementIsFixed = getComputedStyle(element).position === 'fixed';\n  let currentNode = elementIsFixed ? getParentNode(element) : element;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    const computedStyle = getComputedStyle(currentNode);\n    const currentNodeIsContaining = isContainingBlock(currentNode);\n    if (!currentNodeIsContaining && computedStyle.position === 'fixed') {\n      currentContainingBlockComputedStyle = null;\n    }\n    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);\n    if (shouldDropCurrentNode) {\n      // Drop non-containing blocks.\n      result = result.filter(ancestor => ancestor !== currentNode);\n    } else {\n      // Record last containing block for next iteration.\n      currentContainingBlockComputedStyle = computedStyle;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  cache.set(element, result);\n  return result;\n}\n\n// Gets the maximum area that the element is visible in due to any number of\n// clipping ancestors.\nfunction getClippingRect(_ref) {\n  let {\n    element,\n    boundary,\n    rootBoundary,\n    strategy\n  } = _ref;\n  const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);\n  const clippingAncestors = [...elementClippingAncestors, rootBoundary];\n  const firstClippingAncestor = clippingAncestors[0];\n  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {\n    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);\n    accRect.top = max(rect.top, accRect.top);\n    accRect.right = min(rect.right, accRect.right);\n    accRect.bottom = min(rect.bottom, accRect.bottom);\n    accRect.left = max(rect.left, accRect.left);\n    return accRect;\n  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));\n  return {\n    width: clippingRect.right - clippingRect.left,\n    height: clippingRect.bottom - clippingRect.top,\n    x: clippingRect.left,\n    y: clippingRect.top\n  };\n}\n\nfunction getDimensions(element) {\n  const {\n    width,\n    height\n  } = getCssDimensions(element);\n  return {\n    width,\n    height\n  };\n}\n\nfunction getRectRelativeToOffsetParent(element, offsetParent, strategy) {\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n  const isFixed = strategy === 'fixed';\n  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  const offsets = createCoords(0);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isOffsetParentAnElement) {\n      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    } else if (documentElement) {\n      // If the <body> scrollbar appears on the left (e.g. RTL systems). Use\n      // Firefox with layout.scrollbar.side = 3 in about:config to test this.\n      offsets.x = getWindowScrollBarX(documentElement);\n    }\n  }\n  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);\n  const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;\n  const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;\n  return {\n    x,\n    y,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\nfunction isStaticPositioned(element) {\n  return getComputedStyle(element).position === 'static';\n}\n\nfunction getTrueOffsetParent(element, polyfill) {\n  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {\n    return null;\n  }\n  if (polyfill) {\n    return polyfill(element);\n  }\n  let rawOffsetParent = element.offsetParent;\n\n  // Firefox returns the <html> element as the offsetParent if it's non-static,\n  // while Chrome and Safari return the <body> element. The <body> element must\n  // be used to perform the correct calculations even if the <html> element is\n  // non-static.\n  if (getDocumentElement(element) === rawOffsetParent) {\n    rawOffsetParent = rawOffsetParent.ownerDocument.body;\n  }\n  return rawOffsetParent;\n}\n\n// Gets the closest ancestor positioned element. Handles some edge cases,\n// such as table ancestors and cross browser bugs.\nfunction getOffsetParent(element, polyfill) {\n  const win = getWindow(element);\n  if (isTopLayer(element)) {\n    return win;\n  }\n  if (!isHTMLElement(element)) {\n    let svgOffsetParent = getParentNode(element);\n    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {\n      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {\n        return svgOffsetParent;\n      }\n      svgOffsetParent = getParentNode(svgOffsetParent);\n    }\n    return win;\n  }\n  let offsetParent = getTrueOffsetParent(element, polyfill);\n  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {\n    offsetParent = getTrueOffsetParent(offsetParent, polyfill);\n  }\n  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {\n    return win;\n  }\n  return offsetParent || getContainingBlock(element) || win;\n}\n\nconst getElementRects = async function (data) {\n  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;\n  const getDimensionsFn = this.getDimensions;\n  const floatingDimensions = await getDimensionsFn(data.floating);\n  return {\n    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),\n    floating: {\n      x: 0,\n      y: 0,\n      width: floatingDimensions.width,\n      height: floatingDimensions.height\n    }\n  };\n};\n\nfunction isRTL(element) {\n  return getComputedStyle(element).direction === 'rtl';\n}\n\nconst platform = {\n  convertOffsetParentRelativeRectToViewportRelativeRect,\n  getDocumentElement,\n  getClippingRect,\n  getOffsetParent,\n  getElementRects,\n  getClientRects,\n  getDimensions,\n  getScale,\n  isElement,\n  isRTL\n};\n\n// https://samthor.au/2021/observing-dom/\nfunction observeMove(element, onMove) {\n  let io = null;\n  let timeoutId;\n  const root = getDocumentElement(element);\n  function cleanup() {\n    var _io;\n    clearTimeout(timeoutId);\n    (_io = io) == null || _io.disconnect();\n    io = null;\n  }\n  function refresh(skip, threshold) {\n    if (skip === void 0) {\n      skip = false;\n    }\n    if (threshold === void 0) {\n      threshold = 1;\n    }\n    cleanup();\n    const {\n      left,\n      top,\n      width,\n      height\n    } = element.getBoundingClientRect();\n    if (!skip) {\n      onMove();\n    }\n    if (!width || !height) {\n      return;\n    }\n    const insetTop = floor(top);\n    const insetRight = floor(root.clientWidth - (left + width));\n    const insetBottom = floor(root.clientHeight - (top + height));\n    const insetLeft = floor(left);\n    const rootMargin = -insetTop + \"px \" + -insetRight + \"px \" + -insetBottom + \"px \" + -insetLeft + \"px\";\n    const options = {\n      rootMargin,\n      threshold: max(0, min(1, threshold)) || 1\n    };\n    let isFirstUpdate = true;\n    function handleObserve(entries) {\n      const ratio = entries[0].intersectionRatio;\n      if (ratio !== threshold) {\n        if (!isFirstUpdate) {\n          return refresh();\n        }\n        if (!ratio) {\n          // If the reference is clipped, the ratio is 0. Throttle the refresh\n          // to prevent an infinite loop of updates.\n          timeoutId = setTimeout(() => {\n            refresh(false, 1e-7);\n          }, 1000);\n        } else {\n          refresh(false, ratio);\n        }\n      }\n      isFirstUpdate = false;\n    }\n\n    // Older browsers don't support a `document` as the root and will throw an\n    // error.\n    try {\n      io = new IntersectionObserver(handleObserve, {\n        ...options,\n        // Handle <iframe>s\n        root: root.ownerDocument\n      });\n    } catch (e) {\n      io = new IntersectionObserver(handleObserve, options);\n    }\n    io.observe(element);\n  }\n  refresh(true);\n  return cleanup;\n}\n\n/**\n * Automatically updates the position of the floating element when necessary.\n * Should only be called when the floating element is mounted on the DOM or\n * visible on the screen.\n * @returns cleanup function that should be invoked when the floating element is\n * removed from the DOM or hidden from the screen.\n * @see https://floating-ui.com/docs/autoUpdate\n */\nfunction autoUpdate(reference, floating, update, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    ancestorScroll = true,\n    ancestorResize = true,\n    elementResize = typeof ResizeObserver === 'function',\n    layoutShift = typeof IntersectionObserver === 'function',\n    animationFrame = false\n  } = options;\n  const referenceEl = unwrapElement(reference);\n  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];\n  ancestors.forEach(ancestor => {\n    ancestorScroll && ancestor.addEventListener('scroll', update, {\n      passive: true\n    });\n    ancestorResize && ancestor.addEventListener('resize', update);\n  });\n  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;\n  let reobserveFrame = -1;\n  let resizeObserver = null;\n  if (elementResize) {\n    resizeObserver = new ResizeObserver(_ref => {\n      let [firstEntry] = _ref;\n      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {\n        // Prevent update loops when using the `size` middleware.\n        // https://github.com/floating-ui/floating-ui/issues/1740\n        resizeObserver.unobserve(floating);\n        cancelAnimationFrame(reobserveFrame);\n        reobserveFrame = requestAnimationFrame(() => {\n          var _resizeObserver;\n          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);\n        });\n      }\n      update();\n    });\n    if (referenceEl && !animationFrame) {\n      resizeObserver.observe(referenceEl);\n    }\n    resizeObserver.observe(floating);\n  }\n  let frameId;\n  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;\n  if (animationFrame) {\n    frameLoop();\n  }\n  function frameLoop() {\n    const nextRefRect = getBoundingClientRect(reference);\n    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {\n      update();\n    }\n    prevRefRect = nextRefRect;\n    frameId = requestAnimationFrame(frameLoop);\n  }\n  update();\n  return () => {\n    var _resizeObserver2;\n    ancestors.forEach(ancestor => {\n      ancestorScroll && ancestor.removeEventListener('scroll', update);\n      ancestorResize && ancestor.removeEventListener('resize', update);\n    });\n    cleanupIo == null || cleanupIo();\n    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();\n    resizeObserver = null;\n    if (animationFrame) {\n      cancelAnimationFrame(frameId);\n    }\n  };\n}\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nconst detectOverflow = detectOverflow$1;\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = offset$1;\n\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = autoPlacement$1;\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = shift$1;\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = flip$1;\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = size$1;\n\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = hide$1;\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = arrow$1;\n\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = inline$1;\n\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = limitShift$1;\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n */\nconst computePosition = (reference, floating, options) => {\n  // This caches the expensive `getClippingElementAncestors` function so that\n  // multiple lifecycle resets re-use the same result. It only lives for a\n  // single call. If other functions become expensive, we can add them as well.\n  const cache = new Map();\n  const mergedOptions = {\n    platform,\n    ...options\n  };\n  const platformWithCache = {\n    ...mergedOptions.platform,\n    _c: cache\n  };\n  return computePosition$1(reference, floating, {\n    ...mergedOptions,\n    platform: platformWithCache\n  });\n};\n\nexport { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, platform, shift, size };\n","import { computePosition, arrow as arrow$2, offset as offset$1, shift as shift$1, limitShift as limitShift$1, flip as flip$1, size as size$1, autoPlacement as autoPlacement$1, hide as hide$1, inline as inline$1 } from '@floating-ui/dom';\nexport { autoUpdate, computePosition, detectOverflow, getOverflowAncestors, platform } from '@floating-ui/dom';\nimport * as React from 'react';\nimport { useLayoutEffect, useEffect } from 'react';\nimport * as ReactDOM from 'react-dom';\n\nvar index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\n\n// Fork of `fast-deep-equal` that only does the comparisons we need and compares\n// functions\nfunction deepEqual(a, b) {\n  if (a === b) {\n    return true;\n  }\n  if (typeof a !== typeof b) {\n    return false;\n  }\n  if (typeof a === 'function' && a.toString() === b.toString()) {\n    return true;\n  }\n  let length;\n  let i;\n  let keys;\n  if (a && b && typeof a === 'object') {\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length !== b.length) return false;\n      for (i = length; i-- !== 0;) {\n        if (!deepEqual(a[i], b[i])) {\n          return false;\n        }\n      }\n      return true;\n    }\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) {\n      return false;\n    }\n    for (i = length; i-- !== 0;) {\n      if (!{}.hasOwnProperty.call(b, keys[i])) {\n        return false;\n      }\n    }\n    for (i = length; i-- !== 0;) {\n      const key = keys[i];\n      if (key === '_owner' && a.$$typeof) {\n        continue;\n      }\n      if (!deepEqual(a[key], b[key])) {\n        return false;\n      }\n    }\n    return true;\n  }\n  return a !== a && b !== b;\n}\n\nfunction getDPR(element) {\n  if (typeof window === 'undefined') {\n    return 1;\n  }\n  const win = element.ownerDocument.defaultView || window;\n  return win.devicePixelRatio || 1;\n}\n\nfunction roundByDPR(element, value) {\n  const dpr = getDPR(element);\n  return Math.round(value * dpr) / dpr;\n}\n\nfunction useLatestRef(value) {\n  const ref = React.useRef(value);\n  index(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n\n/**\n * Provides data to position a floating element.\n * @see https://floating-ui.com/docs/useFloating\n */\nfunction useFloating(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform,\n    elements: {\n      reference: externalReference,\n      floating: externalFloating\n    } = {},\n    transform = true,\n    whileElementsMounted,\n    open\n  } = options;\n  const [data, setData] = React.useState({\n    x: 0,\n    y: 0,\n    strategy,\n    placement,\n    middlewareData: {},\n    isPositioned: false\n  });\n  const [latestMiddleware, setLatestMiddleware] = React.useState(middleware);\n  if (!deepEqual(latestMiddleware, middleware)) {\n    setLatestMiddleware(middleware);\n  }\n  const [_reference, _setReference] = React.useState(null);\n  const [_floating, _setFloating] = React.useState(null);\n  const setReference = React.useCallback(node => {\n    if (node !== referenceRef.current) {\n      referenceRef.current = node;\n      _setReference(node);\n    }\n  }, []);\n  const setFloating = React.useCallback(node => {\n    if (node !== floatingRef.current) {\n      floatingRef.current = node;\n      _setFloating(node);\n    }\n  }, []);\n  const referenceEl = externalReference || _reference;\n  const floatingEl = externalFloating || _floating;\n  const referenceRef = React.useRef(null);\n  const floatingRef = React.useRef(null);\n  const dataRef = React.useRef(data);\n  const hasWhileElementsMounted = whileElementsMounted != null;\n  const whileElementsMountedRef = useLatestRef(whileElementsMounted);\n  const platformRef = useLatestRef(platform);\n  const openRef = useLatestRef(open);\n  const update = React.useCallback(() => {\n    if (!referenceRef.current || !floatingRef.current) {\n      return;\n    }\n    const config = {\n      placement,\n      strategy,\n      middleware: latestMiddleware\n    };\n    if (platformRef.current) {\n      config.platform = platformRef.current;\n    }\n    computePosition(referenceRef.current, floatingRef.current, config).then(data => {\n      const fullData = {\n        ...data,\n        // The floating element's position may be recomputed while it's closed\n        // but still mounted (such as when transitioning out). To ensure\n        // `isPositioned` will be `false` initially on the next open, avoid\n        // setting it to `true` when `open === false` (must be specified).\n        isPositioned: openRef.current !== false\n      };\n      if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {\n        dataRef.current = fullData;\n        ReactDOM.flushSync(() => {\n          setData(fullData);\n        });\n      }\n    });\n  }, [latestMiddleware, placement, strategy, platformRef, openRef]);\n  index(() => {\n    if (open === false && dataRef.current.isPositioned) {\n      dataRef.current.isPositioned = false;\n      setData(data => ({\n        ...data,\n        isPositioned: false\n      }));\n    }\n  }, [open]);\n  const isMountedRef = React.useRef(false);\n  index(() => {\n    isMountedRef.current = true;\n    return () => {\n      isMountedRef.current = false;\n    };\n  }, []);\n  index(() => {\n    if (referenceEl) referenceRef.current = referenceEl;\n    if (floatingEl) floatingRef.current = floatingEl;\n    if (referenceEl && floatingEl) {\n      if (whileElementsMountedRef.current) {\n        return whileElementsMountedRef.current(referenceEl, floatingEl, update);\n      }\n      update();\n    }\n  }, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);\n  const refs = React.useMemo(() => ({\n    reference: referenceRef,\n    floating: floatingRef,\n    setReference,\n    setFloating\n  }), [setReference, setFloating]);\n  const elements = React.useMemo(() => ({\n    reference: referenceEl,\n    floating: floatingEl\n  }), [referenceEl, floatingEl]);\n  const floatingStyles = React.useMemo(() => {\n    const initialStyles = {\n      position: strategy,\n      left: 0,\n      top: 0\n    };\n    if (!elements.floating) {\n      return initialStyles;\n    }\n    const x = roundByDPR(elements.floating, data.x);\n    const y = roundByDPR(elements.floating, data.y);\n    if (transform) {\n      return {\n        ...initialStyles,\n        transform: \"translate(\" + x + \"px, \" + y + \"px)\",\n        ...(getDPR(elements.floating) >= 1.5 && {\n          willChange: 'transform'\n        })\n      };\n    }\n    return {\n      position: strategy,\n      left: x,\n      top: y\n    };\n  }, [strategy, transform, elements.floating, data.x, data.y]);\n  return React.useMemo(() => ({\n    ...data,\n    update,\n    refs,\n    elements,\n    floatingStyles\n  }), [data, update, refs, elements, floatingStyles]);\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * This wraps the core `arrow` middleware to allow React refs as the element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow$1 = options => {\n  function isRef(value) {\n    return {}.hasOwnProperty.call(value, 'current');\n  }\n  return {\n    name: 'arrow',\n    options,\n    fn(state) {\n      const {\n        element,\n        padding\n      } = typeof options === 'function' ? options(state) : options;\n      if (element && isRef(element)) {\n        if (element.current != null) {\n          return arrow$2({\n            element: element.current,\n            padding\n          }).fn(state);\n        }\n        return {};\n      }\n      if (element) {\n        return arrow$2({\n          element,\n          padding\n        }).fn(state);\n      }\n      return {};\n    }\n  };\n};\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = (options, deps) => ({\n  ...offset$1(options),\n  options: [options, deps]\n});\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = (options, deps) => ({\n  ...shift$1(options),\n  options: [options, deps]\n});\n\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = (options, deps) => ({\n  ...limitShift$1(options),\n  options: [options, deps]\n});\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = (options, deps) => ({\n  ...flip$1(options),\n  options: [options, deps]\n});\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = (options, deps) => ({\n  ...size$1(options),\n  options: [options, deps]\n});\n\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = (options, deps) => ({\n  ...autoPlacement$1(options),\n  options: [options, deps]\n});\n\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = (options, deps) => ({\n  ...hide$1(options),\n  options: [options, deps]\n});\n\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = (options, deps) => ({\n  ...inline$1(options),\n  options: [options, deps]\n});\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * This wraps the core `arrow` middleware to allow React refs as the element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = (options, deps) => ({\n  ...arrow$1(options),\n  options: [options, deps]\n});\n\nexport { arrow, autoPlacement, flip, hide, inline, limitShift, offset, shift, size, useFloating };\n","import * as React from 'react';\nimport { useLayoutEffect, useEffect, useRef } from 'react';\nimport { stopEvent, getDocument, isMouseLikePointerType, contains, activeElement, isSafari, isTypeableCombobox, isVirtualClick, isVirtualPointerEvent, getTarget, getPlatform, isTypeableElement, isReactEvent, isRootElement, isEventTargetWithin, isMac, getUserAgent } from '@floating-ui/react/utils';\nimport { floor, evaluate, max, min, round } from '@floating-ui/utils';\nimport { getComputedStyle, isElement, getNodeName, isHTMLElement, getWindow, isLastTraversableNode, getParentNode, isWebKit } from '@floating-ui/utils/dom';\nimport { tabbable, isTabbable } from 'tabbable';\nimport * as ReactDOM from 'react-dom';\nimport { getOverflowAncestors, useFloating as useFloating$1, offset, detectOverflow } from '@floating-ui/react-dom';\nexport { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size } from '@floating-ui/react-dom';\n\n/**\n * Merges an array of refs into a single memoized callback ref or `null`.\n * @see https://floating-ui.com/docs/react-utils#usemergerefs\n */\nfunction useMergeRefs(refs) {\n  return React.useMemo(() => {\n    if (refs.every(ref => ref == null)) {\n      return null;\n    }\n    return value => {\n      refs.forEach(ref => {\n        if (typeof ref === 'function') {\n          ref(value);\n        } else if (ref != null) {\n          ref.current = value;\n        }\n      });\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, refs);\n}\n\n// https://github.com/mui/material-ui/issues/41190#issuecomment-2040873379\nconst SafeReact = {\n  ...React\n};\n\nconst useInsertionEffect = SafeReact.useInsertionEffect;\nconst useSafeInsertionEffect = useInsertionEffect || (fn => fn());\nfunction useEffectEvent(callback) {\n  const ref = React.useRef(() => {\n    if (process.env.NODE_ENV !== \"production\") {\n      throw new Error('Cannot call an event handler while rendering.');\n    }\n  });\n  useSafeInsertionEffect(() => {\n    ref.current = callback;\n  });\n  return React.useCallback(function () {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n    return ref.current == null ? void 0 : ref.current(...args);\n  }, []);\n}\n\nconst ARROW_UP = 'ArrowUp';\nconst ARROW_DOWN = 'ArrowDown';\nconst ARROW_LEFT = 'ArrowLeft';\nconst ARROW_RIGHT = 'ArrowRight';\nfunction isDifferentRow(index, cols, prevRow) {\n  return Math.floor(index / cols) !== prevRow;\n}\nfunction isIndexOutOfBounds(listRef, index) {\n  return index < 0 || index >= listRef.current.length;\n}\nfunction getMinIndex(listRef, disabledIndices) {\n  return findNonDisabledIndex(listRef, {\n    disabledIndices\n  });\n}\nfunction getMaxIndex(listRef, disabledIndices) {\n  return findNonDisabledIndex(listRef, {\n    decrement: true,\n    startingIndex: listRef.current.length,\n    disabledIndices\n  });\n}\nfunction findNonDisabledIndex(listRef, _temp) {\n  let {\n    startingIndex = -1,\n    decrement = false,\n    disabledIndices,\n    amount = 1\n  } = _temp === void 0 ? {} : _temp;\n  const list = listRef.current;\n  let index = startingIndex;\n  do {\n    index += decrement ? -amount : amount;\n  } while (index >= 0 && index <= list.length - 1 && isDisabled(list, index, disabledIndices));\n  return index;\n}\nfunction getGridNavigatedIndex(elementsRef, _ref) {\n  let {\n    event,\n    orientation,\n    loop,\n    rtl,\n    cols,\n    disabledIndices,\n    minIndex,\n    maxIndex,\n    prevIndex,\n    stopEvent: stop = false\n  } = _ref;\n  let nextIndex = prevIndex;\n  if (event.key === ARROW_UP) {\n    stop && stopEvent(event);\n    if (prevIndex === -1) {\n      nextIndex = maxIndex;\n    } else {\n      nextIndex = findNonDisabledIndex(elementsRef, {\n        startingIndex: nextIndex,\n        amount: cols,\n        decrement: true,\n        disabledIndices\n      });\n      if (loop && (prevIndex - cols < minIndex || nextIndex < 0)) {\n        const col = prevIndex % cols;\n        const maxCol = maxIndex % cols;\n        const offset = maxIndex - (maxCol - col);\n        if (maxCol === col) {\n          nextIndex = maxIndex;\n        } else {\n          nextIndex = maxCol > col ? offset : offset - cols;\n        }\n      }\n    }\n    if (isIndexOutOfBounds(elementsRef, nextIndex)) {\n      nextIndex = prevIndex;\n    }\n  }\n  if (event.key === ARROW_DOWN) {\n    stop && stopEvent(event);\n    if (prevIndex === -1) {\n      nextIndex = minIndex;\n    } else {\n      nextIndex = findNonDisabledIndex(elementsRef, {\n        startingIndex: prevIndex,\n        amount: cols,\n        disabledIndices\n      });\n      if (loop && prevIndex + cols > maxIndex) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex % cols - cols,\n          amount: cols,\n          disabledIndices\n        });\n      }\n    }\n    if (isIndexOutOfBounds(elementsRef, nextIndex)) {\n      nextIndex = prevIndex;\n    }\n  }\n\n  // Remains on the same row/column.\n  if (orientation === 'both') {\n    const prevRow = floor(prevIndex / cols);\n    if (event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT)) {\n      stop && stopEvent(event);\n      if (prevIndex % cols !== cols - 1) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex,\n          disabledIndices\n        });\n        if (loop && isDifferentRow(nextIndex, cols, prevRow)) {\n          nextIndex = findNonDisabledIndex(elementsRef, {\n            startingIndex: prevIndex - prevIndex % cols - 1,\n            disabledIndices\n          });\n        }\n      } else if (loop) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex - prevIndex % cols - 1,\n          disabledIndices\n        });\n      }\n      if (isDifferentRow(nextIndex, cols, prevRow)) {\n        nextIndex = prevIndex;\n      }\n    }\n    if (event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT)) {\n      stop && stopEvent(event);\n      if (prevIndex % cols !== 0) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex,\n          decrement: true,\n          disabledIndices\n        });\n        if (loop && isDifferentRow(nextIndex, cols, prevRow)) {\n          nextIndex = findNonDisabledIndex(elementsRef, {\n            startingIndex: prevIndex + (cols - prevIndex % cols),\n            decrement: true,\n            disabledIndices\n          });\n        }\n      } else if (loop) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex + (cols - prevIndex % cols),\n          decrement: true,\n          disabledIndices\n        });\n      }\n      if (isDifferentRow(nextIndex, cols, prevRow)) {\n        nextIndex = prevIndex;\n      }\n    }\n    const lastRow = floor(maxIndex / cols) === prevRow;\n    if (isIndexOutOfBounds(elementsRef, nextIndex)) {\n      if (loop && lastRow) {\n        nextIndex = event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT) ? maxIndex : findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex - prevIndex % cols - 1,\n          disabledIndices\n        });\n      } else {\n        nextIndex = prevIndex;\n      }\n    }\n  }\n  return nextIndex;\n}\n\n/** For each cell index, gets the item index that occupies that cell */\nfunction buildCellMap(sizes, cols, dense) {\n  const cellMap = [];\n  let startIndex = 0;\n  sizes.forEach((_ref2, index) => {\n    let {\n      width,\n      height\n    } = _ref2;\n    if (width > cols) {\n      if (process.env.NODE_ENV !== \"production\") {\n        throw new Error(\"[Floating UI]: Invalid grid - item width at index \" + index + \" is greater than grid columns\");\n      }\n    }\n    let itemPlaced = false;\n    if (dense) {\n      startIndex = 0;\n    }\n    while (!itemPlaced) {\n      const targetCells = [];\n      for (let i = 0; i < width; i++) {\n        for (let j = 0; j < height; j++) {\n          targetCells.push(startIndex + i + j * cols);\n        }\n      }\n      if (startIndex % cols + width <= cols && targetCells.every(cell => cellMap[cell] == null)) {\n        targetCells.forEach(cell => {\n          cellMap[cell] = index;\n        });\n        itemPlaced = true;\n      } else {\n        startIndex++;\n      }\n    }\n  });\n\n  // convert into a non-sparse array\n  return [...cellMap];\n}\n\n/** Gets cell index of an item's corner or -1 when index is -1. */\nfunction getCellIndexOfCorner(index, sizes, cellMap, cols, corner) {\n  if (index === -1) return -1;\n  const firstCellIndex = cellMap.indexOf(index);\n  const sizeItem = sizes[index];\n  switch (corner) {\n    case 'tl':\n      return firstCellIndex;\n    case 'tr':\n      if (!sizeItem) {\n        return firstCellIndex;\n      }\n      return firstCellIndex + sizeItem.width - 1;\n    case 'bl':\n      if (!sizeItem) {\n        return firstCellIndex;\n      }\n      return firstCellIndex + (sizeItem.height - 1) * cols;\n    case 'br':\n      return cellMap.lastIndexOf(index);\n  }\n}\n\n/** Gets all cell indices that correspond to the specified indices */\nfunction getCellIndices(indices, cellMap) {\n  return cellMap.flatMap((index, cellIndex) => indices.includes(index) ? [cellIndex] : []);\n}\nfunction isDisabled(list, index, disabledIndices) {\n  if (disabledIndices) {\n    return disabledIndices.includes(index);\n  }\n  const element = list[index];\n  return element == null || element.hasAttribute('disabled') || element.getAttribute('aria-disabled') === 'true';\n}\n\nvar index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\n\nfunction sortByDocumentPosition(a, b) {\n  const position = a.compareDocumentPosition(b);\n  if (position & Node.DOCUMENT_POSITION_FOLLOWING || position & Node.DOCUMENT_POSITION_CONTAINED_BY) {\n    return -1;\n  }\n  if (position & Node.DOCUMENT_POSITION_PRECEDING || position & Node.DOCUMENT_POSITION_CONTAINS) {\n    return 1;\n  }\n  return 0;\n}\nfunction areMapsEqual(map1, map2) {\n  if (map1.size !== map2.size) {\n    return false;\n  }\n  for (const [key, value] of map1.entries()) {\n    if (value !== map2.get(key)) {\n      return false;\n    }\n  }\n  return true;\n}\nconst FloatingListContext = /*#__PURE__*/React.createContext({\n  register: () => {},\n  unregister: () => {},\n  map: /*#__PURE__*/new Map(),\n  elementsRef: {\n    current: []\n  }\n});\n/**\n * Provides context for a list of items within the floating element.\n * @see https://floating-ui.com/docs/FloatingList\n */\nfunction FloatingList(props) {\n  const {\n    children,\n    elementsRef,\n    labelsRef\n  } = props;\n  const [map, setMap] = React.useState(() => new Map());\n  const register = React.useCallback(node => {\n    setMap(prevMap => new Map(prevMap).set(node, null));\n  }, []);\n  const unregister = React.useCallback(node => {\n    setMap(prevMap => {\n      const map = new Map(prevMap);\n      map.delete(node);\n      return map;\n    });\n  }, []);\n  index(() => {\n    const newMap = new Map(map);\n    const nodes = Array.from(newMap.keys()).sort(sortByDocumentPosition);\n    nodes.forEach((node, index) => {\n      newMap.set(node, index);\n    });\n    if (!areMapsEqual(map, newMap)) {\n      setMap(newMap);\n    }\n  }, [map]);\n  return /*#__PURE__*/React.createElement(FloatingListContext.Provider, {\n    value: React.useMemo(() => ({\n      register,\n      unregister,\n      map,\n      elementsRef,\n      labelsRef\n    }), [register, unregister, map, elementsRef, labelsRef])\n  }, children);\n}\n/**\n * Used to register a list item and its index (DOM position) in the\n * `FloatingList`.\n * @see https://floating-ui.com/docs/FloatingList#uselistitem\n */\nfunction useListItem(props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    label\n  } = props;\n  const {\n    register,\n    unregister,\n    map,\n    elementsRef,\n    labelsRef\n  } = React.useContext(FloatingListContext);\n  const [index$1, setIndex] = React.useState(null);\n  const componentRef = React.useRef(null);\n  const ref = React.useCallback(node => {\n    componentRef.current = node;\n    if (index$1 !== null) {\n      elementsRef.current[index$1] = node;\n      if (labelsRef) {\n        var _node$textContent;\n        const isLabelDefined = label !== undefined;\n        labelsRef.current[index$1] = isLabelDefined ? label : (_node$textContent = node == null ? void 0 : node.textContent) != null ? _node$textContent : null;\n      }\n    }\n  }, [index$1, elementsRef, labelsRef, label]);\n  index(() => {\n    const node = componentRef.current;\n    if (node) {\n      register(node);\n      return () => {\n        unregister(node);\n      };\n    }\n  }, [register, unregister]);\n  index(() => {\n    const index = componentRef.current ? map.get(componentRef.current) : null;\n    if (index != null) {\n      setIndex(index);\n    }\n  }, [map]);\n  return React.useMemo(() => ({\n    ref,\n    index: index$1 == null ? -1 : index$1\n  }), [index$1, ref]);\n}\n\nfunction renderJsx(render, computedProps) {\n  if (typeof render === 'function') {\n    return render(computedProps);\n  }\n  if (render) {\n    return /*#__PURE__*/React.cloneElement(render, computedProps);\n  }\n  return /*#__PURE__*/React.createElement(\"div\", computedProps);\n}\nconst CompositeContext = /*#__PURE__*/React.createContext({\n  activeIndex: 0,\n  onNavigate: () => {}\n});\nconst horizontalKeys = [ARROW_LEFT, ARROW_RIGHT];\nconst verticalKeys = [ARROW_UP, ARROW_DOWN];\nconst allKeys = [...horizontalKeys, ...verticalKeys];\n\n/**\n * Creates a single tab stop whose items are navigated by arrow keys, which\n * provides list navigation outside of floating element contexts.\n *\n * This is useful to enable navigation of a list of items that aren’t part of a\n * floating element. A menubar is an example of a composite, with each reference\n * element being an item.\n * @see https://floating-ui.com/docs/Composite\n */\nconst Composite = /*#__PURE__*/React.forwardRef(function Composite(props, forwardedRef) {\n  const {\n    render,\n    orientation = 'both',\n    loop = true,\n    rtl = false,\n    cols = 1,\n    disabledIndices,\n    activeIndex: externalActiveIndex,\n    onNavigate: externalSetActiveIndex,\n    itemSizes,\n    dense = false,\n    ...domProps\n  } = props;\n  const [internalActiveIndex, internalSetActiveIndex] = React.useState(0);\n  const activeIndex = externalActiveIndex != null ? externalActiveIndex : internalActiveIndex;\n  const onNavigate = useEffectEvent(externalSetActiveIndex != null ? externalSetActiveIndex : internalSetActiveIndex);\n  const elementsRef = React.useRef([]);\n  const renderElementProps = render && typeof render !== 'function' ? render.props : {};\n  const contextValue = React.useMemo(() => ({\n    activeIndex,\n    onNavigate\n  }), [activeIndex, onNavigate]);\n  const isGrid = cols > 1;\n  function handleKeyDown(event) {\n    if (!allKeys.includes(event.key)) return;\n    let nextIndex = activeIndex;\n    const minIndex = getMinIndex(elementsRef, disabledIndices);\n    const maxIndex = getMaxIndex(elementsRef, disabledIndices);\n    const horizontalEndKey = rtl ? ARROW_LEFT : ARROW_RIGHT;\n    const horizontalStartKey = rtl ? ARROW_RIGHT : ARROW_LEFT;\n    if (isGrid) {\n      const sizes = itemSizes || Array.from({\n        length: elementsRef.current.length\n      }, () => ({\n        width: 1,\n        height: 1\n      }));\n      // To calculate movements on the grid, we use hypothetical cell indices\n      // as if every item was 1x1, then convert back to real indices.\n      const cellMap = buildCellMap(sizes, cols, dense);\n      const minGridIndex = cellMap.findIndex(index => index != null && !isDisabled(elementsRef.current, index, disabledIndices));\n      // last enabled index\n      const maxGridIndex = cellMap.reduce((foundIndex, index, cellIndex) => index != null && !isDisabled(elementsRef.current, index, disabledIndices) ? cellIndex : foundIndex, -1);\n      const maybeNextIndex = cellMap[getGridNavigatedIndex({\n        current: cellMap.map(itemIndex => itemIndex ? elementsRef.current[itemIndex] : null)\n      }, {\n        event,\n        orientation,\n        loop,\n        rtl,\n        cols,\n        // treat undefined (empty grid spaces) as disabled indices so we\n        // don't end up in them\n        disabledIndices: getCellIndices([...(disabledIndices || elementsRef.current.map((_, index) => isDisabled(elementsRef.current, index) ? index : undefined)), undefined], cellMap),\n        minIndex: minGridIndex,\n        maxIndex: maxGridIndex,\n        prevIndex: getCellIndexOfCorner(activeIndex > maxIndex ? minIndex : activeIndex, sizes, cellMap, cols,\n        // use a corner matching the edge closest to the direction we're\n        // moving in so we don't end up in the same item. Prefer\n        // top/left over bottom/right.\n        event.key === ARROW_DOWN ? 'bl' : event.key === horizontalEndKey ? 'tr' : 'tl')\n      })];\n      if (maybeNextIndex != null) {\n        nextIndex = maybeNextIndex;\n      }\n    }\n    const toEndKeys = {\n      horizontal: [horizontalEndKey],\n      vertical: [ARROW_DOWN],\n      both: [horizontalEndKey, ARROW_DOWN]\n    }[orientation];\n    const toStartKeys = {\n      horizontal: [horizontalStartKey],\n      vertical: [ARROW_UP],\n      both: [horizontalStartKey, ARROW_UP]\n    }[orientation];\n    const preventedKeys = isGrid ? allKeys : {\n      horizontal: horizontalKeys,\n      vertical: verticalKeys,\n      both: allKeys\n    }[orientation];\n    if (nextIndex === activeIndex && [...toEndKeys, ...toStartKeys].includes(event.key)) {\n      if (loop && nextIndex === maxIndex && toEndKeys.includes(event.key)) {\n        nextIndex = minIndex;\n      } else if (loop && nextIndex === minIndex && toStartKeys.includes(event.key)) {\n        nextIndex = maxIndex;\n      } else {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: nextIndex,\n          decrement: toStartKeys.includes(event.key),\n          disabledIndices\n        });\n      }\n    }\n    if (nextIndex !== activeIndex && !isIndexOutOfBounds(elementsRef, nextIndex)) {\n      var _elementsRef$current$;\n      event.stopPropagation();\n      if (preventedKeys.includes(event.key)) {\n        event.preventDefault();\n      }\n      onNavigate(nextIndex);\n      (_elementsRef$current$ = elementsRef.current[nextIndex]) == null || _elementsRef$current$.focus();\n    }\n  }\n  const computedProps = {\n    ...domProps,\n    ...renderElementProps,\n    ref: forwardedRef,\n    'aria-orientation': orientation === 'both' ? undefined : orientation,\n    onKeyDown(e) {\n      domProps.onKeyDown == null || domProps.onKeyDown(e);\n      renderElementProps.onKeyDown == null || renderElementProps.onKeyDown(e);\n      handleKeyDown(e);\n    }\n  };\n  return /*#__PURE__*/React.createElement(CompositeContext.Provider, {\n    value: contextValue\n  }, /*#__PURE__*/React.createElement(FloatingList, {\n    elementsRef: elementsRef\n  }, renderJsx(render, computedProps)));\n});\n/**\n * @see https://floating-ui.com/docs/Composite\n */\nconst CompositeItem = /*#__PURE__*/React.forwardRef(function CompositeItem(props, forwardedRef) {\n  const {\n    render,\n    ...domProps\n  } = props;\n  const renderElementProps = render && typeof render !== 'function' ? render.props : {};\n  const {\n    activeIndex,\n    onNavigate\n  } = React.useContext(CompositeContext);\n  const {\n    ref,\n    index\n  } = useListItem();\n  const mergedRef = useMergeRefs([ref, forwardedRef, renderElementProps.ref]);\n  const isActive = activeIndex === index;\n  const computedProps = {\n    ...domProps,\n    ...renderElementProps,\n    ref: mergedRef,\n    tabIndex: isActive ? 0 : -1,\n    'data-active': isActive ? '' : undefined,\n    onFocus(e) {\n      domProps.onFocus == null || domProps.onFocus(e);\n      renderElementProps.onFocus == null || renderElementProps.onFocus(e);\n      onNavigate(index);\n    }\n  };\n  return renderJsx(render, computedProps);\n});\n\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\nlet serverHandoffComplete = false;\nlet count = 0;\nconst genId = () => // Ensure the id is unique with multiple independent versions of Floating UI\n// on <React 18\n\"floating-ui-\" + Math.random().toString(36).slice(2, 6) + count++;\nfunction useFloatingId() {\n  const [id, setId] = React.useState(() => serverHandoffComplete ? genId() : undefined);\n  index(() => {\n    if (id == null) {\n      setId(genId());\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n  React.useEffect(() => {\n    serverHandoffComplete = true;\n  }, []);\n  return id;\n}\nconst useReactId = SafeReact.useId;\n\n/**\n * Uses React 18's built-in `useId()` when available, or falls back to a\n * slightly less performant (requiring a double render) implementation for\n * earlier React versions.\n * @see https://floating-ui.com/docs/react-utils#useid\n */\nconst useId = useReactId || useFloatingId;\n\nlet devMessageSet;\nif (process.env.NODE_ENV !== \"production\") {\n  devMessageSet = /*#__PURE__*/new Set();\n}\nfunction warn() {\n  var _devMessageSet;\n  for (var _len = arguments.length, messages = new Array(_len), _key = 0; _key < _len; _key++) {\n    messages[_key] = arguments[_key];\n  }\n  const message = \"Floating UI: \" + messages.join(' ');\n  if (!((_devMessageSet = devMessageSet) != null && _devMessageSet.has(message))) {\n    var _devMessageSet2;\n    (_devMessageSet2 = devMessageSet) == null || _devMessageSet2.add(message);\n    console.warn(message);\n  }\n}\nfunction error() {\n  var _devMessageSet3;\n  for (var _len2 = arguments.length, messages = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n    messages[_key2] = arguments[_key2];\n  }\n  const message = \"Floating UI: \" + messages.join(' ');\n  if (!((_devMessageSet3 = devMessageSet) != null && _devMessageSet3.has(message))) {\n    var _devMessageSet4;\n    (_devMessageSet4 = devMessageSet) == null || _devMessageSet4.add(message);\n    console.error(message);\n  }\n}\n\n/**\n * Renders a pointing arrow triangle.\n * @see https://floating-ui.com/docs/FloatingArrow\n */\nconst FloatingArrow = /*#__PURE__*/React.forwardRef(function FloatingArrow(props, ref) {\n  const {\n    context: {\n      placement,\n      elements: {\n        floating\n      },\n      middlewareData: {\n        arrow,\n        shift\n      }\n    },\n    width = 14,\n    height = 7,\n    tipRadius = 0,\n    strokeWidth = 0,\n    staticOffset,\n    stroke,\n    d,\n    style: {\n      transform,\n      ...restStyle\n    } = {},\n    ...rest\n  } = props;\n  if (process.env.NODE_ENV !== \"production\") {\n    if (!ref) {\n      warn('The `ref` prop is required for `FloatingArrow`.');\n    }\n  }\n  const clipPathId = useId();\n  const [isRTL, setIsRTL] = React.useState(false);\n\n  // https://github.com/floating-ui/floating-ui/issues/2932\n  index(() => {\n    if (!floating) return;\n    const isRTL = getComputedStyle(floating).direction === 'rtl';\n    if (isRTL) {\n      setIsRTL(true);\n    }\n  }, [floating]);\n  if (!floating) {\n    return null;\n  }\n  const [side, alignment] = placement.split('-');\n  const isVerticalSide = side === 'top' || side === 'bottom';\n  let computedStaticOffset = staticOffset;\n  if (isVerticalSide && shift != null && shift.x || !isVerticalSide && shift != null && shift.y) {\n    computedStaticOffset = null;\n  }\n\n  // Strokes must be double the border width, this ensures the stroke's width\n  // works as you'd expect.\n  const computedStrokeWidth = strokeWidth * 2;\n  const halfStrokeWidth = computedStrokeWidth / 2;\n  const svgX = width / 2 * (tipRadius / -8 + 1);\n  const svgY = height / 2 * tipRadius / 4;\n  const isCustomShape = !!d;\n  const yOffsetProp = computedStaticOffset && alignment === 'end' ? 'bottom' : 'top';\n  let xOffsetProp = computedStaticOffset && alignment === 'end' ? 'right' : 'left';\n  if (computedStaticOffset && isRTL) {\n    xOffsetProp = alignment === 'end' ? 'left' : 'right';\n  }\n  const arrowX = (arrow == null ? void 0 : arrow.x) != null ? computedStaticOffset || arrow.x : '';\n  const arrowY = (arrow == null ? void 0 : arrow.y) != null ? computedStaticOffset || arrow.y : '';\n  const dValue = d || 'M0,0' + (\" H\" + width) + (\" L\" + (width - svgX) + \",\" + (height - svgY)) + (\" Q\" + width / 2 + \",\" + height + \" \" + svgX + \",\" + (height - svgY)) + ' Z';\n  const rotation = {\n    top: isCustomShape ? 'rotate(180deg)' : '',\n    left: isCustomShape ? 'rotate(90deg)' : 'rotate(-90deg)',\n    bottom: isCustomShape ? '' : 'rotate(180deg)',\n    right: isCustomShape ? 'rotate(-90deg)' : 'rotate(90deg)'\n  }[side];\n  return /*#__PURE__*/React.createElement(\"svg\", _extends({}, rest, {\n    \"aria-hidden\": true,\n    ref: ref,\n    width: isCustomShape ? width : width + computedStrokeWidth,\n    height: width,\n    viewBox: \"0 0 \" + width + \" \" + (height > width ? height : width),\n    style: {\n      position: 'absolute',\n      pointerEvents: 'none',\n      [xOffsetProp]: arrowX,\n      [yOffsetProp]: arrowY,\n      [side]: isVerticalSide || isCustomShape ? '100%' : \"calc(100% - \" + computedStrokeWidth / 2 + \"px)\",\n      transform: [rotation, transform].filter(t => !!t).join(' '),\n      ...restStyle\n    }\n  }), computedStrokeWidth > 0 && /*#__PURE__*/React.createElement(\"path\", {\n    clipPath: \"url(#\" + clipPathId + \")\",\n    fill: \"none\",\n    stroke: stroke\n    // Account for the stroke on the fill path rendered below.\n    ,\n    strokeWidth: computedStrokeWidth + (d ? 0 : 1),\n    d: dValue\n  }), /*#__PURE__*/React.createElement(\"path\", {\n    stroke: computedStrokeWidth && !d ? rest.fill : 'none',\n    d: dValue\n  }), /*#__PURE__*/React.createElement(\"clipPath\", {\n    id: clipPathId\n  }, /*#__PURE__*/React.createElement(\"rect\", {\n    x: -halfStrokeWidth,\n    y: halfStrokeWidth * (isCustomShape ? -1 : 1),\n    width: width + computedStrokeWidth,\n    height: width\n  })));\n});\n\nfunction createPubSub() {\n  const map = new Map();\n  return {\n    emit(event, data) {\n      var _map$get;\n      (_map$get = map.get(event)) == null || _map$get.forEach(handler => handler(data));\n    },\n    on(event, listener) {\n      map.set(event, [...(map.get(event) || []), listener]);\n    },\n    off(event, listener) {\n      var _map$get2;\n      map.set(event, ((_map$get2 = map.get(event)) == null ? void 0 : _map$get2.filter(l => l !== listener)) || []);\n    }\n  };\n}\n\nconst FloatingNodeContext = /*#__PURE__*/React.createContext(null);\nconst FloatingTreeContext = /*#__PURE__*/React.createContext(null);\n\n/**\n * Returns the parent node id for nested floating elements, if available.\n * Returns `null` for top-level floating elements.\n */\nconst useFloatingParentNodeId = () => {\n  var _React$useContext;\n  return ((_React$useContext = React.useContext(FloatingNodeContext)) == null ? void 0 : _React$useContext.id) || null;\n};\n\n/**\n * Returns the nearest floating tree context, if available.\n */\nconst useFloatingTree = () => React.useContext(FloatingTreeContext);\n\n/**\n * Registers a node into the `FloatingTree`, returning its id.\n * @see https://floating-ui.com/docs/FloatingTree\n */\nfunction useFloatingNodeId(customParentId) {\n  const id = useId();\n  const tree = useFloatingTree();\n  const reactParentId = useFloatingParentNodeId();\n  const parentId = customParentId || reactParentId;\n  index(() => {\n    const node = {\n      id,\n      parentId\n    };\n    tree == null || tree.addNode(node);\n    return () => {\n      tree == null || tree.removeNode(node);\n    };\n  }, [tree, id, parentId]);\n  return id;\n}\n/**\n * Provides parent node context for nested floating elements.\n * @see https://floating-ui.com/docs/FloatingTree\n */\nfunction FloatingNode(props) {\n  const {\n    children,\n    id\n  } = props;\n  const parentId = useFloatingParentNodeId();\n  return /*#__PURE__*/React.createElement(FloatingNodeContext.Provider, {\n    value: React.useMemo(() => ({\n      id,\n      parentId\n    }), [id, parentId])\n  }, children);\n}\n/**\n * Provides context for nested floating elements when they are not children of\n * each other on the DOM.\n * This is not necessary in all cases, except when there must be explicit communication between parent and child floating elements. It is necessary for:\n * - The `bubbles` option in the `useDismiss()` Hook\n * - Nested virtual list navigation\n * - Nested floating elements that each open on hover\n * - Custom communication between parent and child floating elements\n * @see https://floating-ui.com/docs/FloatingTree\n */\nfunction FloatingTree(props) {\n  const {\n    children\n  } = props;\n  const nodesRef = React.useRef([]);\n  const addNode = React.useCallback(node => {\n    nodesRef.current = [...nodesRef.current, node];\n  }, []);\n  const removeNode = React.useCallback(node => {\n    nodesRef.current = nodesRef.current.filter(n => n !== node);\n  }, []);\n  const events = React.useState(() => createPubSub())[0];\n  return /*#__PURE__*/React.createElement(FloatingTreeContext.Provider, {\n    value: React.useMemo(() => ({\n      nodesRef,\n      addNode,\n      removeNode,\n      events\n    }), [addNode, removeNode, events])\n  }, children);\n}\n\nfunction createAttribute(name) {\n  return \"data-floating-ui-\" + name;\n}\n\nfunction useLatestRef(value) {\n  const ref = useRef(value);\n  index(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n\nconst safePolygonIdentifier = /*#__PURE__*/createAttribute('safe-polygon');\nfunction getDelay(value, prop, pointerType) {\n  if (pointerType && !isMouseLikePointerType(pointerType)) {\n    return 0;\n  }\n  if (typeof value === 'number') {\n    return value;\n  }\n  return value == null ? void 0 : value[prop];\n}\n/**\n * Opens the floating element while hovering over the reference element, like\n * CSS `:hover`.\n * @see https://floating-ui.com/docs/useHover\n */\nfunction useHover(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    dataRef,\n    events,\n    elements\n  } = context;\n  const {\n    enabled = true,\n    delay = 0,\n    handleClose = null,\n    mouseOnly = false,\n    restMs = 0,\n    move = true\n  } = props;\n  const tree = useFloatingTree();\n  const parentId = useFloatingParentNodeId();\n  const handleCloseRef = useLatestRef(handleClose);\n  const delayRef = useLatestRef(delay);\n  const openRef = useLatestRef(open);\n  const pointerTypeRef = React.useRef();\n  const timeoutRef = React.useRef(-1);\n  const handlerRef = React.useRef();\n  const restTimeoutRef = React.useRef(-1);\n  const blockMouseMoveRef = React.useRef(true);\n  const performedPointerEventsMutationRef = React.useRef(false);\n  const unbindMouseMoveRef = React.useRef(() => {});\n  const restTimeoutPendingRef = React.useRef(false);\n  const isHoverOpen = React.useCallback(() => {\n    var _dataRef$current$open;\n    const type = (_dataRef$current$open = dataRef.current.openEvent) == null ? void 0 : _dataRef$current$open.type;\n    return (type == null ? void 0 : type.includes('mouse')) && type !== 'mousedown';\n  }, [dataRef]);\n\n  // When closing before opening, clear the delay timeouts to cancel it\n  // from showing.\n  React.useEffect(() => {\n    if (!enabled) return;\n    function onOpenChange(_ref) {\n      let {\n        open\n      } = _ref;\n      if (!open) {\n        clearTimeout(timeoutRef.current);\n        clearTimeout(restTimeoutRef.current);\n        blockMouseMoveRef.current = true;\n        restTimeoutPendingRef.current = false;\n      }\n    }\n    events.on('openchange', onOpenChange);\n    return () => {\n      events.off('openchange', onOpenChange);\n    };\n  }, [enabled, events]);\n  React.useEffect(() => {\n    if (!enabled) return;\n    if (!handleCloseRef.current) return;\n    if (!open) return;\n    function onLeave(event) {\n      if (isHoverOpen()) {\n        onOpenChange(false, event, 'hover');\n      }\n    }\n    const html = getDocument(elements.floating).documentElement;\n    html.addEventListener('mouseleave', onLeave);\n    return () => {\n      html.removeEventListener('mouseleave', onLeave);\n    };\n  }, [elements.floating, open, onOpenChange, enabled, handleCloseRef, isHoverOpen]);\n  const closeWithDelay = React.useCallback(function (event, runElseBranch, reason) {\n    if (runElseBranch === void 0) {\n      runElseBranch = true;\n    }\n    if (reason === void 0) {\n      reason = 'hover';\n    }\n    const closeDelay = getDelay(delayRef.current, 'close', pointerTypeRef.current);\n    if (closeDelay && !handlerRef.current) {\n      clearTimeout(timeoutRef.current);\n      timeoutRef.current = window.setTimeout(() => onOpenChange(false, event, reason), closeDelay);\n    } else if (runElseBranch) {\n      clearTimeout(timeoutRef.current);\n      onOpenChange(false, event, reason);\n    }\n  }, [delayRef, onOpenChange]);\n  const cleanupMouseMoveHandler = useEffectEvent(() => {\n    unbindMouseMoveRef.current();\n    handlerRef.current = undefined;\n  });\n  const clearPointerEvents = useEffectEvent(() => {\n    if (performedPointerEventsMutationRef.current) {\n      const body = getDocument(elements.floating).body;\n      body.style.pointerEvents = '';\n      body.removeAttribute(safePolygonIdentifier);\n      performedPointerEventsMutationRef.current = false;\n    }\n  });\n  const isClickLikeOpenEvent = useEffectEvent(() => {\n    return dataRef.current.openEvent ? ['click', 'mousedown'].includes(dataRef.current.openEvent.type) : false;\n  });\n\n  // Registering the mouse events on the reference directly to bypass React's\n  // delegation system. If the cursor was on a disabled element and then entered\n  // the reference (no gap), `mouseenter` doesn't fire in the delegation system.\n  React.useEffect(() => {\n    if (!enabled) return;\n    function onMouseEnter(event) {\n      clearTimeout(timeoutRef.current);\n      blockMouseMoveRef.current = false;\n      if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current) || restMs > 0 && !getDelay(delayRef.current, 'open')) {\n        return;\n      }\n      const openDelay = getDelay(delayRef.current, 'open', pointerTypeRef.current);\n      if (openDelay) {\n        timeoutRef.current = window.setTimeout(() => {\n          if (!openRef.current) {\n            onOpenChange(true, event, 'hover');\n          }\n        }, openDelay);\n      } else if (!open) {\n        onOpenChange(true, event, 'hover');\n      }\n    }\n    function onMouseLeave(event) {\n      if (isClickLikeOpenEvent()) return;\n      unbindMouseMoveRef.current();\n      const doc = getDocument(elements.floating);\n      clearTimeout(restTimeoutRef.current);\n      restTimeoutPendingRef.current = false;\n      if (handleCloseRef.current && dataRef.current.floatingContext) {\n        // Prevent clearing `onScrollMouseLeave` timeout.\n        if (!open) {\n          clearTimeout(timeoutRef.current);\n        }\n        handlerRef.current = handleCloseRef.current({\n          ...dataRef.current.floatingContext,\n          tree,\n          x: event.clientX,\n          y: event.clientY,\n          onClose() {\n            clearPointerEvents();\n            cleanupMouseMoveHandler();\n            if (!isClickLikeOpenEvent()) {\n              closeWithDelay(event, true, 'safe-polygon');\n            }\n          }\n        });\n        const handler = handlerRef.current;\n        doc.addEventListener('mousemove', handler);\n        unbindMouseMoveRef.current = () => {\n          doc.removeEventListener('mousemove', handler);\n        };\n        return;\n      }\n\n      // Allow interactivity without `safePolygon` on touch devices. With a\n      // pointer, a short close delay is an alternative, so it should work\n      // consistently.\n      const shouldClose = pointerTypeRef.current === 'touch' ? !contains(elements.floating, event.relatedTarget) : true;\n      if (shouldClose) {\n        closeWithDelay(event);\n      }\n    }\n\n    // Ensure the floating element closes after scrolling even if the pointer\n    // did not move.\n    // https://github.com/floating-ui/floating-ui/discussions/1692\n    function onScrollMouseLeave(event) {\n      if (isClickLikeOpenEvent()) return;\n      if (!dataRef.current.floatingContext) return;\n      handleCloseRef.current == null || handleCloseRef.current({\n        ...dataRef.current.floatingContext,\n        tree,\n        x: event.clientX,\n        y: event.clientY,\n        onClose() {\n          clearPointerEvents();\n          cleanupMouseMoveHandler();\n          if (!isClickLikeOpenEvent()) {\n            closeWithDelay(event);\n          }\n        }\n      })(event);\n    }\n    if (isElement(elements.domReference)) {\n      var _elements$floating;\n      const ref = elements.domReference;\n      open && ref.addEventListener('mouseleave', onScrollMouseLeave);\n      (_elements$floating = elements.floating) == null || _elements$floating.addEventListener('mouseleave', onScrollMouseLeave);\n      move && ref.addEventListener('mousemove', onMouseEnter, {\n        once: true\n      });\n      ref.addEventListener('mouseenter', onMouseEnter);\n      ref.addEventListener('mouseleave', onMouseLeave);\n      return () => {\n        var _elements$floating2;\n        open && ref.removeEventListener('mouseleave', onScrollMouseLeave);\n        (_elements$floating2 = elements.floating) == null || _elements$floating2.removeEventListener('mouseleave', onScrollMouseLeave);\n        move && ref.removeEventListener('mousemove', onMouseEnter);\n        ref.removeEventListener('mouseenter', onMouseEnter);\n        ref.removeEventListener('mouseleave', onMouseLeave);\n      };\n    }\n  }, [elements, enabled, context, mouseOnly, restMs, move, closeWithDelay, cleanupMouseMoveHandler, clearPointerEvents, onOpenChange, open, openRef, tree, delayRef, handleCloseRef, dataRef, isClickLikeOpenEvent]);\n\n  // Block pointer-events of every element other than the reference and floating\n  // while the floating element is open and has a `handleClose` handler. Also\n  // handles nested floating elements.\n  // https://github.com/floating-ui/floating-ui/issues/1722\n  index(() => {\n    var _handleCloseRef$curre;\n    if (!enabled) return;\n    if (open && (_handleCloseRef$curre = handleCloseRef.current) != null && _handleCloseRef$curre.__options.blockPointerEvents && isHoverOpen()) {\n      performedPointerEventsMutationRef.current = true;\n      const floatingEl = elements.floating;\n      if (isElement(elements.domReference) && floatingEl) {\n        var _tree$nodesRef$curren;\n        const body = getDocument(elements.floating).body;\n        body.setAttribute(safePolygonIdentifier, '');\n        const ref = elements.domReference;\n        const parentFloating = tree == null || (_tree$nodesRef$curren = tree.nodesRef.current.find(node => node.id === parentId)) == null || (_tree$nodesRef$curren = _tree$nodesRef$curren.context) == null ? void 0 : _tree$nodesRef$curren.elements.floating;\n        if (parentFloating) {\n          parentFloating.style.pointerEvents = '';\n        }\n        body.style.pointerEvents = 'none';\n        ref.style.pointerEvents = 'auto';\n        floatingEl.style.pointerEvents = 'auto';\n        return () => {\n          body.style.pointerEvents = '';\n          ref.style.pointerEvents = '';\n          floatingEl.style.pointerEvents = '';\n        };\n      }\n    }\n  }, [enabled, open, parentId, elements, tree, handleCloseRef, isHoverOpen]);\n  index(() => {\n    if (!open) {\n      pointerTypeRef.current = undefined;\n      restTimeoutPendingRef.current = false;\n      cleanupMouseMoveHandler();\n      clearPointerEvents();\n    }\n  }, [open, cleanupMouseMoveHandler, clearPointerEvents]);\n  React.useEffect(() => {\n    return () => {\n      cleanupMouseMoveHandler();\n      clearTimeout(timeoutRef.current);\n      clearTimeout(restTimeoutRef.current);\n      clearPointerEvents();\n    };\n  }, [enabled, elements.domReference, cleanupMouseMoveHandler, clearPointerEvents]);\n  const reference = React.useMemo(() => {\n    function setPointerRef(event) {\n      pointerTypeRef.current = event.pointerType;\n    }\n    return {\n      onPointerDown: setPointerRef,\n      onPointerEnter: setPointerRef,\n      onMouseMove(event) {\n        const {\n          nativeEvent\n        } = event;\n        function handleMouseMove() {\n          if (!blockMouseMoveRef.current && !openRef.current) {\n            onOpenChange(true, nativeEvent, 'hover');\n          }\n        }\n        if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current)) {\n          return;\n        }\n        if (open || restMs === 0) {\n          return;\n        }\n\n        // Ignore insignificant movements to account for tremors.\n        if (restTimeoutPendingRef.current && event.movementX ** 2 + event.movementY ** 2 < 2) {\n          return;\n        }\n        clearTimeout(restTimeoutRef.current);\n        if (pointerTypeRef.current === 'touch') {\n          handleMouseMove();\n        } else {\n          restTimeoutPendingRef.current = true;\n          restTimeoutRef.current = window.setTimeout(handleMouseMove, restMs);\n        }\n      }\n    };\n  }, [mouseOnly, onOpenChange, open, openRef, restMs]);\n  const floating = React.useMemo(() => ({\n    onMouseEnter() {\n      clearTimeout(timeoutRef.current);\n    },\n    onMouseLeave(event) {\n      if (!isClickLikeOpenEvent()) {\n        closeWithDelay(event.nativeEvent, false);\n      }\n    }\n  }), [closeWithDelay, isClickLikeOpenEvent]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating\n  } : {}, [enabled, reference, floating]);\n}\n\nconst NOOP = () => {};\nconst FloatingDelayGroupContext = /*#__PURE__*/React.createContext({\n  delay: 0,\n  initialDelay: 0,\n  timeoutMs: 0,\n  currentId: null,\n  setCurrentId: NOOP,\n  setState: NOOP,\n  isInstantPhase: false\n});\n\n/**\n * @deprecated\n * Use the return value of `useDelayGroup()` instead.\n */\nconst useDelayGroupContext = () => React.useContext(FloatingDelayGroupContext);\n/**\n * Provides context for a group of floating elements that should share a\n * `delay`.\n * @see https://floating-ui.com/docs/FloatingDelayGroup\n */\nfunction FloatingDelayGroup(props) {\n  const {\n    children,\n    delay,\n    timeoutMs = 0\n  } = props;\n  const [state, setState] = React.useReducer((prev, next) => ({\n    ...prev,\n    ...next\n  }), {\n    delay,\n    timeoutMs,\n    initialDelay: delay,\n    currentId: null,\n    isInstantPhase: false\n  });\n  const initialCurrentIdRef = React.useRef(null);\n  const setCurrentId = React.useCallback(currentId => {\n    setState({\n      currentId\n    });\n  }, []);\n  index(() => {\n    if (state.currentId) {\n      if (initialCurrentIdRef.current === null) {\n        initialCurrentIdRef.current = state.currentId;\n      } else if (!state.isInstantPhase) {\n        setState({\n          isInstantPhase: true\n        });\n      }\n    } else {\n      if (state.isInstantPhase) {\n        setState({\n          isInstantPhase: false\n        });\n      }\n      initialCurrentIdRef.current = null;\n    }\n  }, [state.currentId, state.isInstantPhase]);\n  return /*#__PURE__*/React.createElement(FloatingDelayGroupContext.Provider, {\n    value: React.useMemo(() => ({\n      ...state,\n      setState,\n      setCurrentId\n    }), [state, setCurrentId])\n  }, children);\n}\n/**\n * Enables grouping when called inside a component that's a child of a\n * `FloatingDelayGroup`.\n * @see https://floating-ui.com/docs/FloatingDelayGroup\n */\nfunction useDelayGroup(context, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    floatingId\n  } = context;\n  const {\n    id: optionId,\n    enabled = true\n  } = options;\n  const id = optionId != null ? optionId : floatingId;\n  const groupContext = useDelayGroupContext();\n  const {\n    currentId,\n    setCurrentId,\n    initialDelay,\n    setState,\n    timeoutMs\n  } = groupContext;\n  index(() => {\n    if (!enabled) return;\n    if (!currentId) return;\n    setState({\n      delay: {\n        open: 1,\n        close: getDelay(initialDelay, 'close')\n      }\n    });\n    if (currentId !== id) {\n      onOpenChange(false);\n    }\n  }, [enabled, id, onOpenChange, setState, currentId, initialDelay]);\n  index(() => {\n    function unset() {\n      onOpenChange(false);\n      setState({\n        delay: initialDelay,\n        currentId: null\n      });\n    }\n    if (!enabled) return;\n    if (!currentId) return;\n    if (!open && currentId === id) {\n      if (timeoutMs) {\n        const timeout = window.setTimeout(unset, timeoutMs);\n        return () => {\n          clearTimeout(timeout);\n        };\n      }\n      unset();\n    }\n  }, [enabled, open, setState, currentId, id, onOpenChange, initialDelay, timeoutMs]);\n  index(() => {\n    if (!enabled) return;\n    if (setCurrentId === NOOP || !open) return;\n    setCurrentId(id);\n  }, [enabled, open, setCurrentId, id]);\n  return groupContext;\n}\n\nlet rafId = 0;\nfunction enqueueFocus(el, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    preventScroll = false,\n    cancelPrevious = true,\n    sync = false\n  } = options;\n  cancelPrevious && cancelAnimationFrame(rafId);\n  const exec = () => el == null ? void 0 : el.focus({\n    preventScroll\n  });\n  if (sync) {\n    exec();\n  } else {\n    rafId = requestAnimationFrame(exec);\n  }\n}\n\nfunction getAncestors(nodes, id) {\n  var _nodes$find;\n  let allAncestors = [];\n  let currentParentId = (_nodes$find = nodes.find(node => node.id === id)) == null ? void 0 : _nodes$find.parentId;\n  while (currentParentId) {\n    const currentNode = nodes.find(node => node.id === currentParentId);\n    currentParentId = currentNode == null ? void 0 : currentNode.parentId;\n    if (currentNode) {\n      allAncestors = allAncestors.concat(currentNode);\n    }\n  }\n  return allAncestors;\n}\n\nfunction getChildren(nodes, id) {\n  let allChildren = nodes.filter(node => {\n    var _node$context;\n    return node.parentId === id && ((_node$context = node.context) == null ? void 0 : _node$context.open);\n  });\n  let currentChildren = allChildren;\n  while (currentChildren.length) {\n    currentChildren = nodes.filter(node => {\n      var _currentChildren;\n      return (_currentChildren = currentChildren) == null ? void 0 : _currentChildren.some(n => {\n        var _node$context2;\n        return node.parentId === n.id && ((_node$context2 = node.context) == null ? void 0 : _node$context2.open);\n      });\n    });\n    allChildren = allChildren.concat(currentChildren);\n  }\n  return allChildren;\n}\nfunction getDeepestNode(nodes, id) {\n  let deepestNodeId;\n  let maxDepth = -1;\n  function findDeepest(nodeId, depth) {\n    if (depth > maxDepth) {\n      deepestNodeId = nodeId;\n      maxDepth = depth;\n    }\n    const children = getChildren(nodes, nodeId);\n    children.forEach(child => {\n      findDeepest(child.id, depth + 1);\n    });\n  }\n  findDeepest(id, 0);\n  return nodes.find(node => node.id === deepestNodeId);\n}\n\n// Modified to add conditional `aria-hidden` support:\n// https://github.com/theKashey/aria-hidden/blob/9220c8f4a4fd35f63bee5510a9f41a37264382d4/src/index.ts\nlet counterMap = /*#__PURE__*/new WeakMap();\nlet uncontrolledElementsSet = /*#__PURE__*/new WeakSet();\nlet markerMap = {};\nlet lockCount$1 = 0;\nconst supportsInert = () => typeof HTMLElement !== 'undefined' && 'inert' in HTMLElement.prototype;\nconst unwrapHost = node => node && (node.host || unwrapHost(node.parentNode));\nconst correctElements = (parent, targets) => targets.map(target => {\n  if (parent.contains(target)) {\n    return target;\n  }\n  const correctedTarget = unwrapHost(target);\n  if (parent.contains(correctedTarget)) {\n    return correctedTarget;\n  }\n  return null;\n}).filter(x => x != null);\nfunction applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, inert) {\n  const markerName = 'data-floating-ui-inert';\n  const controlAttribute = inert ? 'inert' : ariaHidden ? 'aria-hidden' : null;\n  const avoidElements = correctElements(body, uncorrectedAvoidElements);\n  const elementsToKeep = new Set();\n  const elementsToStop = new Set(avoidElements);\n  const hiddenElements = [];\n  if (!markerMap[markerName]) {\n    markerMap[markerName] = new WeakMap();\n  }\n  const markerCounter = markerMap[markerName];\n  avoidElements.forEach(keep);\n  deep(body);\n  elementsToKeep.clear();\n  function keep(el) {\n    if (!el || elementsToKeep.has(el)) {\n      return;\n    }\n    elementsToKeep.add(el);\n    el.parentNode && keep(el.parentNode);\n  }\n  function deep(parent) {\n    if (!parent || elementsToStop.has(parent)) {\n      return;\n    }\n    [].forEach.call(parent.children, node => {\n      if (getNodeName(node) === 'script') return;\n      if (elementsToKeep.has(node)) {\n        deep(node);\n      } else {\n        const attr = controlAttribute ? node.getAttribute(controlAttribute) : null;\n        const alreadyHidden = attr !== null && attr !== 'false';\n        const counterValue = (counterMap.get(node) || 0) + 1;\n        const markerValue = (markerCounter.get(node) || 0) + 1;\n        counterMap.set(node, counterValue);\n        markerCounter.set(node, markerValue);\n        hiddenElements.push(node);\n        if (counterValue === 1 && alreadyHidden) {\n          uncontrolledElementsSet.add(node);\n        }\n        if (markerValue === 1) {\n          node.setAttribute(markerName, '');\n        }\n        if (!alreadyHidden && controlAttribute) {\n          node.setAttribute(controlAttribute, 'true');\n        }\n      }\n    });\n  }\n  lockCount$1++;\n  return () => {\n    hiddenElements.forEach(element => {\n      const counterValue = (counterMap.get(element) || 0) - 1;\n      const markerValue = (markerCounter.get(element) || 0) - 1;\n      counterMap.set(element, counterValue);\n      markerCounter.set(element, markerValue);\n      if (!counterValue) {\n        if (!uncontrolledElementsSet.has(element) && controlAttribute) {\n          element.removeAttribute(controlAttribute);\n        }\n        uncontrolledElementsSet.delete(element);\n      }\n      if (!markerValue) {\n        element.removeAttribute(markerName);\n      }\n    });\n    lockCount$1--;\n    if (!lockCount$1) {\n      counterMap = new WeakMap();\n      counterMap = new WeakMap();\n      uncontrolledElementsSet = new WeakSet();\n      markerMap = {};\n    }\n  };\n}\nfunction markOthers(avoidElements, ariaHidden, inert) {\n  if (ariaHidden === void 0) {\n    ariaHidden = false;\n  }\n  if (inert === void 0) {\n    inert = false;\n  }\n  const body = getDocument(avoidElements[0]).body;\n  return applyAttributeToOthers(avoidElements.concat(Array.from(body.querySelectorAll('[aria-live]'))), body, ariaHidden, inert);\n}\n\nconst getTabbableOptions = () => ({\n  getShadowRoot: true,\n  displayCheck:\n  // JSDOM does not support the `tabbable` library. To solve this we can\n  // check if `ResizeObserver` is a real function (not polyfilled), which\n  // determines if the current environment is JSDOM-like.\n  typeof ResizeObserver === 'function' && ResizeObserver.toString().includes('[native code]') ? 'full' : 'none'\n});\nfunction getTabbableIn(container, direction) {\n  const allTabbable = tabbable(container, getTabbableOptions());\n  if (direction === 'prev') {\n    allTabbable.reverse();\n  }\n  const activeIndex = allTabbable.indexOf(activeElement(getDocument(container)));\n  const nextTabbableElements = allTabbable.slice(activeIndex + 1);\n  return nextTabbableElements[0];\n}\nfunction getNextTabbable() {\n  return getTabbableIn(document.body, 'next');\n}\nfunction getPreviousTabbable() {\n  return getTabbableIn(document.body, 'prev');\n}\nfunction isOutsideEvent(event, container) {\n  const containerElement = container || event.currentTarget;\n  const relatedTarget = event.relatedTarget;\n  return !relatedTarget || !contains(containerElement, relatedTarget);\n}\nfunction disableFocusInside(container) {\n  const tabbableElements = tabbable(container, getTabbableOptions());\n  tabbableElements.forEach(element => {\n    element.dataset.tabindex = element.getAttribute('tabindex') || '';\n    element.setAttribute('tabindex', '-1');\n  });\n}\nfunction enableFocusInside(container) {\n  const elements = container.querySelectorAll('[data-tabindex]');\n  elements.forEach(element => {\n    const tabindex = element.dataset.tabindex;\n    delete element.dataset.tabindex;\n    if (tabindex) {\n      element.setAttribute('tabindex', tabindex);\n    } else {\n      element.removeAttribute('tabindex');\n    }\n  });\n}\n\n// See Diego Haz's Sandbox for making this logic work well on Safari/iOS:\n// https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/FocusTrap.tsx\n\nconst HIDDEN_STYLES = {\n  border: 0,\n  clip: 'rect(0 0 0 0)',\n  height: '1px',\n  margin: '-1px',\n  overflow: 'hidden',\n  padding: 0,\n  position: 'fixed',\n  whiteSpace: 'nowrap',\n  width: '1px',\n  top: 0,\n  left: 0\n};\nlet timeoutId;\nfunction setActiveElementOnTab(event) {\n  if (event.key === 'Tab') {\n    event.target;\n    clearTimeout(timeoutId);\n  }\n}\nconst FocusGuard = /*#__PURE__*/React.forwardRef(function FocusGuard(props, ref) {\n  const [role, setRole] = React.useState();\n  index(() => {\n    if (isSafari()) {\n      // Unlike other screen readers such as NVDA and JAWS, the virtual cursor\n      // on VoiceOver does trigger the onFocus event, so we can use the focus\n      // trap element. On Safari, only buttons trigger the onFocus event.\n      // NB: \"group\" role in the Sandbox no longer appears to work, must be a\n      // button role.\n      setRole('button');\n    }\n    document.addEventListener('keydown', setActiveElementOnTab);\n    return () => {\n      document.removeEventListener('keydown', setActiveElementOnTab);\n    };\n  }, []);\n  const restProps = {\n    ref,\n    tabIndex: 0,\n    // Role is only for VoiceOver\n    role,\n    'aria-hidden': role ? undefined : true,\n    [createAttribute('focus-guard')]: '',\n    style: HIDDEN_STYLES\n  };\n  return /*#__PURE__*/React.createElement(\"span\", _extends({}, props, restProps));\n});\n\nconst PortalContext = /*#__PURE__*/React.createContext(null);\nconst attr = /*#__PURE__*/createAttribute('portal');\n/**\n * @see https://floating-ui.com/docs/FloatingPortal#usefloatingportalnode\n */\nfunction useFloatingPortalNode(props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    id,\n    root\n  } = props;\n  const uniqueId = useId();\n  const portalContext = usePortalContext();\n  const [portalNode, setPortalNode] = React.useState(null);\n  const portalNodeRef = React.useRef(null);\n  index(() => {\n    return () => {\n      portalNode == null || portalNode.remove();\n      // Allow the subsequent layout effects to create a new node on updates.\n      // The portal node will still be cleaned up on unmount.\n      // https://github.com/floating-ui/floating-ui/issues/2454\n      queueMicrotask(() => {\n        portalNodeRef.current = null;\n      });\n    };\n  }, [portalNode]);\n  index(() => {\n    // Wait for the uniqueId to be generated before creating the portal node in\n    // React <18 (using `useFloatingId` instead of the native `useId`).\n    // https://github.com/floating-ui/floating-ui/issues/2778\n    if (!uniqueId) return;\n    if (portalNodeRef.current) return;\n    const existingIdRoot = id ? document.getElementById(id) : null;\n    if (!existingIdRoot) return;\n    const subRoot = document.createElement('div');\n    subRoot.id = uniqueId;\n    subRoot.setAttribute(attr, '');\n    existingIdRoot.appendChild(subRoot);\n    portalNodeRef.current = subRoot;\n    setPortalNode(subRoot);\n  }, [id, uniqueId]);\n  index(() => {\n    // Wait for the root to exist before creating the portal node. The root must\n    // be stored in state, not a ref, for this to work reactively.\n    if (root === null) return;\n    if (!uniqueId) return;\n    if (portalNodeRef.current) return;\n    let container = root || (portalContext == null ? void 0 : portalContext.portalNode);\n    if (container && !isElement(container)) container = container.current;\n    container = container || document.body;\n    let idWrapper = null;\n    if (id) {\n      idWrapper = document.createElement('div');\n      idWrapper.id = id;\n      container.appendChild(idWrapper);\n    }\n    const subRoot = document.createElement('div');\n    subRoot.id = uniqueId;\n    subRoot.setAttribute(attr, '');\n    container = idWrapper || container;\n    container.appendChild(subRoot);\n    portalNodeRef.current = subRoot;\n    setPortalNode(subRoot);\n  }, [id, root, uniqueId, portalContext]);\n  return portalNode;\n}\n/**\n * Portals the floating element into a given container element — by default,\n * outside of the app root and into the body.\n * This is necessary to ensure the floating element can appear outside any\n * potential parent containers that cause clipping (such as `overflow: hidden`),\n * while retaining its location in the React tree.\n * @see https://floating-ui.com/docs/FloatingPortal\n */\nfunction FloatingPortal(props) {\n  const {\n    children,\n    id,\n    root,\n    preserveTabOrder = true\n  } = props;\n  const portalNode = useFloatingPortalNode({\n    id,\n    root\n  });\n  const [focusManagerState, setFocusManagerState] = React.useState(null);\n  const beforeOutsideRef = React.useRef(null);\n  const afterOutsideRef = React.useRef(null);\n  const beforeInsideRef = React.useRef(null);\n  const afterInsideRef = React.useRef(null);\n  const modal = focusManagerState == null ? void 0 : focusManagerState.modal;\n  const open = focusManagerState == null ? void 0 : focusManagerState.open;\n  const shouldRenderGuards =\n  // The FocusManager and therefore floating element are currently open/\n  // rendered.\n  !!focusManagerState &&\n  // Guards are only for non-modal focus management.\n  !focusManagerState.modal &&\n  // Don't render if unmount is transitioning.\n  focusManagerState.open && preserveTabOrder && !!(root || portalNode);\n\n  // https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/TabbablePortal.tsx\n  React.useEffect(() => {\n    if (!portalNode || !preserveTabOrder || modal) {\n      return;\n    }\n\n    // Make sure elements inside the portal element are tabbable only when the\n    // portal has already been focused, either by tabbing into a focus trap\n    // element outside or using the mouse.\n    function onFocus(event) {\n      if (portalNode && isOutsideEvent(event)) {\n        const focusing = event.type === 'focusin';\n        const manageFocus = focusing ? enableFocusInside : disableFocusInside;\n        manageFocus(portalNode);\n      }\n    }\n    // Listen to the event on the capture phase so they run before the focus\n    // trap elements onFocus prop is called.\n    portalNode.addEventListener('focusin', onFocus, true);\n    portalNode.addEventListener('focusout', onFocus, true);\n    return () => {\n      portalNode.removeEventListener('focusin', onFocus, true);\n      portalNode.removeEventListener('focusout', onFocus, true);\n    };\n  }, [portalNode, preserveTabOrder, modal]);\n  React.useEffect(() => {\n    if (!portalNode) return;\n    if (open) return;\n    enableFocusInside(portalNode);\n  }, [open, portalNode]);\n  return /*#__PURE__*/React.createElement(PortalContext.Provider, {\n    value: React.useMemo(() => ({\n      preserveTabOrder,\n      beforeOutsideRef,\n      afterOutsideRef,\n      beforeInsideRef,\n      afterInsideRef,\n      portalNode,\n      setFocusManagerState\n    }), [preserveTabOrder, portalNode])\n  }, shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"outside\",\n    ref: beforeOutsideRef,\n    onFocus: event => {\n      if (isOutsideEvent(event, portalNode)) {\n        var _beforeInsideRef$curr;\n        (_beforeInsideRef$curr = beforeInsideRef.current) == null || _beforeInsideRef$curr.focus();\n      } else {\n        const prevTabbable = getPreviousTabbable() || (focusManagerState == null ? void 0 : focusManagerState.refs.domReference.current);\n        prevTabbable == null || prevTabbable.focus();\n      }\n    }\n  }), shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(\"span\", {\n    \"aria-owns\": portalNode.id,\n    style: HIDDEN_STYLES\n  }), portalNode && /*#__PURE__*/ReactDOM.createPortal(children, portalNode), shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"outside\",\n    ref: afterOutsideRef,\n    onFocus: event => {\n      if (isOutsideEvent(event, portalNode)) {\n        var _afterInsideRef$curre;\n        (_afterInsideRef$curre = afterInsideRef.current) == null || _afterInsideRef$curre.focus();\n      } else {\n        const nextTabbable = getNextTabbable() || (focusManagerState == null ? void 0 : focusManagerState.refs.domReference.current);\n        nextTabbable == null || nextTabbable.focus();\n        (focusManagerState == null ? void 0 : focusManagerState.closeOnFocusOut) && (focusManagerState == null ? void 0 : focusManagerState.onOpenChange(false, event.nativeEvent, 'focus-out'));\n      }\n    }\n  }));\n}\nconst usePortalContext = () => React.useContext(PortalContext);\n\nconst FOCUSABLE_ATTRIBUTE = 'data-floating-ui-focusable';\nfunction getFloatingFocusElement(floatingElement) {\n  if (!floatingElement) {\n    return null;\n  }\n  // Try to find the element that has `{...getFloatingProps()}` spread on it.\n  // This indicates the floating element is acting as a positioning wrapper, and\n  // so focus should be managed on the child element with the event handlers and\n  // aria props.\n  return floatingElement.hasAttribute(FOCUSABLE_ATTRIBUTE) ? floatingElement : floatingElement.querySelector(\"[\" + FOCUSABLE_ATTRIBUTE + \"]\") || floatingElement;\n}\n\nconst LIST_LIMIT = 20;\nlet previouslyFocusedElements = [];\nfunction addPreviouslyFocusedElement(element) {\n  previouslyFocusedElements = previouslyFocusedElements.filter(el => el.isConnected);\n  let tabbableEl = element;\n  if (!tabbableEl || getNodeName(tabbableEl) === 'body') return;\n  if (!isTabbable(tabbableEl, getTabbableOptions())) {\n    const tabbableChild = tabbable(tabbableEl, getTabbableOptions())[0];\n    if (tabbableChild) {\n      tabbableEl = tabbableChild;\n    }\n  }\n  previouslyFocusedElements.push(tabbableEl);\n  if (previouslyFocusedElements.length > LIST_LIMIT) {\n    previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);\n  }\n}\nfunction getPreviouslyFocusedElement() {\n  return previouslyFocusedElements.slice().reverse().find(el => el.isConnected);\n}\nconst VisuallyHiddenDismiss = /*#__PURE__*/React.forwardRef(function VisuallyHiddenDismiss(props, ref) {\n  return /*#__PURE__*/React.createElement(\"button\", _extends({}, props, {\n    type: \"button\",\n    ref: ref,\n    tabIndex: -1,\n    style: HIDDEN_STYLES\n  }));\n});\n/**\n * Provides focus management for the floating element.\n * @see https://floating-ui.com/docs/FloatingFocusManager\n */\nfunction FloatingFocusManager(props) {\n  const {\n    context,\n    children,\n    disabled = false,\n    order = ['content'],\n    guards: _guards = true,\n    initialFocus = 0,\n    returnFocus = true,\n    restoreFocus = false,\n    modal = true,\n    visuallyHiddenDismiss = false,\n    closeOnFocusOut = true\n  } = props;\n  const {\n    open,\n    refs,\n    nodeId,\n    onOpenChange,\n    events,\n    dataRef,\n    floatingId,\n    elements: {\n      domReference,\n      floating\n    }\n  } = context;\n  const ignoreInitialFocus = typeof initialFocus === 'number' && initialFocus < 0;\n  // If the reference is a combobox and is typeable (e.g. input/textarea),\n  // there are different focus semantics. The guards should not be rendered, but\n  // aria-hidden should be applied to all nodes still. Further, the visually\n  // hidden dismiss button should only appear at the end of the list, not the\n  // start.\n  const isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;\n\n  // Force the guards to be rendered if the `inert` attribute is not supported.\n  const guards = supportsInert() ? _guards : true;\n  const orderRef = useLatestRef(order);\n  const initialFocusRef = useLatestRef(initialFocus);\n  const returnFocusRef = useLatestRef(returnFocus);\n  const tree = useFloatingTree();\n  const portalContext = usePortalContext();\n  const startDismissButtonRef = React.useRef(null);\n  const endDismissButtonRef = React.useRef(null);\n  const preventReturnFocusRef = React.useRef(false);\n  const isPointerDownRef = React.useRef(false);\n  const tabbableIndexRef = React.useRef(-1);\n  const isInsidePortal = portalContext != null;\n  const floatingFocusElement = getFloatingFocusElement(floating);\n  const getTabbableContent = useEffectEvent(function (container) {\n    if (container === void 0) {\n      container = floatingFocusElement;\n    }\n    return container ? tabbable(container, getTabbableOptions()) : [];\n  });\n  const getTabbableElements = useEffectEvent(container => {\n    const content = getTabbableContent(container);\n    return orderRef.current.map(type => {\n      if (domReference && type === 'reference') {\n        return domReference;\n      }\n      if (floatingFocusElement && type === 'floating') {\n        return floatingFocusElement;\n      }\n      return content;\n    }).filter(Boolean).flat();\n  });\n  React.useEffect(() => {\n    if (disabled) return;\n    if (!modal) return;\n    function onKeyDown(event) {\n      if (event.key === 'Tab') {\n        // The focus guards have nothing to focus, so we need to stop the event.\n        if (contains(floatingFocusElement, activeElement(getDocument(floatingFocusElement))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) {\n          stopEvent(event);\n        }\n        const els = getTabbableElements();\n        const target = getTarget(event);\n        if (orderRef.current[0] === 'reference' && target === domReference) {\n          stopEvent(event);\n          if (event.shiftKey) {\n            enqueueFocus(els[els.length - 1]);\n          } else {\n            enqueueFocus(els[1]);\n          }\n        }\n        if (orderRef.current[1] === 'floating' && target === floatingFocusElement && event.shiftKey) {\n          stopEvent(event);\n          enqueueFocus(els[0]);\n        }\n      }\n    }\n    const doc = getDocument(floatingFocusElement);\n    doc.addEventListener('keydown', onKeyDown);\n    return () => {\n      doc.removeEventListener('keydown', onKeyDown);\n    };\n  }, [disabled, domReference, floatingFocusElement, modal, orderRef, isUntrappedTypeableCombobox, getTabbableContent, getTabbableElements]);\n  React.useEffect(() => {\n    if (disabled) return;\n    if (!floating) return;\n    function handleFocusIn(event) {\n      const target = getTarget(event);\n      const tabbableContent = getTabbableContent();\n      const tabbableIndex = tabbableContent.indexOf(target);\n      if (tabbableIndex !== -1) {\n        tabbableIndexRef.current = tabbableIndex;\n      }\n    }\n    floating.addEventListener('focusin', handleFocusIn);\n    return () => {\n      floating.removeEventListener('focusin', handleFocusIn);\n    };\n  }, [disabled, floating, getTabbableContent]);\n  React.useEffect(() => {\n    if (disabled) return;\n    if (!closeOnFocusOut) return;\n\n    // In Safari, buttons lose focus when pressing them.\n    function handlePointerDown() {\n      isPointerDownRef.current = true;\n      setTimeout(() => {\n        isPointerDownRef.current = false;\n      });\n    }\n    function handleFocusOutside(event) {\n      const relatedTarget = event.relatedTarget;\n      queueMicrotask(() => {\n        const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext == null ? void 0 : portalContext.portalNode, relatedTarget) || relatedTarget != null && relatedTarget.hasAttribute(createAttribute('focus-guard')) || tree && (getChildren(tree.nodesRef.current, nodeId).find(node => {\n          var _node$context, _node$context2;\n          return contains((_node$context = node.context) == null ? void 0 : _node$context.elements.floating, relatedTarget) || contains((_node$context2 = node.context) == null ? void 0 : _node$context2.elements.domReference, relatedTarget);\n        }) || getAncestors(tree.nodesRef.current, nodeId).find(node => {\n          var _node$context3, _node$context4;\n          return ((_node$context3 = node.context) == null ? void 0 : _node$context3.elements.floating) === relatedTarget || ((_node$context4 = node.context) == null ? void 0 : _node$context4.elements.domReference) === relatedTarget;\n        })));\n\n        // Restore focus to the previous tabbable element index to prevent\n        // focus from being lost outside the floating tree.\n        if (restoreFocus && movedToUnrelatedNode && activeElement(getDocument(floatingFocusElement)) === getDocument(floatingFocusElement).body) {\n          // Let `FloatingPortal` effect knows that focus is still inside the\n          // floating tree.\n          if (isHTMLElement(floatingFocusElement)) {\n            floatingFocusElement.focus();\n          }\n          const prevTabbableIndex = tabbableIndexRef.current;\n          const tabbableContent = getTabbableContent();\n          const nodeToFocus = tabbableContent[prevTabbableIndex] || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;\n          if (isHTMLElement(nodeToFocus)) {\n            nodeToFocus.focus();\n          }\n        }\n\n        // Focus did not move inside the floating tree, and there are no tabbable\n        // portal guards to handle closing.\n        if ((isUntrappedTypeableCombobox ? true : !modal) && relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current &&\n        // Fix React 18 Strict Mode returnFocus due to double rendering.\n        relatedTarget !== getPreviouslyFocusedElement()) {\n          preventReturnFocusRef.current = true;\n          onOpenChange(false, event, 'focus-out');\n        }\n      });\n    }\n    if (floating && isHTMLElement(domReference)) {\n      domReference.addEventListener('focusout', handleFocusOutside);\n      domReference.addEventListener('pointerdown', handlePointerDown);\n      floating.addEventListener('focusout', handleFocusOutside);\n      return () => {\n        domReference.removeEventListener('focusout', handleFocusOutside);\n        domReference.removeEventListener('pointerdown', handlePointerDown);\n        floating.removeEventListener('focusout', handleFocusOutside);\n      };\n    }\n  }, [disabled, domReference, floating, floatingFocusElement, modal, nodeId, tree, portalContext, onOpenChange, closeOnFocusOut, restoreFocus, getTabbableContent, isUntrappedTypeableCombobox]);\n  React.useEffect(() => {\n    var _portalContext$portal;\n    if (disabled) return;\n\n    // Don't hide portals nested within the parent portal.\n    const portalNodes = Array.from((portalContext == null || (_portalContext$portal = portalContext.portalNode) == null ? void 0 : _portalContext$portal.querySelectorAll(\"[\" + createAttribute('portal') + \"]\")) || []);\n    if (floating) {\n      const insideElements = [floating, ...portalNodes, startDismissButtonRef.current, endDismissButtonRef.current, orderRef.current.includes('reference') || isUntrappedTypeableCombobox ? domReference : null].filter(x => x != null);\n      const cleanup = modal || isUntrappedTypeableCombobox ? markOthers(insideElements, guards, !guards) : markOthers(insideElements);\n      return () => {\n        cleanup();\n      };\n    }\n  }, [disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, guards]);\n  index(() => {\n    if (disabled || !isHTMLElement(floatingFocusElement)) return;\n    const doc = getDocument(floatingFocusElement);\n    const previouslyFocusedElement = activeElement(doc);\n\n    // Wait for any layout effect state setters to execute to set `tabIndex`.\n    queueMicrotask(() => {\n      const focusableElements = getTabbableElements(floatingFocusElement);\n      const initialFocusValue = initialFocusRef.current;\n      const elToFocus = (typeof initialFocusValue === 'number' ? focusableElements[initialFocusValue] : initialFocusValue.current) || floatingFocusElement;\n      const focusAlreadyInsideFloatingEl = contains(floatingFocusElement, previouslyFocusedElement);\n      if (!ignoreInitialFocus && !focusAlreadyInsideFloatingEl && open) {\n        enqueueFocus(elToFocus, {\n          preventScroll: elToFocus === floatingFocusElement\n        });\n      }\n    });\n  }, [disabled, open, floatingFocusElement, ignoreInitialFocus, getTabbableElements, initialFocusRef]);\n  index(() => {\n    if (disabled || !floatingFocusElement) return;\n    let preventReturnFocusScroll = false;\n    const doc = getDocument(floatingFocusElement);\n    const previouslyFocusedElement = activeElement(doc);\n    const contextData = dataRef.current;\n    let openEvent = contextData.openEvent;\n    addPreviouslyFocusedElement(previouslyFocusedElement);\n\n    // Dismissing via outside press should always ignore `returnFocus` to\n    // prevent unwanted scrolling.\n    function onOpenChange(_ref) {\n      let {\n        open,\n        reason,\n        event,\n        nested\n      } = _ref;\n      if (open) {\n        openEvent = event;\n      }\n      if (reason === 'escape-key' && refs.domReference.current) {\n        addPreviouslyFocusedElement(refs.domReference.current);\n      }\n      if (reason === 'hover' && event.type === 'mouseleave') {\n        preventReturnFocusRef.current = true;\n      }\n      if (reason !== 'outside-press') return;\n      if (nested) {\n        preventReturnFocusRef.current = false;\n        preventReturnFocusScroll = true;\n      } else {\n        preventReturnFocusRef.current = !(isVirtualClick(event) || isVirtualPointerEvent(event));\n      }\n    }\n    events.on('openchange', onOpenChange);\n    const fallbackEl = doc.createElement('span');\n    fallbackEl.setAttribute('tabindex', '-1');\n    fallbackEl.setAttribute('aria-hidden', 'true');\n    Object.assign(fallbackEl.style, HIDDEN_STYLES);\n    if (isInsidePortal && domReference) {\n      domReference.insertAdjacentElement('afterend', fallbackEl);\n    }\n    function getReturnElement() {\n      if (typeof returnFocusRef.current === 'boolean') {\n        return getPreviouslyFocusedElement() || fallbackEl;\n      }\n      return returnFocusRef.current.current || fallbackEl;\n    }\n    return () => {\n      events.off('openchange', onOpenChange);\n      const activeEl = activeElement(doc);\n      const isFocusInsideFloatingTree = contains(floating, activeEl) || tree && getChildren(tree.nodesRef.current, nodeId).some(node => {\n        var _node$context5;\n        return contains((_node$context5 = node.context) == null ? void 0 : _node$context5.elements.floating, activeEl);\n      });\n      const shouldFocusReference = isFocusInsideFloatingTree || openEvent && ['click', 'mousedown'].includes(openEvent.type);\n      if (shouldFocusReference && refs.domReference.current) {\n        addPreviouslyFocusedElement(refs.domReference.current);\n      }\n      const returnElement = getReturnElement();\n      queueMicrotask(() => {\n        if (\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n        returnFocusRef.current && !preventReturnFocusRef.current && isHTMLElement(returnElement) && (\n        // If the focus moved somewhere else after mount, avoid returning focus\n        // since it likely entered a different element which should be\n        // respected: https://github.com/floating-ui/floating-ui/issues/2607\n        returnElement !== activeEl && activeEl !== doc.body ? isFocusInsideFloatingTree : true)) {\n          returnElement.focus({\n            preventScroll: preventReturnFocusScroll\n          });\n        }\n        fallbackEl.remove();\n      });\n    };\n  }, [disabled, floating, floatingFocusElement, returnFocusRef, dataRef, refs, events, tree, nodeId, isInsidePortal, domReference]);\n  React.useEffect(() => {\n    // The `returnFocus` cleanup behavior is inside a microtask; ensure we\n    // wait for it to complete before resetting the flag.\n    queueMicrotask(() => {\n      preventReturnFocusRef.current = false;\n    });\n  }, [disabled]);\n\n  // Synchronize the `context` & `modal` value to the FloatingPortal context.\n  // It will decide whether or not it needs to render its own guards.\n  index(() => {\n    if (disabled) return;\n    if (!portalContext) return;\n    portalContext.setFocusManagerState({\n      modal,\n      closeOnFocusOut,\n      open,\n      onOpenChange,\n      refs\n    });\n    return () => {\n      portalContext.setFocusManagerState(null);\n    };\n  }, [disabled, portalContext, modal, open, onOpenChange, refs, closeOnFocusOut]);\n  index(() => {\n    if (disabled) return;\n    if (!floatingFocusElement) return;\n    if (typeof MutationObserver !== 'function') return;\n    if (ignoreInitialFocus) return;\n    const handleMutation = () => {\n      const tabIndex = floatingFocusElement.getAttribute('tabindex');\n      const tabbableContent = getTabbableContent();\n      const activeEl = activeElement(getDocument(floating));\n      const tabbableIndex = tabbableContent.indexOf(activeEl);\n      if (tabbableIndex !== -1) {\n        tabbableIndexRef.current = tabbableIndex;\n      }\n      if (orderRef.current.includes('floating') || activeEl !== refs.domReference.current && tabbableContent.length === 0) {\n        if (tabIndex !== '0') {\n          floatingFocusElement.setAttribute('tabindex', '0');\n        }\n      } else if (tabIndex !== '-1') {\n        floatingFocusElement.setAttribute('tabindex', '-1');\n      }\n    };\n    handleMutation();\n    const observer = new MutationObserver(handleMutation);\n    observer.observe(floatingFocusElement, {\n      childList: true,\n      subtree: true,\n      attributes: true\n    });\n    return () => {\n      observer.disconnect();\n    };\n  }, [disabled, floating, floatingFocusElement, refs, orderRef, getTabbableContent, ignoreInitialFocus]);\n  function renderDismissButton(location) {\n    if (disabled || !visuallyHiddenDismiss || !modal) {\n      return null;\n    }\n    return /*#__PURE__*/React.createElement(VisuallyHiddenDismiss, {\n      ref: location === 'start' ? startDismissButtonRef : endDismissButtonRef,\n      onClick: event => onOpenChange(false, event.nativeEvent)\n    }, typeof visuallyHiddenDismiss === 'string' ? visuallyHiddenDismiss : 'Dismiss');\n  }\n  const shouldRenderGuards = !disabled && guards && (modal ? !isUntrappedTypeableCombobox : true) && (isInsidePortal || modal);\n  return /*#__PURE__*/React.createElement(React.Fragment, null, shouldRenderGuards && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"inside\",\n    ref: portalContext == null ? void 0 : portalContext.beforeInsideRef,\n    onFocus: event => {\n      if (modal) {\n        const els = getTabbableElements();\n        enqueueFocus(order[0] === 'reference' ? els[0] : els[els.length - 1]);\n      } else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {\n        preventReturnFocusRef.current = false;\n        if (isOutsideEvent(event, portalContext.portalNode)) {\n          const nextTabbable = getNextTabbable() || domReference;\n          nextTabbable == null || nextTabbable.focus();\n        } else {\n          var _portalContext$before;\n          (_portalContext$before = portalContext.beforeOutsideRef.current) == null || _portalContext$before.focus();\n        }\n      }\n    }\n  }), !isUntrappedTypeableCombobox && renderDismissButton('start'), children, renderDismissButton('end'), shouldRenderGuards && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"inside\",\n    ref: portalContext == null ? void 0 : portalContext.afterInsideRef,\n    onFocus: event => {\n      if (modal) {\n        enqueueFocus(getTabbableElements()[0]);\n      } else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {\n        if (closeOnFocusOut) {\n          preventReturnFocusRef.current = true;\n        }\n        if (isOutsideEvent(event, portalContext.portalNode)) {\n          const prevTabbable = getPreviousTabbable() || domReference;\n          prevTabbable == null || prevTabbable.focus();\n        } else {\n          var _portalContext$afterO;\n          (_portalContext$afterO = portalContext.afterOutsideRef.current) == null || _portalContext$afterO.focus();\n        }\n      }\n    }\n  }));\n}\n\nlet lockCount = 0;\nfunction enableScrollLock() {\n  const isIOS = /iP(hone|ad|od)|iOS/.test(getPlatform());\n  const bodyStyle = document.body.style;\n  // RTL <body> scrollbar\n  const scrollbarX = Math.round(document.documentElement.getBoundingClientRect().left) + document.documentElement.scrollLeft;\n  const paddingProp = scrollbarX ? 'paddingLeft' : 'paddingRight';\n  const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;\n  const scrollX = bodyStyle.left ? parseFloat(bodyStyle.left) : window.scrollX;\n  const scrollY = bodyStyle.top ? parseFloat(bodyStyle.top) : window.scrollY;\n  bodyStyle.overflow = 'hidden';\n  if (scrollbarWidth) {\n    bodyStyle[paddingProp] = scrollbarWidth + \"px\";\n  }\n\n  // Only iOS doesn't respect `overflow: hidden` on document.body, and this\n  // technique has fewer side effects.\n  if (isIOS) {\n    var _window$visualViewpor, _window$visualViewpor2;\n    // iOS 12 does not support `visualViewport`.\n    const offsetLeft = ((_window$visualViewpor = window.visualViewport) == null ? void 0 : _window$visualViewpor.offsetLeft) || 0;\n    const offsetTop = ((_window$visualViewpor2 = window.visualViewport) == null ? void 0 : _window$visualViewpor2.offsetTop) || 0;\n    Object.assign(bodyStyle, {\n      position: 'fixed',\n      top: -(scrollY - Math.floor(offsetTop)) + \"px\",\n      left: -(scrollX - Math.floor(offsetLeft)) + \"px\",\n      right: '0'\n    });\n  }\n  return () => {\n    Object.assign(bodyStyle, {\n      overflow: '',\n      [paddingProp]: ''\n    });\n    if (isIOS) {\n      Object.assign(bodyStyle, {\n        position: '',\n        top: '',\n        left: '',\n        right: ''\n      });\n      window.scrollTo(scrollX, scrollY);\n    }\n  };\n}\nlet cleanup = () => {};\n\n/**\n * Provides base styling for a fixed overlay element to dim content or block\n * pointer events behind a floating element.\n * It's a regular `<div>`, so it can be styled via any CSS solution you prefer.\n * @see https://floating-ui.com/docs/FloatingOverlay\n */\nconst FloatingOverlay = /*#__PURE__*/React.forwardRef(function FloatingOverlay(props, ref) {\n  const {\n    lockScroll = false,\n    ...rest\n  } = props;\n  index(() => {\n    if (!lockScroll) return;\n    lockCount++;\n    if (lockCount === 1) {\n      cleanup = enableScrollLock();\n    }\n    return () => {\n      lockCount--;\n      if (lockCount === 0) {\n        cleanup();\n      }\n    };\n  }, [lockScroll]);\n  return /*#__PURE__*/React.createElement(\"div\", _extends({\n    ref: ref\n  }, rest, {\n    style: {\n      position: 'fixed',\n      overflow: 'auto',\n      top: 0,\n      right: 0,\n      bottom: 0,\n      left: 0,\n      ...rest.style\n    }\n  }));\n});\n\nfunction isButtonTarget(event) {\n  return isHTMLElement(event.target) && event.target.tagName === 'BUTTON';\n}\nfunction isSpaceIgnored(element) {\n  return isTypeableElement(element);\n}\n/**\n * Opens or closes the floating element when clicking the reference element.\n * @see https://floating-ui.com/docs/useClick\n */\nfunction useClick(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    dataRef,\n    elements: {\n      domReference\n    }\n  } = context;\n  const {\n    enabled = true,\n    event: eventOption = 'click',\n    toggle = true,\n    ignoreMouse = false,\n    keyboardHandlers = true,\n    stickIfOpen = true\n  } = props;\n  const pointerTypeRef = React.useRef();\n  const didKeyDownRef = React.useRef(false);\n  const reference = React.useMemo(() => ({\n    onPointerDown(event) {\n      pointerTypeRef.current = event.pointerType;\n    },\n    onMouseDown(event) {\n      const pointerType = pointerTypeRef.current;\n\n      // Ignore all buttons except for the \"main\" button.\n      // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button\n      if (event.button !== 0) return;\n      if (eventOption === 'click') return;\n      if (isMouseLikePointerType(pointerType, true) && ignoreMouse) return;\n      if (open && toggle && (dataRef.current.openEvent && stickIfOpen ? dataRef.current.openEvent.type === 'mousedown' : true)) {\n        onOpenChange(false, event.nativeEvent, 'click');\n      } else {\n        // Prevent stealing focus from the floating element\n        event.preventDefault();\n        onOpenChange(true, event.nativeEvent, 'click');\n      }\n    },\n    onClick(event) {\n      const pointerType = pointerTypeRef.current;\n      if (eventOption === 'mousedown' && pointerTypeRef.current) {\n        pointerTypeRef.current = undefined;\n        return;\n      }\n      if (isMouseLikePointerType(pointerType, true) && ignoreMouse) return;\n      if (open && toggle && (dataRef.current.openEvent && stickIfOpen ? dataRef.current.openEvent.type === 'click' : true)) {\n        onOpenChange(false, event.nativeEvent, 'click');\n      } else {\n        onOpenChange(true, event.nativeEvent, 'click');\n      }\n    },\n    onKeyDown(event) {\n      pointerTypeRef.current = undefined;\n      if (event.defaultPrevented || !keyboardHandlers || isButtonTarget(event)) {\n        return;\n      }\n      if (event.key === ' ' && !isSpaceIgnored(domReference)) {\n        // Prevent scrolling\n        event.preventDefault();\n        didKeyDownRef.current = true;\n      }\n      if (event.key === 'Enter') {\n        if (open && toggle) {\n          onOpenChange(false, event.nativeEvent, 'click');\n        } else {\n          onOpenChange(true, event.nativeEvent, 'click');\n        }\n      }\n    },\n    onKeyUp(event) {\n      if (event.defaultPrevented || !keyboardHandlers || isButtonTarget(event) || isSpaceIgnored(domReference)) {\n        return;\n      }\n      if (event.key === ' ' && didKeyDownRef.current) {\n        didKeyDownRef.current = false;\n        if (open && toggle) {\n          onOpenChange(false, event.nativeEvent, 'click');\n        } else {\n          onOpenChange(true, event.nativeEvent, 'click');\n        }\n      }\n    }\n  }), [dataRef, domReference, eventOption, ignoreMouse, keyboardHandlers, onOpenChange, open, stickIfOpen, toggle]);\n  return React.useMemo(() => enabled ? {\n    reference\n  } : {}, [enabled, reference]);\n}\n\nfunction createVirtualElement(domElement, data) {\n  let offsetX = null;\n  let offsetY = null;\n  let isAutoUpdateEvent = false;\n  return {\n    contextElement: domElement || undefined,\n    getBoundingClientRect() {\n      var _data$dataRef$current;\n      const domRect = (domElement == null ? void 0 : domElement.getBoundingClientRect()) || {\n        width: 0,\n        height: 0,\n        x: 0,\n        y: 0\n      };\n      const isXAxis = data.axis === 'x' || data.axis === 'both';\n      const isYAxis = data.axis === 'y' || data.axis === 'both';\n      const canTrackCursorOnAutoUpdate = ['mouseenter', 'mousemove'].includes(((_data$dataRef$current = data.dataRef.current.openEvent) == null ? void 0 : _data$dataRef$current.type) || '') && data.pointerType !== 'touch';\n      let width = domRect.width;\n      let height = domRect.height;\n      let x = domRect.x;\n      let y = domRect.y;\n      if (offsetX == null && data.x && isXAxis) {\n        offsetX = domRect.x - data.x;\n      }\n      if (offsetY == null && data.y && isYAxis) {\n        offsetY = domRect.y - data.y;\n      }\n      x -= offsetX || 0;\n      y -= offsetY || 0;\n      width = 0;\n      height = 0;\n      if (!isAutoUpdateEvent || canTrackCursorOnAutoUpdate) {\n        width = data.axis === 'y' ? domRect.width : 0;\n        height = data.axis === 'x' ? domRect.height : 0;\n        x = isXAxis && data.x != null ? data.x : x;\n        y = isYAxis && data.y != null ? data.y : y;\n      } else if (isAutoUpdateEvent && !canTrackCursorOnAutoUpdate) {\n        height = data.axis === 'x' ? domRect.height : height;\n        width = data.axis === 'y' ? domRect.width : width;\n      }\n      isAutoUpdateEvent = true;\n      return {\n        width,\n        height,\n        x,\n        y,\n        top: y,\n        right: x + width,\n        bottom: y + height,\n        left: x\n      };\n    }\n  };\n}\nfunction isMouseBasedEvent(event) {\n  return event != null && event.clientX != null;\n}\n/**\n * Positions the floating element relative to a client point (in the viewport),\n * such as the mouse position. By default, it follows the mouse cursor.\n * @see https://floating-ui.com/docs/useClientPoint\n */\nfunction useClientPoint(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    dataRef,\n    elements: {\n      floating,\n      domReference\n    },\n    refs\n  } = context;\n  const {\n    enabled = true,\n    axis = 'both',\n    x = null,\n    y = null\n  } = props;\n  const initialRef = React.useRef(false);\n  const cleanupListenerRef = React.useRef(null);\n  const [pointerType, setPointerType] = React.useState();\n  const [reactive, setReactive] = React.useState([]);\n  const setReference = useEffectEvent((x, y) => {\n    if (initialRef.current) return;\n\n    // Prevent setting if the open event was not a mouse-like one\n    // (e.g. focus to open, then hover over the reference element).\n    // Only apply if the event exists.\n    if (dataRef.current.openEvent && !isMouseBasedEvent(dataRef.current.openEvent)) {\n      return;\n    }\n    refs.setPositionReference(createVirtualElement(domReference, {\n      x,\n      y,\n      axis,\n      dataRef,\n      pointerType\n    }));\n  });\n  const handleReferenceEnterOrMove = useEffectEvent(event => {\n    if (x != null || y != null) return;\n    if (!open) {\n      setReference(event.clientX, event.clientY);\n    } else if (!cleanupListenerRef.current) {\n      // If there's no cleanup, there's no listener, but we want to ensure\n      // we add the listener if the cursor landed on the floating element and\n      // then back on the reference (i.e. it's interactive).\n      setReactive([]);\n    }\n  });\n\n  // If the pointer is a mouse-like pointer, we want to continue following the\n  // mouse even if the floating element is transitioning out. On touch\n  // devices, this is undesirable because the floating element will move to\n  // the dismissal touch point.\n  const openCheck = isMouseLikePointerType(pointerType) ? floating : open;\n  const addListener = React.useCallback(() => {\n    // Explicitly specified `x`/`y` coordinates shouldn't add a listener.\n    if (!openCheck || !enabled || x != null || y != null) return;\n    const win = getWindow(floating);\n    function handleMouseMove(event) {\n      const target = getTarget(event);\n      if (!contains(floating, target)) {\n        setReference(event.clientX, event.clientY);\n      } else {\n        win.removeEventListener('mousemove', handleMouseMove);\n        cleanupListenerRef.current = null;\n      }\n    }\n    if (!dataRef.current.openEvent || isMouseBasedEvent(dataRef.current.openEvent)) {\n      win.addEventListener('mousemove', handleMouseMove);\n      const cleanup = () => {\n        win.removeEventListener('mousemove', handleMouseMove);\n        cleanupListenerRef.current = null;\n      };\n      cleanupListenerRef.current = cleanup;\n      return cleanup;\n    }\n    refs.setPositionReference(domReference);\n  }, [openCheck, enabled, x, y, floating, dataRef, refs, domReference, setReference]);\n  React.useEffect(() => {\n    return addListener();\n  }, [addListener, reactive]);\n  React.useEffect(() => {\n    if (enabled && !floating) {\n      initialRef.current = false;\n    }\n  }, [enabled, floating]);\n  React.useEffect(() => {\n    if (!enabled && open) {\n      initialRef.current = true;\n    }\n  }, [enabled, open]);\n  index(() => {\n    if (enabled && (x != null || y != null)) {\n      initialRef.current = false;\n      setReference(x, y);\n    }\n  }, [enabled, x, y, setReference]);\n  const reference = React.useMemo(() => {\n    function setPointerTypeRef(_ref) {\n      let {\n        pointerType\n      } = _ref;\n      setPointerType(pointerType);\n    }\n    return {\n      onPointerDown: setPointerTypeRef,\n      onPointerEnter: setPointerTypeRef,\n      onMouseMove: handleReferenceEnterOrMove,\n      onMouseEnter: handleReferenceEnterOrMove\n    };\n  }, [handleReferenceEnterOrMove]);\n  return React.useMemo(() => enabled ? {\n    reference\n  } : {}, [enabled, reference]);\n}\n\nconst bubbleHandlerKeys = {\n  pointerdown: 'onPointerDown',\n  mousedown: 'onMouseDown',\n  click: 'onClick'\n};\nconst captureHandlerKeys = {\n  pointerdown: 'onPointerDownCapture',\n  mousedown: 'onMouseDownCapture',\n  click: 'onClickCapture'\n};\nconst normalizeProp = normalizable => {\n  var _normalizable$escapeK, _normalizable$outside;\n  return {\n    escapeKey: typeof normalizable === 'boolean' ? normalizable : (_normalizable$escapeK = normalizable == null ? void 0 : normalizable.escapeKey) != null ? _normalizable$escapeK : false,\n    outsidePress: typeof normalizable === 'boolean' ? normalizable : (_normalizable$outside = normalizable == null ? void 0 : normalizable.outsidePress) != null ? _normalizable$outside : true\n  };\n};\n/**\n * Closes the floating element when a dismissal is requested — by default, when\n * the user presses the `escape` key or outside of the floating element.\n * @see https://floating-ui.com/docs/useDismiss\n */\nfunction useDismiss(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    elements,\n    dataRef\n  } = context;\n  const {\n    enabled = true,\n    escapeKey = true,\n    outsidePress: unstable_outsidePress = true,\n    outsidePressEvent = 'pointerdown',\n    referencePress = false,\n    referencePressEvent = 'pointerdown',\n    ancestorScroll = false,\n    bubbles,\n    capture\n  } = props;\n  const tree = useFloatingTree();\n  const outsidePressFn = useEffectEvent(typeof unstable_outsidePress === 'function' ? unstable_outsidePress : () => false);\n  const outsidePress = typeof unstable_outsidePress === 'function' ? outsidePressFn : unstable_outsidePress;\n  const insideReactTreeRef = React.useRef(false);\n  const endedOrStartedInsideRef = React.useRef(false);\n  const {\n    escapeKey: escapeKeyBubbles,\n    outsidePress: outsidePressBubbles\n  } = normalizeProp(bubbles);\n  const {\n    escapeKey: escapeKeyCapture,\n    outsidePress: outsidePressCapture\n  } = normalizeProp(capture);\n  const isComposingRef = React.useRef(false);\n  const closeOnEscapeKeyDown = useEffectEvent(event => {\n    var _dataRef$current$floa;\n    if (!open || !enabled || !escapeKey || event.key !== 'Escape') {\n      return;\n    }\n\n    // Wait until IME is settled. Pressing `Escape` while composing should\n    // close the compose menu, but not the floating element.\n    if (isComposingRef.current) {\n      return;\n    }\n    const nodeId = (_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.nodeId;\n    const children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];\n    if (!escapeKeyBubbles) {\n      event.stopPropagation();\n      if (children.length > 0) {\n        let shouldDismiss = true;\n        children.forEach(child => {\n          var _child$context;\n          if ((_child$context = child.context) != null && _child$context.open && !child.context.dataRef.current.__escapeKeyBubbles) {\n            shouldDismiss = false;\n            return;\n          }\n        });\n        if (!shouldDismiss) {\n          return;\n        }\n      }\n    }\n    onOpenChange(false, isReactEvent(event) ? event.nativeEvent : event, 'escape-key');\n  });\n  const closeOnEscapeKeyDownCapture = useEffectEvent(event => {\n    var _getTarget2;\n    const callback = () => {\n      var _getTarget;\n      closeOnEscapeKeyDown(event);\n      (_getTarget = getTarget(event)) == null || _getTarget.removeEventListener('keydown', callback);\n    };\n    (_getTarget2 = getTarget(event)) == null || _getTarget2.addEventListener('keydown', callback);\n  });\n  const closeOnPressOutside = useEffectEvent(event => {\n    var _dataRef$current$floa2;\n    // Given developers can stop the propagation of the synthetic event,\n    // we can only be confident with a positive value.\n    const insideReactTree = insideReactTreeRef.current;\n    insideReactTreeRef.current = false;\n\n    // When click outside is lazy (`click` event), handle dragging.\n    // Don't close if:\n    // - The click started inside the floating element.\n    // - The click ended inside the floating element.\n    const endedOrStartedInside = endedOrStartedInsideRef.current;\n    endedOrStartedInsideRef.current = false;\n    if (outsidePressEvent === 'click' && endedOrStartedInside) {\n      return;\n    }\n    if (insideReactTree) {\n      return;\n    }\n    if (typeof outsidePress === 'function' && !outsidePress(event)) {\n      return;\n    }\n    const target = getTarget(event);\n    const inertSelector = \"[\" + createAttribute('inert') + \"]\";\n    const markers = getDocument(elements.floating).querySelectorAll(inertSelector);\n    let targetRootAncestor = isElement(target) ? target : null;\n    while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {\n      const nextParent = getParentNode(targetRootAncestor);\n      if (isLastTraversableNode(nextParent) || !isElement(nextParent)) {\n        break;\n      }\n      targetRootAncestor = nextParent;\n    }\n\n    // Check if the click occurred on a third-party element injected after the\n    // floating element rendered.\n    if (markers.length && isElement(target) && !isRootElement(target) &&\n    // Clicked on a direct ancestor (e.g. FloatingOverlay).\n    !contains(target, elements.floating) &&\n    // If the target root element contains none of the markers, then the\n    // element was injected after the floating element rendered.\n    Array.from(markers).every(marker => !contains(targetRootAncestor, marker))) {\n      return;\n    }\n\n    // Check if the click occurred on the scrollbar\n    if (isHTMLElement(target) && floating) {\n      // In Firefox, `target.scrollWidth > target.clientWidth` for inline\n      // elements.\n      const canScrollX = target.clientWidth > 0 && target.scrollWidth > target.clientWidth;\n      const canScrollY = target.clientHeight > 0 && target.scrollHeight > target.clientHeight;\n      let xCond = canScrollY && event.offsetX > target.clientWidth;\n\n      // In some browsers it is possible to change the <body> (or window)\n      // scrollbar to the left side, but is very rare and is difficult to\n      // check for. Plus, for modal dialogs with backdrops, it is more\n      // important that the backdrop is checked but not so much the window.\n      if (canScrollY) {\n        const isRTL = getComputedStyle(target).direction === 'rtl';\n        if (isRTL) {\n          xCond = event.offsetX <= target.offsetWidth - target.clientWidth;\n        }\n      }\n      if (xCond || canScrollX && event.offsetY > target.clientHeight) {\n        return;\n      }\n    }\n    const nodeId = (_dataRef$current$floa2 = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa2.nodeId;\n    const targetIsInsideChildren = tree && getChildren(tree.nodesRef.current, nodeId).some(node => {\n      var _node$context;\n      return isEventTargetWithin(event, (_node$context = node.context) == null ? void 0 : _node$context.elements.floating);\n    });\n    if (isEventTargetWithin(event, elements.floating) || isEventTargetWithin(event, elements.domReference) || targetIsInsideChildren) {\n      return;\n    }\n    const children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];\n    if (children.length > 0) {\n      let shouldDismiss = true;\n      children.forEach(child => {\n        var _child$context2;\n        if ((_child$context2 = child.context) != null && _child$context2.open && !child.context.dataRef.current.__outsidePressBubbles) {\n          shouldDismiss = false;\n          return;\n        }\n      });\n      if (!shouldDismiss) {\n        return;\n      }\n    }\n    onOpenChange(false, event, 'outside-press');\n  });\n  const closeOnPressOutsideCapture = useEffectEvent(event => {\n    var _getTarget4;\n    const callback = () => {\n      var _getTarget3;\n      closeOnPressOutside(event);\n      (_getTarget3 = getTarget(event)) == null || _getTarget3.removeEventListener(outsidePressEvent, callback);\n    };\n    (_getTarget4 = getTarget(event)) == null || _getTarget4.addEventListener(outsidePressEvent, callback);\n  });\n  React.useEffect(() => {\n    if (!open || !enabled) {\n      return;\n    }\n    dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;\n    dataRef.current.__outsidePressBubbles = outsidePressBubbles;\n    let compositionTimeout = -1;\n    function onScroll(event) {\n      onOpenChange(false, event, 'ancestor-scroll');\n    }\n    function handleCompositionStart() {\n      window.clearTimeout(compositionTimeout);\n      isComposingRef.current = true;\n    }\n    function handleCompositionEnd() {\n      // Safari fires `compositionend` before `keydown`, so we need to wait\n      // until the next tick to set `isComposing` to `false`.\n      // https://bugs.webkit.org/show_bug.cgi?id=165004\n      compositionTimeout = window.setTimeout(() => {\n        isComposingRef.current = false;\n      },\n      // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.\n      // Only apply to WebKit for the test to remain 0ms.\n      isWebKit() ? 5 : 0);\n    }\n    const doc = getDocument(elements.floating);\n    if (escapeKey) {\n      doc.addEventListener('keydown', escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);\n      doc.addEventListener('compositionstart', handleCompositionStart);\n      doc.addEventListener('compositionend', handleCompositionEnd);\n    }\n    outsidePress && doc.addEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);\n    let ancestors = [];\n    if (ancestorScroll) {\n      if (isElement(elements.domReference)) {\n        ancestors = getOverflowAncestors(elements.domReference);\n      }\n      if (isElement(elements.floating)) {\n        ancestors = ancestors.concat(getOverflowAncestors(elements.floating));\n      }\n      if (!isElement(elements.reference) && elements.reference && elements.reference.contextElement) {\n        ancestors = ancestors.concat(getOverflowAncestors(elements.reference.contextElement));\n      }\n    }\n\n    // Ignore the visual viewport for scrolling dismissal (allow pinch-zoom)\n    ancestors = ancestors.filter(ancestor => {\n      var _doc$defaultView;\n      return ancestor !== ((_doc$defaultView = doc.defaultView) == null ? void 0 : _doc$defaultView.visualViewport);\n    });\n    ancestors.forEach(ancestor => {\n      ancestor.addEventListener('scroll', onScroll, {\n        passive: true\n      });\n    });\n    return () => {\n      if (escapeKey) {\n        doc.removeEventListener('keydown', escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);\n        doc.removeEventListener('compositionstart', handleCompositionStart);\n        doc.removeEventListener('compositionend', handleCompositionEnd);\n      }\n      outsidePress && doc.removeEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);\n      ancestors.forEach(ancestor => {\n        ancestor.removeEventListener('scroll', onScroll);\n      });\n      window.clearTimeout(compositionTimeout);\n    };\n  }, [dataRef, elements, escapeKey, outsidePress, outsidePressEvent, open, onOpenChange, ancestorScroll, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, escapeKeyCapture, closeOnEscapeKeyDownCapture, closeOnPressOutside, outsidePressCapture, closeOnPressOutsideCapture]);\n  React.useEffect(() => {\n    insideReactTreeRef.current = false;\n  }, [outsidePress, outsidePressEvent]);\n  const reference = React.useMemo(() => ({\n    onKeyDown: closeOnEscapeKeyDown,\n    [bubbleHandlerKeys[referencePressEvent]]: event => {\n      if (referencePress) {\n        onOpenChange(false, event.nativeEvent, 'reference-press');\n      }\n    }\n  }), [closeOnEscapeKeyDown, onOpenChange, referencePress, referencePressEvent]);\n  const floating = React.useMemo(() => ({\n    onKeyDown: closeOnEscapeKeyDown,\n    onMouseDown() {\n      endedOrStartedInsideRef.current = true;\n    },\n    onMouseUp() {\n      endedOrStartedInsideRef.current = true;\n    },\n    [captureHandlerKeys[outsidePressEvent]]: () => {\n      insideReactTreeRef.current = true;\n    }\n  }), [closeOnEscapeKeyDown, outsidePressEvent]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating\n  } : {}, [enabled, reference, floating]);\n}\n\nfunction useFloatingRootContext(options) {\n  const {\n    open = false,\n    onOpenChange: onOpenChangeProp,\n    elements: elementsProp\n  } = options;\n  const floatingId = useId();\n  const dataRef = React.useRef({});\n  const [events] = React.useState(() => createPubSub());\n  const nested = useFloatingParentNodeId() != null;\n  if (process.env.NODE_ENV !== \"production\") {\n    const optionDomReference = elementsProp.reference;\n    if (optionDomReference && !isElement(optionDomReference)) {\n      error('Cannot pass a virtual element to the `elements.reference` option,', 'as it must be a real DOM element. Use `refs.setPositionReference()`', 'instead.');\n    }\n  }\n  const [positionReference, setPositionReference] = React.useState(elementsProp.reference);\n  const onOpenChange = useEffectEvent((open, event, reason) => {\n    dataRef.current.openEvent = open ? event : undefined;\n    events.emit('openchange', {\n      open,\n      event,\n      reason,\n      nested\n    });\n    onOpenChangeProp == null || onOpenChangeProp(open, event, reason);\n  });\n  const refs = React.useMemo(() => ({\n    setPositionReference\n  }), []);\n  const elements = React.useMemo(() => ({\n    reference: positionReference || elementsProp.reference || null,\n    floating: elementsProp.floating || null,\n    domReference: elementsProp.reference\n  }), [positionReference, elementsProp.reference, elementsProp.floating]);\n  return React.useMemo(() => ({\n    dataRef,\n    open,\n    onOpenChange,\n    elements,\n    events,\n    floatingId,\n    refs\n  }), [open, onOpenChange, elements, events, floatingId, refs]);\n}\n\n/**\n * Provides data to position a floating element and context to add interactions.\n * @see https://floating-ui.com/docs/useFloating\n */\nfunction useFloating(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    nodeId\n  } = options;\n  const internalRootContext = useFloatingRootContext({\n    ...options,\n    elements: {\n      reference: null,\n      floating: null,\n      ...options.elements\n    }\n  });\n  const rootContext = options.rootContext || internalRootContext;\n  const computedElements = rootContext.elements;\n  const [_domReference, setDomReference] = React.useState(null);\n  const [positionReference, _setPositionReference] = React.useState(null);\n  const optionDomReference = computedElements == null ? void 0 : computedElements.domReference;\n  const domReference = optionDomReference || _domReference;\n  const domReferenceRef = React.useRef(null);\n  const tree = useFloatingTree();\n  index(() => {\n    if (domReference) {\n      domReferenceRef.current = domReference;\n    }\n  }, [domReference]);\n  const position = useFloating$1({\n    ...options,\n    elements: {\n      ...computedElements,\n      ...(positionReference && {\n        reference: positionReference\n      })\n    }\n  });\n  const setPositionReference = React.useCallback(node => {\n    const computedPositionReference = isElement(node) ? {\n      getBoundingClientRect: () => node.getBoundingClientRect(),\n      contextElement: node\n    } : node;\n    // Store the positionReference in state if the DOM reference is specified externally via the\n    // `elements.reference` option. This ensures that it won't be overridden on future renders.\n    _setPositionReference(computedPositionReference);\n    position.refs.setReference(computedPositionReference);\n  }, [position.refs]);\n  const setReference = React.useCallback(node => {\n    if (isElement(node) || node === null) {\n      domReferenceRef.current = node;\n      setDomReference(node);\n    }\n\n    // Backwards-compatibility for passing a virtual element to `reference`\n    // after it has set the DOM reference.\n    if (isElement(position.refs.reference.current) || position.refs.reference.current === null ||\n    // Don't allow setting virtual elements using the old technique back to\n    // `null` to support `positionReference` + an unstable `reference`\n    // callback ref.\n    node !== null && !isElement(node)) {\n      position.refs.setReference(node);\n    }\n  }, [position.refs]);\n  const refs = React.useMemo(() => ({\n    ...position.refs,\n    setReference,\n    setPositionReference,\n    domReference: domReferenceRef\n  }), [position.refs, setReference, setPositionReference]);\n  const elements = React.useMemo(() => ({\n    ...position.elements,\n    domReference: domReference\n  }), [position.elements, domReference]);\n  const context = React.useMemo(() => ({\n    ...position,\n    ...rootContext,\n    refs,\n    elements,\n    nodeId\n  }), [position, refs, elements, nodeId, rootContext]);\n  index(() => {\n    rootContext.dataRef.current.floatingContext = context;\n    const node = tree == null ? void 0 : tree.nodesRef.current.find(node => node.id === nodeId);\n    if (node) {\n      node.context = context;\n    }\n  });\n  return React.useMemo(() => ({\n    ...position,\n    context,\n    refs,\n    elements\n  }), [position, refs, elements, context]);\n}\n\n/**\n * Opens the floating element while the reference element has focus, like CSS\n * `:focus`.\n * @see https://floating-ui.com/docs/useFocus\n */\nfunction useFocus(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    events,\n    dataRef,\n    elements\n  } = context;\n  const {\n    enabled = true,\n    visibleOnly = true\n  } = props;\n  const blockFocusRef = React.useRef(false);\n  const timeoutRef = React.useRef();\n  const keyboardModalityRef = React.useRef(true);\n  React.useEffect(() => {\n    if (!enabled) return;\n    const win = getWindow(elements.domReference);\n\n    // If the reference was focused and the user left the tab/window, and the\n    // floating element was not open, the focus should be blocked when they\n    // return to the tab/window.\n    function onBlur() {\n      if (!open && isHTMLElement(elements.domReference) && elements.domReference === activeElement(getDocument(elements.domReference))) {\n        blockFocusRef.current = true;\n      }\n    }\n    function onKeyDown() {\n      keyboardModalityRef.current = true;\n    }\n    win.addEventListener('blur', onBlur);\n    win.addEventListener('keydown', onKeyDown, true);\n    return () => {\n      win.removeEventListener('blur', onBlur);\n      win.removeEventListener('keydown', onKeyDown, true);\n    };\n  }, [elements.domReference, open, enabled]);\n  React.useEffect(() => {\n    if (!enabled) return;\n    function onOpenChange(_ref) {\n      let {\n        reason\n      } = _ref;\n      if (reason === 'reference-press' || reason === 'escape-key') {\n        blockFocusRef.current = true;\n      }\n    }\n    events.on('openchange', onOpenChange);\n    return () => {\n      events.off('openchange', onOpenChange);\n    };\n  }, [events, enabled]);\n  React.useEffect(() => {\n    return () => {\n      clearTimeout(timeoutRef.current);\n    };\n  }, []);\n  const reference = React.useMemo(() => ({\n    onPointerDown(event) {\n      if (isVirtualPointerEvent(event.nativeEvent)) return;\n      keyboardModalityRef.current = false;\n    },\n    onMouseLeave() {\n      blockFocusRef.current = false;\n    },\n    onFocus(event) {\n      if (blockFocusRef.current) return;\n      const target = getTarget(event.nativeEvent);\n      if (visibleOnly && isElement(target)) {\n        try {\n          // Mac Safari unreliably matches `:focus-visible` on the reference\n          // if focus was outside the page initially - use the fallback\n          // instead.\n          if (isSafari() && isMac()) throw Error();\n          if (!target.matches(':focus-visible')) return;\n        } catch (e) {\n          // Old browsers will throw an error when using `:focus-visible`.\n          if (!keyboardModalityRef.current && !isTypeableElement(target)) {\n            return;\n          }\n        }\n      }\n      onOpenChange(true, event.nativeEvent, 'focus');\n    },\n    onBlur(event) {\n      blockFocusRef.current = false;\n      const relatedTarget = event.relatedTarget;\n      const nativeEvent = event.nativeEvent;\n\n      // Hit the non-modal focus management portal guard. Focus will be\n      // moved into the floating element immediately after.\n      const movedToFocusGuard = isElement(relatedTarget) && relatedTarget.hasAttribute(createAttribute('focus-guard')) && relatedTarget.getAttribute('data-type') === 'outside';\n\n      // Wait for the window blur listener to fire.\n      timeoutRef.current = window.setTimeout(() => {\n        var _dataRef$current$floa;\n        const activeEl = activeElement(elements.domReference ? elements.domReference.ownerDocument : document);\n\n        // Focus left the page, keep it open.\n        if (!relatedTarget && activeEl === elements.domReference) return;\n\n        // When focusing the reference element (e.g. regular click), then\n        // clicking into the floating element, prevent it from hiding.\n        // Note: it must be focusable, e.g. `tabindex=\"-1\"`.\n        // We can not rely on relatedTarget to point to the correct element\n        // as it will only point to the shadow host of the newly focused element\n        // and not the element that actually has received focus if it is located\n        // inside a shadow root.\n        if (contains((_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.refs.floating.current, activeEl) || contains(elements.domReference, activeEl) || movedToFocusGuard) {\n          return;\n        }\n        onOpenChange(false, nativeEvent, 'focus');\n      });\n    }\n  }), [dataRef, elements.domReference, onOpenChange, visibleOnly]);\n  return React.useMemo(() => enabled ? {\n    reference\n  } : {}, [enabled, reference]);\n}\n\nconst ACTIVE_KEY = 'active';\nconst SELECTED_KEY = 'selected';\nfunction mergeProps(userProps, propsList, elementKey) {\n  const map = new Map();\n  const isItem = elementKey === 'item';\n  let domUserProps = userProps;\n  if (isItem && userProps) {\n    const {\n      [ACTIVE_KEY]: _,\n      [SELECTED_KEY]: __,\n      ...validProps\n    } = userProps;\n    domUserProps = validProps;\n  }\n  return {\n    ...(elementKey === 'floating' && {\n      tabIndex: -1,\n      [FOCUSABLE_ATTRIBUTE]: ''\n    }),\n    ...domUserProps,\n    ...propsList.map(value => {\n      const propsOrGetProps = value ? value[elementKey] : null;\n      if (typeof propsOrGetProps === 'function') {\n        return userProps ? propsOrGetProps(userProps) : null;\n      }\n      return propsOrGetProps;\n    }).concat(userProps).reduce((acc, props) => {\n      if (!props) {\n        return acc;\n      }\n      Object.entries(props).forEach(_ref => {\n        let [key, value] = _ref;\n        if (isItem && [ACTIVE_KEY, SELECTED_KEY].includes(key)) {\n          return;\n        }\n        if (key.indexOf('on') === 0) {\n          if (!map.has(key)) {\n            map.set(key, []);\n          }\n          if (typeof value === 'function') {\n            var _map$get;\n            (_map$get = map.get(key)) == null || _map$get.push(value);\n            acc[key] = function () {\n              var _map$get2;\n              for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n                args[_key] = arguments[_key];\n              }\n              return (_map$get2 = map.get(key)) == null ? void 0 : _map$get2.map(fn => fn(...args)).find(val => val !== undefined);\n            };\n          }\n        } else {\n          acc[key] = value;\n        }\n      });\n      return acc;\n    }, {})\n  };\n}\n/**\n * Merges an array of interaction hooks' props into prop getters, allowing\n * event handler functions to be composed together without overwriting one\n * another.\n * @see https://floating-ui.com/docs/useInteractions\n */\nfunction useInteractions(propsList) {\n  if (propsList === void 0) {\n    propsList = [];\n  }\n  const referenceDeps = propsList.map(key => key == null ? void 0 : key.reference);\n  const floatingDeps = propsList.map(key => key == null ? void 0 : key.floating);\n  const itemDeps = propsList.map(key => key == null ? void 0 : key.item);\n  const getReferenceProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'reference'),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  referenceDeps);\n  const getFloatingProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'floating'),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  floatingDeps);\n  const getItemProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'item'),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  itemDeps);\n  return React.useMemo(() => ({\n    getReferenceProps,\n    getFloatingProps,\n    getItemProps\n  }), [getReferenceProps, getFloatingProps, getItemProps]);\n}\n\nlet isPreventScrollSupported = false;\nfunction doSwitch(orientation, vertical, horizontal) {\n  switch (orientation) {\n    case 'vertical':\n      return vertical;\n    case 'horizontal':\n      return horizontal;\n    default:\n      return vertical || horizontal;\n  }\n}\nfunction isMainOrientationKey(key, orientation) {\n  const vertical = key === ARROW_UP || key === ARROW_DOWN;\n  const horizontal = key === ARROW_LEFT || key === ARROW_RIGHT;\n  return doSwitch(orientation, vertical, horizontal);\n}\nfunction isMainOrientationToEndKey(key, orientation, rtl) {\n  const vertical = key === ARROW_DOWN;\n  const horizontal = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;\n  return doSwitch(orientation, vertical, horizontal) || key === 'Enter' || key === ' ' || key === '';\n}\nfunction isCrossOrientationOpenKey(key, orientation, rtl) {\n  const vertical = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;\n  const horizontal = key === ARROW_DOWN;\n  return doSwitch(orientation, vertical, horizontal);\n}\nfunction isCrossOrientationCloseKey(key, orientation, rtl) {\n  const vertical = rtl ? key === ARROW_RIGHT : key === ARROW_LEFT;\n  const horizontal = key === ARROW_UP;\n  return doSwitch(orientation, vertical, horizontal);\n}\n/**\n * Adds arrow key-based navigation of a list of items, either using real DOM\n * focus or virtual focus.\n * @see https://floating-ui.com/docs/useListNavigation\n */\nfunction useListNavigation(context, props) {\n  const {\n    open,\n    onOpenChange,\n    elements\n  } = context;\n  const {\n    listRef,\n    activeIndex,\n    onNavigate: unstable_onNavigate = () => {},\n    enabled = true,\n    selectedIndex = null,\n    allowEscape = false,\n    loop = false,\n    nested = false,\n    rtl = false,\n    virtual = false,\n    focusItemOnOpen = 'auto',\n    focusItemOnHover = true,\n    openOnArrowKeyDown = true,\n    disabledIndices = undefined,\n    orientation = 'vertical',\n    cols = 1,\n    scrollItemIntoView = true,\n    virtualItemRef,\n    itemSizes,\n    dense = false\n  } = props;\n  if (process.env.NODE_ENV !== \"production\") {\n    if (allowEscape) {\n      if (!loop) {\n        warn('`useListNavigation` looping must be enabled to allow escaping.');\n      }\n      if (!virtual) {\n        warn('`useListNavigation` must be virtual to allow escaping.');\n      }\n    }\n    if (orientation === 'vertical' && cols > 1) {\n      warn('In grid list navigation mode (`cols` > 1), the `orientation` should', 'be either \"horizontal\" or \"both\".');\n    }\n  }\n  const floatingFocusElement = getFloatingFocusElement(elements.floating);\n  const floatingFocusElementRef = useLatestRef(floatingFocusElement);\n  const parentId = useFloatingParentNodeId();\n  const tree = useFloatingTree();\n  const onNavigate = useEffectEvent(unstable_onNavigate);\n  const typeableComboboxReference = isTypeableCombobox(elements.domReference);\n  const focusItemOnOpenRef = React.useRef(focusItemOnOpen);\n  const indexRef = React.useRef(selectedIndex != null ? selectedIndex : -1);\n  const keyRef = React.useRef(null);\n  const isPointerModalityRef = React.useRef(true);\n  const previousOnNavigateRef = React.useRef(onNavigate);\n  const previousMountedRef = React.useRef(!!elements.floating);\n  const previousOpenRef = React.useRef(open);\n  const forceSyncFocus = React.useRef(false);\n  const forceScrollIntoViewRef = React.useRef(false);\n  const disabledIndicesRef = useLatestRef(disabledIndices);\n  const latestOpenRef = useLatestRef(open);\n  const scrollItemIntoViewRef = useLatestRef(scrollItemIntoView);\n  const selectedIndexRef = useLatestRef(selectedIndex);\n  const [activeId, setActiveId] = React.useState();\n  const [virtualId, setVirtualId] = React.useState();\n  const focusItem = useEffectEvent(function (listRef, indexRef, forceScrollIntoView) {\n    if (forceScrollIntoView === void 0) {\n      forceScrollIntoView = false;\n    }\n    function runFocus(item) {\n      if (virtual) {\n        setActiveId(item.id);\n        tree == null || tree.events.emit('virtualfocus', item);\n        if (virtualItemRef) {\n          virtualItemRef.current = item;\n        }\n      } else {\n        enqueueFocus(item, {\n          preventScroll: true,\n          // Mac Safari does not move the virtual cursor unless the focus call\n          // is sync. However, for the very first focus call, we need to wait\n          // for the position to be ready in order to prevent unwanted\n          // scrolling. This means the virtual cursor will not move to the first\n          // item when first opening the floating element, but will on\n          // subsequent calls. `preventScroll` is supported in modern Safari,\n          // so we can use that instead.\n          // iOS Safari must be async or the first item will not be focused.\n          sync: isMac() && isSafari() ? isPreventScrollSupported || forceSyncFocus.current : false\n        });\n      }\n    }\n    const initialItem = listRef.current[indexRef.current];\n    if (initialItem) {\n      runFocus(initialItem);\n    }\n    requestAnimationFrame(() => {\n      const waitedItem = listRef.current[indexRef.current] || initialItem;\n      if (!waitedItem) return;\n      if (!initialItem) {\n        runFocus(waitedItem);\n      }\n      const scrollIntoViewOptions = scrollItemIntoViewRef.current;\n      const shouldScrollIntoView = scrollIntoViewOptions && item && (forceScrollIntoView || !isPointerModalityRef.current);\n      if (shouldScrollIntoView) {\n        // JSDOM doesn't support `.scrollIntoView()` but it's widely supported\n        // by all browsers.\n        waitedItem.scrollIntoView == null || waitedItem.scrollIntoView(typeof scrollIntoViewOptions === 'boolean' ? {\n          block: 'nearest',\n          inline: 'nearest'\n        } : scrollIntoViewOptions);\n      }\n    });\n  });\n  index(() => {\n    document.createElement('div').focus({\n      get preventScroll() {\n        isPreventScrollSupported = true;\n        return false;\n      }\n    });\n  }, []);\n\n  // Sync `selectedIndex` to be the `activeIndex` upon opening the floating\n  // element. Also, reset `activeIndex` upon closing the floating element.\n  index(() => {\n    if (!enabled) return;\n    if (open && elements.floating) {\n      if (focusItemOnOpenRef.current && selectedIndex != null) {\n        // Regardless of the pointer modality, we want to ensure the selected\n        // item comes into view when the floating element is opened.\n        forceScrollIntoViewRef.current = true;\n        indexRef.current = selectedIndex;\n        onNavigate(selectedIndex);\n      }\n    } else if (previousMountedRef.current) {\n      // Since the user can specify `onNavigate` conditionally\n      // (onNavigate: open ? setActiveIndex : setSelectedIndex),\n      // we store and call the previous function.\n      indexRef.current = -1;\n      previousOnNavigateRef.current(null);\n    }\n  }, [enabled, open, elements.floating, selectedIndex, onNavigate]);\n\n  // Sync `activeIndex` to be the focused item while the floating element is\n  // open.\n  index(() => {\n    if (!enabled) return;\n    if (open && elements.floating) {\n      if (activeIndex == null) {\n        forceSyncFocus.current = false;\n        if (selectedIndexRef.current != null) {\n          return;\n        }\n\n        // Reset while the floating element was open (e.g. the list changed).\n        if (previousMountedRef.current) {\n          indexRef.current = -1;\n          focusItem(listRef, indexRef);\n        }\n\n        // Initial sync.\n        if ((!previousOpenRef.current || !previousMountedRef.current) && focusItemOnOpenRef.current && (keyRef.current != null || focusItemOnOpenRef.current === true && keyRef.current == null)) {\n          let runs = 0;\n          const waitForListPopulated = () => {\n            if (listRef.current[0] == null) {\n              // Avoid letting the browser paint if possible on the first try,\n              // otherwise use rAF. Don't try more than twice, since something\n              // is wrong otherwise.\n              if (runs < 2) {\n                const scheduler = runs ? requestAnimationFrame : queueMicrotask;\n                scheduler(waitForListPopulated);\n              }\n              runs++;\n            } else {\n              indexRef.current = keyRef.current == null || isMainOrientationToEndKey(keyRef.current, orientation, rtl) || nested ? getMinIndex(listRef, disabledIndicesRef.current) : getMaxIndex(listRef, disabledIndicesRef.current);\n              keyRef.current = null;\n              onNavigate(indexRef.current);\n            }\n          };\n          waitForListPopulated();\n        }\n      } else if (!isIndexOutOfBounds(listRef, activeIndex)) {\n        indexRef.current = activeIndex;\n        focusItem(listRef, indexRef, forceScrollIntoViewRef.current);\n        forceScrollIntoViewRef.current = false;\n      }\n    }\n  }, [enabled, open, elements.floating, activeIndex, selectedIndexRef, nested, listRef, orientation, rtl, onNavigate, focusItem, disabledIndicesRef]);\n\n  // Ensure the parent floating element has focus when a nested child closes\n  // to allow arrow key navigation to work after the pointer leaves the child.\n  index(() => {\n    var _nodes$find;\n    if (!enabled || elements.floating || !tree || virtual || !previousMountedRef.current) {\n      return;\n    }\n    const nodes = tree.nodesRef.current;\n    const parent = (_nodes$find = nodes.find(node => node.id === parentId)) == null || (_nodes$find = _nodes$find.context) == null ? void 0 : _nodes$find.elements.floating;\n    const activeEl = activeElement(getDocument(elements.floating));\n    const treeContainsActiveEl = nodes.some(node => node.context && contains(node.context.elements.floating, activeEl));\n    if (parent && !treeContainsActiveEl && isPointerModalityRef.current) {\n      parent.focus({\n        preventScroll: true\n      });\n    }\n  }, [enabled, elements.floating, tree, parentId, virtual]);\n  index(() => {\n    if (!enabled) return;\n    if (!tree) return;\n    if (!virtual) return;\n    if (parentId) return;\n    function handleVirtualFocus(item) {\n      setVirtualId(item.id);\n      if (virtualItemRef) {\n        virtualItemRef.current = item;\n      }\n    }\n    tree.events.on('virtualfocus', handleVirtualFocus);\n    return () => {\n      tree.events.off('virtualfocus', handleVirtualFocus);\n    };\n  }, [enabled, tree, virtual, parentId, virtualItemRef]);\n  index(() => {\n    previousOnNavigateRef.current = onNavigate;\n    previousMountedRef.current = !!elements.floating;\n  });\n  index(() => {\n    if (!open) {\n      keyRef.current = null;\n    }\n  }, [open]);\n  index(() => {\n    previousOpenRef.current = open;\n  }, [open]);\n  const hasActiveIndex = activeIndex != null;\n  const item = React.useMemo(() => {\n    function syncCurrentTarget(currentTarget) {\n      if (!open) return;\n      const index = listRef.current.indexOf(currentTarget);\n      if (index !== -1) {\n        onNavigate(index);\n      }\n    }\n    const props = {\n      onFocus(_ref) {\n        let {\n          currentTarget\n        } = _ref;\n        syncCurrentTarget(currentTarget);\n      },\n      onClick: _ref2 => {\n        let {\n          currentTarget\n        } = _ref2;\n        return currentTarget.focus({\n          preventScroll: true\n        });\n      },\n      // Safari\n      ...(focusItemOnHover && {\n        onMouseMove(_ref3) {\n          let {\n            currentTarget\n          } = _ref3;\n          syncCurrentTarget(currentTarget);\n        },\n        onPointerLeave(_ref4) {\n          let {\n            pointerType\n          } = _ref4;\n          if (!isPointerModalityRef.current || pointerType === 'touch') {\n            return;\n          }\n          indexRef.current = -1;\n          focusItem(listRef, indexRef);\n          onNavigate(null);\n          if (!virtual) {\n            enqueueFocus(floatingFocusElementRef.current, {\n              preventScroll: true\n            });\n          }\n        }\n      })\n    };\n    return props;\n  }, [open, floatingFocusElementRef, focusItem, focusItemOnHover, listRef, onNavigate, virtual]);\n  const commonOnKeyDown = useEffectEvent(event => {\n    isPointerModalityRef.current = false;\n    forceSyncFocus.current = true;\n\n    // When composing a character, Chrome fires ArrowDown twice. Firefox/Safari\n    // don't appear to suffer from this. `event.isComposing` is avoided due to\n    // Safari not supporting it properly (although it's not needed in the first\n    // place for Safari, just avoiding any possible issues).\n    if (event.which === 229) {\n      return;\n    }\n\n    // If the floating element is animating out, ignore navigation. Otherwise,\n    // the `activeIndex` gets set to 0 despite not being open so the next time\n    // the user ArrowDowns, the first item won't be focused.\n    if (!latestOpenRef.current && event.currentTarget === floatingFocusElementRef.current) {\n      return;\n    }\n    if (nested && isCrossOrientationCloseKey(event.key, orientation, rtl)) {\n      stopEvent(event);\n      onOpenChange(false, event.nativeEvent, 'list-navigation');\n      if (isHTMLElement(elements.domReference)) {\n        if (virtual) {\n          tree == null || tree.events.emit('virtualfocus', elements.domReference);\n        } else {\n          elements.domReference.focus();\n        }\n      }\n      return;\n    }\n    const currentIndex = indexRef.current;\n    const minIndex = getMinIndex(listRef, disabledIndices);\n    const maxIndex = getMaxIndex(listRef, disabledIndices);\n    if (!typeableComboboxReference) {\n      if (event.key === 'Home') {\n        stopEvent(event);\n        indexRef.current = minIndex;\n        onNavigate(indexRef.current);\n      }\n      if (event.key === 'End') {\n        stopEvent(event);\n        indexRef.current = maxIndex;\n        onNavigate(indexRef.current);\n      }\n    }\n\n    // Grid navigation.\n    if (cols > 1) {\n      const sizes = itemSizes || Array.from({\n        length: listRef.current.length\n      }, () => ({\n        width: 1,\n        height: 1\n      }));\n      // To calculate movements on the grid, we use hypothetical cell indices\n      // as if every item was 1x1, then convert back to real indices.\n      const cellMap = buildCellMap(sizes, cols, dense);\n      const minGridIndex = cellMap.findIndex(index => index != null && !isDisabled(listRef.current, index, disabledIndices));\n      // last enabled index\n      const maxGridIndex = cellMap.reduce((foundIndex, index, cellIndex) => index != null && !isDisabled(listRef.current, index, disabledIndices) ? cellIndex : foundIndex, -1);\n      const index = cellMap[getGridNavigatedIndex({\n        current: cellMap.map(itemIndex => itemIndex != null ? listRef.current[itemIndex] : null)\n      }, {\n        event,\n        orientation,\n        loop,\n        rtl,\n        cols,\n        // treat undefined (empty grid spaces) as disabled indices so we\n        // don't end up in them\n        disabledIndices: getCellIndices([...(disabledIndices || listRef.current.map((_, index) => isDisabled(listRef.current, index) ? index : undefined)), undefined], cellMap),\n        minIndex: minGridIndex,\n        maxIndex: maxGridIndex,\n        prevIndex: getCellIndexOfCorner(indexRef.current > maxIndex ? minIndex : indexRef.current, sizes, cellMap, cols,\n        // use a corner matching the edge closest to the direction\n        // we're moving in so we don't end up in the same item. Prefer\n        // top/left over bottom/right.\n        event.key === ARROW_DOWN ? 'bl' : event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT) ? 'tr' : 'tl'),\n        stopEvent: true\n      })];\n      if (index != null) {\n        indexRef.current = index;\n        onNavigate(indexRef.current);\n      }\n      if (orientation === 'both') {\n        return;\n      }\n    }\n    if (isMainOrientationKey(event.key, orientation)) {\n      stopEvent(event);\n\n      // Reset the index if no item is focused.\n      if (open && !virtual && activeElement(event.currentTarget.ownerDocument) === event.currentTarget) {\n        indexRef.current = isMainOrientationToEndKey(event.key, orientation, rtl) ? minIndex : maxIndex;\n        onNavigate(indexRef.current);\n        return;\n      }\n      if (isMainOrientationToEndKey(event.key, orientation, rtl)) {\n        if (loop) {\n          indexRef.current = currentIndex >= maxIndex ? allowEscape && currentIndex !== listRef.current.length ? -1 : minIndex : findNonDisabledIndex(listRef, {\n            startingIndex: currentIndex,\n            disabledIndices\n          });\n        } else {\n          indexRef.current = Math.min(maxIndex, findNonDisabledIndex(listRef, {\n            startingIndex: currentIndex,\n            disabledIndices\n          }));\n        }\n      } else {\n        if (loop) {\n          indexRef.current = currentIndex <= minIndex ? allowEscape && currentIndex !== -1 ? listRef.current.length : maxIndex : findNonDisabledIndex(listRef, {\n            startingIndex: currentIndex,\n            decrement: true,\n            disabledIndices\n          });\n        } else {\n          indexRef.current = Math.max(minIndex, findNonDisabledIndex(listRef, {\n            startingIndex: currentIndex,\n            decrement: true,\n            disabledIndices\n          }));\n        }\n      }\n      if (isIndexOutOfBounds(listRef, indexRef.current)) {\n        onNavigate(null);\n      } else {\n        onNavigate(indexRef.current);\n      }\n    }\n  });\n  const ariaActiveDescendantProp = React.useMemo(() => {\n    return virtual && open && hasActiveIndex && {\n      'aria-activedescendant': virtualId || activeId\n    };\n  }, [virtual, open, hasActiveIndex, virtualId, activeId]);\n  const floating = React.useMemo(() => {\n    return {\n      'aria-orientation': orientation === 'both' ? undefined : orientation,\n      ...(!isTypeableCombobox(elements.domReference) && ariaActiveDescendantProp),\n      onKeyDown: commonOnKeyDown,\n      onPointerMove() {\n        isPointerModalityRef.current = true;\n      }\n    };\n  }, [ariaActiveDescendantProp, commonOnKeyDown, elements.domReference, orientation]);\n  const reference = React.useMemo(() => {\n    function checkVirtualMouse(event) {\n      if (focusItemOnOpen === 'auto' && isVirtualClick(event.nativeEvent)) {\n        focusItemOnOpenRef.current = true;\n      }\n    }\n    function checkVirtualPointer(event) {\n      // `pointerdown` fires first, reset the state then perform the checks.\n      focusItemOnOpenRef.current = focusItemOnOpen;\n      if (focusItemOnOpen === 'auto' && isVirtualPointerEvent(event.nativeEvent)) {\n        focusItemOnOpenRef.current = true;\n      }\n    }\n    return {\n      ...ariaActiveDescendantProp,\n      onKeyDown(event) {\n        isPointerModalityRef.current = false;\n        const isArrowKey = event.key.startsWith('Arrow');\n        const isHomeOrEndKey = ['Home', 'End'].includes(event.key);\n        const isMoveKey = isArrowKey || isHomeOrEndKey;\n        const isCrossOpenKey = isCrossOrientationOpenKey(event.key, orientation, rtl);\n        const isCrossCloseKey = isCrossOrientationCloseKey(event.key, orientation, rtl);\n        const isMainKey = isMainOrientationKey(event.key, orientation);\n        const isNavigationKey = (nested ? isCrossOpenKey : isMainKey) || event.key === 'Enter' || event.key.trim() === '';\n        if (virtual && open) {\n          const rootNode = tree == null ? void 0 : tree.nodesRef.current.find(node => node.parentId == null);\n          const deepestNode = tree && rootNode ? getDeepestNode(tree.nodesRef.current, rootNode.id) : null;\n          if (isMoveKey && deepestNode && virtualItemRef) {\n            const eventObject = new KeyboardEvent('keydown', {\n              key: event.key,\n              bubbles: true\n            });\n            if (isCrossOpenKey || isCrossCloseKey) {\n              var _deepestNode$context, _deepestNode$context2;\n              const isCurrentTarget = ((_deepestNode$context = deepestNode.context) == null ? void 0 : _deepestNode$context.elements.domReference) === event.currentTarget;\n              const dispatchItem = isCrossCloseKey && !isCurrentTarget ? (_deepestNode$context2 = deepestNode.context) == null ? void 0 : _deepestNode$context2.elements.domReference : isCrossOpenKey ? listRef.current.find(item => (item == null ? void 0 : item.id) === activeId) : null;\n              if (dispatchItem) {\n                stopEvent(event);\n                dispatchItem.dispatchEvent(eventObject);\n                setVirtualId(undefined);\n              }\n            }\n            if ((isMainKey || isHomeOrEndKey) && deepestNode.context) {\n              if (deepestNode.context.open && deepestNode.parentId && event.currentTarget !== deepestNode.context.elements.domReference) {\n                var _deepestNode$context$;\n                stopEvent(event);\n                (_deepestNode$context$ = deepestNode.context.elements.domReference) == null || _deepestNode$context$.dispatchEvent(eventObject);\n                return;\n              }\n            }\n          }\n          return commonOnKeyDown(event);\n        }\n\n        // If a floating element should not open on arrow key down, avoid\n        // setting `activeIndex` while it's closed.\n        if (!open && !openOnArrowKeyDown && isArrowKey) {\n          return;\n        }\n        if (isNavigationKey) {\n          keyRef.current = nested && isMainKey ? null : event.key;\n        }\n        if (nested) {\n          if (isCrossOpenKey) {\n            stopEvent(event);\n            if (open) {\n              indexRef.current = getMinIndex(listRef, disabledIndicesRef.current);\n              onNavigate(indexRef.current);\n            } else {\n              onOpenChange(true, event.nativeEvent, 'list-navigation');\n            }\n          }\n          return;\n        }\n        if (isMainKey) {\n          if (selectedIndex != null) {\n            indexRef.current = selectedIndex;\n          }\n          stopEvent(event);\n          if (!open && openOnArrowKeyDown) {\n            onOpenChange(true, event.nativeEvent, 'list-navigation');\n          } else {\n            commonOnKeyDown(event);\n          }\n          if (open) {\n            onNavigate(indexRef.current);\n          }\n        }\n      },\n      onFocus() {\n        if (open && !virtual) {\n          onNavigate(null);\n        }\n      },\n      onPointerDown: checkVirtualPointer,\n      onMouseDown: checkVirtualMouse,\n      onClick: checkVirtualMouse\n    };\n  }, [activeId, ariaActiveDescendantProp, commonOnKeyDown, disabledIndicesRef, focusItemOnOpen, listRef, nested, onNavigate, onOpenChange, open, openOnArrowKeyDown, orientation, rtl, selectedIndex, tree, virtual, virtualItemRef]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating,\n    item\n  } : {}, [enabled, reference, floating, item]);\n}\n\nconst componentRoleToAriaRoleMap = /*#__PURE__*/new Map([['select', 'listbox'], ['combobox', 'listbox'], ['label', false]]);\n\n/**\n * Adds base screen reader props to the reference and floating elements for a\n * given floating element `role`.\n * @see https://floating-ui.com/docs/useRole\n */\nfunction useRole(context, props) {\n  var _componentRoleToAriaR;\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    floatingId\n  } = context;\n  const {\n    enabled = true,\n    role = 'dialog'\n  } = props;\n  const ariaRole = (_componentRoleToAriaR = componentRoleToAriaRoleMap.get(role)) != null ? _componentRoleToAriaR : role;\n  const referenceId = useId();\n  const parentId = useFloatingParentNodeId();\n  const isNested = parentId != null;\n  const reference = React.useMemo(() => {\n    if (ariaRole === 'tooltip' || role === 'label') {\n      return {\n        [\"aria-\" + (role === 'label' ? 'labelledby' : 'describedby')]: open ? floatingId : undefined\n      };\n    }\n    return {\n      'aria-expanded': open ? 'true' : 'false',\n      'aria-haspopup': ariaRole === 'alertdialog' ? 'dialog' : ariaRole,\n      'aria-controls': open ? floatingId : undefined,\n      ...(ariaRole === 'listbox' && {\n        role: 'combobox'\n      }),\n      ...(ariaRole === 'menu' && {\n        id: referenceId\n      }),\n      ...(ariaRole === 'menu' && isNested && {\n        role: 'menuitem'\n      }),\n      ...(role === 'select' && {\n        'aria-autocomplete': 'none'\n      }),\n      ...(role === 'combobox' && {\n        'aria-autocomplete': 'list'\n      })\n    };\n  }, [ariaRole, floatingId, isNested, open, referenceId, role]);\n  const floating = React.useMemo(() => {\n    const floatingProps = {\n      id: floatingId,\n      ...(ariaRole && {\n        role: ariaRole\n      })\n    };\n    if (ariaRole === 'tooltip' || role === 'label') {\n      return floatingProps;\n    }\n    return {\n      ...floatingProps,\n      ...(ariaRole === 'menu' && {\n        'aria-labelledby': referenceId\n      })\n    };\n  }, [ariaRole, floatingId, referenceId, role]);\n  const item = React.useCallback(_ref => {\n    let {\n      active,\n      selected\n    } = _ref;\n    const commonProps = {\n      role: 'option',\n      ...(active && {\n        id: floatingId + \"-option\"\n      })\n    };\n\n    // For `menu`, we are unable to tell if the item is a `menuitemradio`\n    // or `menuitemcheckbox`. For backwards-compatibility reasons, also\n    // avoid defaulting to `menuitem` as it may overwrite custom role props.\n    switch (role) {\n      case 'select':\n        return {\n          ...commonProps,\n          'aria-selected': active && selected\n        };\n      case 'combobox':\n        {\n          return {\n            ...commonProps,\n            ...(active && {\n              'aria-selected': true\n            })\n          };\n        }\n    }\n    return {};\n  }, [floatingId, role]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating,\n    item\n  } : {}, [enabled, reference, floating, item]);\n}\n\n// Converts a JS style key like `backgroundColor` to a CSS transition-property\n// like `background-color`.\nconst camelCaseToKebabCase = str => str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($, ofs) => (ofs ? '-' : '') + $.toLowerCase());\nfunction execWithArgsOrReturn(valueOrFn, args) {\n  return typeof valueOrFn === 'function' ? valueOrFn(args) : valueOrFn;\n}\nfunction useDelayUnmount(open, durationMs) {\n  const [isMounted, setIsMounted] = React.useState(open);\n  if (open && !isMounted) {\n    setIsMounted(true);\n  }\n  React.useEffect(() => {\n    if (!open && isMounted) {\n      const timeout = setTimeout(() => setIsMounted(false), durationMs);\n      return () => clearTimeout(timeout);\n    }\n  }, [open, isMounted, durationMs]);\n  return isMounted;\n}\n/**\n * Provides a status string to apply CSS transitions to a floating element,\n * correctly handling placement-aware transitions.\n * @see https://floating-ui.com/docs/useTransition#usetransitionstatus\n */\nfunction useTransitionStatus(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    elements: {\n      floating\n    }\n  } = context;\n  const {\n    duration = 250\n  } = props;\n  const isNumberDuration = typeof duration === 'number';\n  const closeDuration = (isNumberDuration ? duration : duration.close) || 0;\n  const [status, setStatus] = React.useState('unmounted');\n  const isMounted = useDelayUnmount(open, closeDuration);\n  if (!isMounted && status === 'close') {\n    setStatus('unmounted');\n  }\n  index(() => {\n    if (!floating) return;\n    if (open) {\n      setStatus('initial');\n      const frame = requestAnimationFrame(() => {\n        setStatus('open');\n      });\n      return () => {\n        cancelAnimationFrame(frame);\n      };\n    }\n    setStatus('close');\n  }, [open, floating]);\n  return {\n    isMounted,\n    status\n  };\n}\n/**\n * Provides styles to apply CSS transitions to a floating element, correctly\n * handling placement-aware transitions. Wrapper around `useTransitionStatus`.\n * @see https://floating-ui.com/docs/useTransition#usetransitionstyles\n */\nfunction useTransitionStyles(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    initial: unstable_initial = {\n      opacity: 0\n    },\n    open: unstable_open,\n    close: unstable_close,\n    common: unstable_common,\n    duration = 250\n  } = props;\n  const placement = context.placement;\n  const side = placement.split('-')[0];\n  const fnArgs = React.useMemo(() => ({\n    side,\n    placement\n  }), [side, placement]);\n  const isNumberDuration = typeof duration === 'number';\n  const openDuration = (isNumberDuration ? duration : duration.open) || 0;\n  const closeDuration = (isNumberDuration ? duration : duration.close) || 0;\n  const [styles, setStyles] = React.useState(() => ({\n    ...execWithArgsOrReturn(unstable_common, fnArgs),\n    ...execWithArgsOrReturn(unstable_initial, fnArgs)\n  }));\n  const {\n    isMounted,\n    status\n  } = useTransitionStatus(context, {\n    duration\n  });\n  const initialRef = useLatestRef(unstable_initial);\n  const openRef = useLatestRef(unstable_open);\n  const closeRef = useLatestRef(unstable_close);\n  const commonRef = useLatestRef(unstable_common);\n  index(() => {\n    const initialStyles = execWithArgsOrReturn(initialRef.current, fnArgs);\n    const closeStyles = execWithArgsOrReturn(closeRef.current, fnArgs);\n    const commonStyles = execWithArgsOrReturn(commonRef.current, fnArgs);\n    const openStyles = execWithArgsOrReturn(openRef.current, fnArgs) || Object.keys(initialStyles).reduce((acc, key) => {\n      acc[key] = '';\n      return acc;\n    }, {});\n    if (status === 'initial') {\n      setStyles(styles => ({\n        transitionProperty: styles.transitionProperty,\n        ...commonStyles,\n        ...initialStyles\n      }));\n    }\n    if (status === 'open') {\n      setStyles({\n        transitionProperty: Object.keys(openStyles).map(camelCaseToKebabCase).join(','),\n        transitionDuration: openDuration + \"ms\",\n        ...commonStyles,\n        ...openStyles\n      });\n    }\n    if (status === 'close') {\n      const styles = closeStyles || initialStyles;\n      setStyles({\n        transitionProperty: Object.keys(styles).map(camelCaseToKebabCase).join(','),\n        transitionDuration: closeDuration + \"ms\",\n        ...commonStyles,\n        ...styles\n      });\n    }\n  }, [closeDuration, closeRef, initialRef, openRef, commonRef, openDuration, status, fnArgs]);\n  return {\n    isMounted,\n    styles\n  };\n}\n\n/**\n * Provides a matching callback that can be used to focus an item as the user\n * types, often used in tandem with `useListNavigation()`.\n * @see https://floating-ui.com/docs/useTypeahead\n */\nfunction useTypeahead(context, props) {\n  var _ref;\n  const {\n    open,\n    dataRef\n  } = context;\n  const {\n    listRef,\n    activeIndex,\n    onMatch: unstable_onMatch,\n    onTypingChange: unstable_onTypingChange,\n    enabled = true,\n    findMatch = null,\n    resetMs = 750,\n    ignoreKeys = [],\n    selectedIndex = null\n  } = props;\n  const timeoutIdRef = React.useRef();\n  const stringRef = React.useRef('');\n  const prevIndexRef = React.useRef((_ref = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref : -1);\n  const matchIndexRef = React.useRef(null);\n  const onMatch = useEffectEvent(unstable_onMatch);\n  const onTypingChange = useEffectEvent(unstable_onTypingChange);\n  const findMatchRef = useLatestRef(findMatch);\n  const ignoreKeysRef = useLatestRef(ignoreKeys);\n  index(() => {\n    if (open) {\n      clearTimeout(timeoutIdRef.current);\n      matchIndexRef.current = null;\n      stringRef.current = '';\n    }\n  }, [open]);\n  index(() => {\n    // Sync arrow key navigation but not typeahead navigation.\n    if (open && stringRef.current === '') {\n      var _ref2;\n      prevIndexRef.current = (_ref2 = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref2 : -1;\n    }\n  }, [open, selectedIndex, activeIndex]);\n  const setTypingChange = useEffectEvent(value => {\n    if (value) {\n      if (!dataRef.current.typing) {\n        dataRef.current.typing = value;\n        onTypingChange(value);\n      }\n    } else {\n      if (dataRef.current.typing) {\n        dataRef.current.typing = value;\n        onTypingChange(value);\n      }\n    }\n  });\n  const onKeyDown = useEffectEvent(event => {\n    function getMatchingIndex(list, orderedList, string) {\n      const str = findMatchRef.current ? findMatchRef.current(orderedList, string) : orderedList.find(text => (text == null ? void 0 : text.toLocaleLowerCase().indexOf(string.toLocaleLowerCase())) === 0);\n      return str ? list.indexOf(str) : -1;\n    }\n    const listContent = listRef.current;\n    if (stringRef.current.length > 0 && stringRef.current[0] !== ' ') {\n      if (getMatchingIndex(listContent, listContent, stringRef.current) === -1) {\n        setTypingChange(false);\n      } else if (event.key === ' ') {\n        stopEvent(event);\n      }\n    }\n    if (listContent == null || ignoreKeysRef.current.includes(event.key) ||\n    // Character key.\n    event.key.length !== 1 ||\n    // Modifier key.\n    event.ctrlKey || event.metaKey || event.altKey) {\n      return;\n    }\n    if (open && event.key !== ' ') {\n      stopEvent(event);\n      setTypingChange(true);\n    }\n\n    // Bail out if the list contains a word like \"llama\" or \"aaron\". TODO:\n    // allow it in this case, too.\n    const allowRapidSuccessionOfFirstLetter = listContent.every(text => {\n      var _text$, _text$2;\n      return text ? ((_text$ = text[0]) == null ? void 0 : _text$.toLocaleLowerCase()) !== ((_text$2 = text[1]) == null ? void 0 : _text$2.toLocaleLowerCase()) : true;\n    });\n\n    // Allows the user to cycle through items that start with the same letter\n    // in rapid succession.\n    if (allowRapidSuccessionOfFirstLetter && stringRef.current === event.key) {\n      stringRef.current = '';\n      prevIndexRef.current = matchIndexRef.current;\n    }\n    stringRef.current += event.key;\n    clearTimeout(timeoutIdRef.current);\n    timeoutIdRef.current = setTimeout(() => {\n      stringRef.current = '';\n      prevIndexRef.current = matchIndexRef.current;\n      setTypingChange(false);\n    }, resetMs);\n    const prevIndex = prevIndexRef.current;\n    const index = getMatchingIndex(listContent, [...listContent.slice((prevIndex || 0) + 1), ...listContent.slice(0, (prevIndex || 0) + 1)], stringRef.current);\n    if (index !== -1) {\n      onMatch(index);\n      matchIndexRef.current = index;\n    } else if (event.key !== ' ') {\n      stringRef.current = '';\n      setTypingChange(false);\n    }\n  });\n  const reference = React.useMemo(() => ({\n    onKeyDown\n  }), [onKeyDown]);\n  const floating = React.useMemo(() => {\n    return {\n      onKeyDown,\n      onKeyUp(event) {\n        if (event.key === ' ') {\n          setTypingChange(false);\n        }\n      }\n    };\n  }, [onKeyDown, setTypingChange]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating\n  } : {}, [enabled, reference, floating]);\n}\n\nfunction getArgsWithCustomFloatingHeight(state, height) {\n  return {\n    ...state,\n    rects: {\n      ...state.rects,\n      floating: {\n        ...state.rects.floating,\n        height\n      }\n    }\n  };\n}\n/**\n * Positions the floating element such that an inner element inside of it is\n * anchored to the reference element.\n * @see https://floating-ui.com/docs/inner\n */\nconst inner = props => ({\n  name: 'inner',\n  options: props,\n  async fn(state) {\n    const {\n      listRef,\n      overflowRef,\n      onFallbackChange,\n      offset: innerOffset = 0,\n      index = 0,\n      minItemsVisible = 4,\n      referenceOverflowThreshold = 0,\n      scrollRef,\n      ...detectOverflowOptions\n    } = evaluate(props, state);\n    const {\n      rects,\n      elements: {\n        floating\n      }\n    } = state;\n    const item = listRef.current[index];\n    const scrollEl = (scrollRef == null ? void 0 : scrollRef.current) || floating;\n\n    // Valid combinations:\n    // 1. Floating element is the scrollRef and has a border (default)\n    // 2. Floating element is not the scrollRef, floating element has a border\n    // 3. Floating element is not the scrollRef, scrollRef has a border\n    // Floating > {...getFloatingProps()} wrapper > scrollRef > items is not\n    // allowed as VoiceOver doesn't work.\n    const clientTop = floating.clientTop || scrollEl.clientTop;\n    const floatingIsBordered = floating.clientTop !== 0;\n    const scrollElIsBordered = scrollEl.clientTop !== 0;\n    const floatingIsScrollEl = floating === scrollEl;\n    if (process.env.NODE_ENV !== \"production\") {\n      if (!state.placement.startsWith('bottom')) {\n        warn('`placement` side must be \"bottom\" when using the `inner`', 'middleware.');\n      }\n    }\n    if (!item) {\n      return {};\n    }\n    const nextArgs = {\n      ...state,\n      ...(await offset(-item.offsetTop - floating.clientTop - rects.reference.height / 2 - item.offsetHeight / 2 - innerOffset).fn(state))\n    };\n    const overflow = await detectOverflow(getArgsWithCustomFloatingHeight(nextArgs, scrollEl.scrollHeight + clientTop + floating.clientTop), detectOverflowOptions);\n    const refOverflow = await detectOverflow(nextArgs, {\n      ...detectOverflowOptions,\n      elementContext: 'reference'\n    });\n    const diffY = max(0, overflow.top);\n    const nextY = nextArgs.y + diffY;\n    const isScrollable = scrollEl.scrollHeight > scrollEl.clientHeight;\n    const rounder = isScrollable ? v => v : round;\n    const maxHeight = rounder(max(0, scrollEl.scrollHeight + (floatingIsBordered && floatingIsScrollEl || scrollElIsBordered ? clientTop * 2 : 0) - diffY - max(0, overflow.bottom)));\n    scrollEl.style.maxHeight = maxHeight + \"px\";\n    scrollEl.scrollTop = diffY;\n\n    // There is not enough space, fallback to standard anchored positioning\n    if (onFallbackChange) {\n      const shouldFallback = scrollEl.offsetHeight < item.offsetHeight * min(minItemsVisible, listRef.current.length) - 1 || refOverflow.top >= -referenceOverflowThreshold || refOverflow.bottom >= -referenceOverflowThreshold;\n      ReactDOM.flushSync(() => onFallbackChange(shouldFallback));\n    }\n    if (overflowRef) {\n      overflowRef.current = await detectOverflow(getArgsWithCustomFloatingHeight({\n        ...nextArgs,\n        y: nextY\n      }, scrollEl.offsetHeight + clientTop + floating.clientTop), detectOverflowOptions);\n    }\n    return {\n      y: nextY\n    };\n  }\n});\n/**\n * Changes the `inner` middleware's `offset` upon a `wheel` event to\n * expand the floating element's height, revealing more list items.\n * @see https://floating-ui.com/docs/inner\n */\nfunction useInnerOffset(context, props) {\n  const {\n    open,\n    elements\n  } = context;\n  const {\n    enabled = true,\n    overflowRef,\n    scrollRef,\n    onChange: unstable_onChange\n  } = props;\n  const onChange = useEffectEvent(unstable_onChange);\n  const controlledScrollingRef = React.useRef(false);\n  const prevScrollTopRef = React.useRef(null);\n  const initialOverflowRef = React.useRef(null);\n  React.useEffect(() => {\n    if (!enabled) return;\n    function onWheel(e) {\n      if (e.ctrlKey || !el || overflowRef.current == null) {\n        return;\n      }\n      const dY = e.deltaY;\n      const isAtTop = overflowRef.current.top >= -0.5;\n      const isAtBottom = overflowRef.current.bottom >= -0.5;\n      const remainingScroll = el.scrollHeight - el.clientHeight;\n      const sign = dY < 0 ? -1 : 1;\n      const method = dY < 0 ? 'max' : 'min';\n      if (el.scrollHeight <= el.clientHeight) {\n        return;\n      }\n      if (!isAtTop && dY > 0 || !isAtBottom && dY < 0) {\n        e.preventDefault();\n        ReactDOM.flushSync(() => {\n          onChange(d => d + Math[method](dY, remainingScroll * sign));\n        });\n      } else if (/firefox/i.test(getUserAgent())) {\n        // Needed to propagate scrolling during momentum scrolling phase once\n        // it gets limited by the boundary. UX improvement, not critical.\n        el.scrollTop += dY;\n      }\n    }\n    const el = (scrollRef == null ? void 0 : scrollRef.current) || elements.floating;\n    if (open && el) {\n      el.addEventListener('wheel', onWheel);\n\n      // Wait for the position to be ready.\n      requestAnimationFrame(() => {\n        prevScrollTopRef.current = el.scrollTop;\n        if (overflowRef.current != null) {\n          initialOverflowRef.current = {\n            ...overflowRef.current\n          };\n        }\n      });\n      return () => {\n        prevScrollTopRef.current = null;\n        initialOverflowRef.current = null;\n        el.removeEventListener('wheel', onWheel);\n      };\n    }\n  }, [enabled, open, elements.floating, overflowRef, scrollRef, onChange]);\n  const floating = React.useMemo(() => ({\n    onKeyDown() {\n      controlledScrollingRef.current = true;\n    },\n    onWheel() {\n      controlledScrollingRef.current = false;\n    },\n    onPointerMove() {\n      controlledScrollingRef.current = false;\n    },\n    onScroll() {\n      const el = (scrollRef == null ? void 0 : scrollRef.current) || elements.floating;\n      if (!overflowRef.current || !el || !controlledScrollingRef.current) {\n        return;\n      }\n      if (prevScrollTopRef.current !== null) {\n        const scrollDiff = el.scrollTop - prevScrollTopRef.current;\n        if (overflowRef.current.bottom < -0.5 && scrollDiff < -1 || overflowRef.current.top < -0.5 && scrollDiff > 1) {\n          ReactDOM.flushSync(() => onChange(d => d + scrollDiff));\n        }\n      }\n\n      // [Firefox] Wait for the height change to have been applied.\n      requestAnimationFrame(() => {\n        prevScrollTopRef.current = el.scrollTop;\n      });\n    }\n  }), [elements.floating, onChange, overflowRef, scrollRef]);\n  return React.useMemo(() => enabled ? {\n    floating\n  } : {}, [enabled, floating]);\n}\n\nfunction isPointInPolygon(point, polygon) {\n  const [x, y] = point;\n  let isInside = false;\n  const length = polygon.length;\n  for (let i = 0, j = length - 1; i < length; j = i++) {\n    const [xi, yi] = polygon[i] || [0, 0];\n    const [xj, yj] = polygon[j] || [0, 0];\n    const intersect = yi >= y !== yj >= y && x <= (xj - xi) * (y - yi) / (yj - yi) + xi;\n    if (intersect) {\n      isInside = !isInside;\n    }\n  }\n  return isInside;\n}\nfunction isInside(point, rect) {\n  return point[0] >= rect.x && point[0] <= rect.x + rect.width && point[1] >= rect.y && point[1] <= rect.y + rect.height;\n}\n/**\n * Generates a safe polygon area that the user can traverse without closing the\n * floating element once leaving the reference element.\n * @see https://floating-ui.com/docs/useHover#safepolygon\n */\nfunction safePolygon(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    buffer = 0.5,\n    blockPointerEvents = false,\n    requireIntent = true\n  } = options;\n  let timeoutId;\n  let hasLanded = false;\n  let lastX = null;\n  let lastY = null;\n  let lastCursorTime = performance.now();\n  function getCursorSpeed(x, y) {\n    const currentTime = performance.now();\n    const elapsedTime = currentTime - lastCursorTime;\n    if (lastX === null || lastY === null || elapsedTime === 0) {\n      lastX = x;\n      lastY = y;\n      lastCursorTime = currentTime;\n      return null;\n    }\n    const deltaX = x - lastX;\n    const deltaY = y - lastY;\n    const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);\n    const speed = distance / elapsedTime; // px / ms\n\n    lastX = x;\n    lastY = y;\n    lastCursorTime = currentTime;\n    return speed;\n  }\n  const fn = _ref => {\n    let {\n      x,\n      y,\n      placement,\n      elements,\n      onClose,\n      nodeId,\n      tree\n    } = _ref;\n    return function onMouseMove(event) {\n      function close() {\n        clearTimeout(timeoutId);\n        onClose();\n      }\n      clearTimeout(timeoutId);\n      if (!elements.domReference || !elements.floating || placement == null || x == null || y == null) {\n        return;\n      }\n      const {\n        clientX,\n        clientY\n      } = event;\n      const clientPoint = [clientX, clientY];\n      const target = getTarget(event);\n      const isLeave = event.type === 'mouseleave';\n      const isOverFloatingEl = contains(elements.floating, target);\n      const isOverReferenceEl = contains(elements.domReference, target);\n      const refRect = elements.domReference.getBoundingClientRect();\n      const rect = elements.floating.getBoundingClientRect();\n      const side = placement.split('-')[0];\n      const cursorLeaveFromRight = x > rect.right - rect.width / 2;\n      const cursorLeaveFromBottom = y > rect.bottom - rect.height / 2;\n      const isOverReferenceRect = isInside(clientPoint, refRect);\n      const isFloatingWider = rect.width > refRect.width;\n      const isFloatingTaller = rect.height > refRect.height;\n      const left = (isFloatingWider ? refRect : rect).left;\n      const right = (isFloatingWider ? refRect : rect).right;\n      const top = (isFloatingTaller ? refRect : rect).top;\n      const bottom = (isFloatingTaller ? refRect : rect).bottom;\n      if (isOverFloatingEl) {\n        hasLanded = true;\n        if (!isLeave) {\n          return;\n        }\n      }\n      if (isOverReferenceEl) {\n        hasLanded = false;\n      }\n      if (isOverReferenceEl && !isLeave) {\n        hasLanded = true;\n        return;\n      }\n\n      // Prevent overlapping floating element from being stuck in an open-close\n      // loop: https://github.com/floating-ui/floating-ui/issues/1910\n      if (isLeave && isElement(event.relatedTarget) && contains(elements.floating, event.relatedTarget)) {\n        return;\n      }\n\n      // If any nested child is open, abort.\n      if (tree && getChildren(tree.nodesRef.current, nodeId).some(_ref2 => {\n        let {\n          context\n        } = _ref2;\n        return context == null ? void 0 : context.open;\n      })) {\n        return;\n      }\n\n      // If the pointer is leaving from the opposite side, the \"buffer\" logic\n      // creates a point where the floating element remains open, but should be\n      // ignored.\n      // A constant of 1 handles floating point rounding errors.\n      if (side === 'top' && y >= refRect.bottom - 1 || side === 'bottom' && y <= refRect.top + 1 || side === 'left' && x >= refRect.right - 1 || side === 'right' && x <= refRect.left + 1) {\n        return close();\n      }\n\n      // Ignore when the cursor is within the rectangular trough between the\n      // two elements. Since the triangle is created from the cursor point,\n      // which can start beyond the ref element's edge, traversing back and\n      // forth from the ref to the floating element can cause it to close. This\n      // ensures it always remains open in that case.\n      let rectPoly = [];\n      switch (side) {\n        case 'top':\n          rectPoly = [[left, refRect.top + 1], [left, rect.bottom - 1], [right, rect.bottom - 1], [right, refRect.top + 1]];\n          break;\n        case 'bottom':\n          rectPoly = [[left, rect.top + 1], [left, refRect.bottom - 1], [right, refRect.bottom - 1], [right, rect.top + 1]];\n          break;\n        case 'left':\n          rectPoly = [[rect.right - 1, bottom], [rect.right - 1, top], [refRect.left + 1, top], [refRect.left + 1, bottom]];\n          break;\n        case 'right':\n          rectPoly = [[refRect.right - 1, bottom], [refRect.right - 1, top], [rect.left + 1, top], [rect.left + 1, bottom]];\n          break;\n      }\n      function getPolygon(_ref3) {\n        let [x, y] = _ref3;\n        switch (side) {\n          case 'top':\n            {\n              const cursorPointOne = [isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y + buffer + 1];\n              const cursorPointTwo = [isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y + buffer + 1];\n              const commonPoints = [[rect.left, cursorLeaveFromRight ? rect.bottom - buffer : isFloatingWider ? rect.bottom - buffer : rect.top], [rect.right, cursorLeaveFromRight ? isFloatingWider ? rect.bottom - buffer : rect.top : rect.bottom - buffer]];\n              return [cursorPointOne, cursorPointTwo, ...commonPoints];\n            }\n          case 'bottom':\n            {\n              const cursorPointOne = [isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y - buffer];\n              const cursorPointTwo = [isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y - buffer];\n              const commonPoints = [[rect.left, cursorLeaveFromRight ? rect.top + buffer : isFloatingWider ? rect.top + buffer : rect.bottom], [rect.right, cursorLeaveFromRight ? isFloatingWider ? rect.top + buffer : rect.bottom : rect.top + buffer]];\n              return [cursorPointOne, cursorPointTwo, ...commonPoints];\n            }\n          case 'left':\n            {\n              const cursorPointOne = [x + buffer + 1, isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const cursorPointTwo = [x + buffer + 1, isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const commonPoints = [[cursorLeaveFromBottom ? rect.right - buffer : isFloatingTaller ? rect.right - buffer : rect.left, rect.top], [cursorLeaveFromBottom ? isFloatingTaller ? rect.right - buffer : rect.left : rect.right - buffer, rect.bottom]];\n              return [...commonPoints, cursorPointOne, cursorPointTwo];\n            }\n          case 'right':\n            {\n              const cursorPointOne = [x - buffer, isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const cursorPointTwo = [x - buffer, isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const commonPoints = [[cursorLeaveFromBottom ? rect.left + buffer : isFloatingTaller ? rect.left + buffer : rect.right, rect.top], [cursorLeaveFromBottom ? isFloatingTaller ? rect.left + buffer : rect.right : rect.left + buffer, rect.bottom]];\n              return [cursorPointOne, cursorPointTwo, ...commonPoints];\n            }\n        }\n      }\n      if (isPointInPolygon([clientX, clientY], rectPoly)) {\n        return;\n      }\n      if (hasLanded && !isOverReferenceRect) {\n        return close();\n      }\n      if (!isLeave && requireIntent) {\n        const cursorSpeed = getCursorSpeed(event.clientX, event.clientY);\n        const cursorSpeedThreshold = 0.1;\n        if (cursorSpeed !== null && cursorSpeed < cursorSpeedThreshold) {\n          return close();\n        }\n      }\n      if (!isPointInPolygon([clientX, clientY], getPolygon([x, y]))) {\n        close();\n      } else if (!hasLanded && requireIntent) {\n        timeoutId = window.setTimeout(close, 40);\n      }\n    };\n  };\n  fn.__options = {\n    blockPointerEvents\n  };\n  return fn;\n}\n\nexport { Composite, CompositeItem, FloatingArrow, FloatingDelayGroup, FloatingFocusManager, FloatingList, FloatingNode, FloatingOverlay, FloatingPortal, FloatingTree, inner, safePolygon, useClick, useClientPoint, useDelayGroup, useDelayGroupContext, useDismiss, useFloating, useFloatingNodeId, useFloatingParentNodeId, useFloatingPortalNode, useFloatingRootContext, useFloatingTree, useFocus, useHover, useId, useInnerOffset, useInteractions, useListItem, useListNavigation, useMergeRefs, useRole, useTransitionStatus, useTransitionStyles, useTypeahead };\n","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = debounce;\n","/**\n * Custom positioning reference element.\n * @see https://floating-ui.com/docs/virtual-elements\n */\n\nconst sides = ['top', 'right', 'bottom', 'left'];\nconst alignments = ['start', 'end'];\nconst placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + \"-\" + alignments[0], side + \"-\" + alignments[1]), []);\nconst min = Math.min;\nconst max = Math.max;\nconst round = Math.round;\nconst floor = Math.floor;\nconst createCoords = v => ({\n  x: v,\n  y: v\n});\nconst oppositeSideMap = {\n  left: 'right',\n  right: 'left',\n  bottom: 'top',\n  top: 'bottom'\n};\nconst oppositeAlignmentMap = {\n  start: 'end',\n  end: 'start'\n};\nfunction clamp(start, value, end) {\n  return max(start, min(value, end));\n}\nfunction evaluate(value, param) {\n  return typeof value === 'function' ? value(param) : value;\n}\nfunction getSide(placement) {\n  return placement.split('-')[0];\n}\nfunction getAlignment(placement) {\n  return placement.split('-')[1];\n}\nfunction getOppositeAxis(axis) {\n  return axis === 'x' ? 'y' : 'x';\n}\nfunction getAxisLength(axis) {\n  return axis === 'y' ? 'height' : 'width';\n}\nfunction getSideAxis(placement) {\n  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';\n}\nfunction getAlignmentAxis(placement) {\n  return getOppositeAxis(getSideAxis(placement));\n}\nfunction getAlignmentSides(placement, rects, rtl) {\n  if (rtl === void 0) {\n    rtl = false;\n  }\n  const alignment = getAlignment(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const length = getAxisLength(alignmentAxis);\n  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';\n  if (rects.reference[length] > rects.floating[length]) {\n    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);\n  }\n  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];\n}\nfunction getExpandedPlacements(placement) {\n  const oppositePlacement = getOppositePlacement(placement);\n  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];\n}\nfunction getOppositeAlignmentPlacement(placement) {\n  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);\n}\nfunction getSideList(side, isStart, rtl) {\n  const lr = ['left', 'right'];\n  const rl = ['right', 'left'];\n  const tb = ['top', 'bottom'];\n  const bt = ['bottom', 'top'];\n  switch (side) {\n    case 'top':\n    case 'bottom':\n      if (rtl) return isStart ? rl : lr;\n      return isStart ? lr : rl;\n    case 'left':\n    case 'right':\n      return isStart ? tb : bt;\n    default:\n      return [];\n  }\n}\nfunction getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {\n  const alignment = getAlignment(placement);\n  let list = getSideList(getSide(placement), direction === 'start', rtl);\n  if (alignment) {\n    list = list.map(side => side + \"-\" + alignment);\n    if (flipAlignment) {\n      list = list.concat(list.map(getOppositeAlignmentPlacement));\n    }\n  }\n  return list;\n}\nfunction getOppositePlacement(placement) {\n  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);\n}\nfunction expandPaddingObject(padding) {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0,\n    ...padding\n  };\n}\nfunction getPaddingObject(padding) {\n  return typeof padding !== 'number' ? expandPaddingObject(padding) : {\n    top: padding,\n    right: padding,\n    bottom: padding,\n    left: padding\n  };\n}\nfunction rectToClientRect(rect) {\n  const {\n    x,\n    y,\n    width,\n    height\n  } = rect;\n  return {\n    width,\n    height,\n    top: y,\n    left: x,\n    right: x + width,\n    bottom: y + height,\n    x,\n    y\n  };\n}\n\nexport { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };\n"],"names":["hasWindow","window","getNodeName","node","isNode","nodeName","toLowerCase","getWindow","_node$ownerDocument","ownerDocument","defaultView","getDocumentElement","_ref","document","documentElement","value","Node","isElement","Element","isHTMLElement","HTMLElement","isShadowRoot","ShadowRoot","isOverflowElement","element","overflow","overflowX","overflowY","display","getComputedStyle","test","includes","isTableElement","isTopLayer","some","selector","matches","e","isContainingBlock","elementOrCss","webkit","isWebKit","css","transform","perspective","containerType","backdropFilter","filter","willChange","contain","CSS","supports","isLastTraversableNode","getNodeScroll","scrollLeft","scrollTop","scrollX","scrollY","getParentNode","result","assignedSlot","parentNode","host","getNearestOverflowAncestor","body","getOverflowAncestors","list","traverseIframes","_node$ownerDocument2","scrollableAncestor","isBody","win","frameElement","getFrameElement","concat","visualViewport","parent","Object","getPrototypeOf","activeElement","doc","_activeElement","shadowRoot","contains","child","rootNode","getRootNode","next","getPlatform","uaData","navigator","userAgentData","platform","getUserAgent","Array","isArray","brands","map","brand","version","join","userAgent","isVirtualClick","event","mozInputSource","isTrusted","isAndroid","pointerType","type","buttons","detail","isVirtualPointerEvent","width","height","pressure","isSafari","vendor","re","isMac","startsWith","maxTouchPoints","isMouseLikePointerType","strict","values","push","undefined","getDocument","isEventTargetWithin","composedPath","target","getTarget","TYPEABLE_SELECTOR","isTypeableElement","stopEvent","preventDefault","stopPropagation","isTypeableCombobox","getAttribute","getCssDimensions","parseFloat","hasOffset","offsetWidth","offsetHeight","shouldFallback","$","unwrapElement","contextElement","getScale","domElement","rect","getBoundingClientRect","x","y","Number","isFinite","noOffsets","getVisualOffsets","offsetLeft","offsetTop","includeScale","isFixedStrategy","offsetParent","clientRect","scale","visualOffsets","isFixed","floatingOffsetParent","shouldAddVisualOffsets","left","top","offsetWin","currentWin","currentIFrame","iframeScale","iframeRect","clientLeft","paddingLeft","clientTop","paddingTop","getWindowScrollBarX","leftScroll","getHTMLOffset","scroll","ignoreScrollbarX","htmlRect","getClientRectFromClippingAncestor","clippingAncestor","strategy","html","clientWidth","clientHeight","visualViewportBased","getViewportRect","scrollWidth","scrollHeight","direction","getDocumentRect","getInnerBoundingClientRect","hasFixedPositionAncestor","stopNode","position","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsets","offsetRect","htmlOffset","isStaticPositioned","getTrueOffsetParent","polyfill","rawOffsetParent","getOffsetParent","svgOffsetParent","currentNode","getContainingBlock","convertOffsetParentRelativeRectToViewportRelativeRect","elements","topLayer","floating","getClippingRect","boundary","rootBoundary","clippingAncestors","cache","cachedResult","get","el","currentContainingBlockComputedStyle","elementIsFixed","computedStyle","currentNodeIsContaining","ancestor","set","getClippingElementAncestors","this","_c","firstClippingAncestor","clippingRect","reduce","accRect","right","bottom","getElementRects","async","data","getOffsetParentFn","getDimensionsFn","getDimensions","floatingDimensions","reference","getClientRects","from","isRTL","autoUpdate","update","options","ancestorScroll","ancestorResize","elementResize","ResizeObserver","layoutShift","IntersectionObserver","animationFrame","referenceEl","ancestors","forEach","addEventListener","passive","cleanupIo","onMove","timeoutId","io","root","cleanup","_io","clearTimeout","disconnect","refresh","skip","threshold","rootMargin","isFirstUpdate","handleObserve","entries","ratio","intersectionRatio","setTimeout","observe","observeMove","frameId","reobserveFrame","resizeObserver","firstEntry","unobserve","cancelAnimationFrame","requestAnimationFrame","_resizeObserver","prevRefRect","frameLoop","nextRefRect","_resizeObserver2","removeEventListener","detectOverflow","offset","autoPlacement","shift","flip","size","hide","arrow","inline","limitShift","computePosition","Map","mergedOptions","platformWithCache","index","useLayoutEffect","useEffect","deepEqual","a","b","toString","length","i","keys","hasOwnProperty","call","key","$$typeof","getDPR","devicePixelRatio","roundByDPR","dpr","Math","round","useLatestRef","ref","current","arrow$1","name","fn","state","padding","deps","useMergeRefs","refs","every","SafeReact","useSafeInsertionEffect","useInsertionEffect","useEffectEvent","callback","_len","arguments","args","_key","ARROW_UP","ARROW_DOWN","ARROW_LEFT","ARROW_RIGHT","isDifferentRow","cols","prevRow","floor","isIndexOutOfBounds","listRef","getMinIndex","disabledIndices","findNonDisabledIndex","getMaxIndex","decrement","startingIndex","_temp","amount","isDisabled","getGridNavigatedIndex","elementsRef","orientation","loop","rtl","minIndex","maxIndex","prevIndex","stop","nextIndex","col","maxCol","lastRow","buildCellMap","sizes","dense","cellMap","startIndex","_ref2","itemPlaced","targetCells","j","cell","getCellIndexOfCorner","corner","firstCellIndex","indexOf","sizeItem","lastIndexOf","getCellIndices","indices","flatMap","cellIndex","hasAttribute","sortByDocumentPosition","compareDocumentPosition","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_PRECEDING","DOCUMENT_POSITION_CONTAINS","FloatingListContext","register","unregister","FloatingList","props","children","labelsRef","setMap","prevMap","delete","newMap","sort","map1","map2","areMapsEqual","Provider","useListItem","label","index$1","setIndex","componentRef","_node$textContent","isLabelDefined","textContent","renderJsx","render","computedProps","CompositeContext","activeIndex","onNavigate","horizontalKeys","verticalKeys","allKeys","Composite","forwardedRef","externalActiveIndex","externalSetActiveIndex","itemSizes","domProps","internalActiveIndex","internalSetActiveIndex","renderElementProps","contextValue","isGrid","onKeyDown","horizontalEndKey","horizontalStartKey","minGridIndex","findIndex","maxGridIndex","foundIndex","maybeNextIndex","itemIndex","_","toEndKeys","horizontal","vertical","both","toStartKeys","preventedKeys","_elementsRef$current$","focus","handleKeyDown","CompositeItem","mergedRef","isActive","tabIndex","onFocus","_extends","assign","bind","source","prototype","apply","serverHandoffComplete","count","genId","random","slice","useId","id","setId","FloatingArrow","context","placement","middlewareData","tipRadius","strokeWidth","staticOffset","stroke","d","style","restStyle","rest","clipPathId","setIsRTL","side","alignment","split","isVerticalSide","computedStaticOffset","computedStrokeWidth","halfStrokeWidth","svgX","svgY","isCustomShape","yOffsetProp","xOffsetProp","arrowX","arrowY","dValue","rotation","viewBox","pointerEvents","t","clipPath","fill","createPubSub","emit","_map$get","handler","on","listener","off","_map$get2","l","FloatingNodeContext","FloatingTreeContext","useFloatingParentNodeId","_React$useContext","useFloatingTree","useFloatingNodeId","customParentId","tree","reactParentId","parentId","addNode","removeNode","FloatingNode","FloatingTree","nodesRef","n","events","createAttribute","useRef","safePolygonIdentifier","getDelay","prop","useHover","open","onOpenChange","dataRef","enabled","delay","handleClose","mouseOnly","restMs","move","handleCloseRef","delayRef","openRef","pointerTypeRef","timeoutRef","handlerRef","restTimeoutRef","blockMouseMoveRef","performedPointerEventsMutationRef","unbindMouseMoveRef","restTimeoutPendingRef","isHoverOpen","_dataRef$current$open","openEvent","onLeave","closeWithDelay","runElseBranch","reason","closeDelay","cleanupMouseMoveHandler","clearPointerEvents","removeAttribute","isClickLikeOpenEvent","domReference","_elements$floating","onScrollMouseLeave","onMouseEnter","once","onMouseLeave","_elements$floating2","openDelay","floatingContext","clientX","clientY","onClose","relatedTarget","_handleCloseRef$curre","__options","blockPointerEvents","floatingEl","_tree$nodesRef$curren","setAttribute","parentFloating","find","setPointerRef","onPointerDown","onPointerEnter","onMouseMove","nativeEvent","handleMouseMove","movementX","movementY","NOOP","FloatingDelayGroupContext","initialDelay","timeoutMs","currentId","setCurrentId","setState","isInstantPhase","useDelayGroupContext","FloatingDelayGroup","prev","initialCurrentIdRef","useDelayGroup","floatingId","optionId","groupContext","close","unset","timeout","rafId","enqueueFocus","preventScroll","cancelPrevious","sync","exec","getChildren","nodes","allChildren","_node$context","currentChildren","_currentChildren","_node$context2","counterMap","WeakMap","uncontrolledElementsSet","WeakSet","markerMap","lockCount$1","supportsInert","unwrapHost","correctElements","targets","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","getTabbableIn","container","allTabbable","reverse","getNextTabbable","getPreviousTabbable","isOutsideEvent","containerElement","currentTarget","disableFocusInside","dataset","tabindex","enableFocusInside","HIDDEN_STYLES","border","clip","margin","whiteSpace","setActiveElementOnTab","FocusGuard","role","setRole","restProps","PortalContext","useFloatingPortalNode","uniqueId","portalContext","usePortalContext","portalNode","setPortalNode","portalNodeRef","remove","queueMicrotask","existingIdRoot","getElementById","subRoot","createElement","appendChild","idWrapper","FloatingPortal","preserveTabOrder","focusManagerState","setFocusManagerState","beforeOutsideRef","afterOutsideRef","beforeInsideRef","afterInsideRef","modal","shouldRenderGuards","_beforeInsideRef$curr","prevTabbable","_afterInsideRef$curre","nextTabbable","closeOnFocusOut","FOCUSABLE_ATTRIBUTE","getFloatingFocusElement","floatingElement","querySelector","LIST_LIMIT","previouslyFocusedElements","addPreviouslyFocusedElement","isConnected","tabbableEl","tabbableChild","getPreviouslyFocusedElement","VisuallyHiddenDismiss","FloatingFocusManager","disabled","order","guards","_guards","initialFocus","returnFocus","restoreFocus","visuallyHiddenDismiss","nodeId","ignoreInitialFocus","isUntrappedTypeableCombobox","orderRef","initialFocusRef","returnFocusRef","startDismissButtonRef","endDismissButtonRef","preventReturnFocusRef","isPointerDownRef","tabbableIndexRef","isInsidePortal","floatingFocusElement","getTabbableContent","getTabbableElements","content","Boolean","flat","renderDismissButton","location","onClick","els","shiftKey","handleFocusIn","tabbableIndex","handleFocusOutside","handlePointerDown","movedToUnrelatedNode","_nodes$find","allAncestors","currentParentId","getAncestors","_node$context3","_node$context4","prevTabbableIndex","tabbableContent","nodeToFocus","_portalContext$portal","portalNodes","insideElements","previouslyFocusedElement","focusableElements","initialFocusValue","elToFocus","focusAlreadyInsideFloatingEl","preventReturnFocusScroll","nested","fallbackEl","insertAdjacentElement","activeEl","isFocusInsideFloatingTree","_node$context5","returnElement","MutationObserver","handleMutation","observer","childList","subtree","attributes","_portalContext$before","_portalContext$afterO","lockCount","FloatingOverlay","lockScroll","isIOS","bodyStyle","paddingProp","scrollbarWidth","innerWidth","_window$visualViewpor","_window$visualViewpor2","scrollTo","enableScrollLock","isButtonTarget","tagName","isSpaceIgnored","useClick","eventOption","toggle","ignoreMouse","keyboardHandlers","stickIfOpen","didKeyDownRef","onMouseDown","button","defaultPrevented","onKeyUp","isMouseBasedEvent","useClientPoint","axis","initialRef","cleanupListenerRef","setPointerType","reactive","setReactive","setReference","setPositionReference","offsetX","offsetY","isAutoUpdateEvent","_data$dataRef$current","domRect","isXAxis","isYAxis","canTrackCursorOnAutoUpdate","createVirtualElement","handleReferenceEnterOrMove","openCheck","addListener","setPointerTypeRef","bubbleHandlerKeys","pointerdown","mousedown","click","captureHandlerKeys","normalizeProp","normalizable","_normalizable$escapeK","_normalizable$outside","escapeKey","outsidePress","useDismiss","unstable_outsidePress","outsidePressEvent","referencePress","referencePressEvent","bubbles","capture","outsidePressFn","insideReactTreeRef","endedOrStartedInsideRef","escapeKeyBubbles","outsidePressBubbles","escapeKeyCapture","outsidePressCapture","isComposingRef","closeOnEscapeKeyDown","_dataRef$current$floa","shouldDismiss","_child$context","__escapeKeyBubbles","isReactEvent","closeOnEscapeKeyDownCapture","_getTarget2","_getTarget","closeOnPressOutside","_dataRef$current$floa2","insideReactTree","endedOrStartedInside","inertSelector","markers","targetRootAncestor","nextParent","marker","canScrollX","canScrollY","xCond","targetIsInsideChildren","_child$context2","__outsidePressBubbles","closeOnPressOutsideCapture","_getTarget4","_getTarget3","compositionTimeout","onScroll","handleCompositionStart","handleCompositionEnd","_doc$defaultView","onMouseUp","useFloatingRootContext","onOpenChangeProp","elementsProp","positionReference","internalRootContext","rootContext","computedElements","_domReference","setDomReference","_setPositionReference","domReferenceRef","middleware","externalReference","externalFloating","whileElementsMounted","setData","isPositioned","latestMiddleware","setLatestMiddleware","_reference","_setReference","_floating","_setFloating","referenceRef","setFloating","floatingRef","hasWhileElementsMounted","whileElementsMountedRef","platformRef","config","then","fullData","isMountedRef","floatingStyles","initialStyles","useFloating","computedPositionReference","useFocus","visibleOnly","blockFocusRef","keyboardModalityRef","onBlur","Error","movedToFocusGuard","ACTIVE_KEY","SELECTED_KEY","mergeProps","userProps","propsList","elementKey","isItem","domUserProps","__","validProps","propsOrGetProps","acc","val","useInteractions","referenceDeps","floatingDeps","itemDeps","item","getReferenceProps","getFloatingProps","getItemProps","isPreventScrollSupported","doSwitch","isMainOrientationKey","isMainOrientationToEndKey","isCrossOrientationCloseKey","useListNavigation","unstable_onNavigate","selectedIndex","allowEscape","virtual","focusItemOnOpen","focusItemOnHover","openOnArrowKeyDown","scrollItemIntoView","virtualItemRef","floatingFocusElementRef","typeableComboboxReference","focusItemOnOpenRef","indexRef","keyRef","isPointerModalityRef","previousOnNavigateRef","previousMountedRef","previousOpenRef","forceSyncFocus","forceScrollIntoViewRef","disabledIndicesRef","latestOpenRef","scrollItemIntoViewRef","selectedIndexRef","activeId","setActiveId","virtualId","setVirtualId","focusItem","forceScrollIntoView","runFocus","initialItem","waitedItem","scrollIntoViewOptions","scrollIntoView","block","runs","waitForListPopulated","treeContainsActiveEl","handleVirtualFocus","hasActiveIndex","syncCurrentTarget","_ref3","onPointerLeave","_ref4","commonOnKeyDown","which","currentIndex","min","max","ariaActiveDescendantProp","onPointerMove","checkVirtualMouse","isArrowKey","isHomeOrEndKey","isMoveKey","isCrossOpenKey","isCrossOrientationOpenKey","isCrossCloseKey","isMainKey","isNavigationKey","trim","deepestNode","deepestNodeId","maxDepth","findDeepest","depth","getDeepestNode","eventObject","KeyboardEvent","_deepestNode$context","_deepestNode$context2","isCurrentTarget","dispatchItem","dispatchEvent","_deepestNode$context$","componentRoleToAriaRoleMap","useRole","_componentRoleToAriaR","ariaRole","referenceId","isNested","floatingProps","active","selected","commonProps","camelCaseToKebabCase","str","replace","ofs","execWithArgsOrReturn","valueOrFn","useTransitionStatus","duration","closeDuration","status","setStatus","isMounted","durationMs","setIsMounted","useDelayUnmount","frame","useTransitionStyles","initial","unstable_initial","opacity","unstable_open","unstable_close","common","unstable_common","fnArgs","isNumberDuration","openDuration","styles","setStyles","closeRef","commonRef","closeStyles","commonStyles","openStyles","transitionProperty","transitionDuration","useTypeahead","onMatch","unstable_onMatch","onTypingChange","unstable_onTypingChange","findMatch","resetMs","ignoreKeys","timeoutIdRef","stringRef","prevIndexRef","matchIndexRef","findMatchRef","ignoreKeysRef","setTypingChange","typing","getMatchingIndex","orderedList","string","text","toLocaleLowerCase","listContent","ctrlKey","metaKey","altKey","_text$","_text$2","getArgsWithCustomFloatingHeight","rects","inner","overflowRef","onFallbackChange","innerOffset","minItemsVisible","referenceOverflowThreshold","scrollRef","detectOverflowOptions","scrollEl","floatingIsBordered","scrollElIsBordered","floatingIsScrollEl","nextArgs","refOverflow","elementContext","diffY","nextY","maxHeight","v","useInnerOffset","onChange","unstable_onChange","controlledScrollingRef","prevScrollTopRef","initialOverflowRef","onWheel","dY","deltaY","isAtTop","isAtBottom","remainingScroll","sign","method","scrollDiff","isPointInPolygon","point","polygon","isInside","xi","yi","xj","yj","safePolygon","buffer","requireIntent","hasLanded","lastX","lastY","lastCursorTime","performance","now","clientPoint","isLeave","isOverFloatingEl","isOverReferenceEl","refRect","cursorLeaveFromRight","cursorLeaveFromBottom","isOverReferenceRect","isFloatingWider","isFloatingTaller","rectPoly","cursorSpeed","currentTime","elapsedTime","deltaX","distance","sqrt","getCursorSpeed","cursorPointOne","cursorPointTwo","getPolygon","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","freeGlobal","g","freeSelf","self","Function","objectToString","nativeMax","nativeMin","Date","isObject","toNumber","isObjectLike","isSymbol","other","valueOf","isBinary","module","exports","func","wait","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","TypeError","invokeFunc","time","thisArg","shouldInvoke","timeSinceLastCall","timerExpired","trailingEdge","remainingWait","debounced","isInvoking","leadingEdge","cancel","flush","sides","alignments","placements","createCoords","oppositeSideMap","oppositeAlignmentMap","start","end","clamp","evaluate","param","getSide","getAlignment","getOppositeAxis","getAxisLength","getSideAxis","getAlignmentAxis","getAlignmentSides","alignmentAxis","mainAlignmentSide","getOppositePlacement","getExpandedPlacements","oppositePlacement","getOppositeAlignmentPlacement","getOppositeAxisPlacements","flipAlignment","isStart","lr","rl","tb","bt","getSideList","getPaddingObject","expandPaddingObject","rectToClientRect"],"sourceRoot":""}