{"version":3,"file":"static/chunks/4948-5d261729c8f7a3e7.js","mappings":"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","sources":["webpack://_N_E/./node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.esm.js","webpack://_N_E/./node_modules/@floating-ui/react/dist/floating-ui.react.esm.js","webpack://_N_E/./node_modules/@mantine/core/esm/Floating/FloatingArrow/get-arrow-position-styles.js","webpack://_N_E/./node_modules/@mantine/core/esm/Floating/FloatingArrow/FloatingArrow.js","webpack://_N_E/./node_modules/@mantine/core/esm/Floating/get-floating-position/get-floating-position.js","webpack://_N_E/./node_modules/@mantine/core/esm/Floating/use-floating-auto-update.js","webpack://_N_E/./node_modules/@mantine/core/esm/Input/use-input-props.js","webpack://_N_E/./node_modules/@mantine/hooks/esm/use-click-outside/use-click-outside.js","webpack://_N_E/./node_modules/@mantine/core/esm/Popover/use-popover.js","webpack://_N_E/./node_modules/@mantine/core/esm/Popover/Popover.errors.js","webpack://_N_E/./node_modules/@mantine/core/esm/Popover/Popover.context.js","webpack://_N_E/./node_modules/@mantine/core/esm/Popover/PopoverTarget/PopoverTarget.js","webpack://_N_E/./node_modules/@mantine/utils/esm/noop/noop.js","webpack://_N_E/./node_modules/@mantine/utils/esm/close-on-escape/close-on-escape.js","webpack://_N_E/./node_modules/@mantine/core/esm/Popover/PopoverDropdown/PopoverDropdown.styles.js","webpack://_N_E/./node_modules/@mantine/core/esm/FocusTrap/FocusTrap.js","webpack://_N_E/./node_modules/@mantine/core/esm/Popover/PopoverDropdown/PopoverDropdown.js","webpack://_N_E/./node_modules/@mantine/core/esm/Popover/Popover.js","webpack://_N_E/./node_modules/@radix-ui/react-compose-refs/dist/index.module.js","webpack://_N_E/./node_modules/@radix-ui/react-slot/dist/index.module.js","webpack://_N_E/./node_modules/@radix-ui/react-primitive/dist/index.module.js","webpack://_N_E/./node_modules/@radix-ui/react-use-layout-effect/dist/index.module.js","webpack://_N_E/./node_modules/@radix-ui/react-presence/dist/index.module.js","webpack://_N_E/./node_modules/@radix-ui/react-context/dist/index.module.js","webpack://_N_E/./node_modules/@radix-ui/react-use-callback-ref/dist/index.module.js","webpack://_N_E/./node_modules/@radix-ui/react-direction/dist/index.module.js","webpack://_N_E/./node_modules/@radix-ui/primitive/dist/index.module.js","webpack://_N_E/./node_modules/@radix-ui/react-scroll-area/dist/index.module.js","webpack://_N_E/./node_modules/@radix-ui/number/dist/index.module.js","webpack://_N_E/./node_modules/@mantine/core/esm/ScrollArea/ScrollArea.styles.js","webpack://_N_E/./node_modules/@mantine/core/esm/ScrollArea/ScrollArea.js","webpack://_N_E/./node_modules/@mantine/core/esm/Space/Space.js","webpack://_N_E/./node_modules/@mantine/core/esm/TextInput/TextInput.js","webpack://_N_E/./node_modules/@mantine/form/esm/resolvers/zod-resolver/zod-resolver.js","webpack://_N_E/./node_modules/@mantine/utils/esm/is-element/is-element.js","webpack://_N_E/./node_modules/react-error-boundary/dist/react-error-boundary.umd.js","webpack://_N_E/./node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs","webpack://_N_E/./node_modules/@floating-ui/core/dist/floating-ui.core.mjs","webpack://_N_E/./node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs","webpack://_N_E/./node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs"],"sourcesContent":["import { arrow as arrow$1, computePosition } from '@floating-ui/dom';\nexport { autoPlacement, autoUpdate, computePosition, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size } from '@floating-ui/dom';\nimport * as React from 'react';\nimport { useLayoutEffect, useEffect } from 'react';\nimport * as ReactDOM from 'react-dom';\n\n/**\n * A data provider that provides data to position an inner element of the\n * floating element (usually a triangle or caret) so that it is centered to the\n * reference element.\n * This wraps the core `arrow` middleware to allow React refs as the element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => {\n  const {\n    element,\n    padding\n  } = options;\n  function isRef(value) {\n    return Object.prototype.hasOwnProperty.call(value, 'current');\n  }\n  return {\n    name: 'arrow',\n    options,\n    fn(args) {\n      if (isRef(element)) {\n        if (element.current != null) {\n          return arrow$1({\n            element: element.current,\n            padding\n          }).fn(args);\n        }\n        return {};\n      } else if (element) {\n        return arrow$1({\n          element,\n          padding\n        }).fn(args);\n      }\n      return {};\n    }\n  };\n};\n\nvar index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\n\n// Fork of `fast-deep-equal` that only does the comparisons we need and compares\n// functions\nfunction deepEqual(a, b) {\n  if (a === b) {\n    return true;\n  }\n  if (typeof a !== typeof b) {\n    return false;\n  }\n  if (typeof a === 'function' && a.toString() === b.toString()) {\n    return true;\n  }\n  let length, i, keys;\n  if (a && b && typeof a == 'object') {\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;) {\n        if (!deepEqual(a[i], b[i])) {\n          return false;\n        }\n      }\n      return true;\n    }\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) {\n      return false;\n    }\n    for (i = length; i-- !== 0;) {\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) {\n        return false;\n      }\n    }\n    for (i = length; i-- !== 0;) {\n      const key = keys[i];\n      if (key === '_owner' && a.$$typeof) {\n        continue;\n      }\n      if (!deepEqual(a[key], b[key])) {\n        return false;\n      }\n    }\n    return true;\n  }\n  return a !== a && b !== b;\n}\n\nfunction useLatestRef(value) {\n  const ref = React.useRef(value);\n  index(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n\n/**\n * Provides data to position a floating element.\n * @see https://floating-ui.com/docs/react\n */\nfunction useFloating(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform,\n    whileElementsMounted,\n    open\n  } = options;\n  const [data, setData] = React.useState({\n    x: null,\n    y: null,\n    strategy,\n    placement,\n    middlewareData: {},\n    isPositioned: false\n  });\n  const [latestMiddleware, setLatestMiddleware] = React.useState(middleware);\n  if (!deepEqual(latestMiddleware, middleware)) {\n    setLatestMiddleware(middleware);\n  }\n  const referenceRef = React.useRef(null);\n  const floatingRef = React.useRef(null);\n  const dataRef = React.useRef(data);\n  const whileElementsMountedRef = useLatestRef(whileElementsMounted);\n  const platformRef = useLatestRef(platform);\n  const [reference, _setReference] = React.useState(null);\n  const [floating, _setFloating] = React.useState(null);\n  const setReference = React.useCallback(node => {\n    if (referenceRef.current !== node) {\n      referenceRef.current = node;\n      _setReference(node);\n    }\n  }, []);\n  const setFloating = React.useCallback(node => {\n    if (floatingRef.current !== node) {\n      floatingRef.current = node;\n      _setFloating(node);\n    }\n  }, []);\n  const update = React.useCallback(() => {\n    if (!referenceRef.current || !floatingRef.current) {\n      return;\n    }\n    const config = {\n      placement,\n      strategy,\n      middleware: latestMiddleware\n    };\n    if (platformRef.current) {\n      config.platform = platformRef.current;\n    }\n    computePosition(referenceRef.current, floatingRef.current, config).then(data => {\n      const fullData = {\n        ...data,\n        isPositioned: true\n      };\n      if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {\n        dataRef.current = fullData;\n        ReactDOM.flushSync(() => {\n          setData(fullData);\n        });\n      }\n    });\n  }, [latestMiddleware, placement, strategy, platformRef]);\n  index(() => {\n    if (open === false && dataRef.current.isPositioned) {\n      dataRef.current.isPositioned = false;\n      setData(data => ({\n        ...data,\n        isPositioned: false\n      }));\n    }\n  }, [open]);\n  const isMountedRef = React.useRef(false);\n  index(() => {\n    isMountedRef.current = true;\n    return () => {\n      isMountedRef.current = false;\n    };\n  }, []);\n  index(() => {\n    if (reference && floating) {\n      if (whileElementsMountedRef.current) {\n        return whileElementsMountedRef.current(reference, floating, update);\n      } else {\n        update();\n      }\n    }\n  }, [reference, floating, update, whileElementsMountedRef]);\n  const refs = React.useMemo(() => ({\n    reference: referenceRef,\n    floating: floatingRef,\n    setReference,\n    setFloating\n  }), [setReference, setFloating]);\n  const elements = React.useMemo(() => ({\n    reference,\n    floating\n  }), [reference, floating]);\n  return React.useMemo(() => ({\n    ...data,\n    update,\n    refs,\n    elements,\n    reference: setReference,\n    floating: setFloating\n  }), [data, update, refs, elements, setReference, setFloating]);\n}\n\nexport { arrow, useFloating };\n","import * as React from 'react';\nimport { useLayoutEffect, useEffect, useRef } from 'react';\nimport { hideOthers } from 'aria-hidden';\nimport { tabbable } from 'tabbable';\nimport { createPortal, flushSync } from 'react-dom';\nimport { getOverflowAncestors, offset, detectOverflow, useFloating as useFloating$1 } from '@floating-ui/react-dom';\nexport { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size } from '@floating-ui/react-dom';\n\nvar index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\n\nlet serverHandoffComplete = false;\nlet count = 0;\nconst genId = () => \"floating-ui-\" + count++;\nfunction useFloatingId() {\n  const [id, setId] = React.useState(() => serverHandoffComplete ? genId() : undefined);\n  index(() => {\n    if (id == null) {\n      setId(genId());\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n  React.useEffect(() => {\n    if (!serverHandoffComplete) {\n      serverHandoffComplete = true;\n    }\n  }, []);\n  return id;\n}\n\n// `toString()` prevents bundlers from trying to `import { useId } from 'react'`\nconst useReactId = React[/*#__PURE__*/'useId'.toString()];\n\n/**\n * Uses React 18's built-in `useId()` when available, or falls back to a\n * slightly less performant (requiring a double render) implementation for\n * earlier React versions.\n * @see https://floating-ui.com/docs/useId\n */\nconst useId = useReactId || useFloatingId;\n\nfunction createPubSub() {\n  const map = new Map();\n  return {\n    emit(event, data) {\n      var _map$get;\n      (_map$get = map.get(event)) == null ? void 0 : _map$get.forEach(handler => handler(data));\n    },\n    on(event, listener) {\n      map.set(event, [...(map.get(event) || []), listener]);\n    },\n    off(event, listener) {\n      map.set(event, (map.get(event) || []).filter(l => l !== listener));\n    }\n  };\n}\n\nconst FloatingNodeContext = /*#__PURE__*/React.createContext(null);\nconst FloatingTreeContext = /*#__PURE__*/React.createContext(null);\nconst useFloatingParentNodeId = () => {\n  var _React$useContext;\n  return ((_React$useContext = React.useContext(FloatingNodeContext)) == null ? void 0 : _React$useContext.id) || null;\n};\nconst useFloatingTree = () => React.useContext(FloatingTreeContext);\n\n/**\n * Registers a node into the floating tree, returning its id.\n */\nconst useFloatingNodeId = customParentId => {\n  const id = useId();\n  const tree = useFloatingTree();\n  const reactParentId = useFloatingParentNodeId();\n  const parentId = customParentId || reactParentId;\n  index(() => {\n    const node = {\n      id,\n      parentId\n    };\n    tree == null ? void 0 : tree.addNode(node);\n    return () => {\n      tree == null ? void 0 : tree.removeNode(node);\n    };\n  }, [tree, id, parentId]);\n  return id;\n};\n\n/**\n * Provides parent node context for nested floating elements.\n * @see https://floating-ui.com/docs/FloatingTree\n */\nconst FloatingNode = _ref => {\n  let {\n    children,\n    id\n  } = _ref;\n  const parentId = useFloatingParentNodeId();\n  return /*#__PURE__*/React.createElement(FloatingNodeContext.Provider, {\n    value: React.useMemo(() => ({\n      id,\n      parentId\n    }), [id, parentId])\n  }, children);\n};\n\n/**\n * Provides context for nested floating elements when they are not children of\n * each other on the DOM (i.e. portalled to a common node, rather than their\n * respective parent).\n * @see https://floating-ui.com/docs/FloatingTree\n */\nconst FloatingTree = _ref2 => {\n  let {\n    children\n  } = _ref2;\n  const nodesRef = React.useRef([]);\n  const addNode = React.useCallback(node => {\n    nodesRef.current = [...nodesRef.current, node];\n  }, []);\n  const removeNode = React.useCallback(node => {\n    nodesRef.current = nodesRef.current.filter(n => n !== node);\n  }, []);\n  const events = React.useState(() => createPubSub())[0];\n  return /*#__PURE__*/React.createElement(FloatingTreeContext.Provider, {\n    value: React.useMemo(() => ({\n      nodesRef,\n      addNode,\n      removeNode,\n      events\n    }), [nodesRef, addNode, removeNode, events])\n  }, children);\n};\n\nfunction getDocument(node) {\n  return (node == null ? void 0 : node.ownerDocument) || document;\n}\n\n// Avoid Chrome DevTools blue warning.\nfunction getPlatform() {\n  const uaData = navigator.userAgentData;\n  if (uaData != null && uaData.platform) {\n    return uaData.platform;\n  }\n  return navigator.platform;\n}\nfunction getUserAgent() {\n  const uaData = navigator.userAgentData;\n  if (uaData && Array.isArray(uaData.brands)) {\n    return uaData.brands.map(_ref => {\n      let {\n        brand,\n        version\n      } = _ref;\n      return brand + \"/\" + version;\n    }).join(' ');\n  }\n  return navigator.userAgent;\n}\n\nfunction getWindow(value) {\n  return getDocument(value).defaultView || window;\n}\nfunction isElement(value) {\n  return value ? value instanceof getWindow(value).Element : false;\n}\nfunction isHTMLElement(value) {\n  return value ? value instanceof getWindow(value).HTMLElement : false;\n}\nfunction isShadowRoot(node) {\n  // Browsers without `ShadowRoot` support\n  if (typeof ShadowRoot === 'undefined') {\n    return false;\n  }\n  const OwnElement = getWindow(node).ShadowRoot;\n  return node instanceof OwnElement || node instanceof ShadowRoot;\n}\n\n// License: https://github.com/adobe/react-spectrum/blob/b35d5c02fe900badccd0cf1a8f23bb593419f238/packages/@react-aria/utils/src/isVirtualEvent.ts\nfunction isVirtualClick(event) {\n  if (event.mozInputSource === 0 && event.isTrusted) {\n    return true;\n  }\n  const androidRe = /Android/i;\n  if ((androidRe.test(getPlatform()) || androidRe.test(getUserAgent())) && event.pointerType) {\n    return event.type === 'click' && event.buttons === 1;\n  }\n  return event.detail === 0 && !event.pointerType;\n}\nfunction isVirtualPointerEvent(event) {\n  return event.width === 0 && event.height === 0 || event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType !== 'mouse' ||\n  // iOS VoiceOver returns 0.333• for width/height.\n  event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0;\n}\nfunction isSafari() {\n  // Chrome DevTools does not complain about navigator.vendor\n  return /apple/i.test(navigator.vendor);\n}\nfunction isMac() {\n  return getPlatform().toLowerCase().startsWith('mac') && !navigator.maxTouchPoints;\n}\nfunction isMouseLikePointerType(pointerType, strict) {\n  // On some Linux machines with Chromium, mouse inputs return a `pointerType`\n  // of \"pen\": https://github.com/floating-ui/floating-ui/issues/2015\n  const values = ['mouse', 'pen'];\n  if (!strict) {\n    values.push('', undefined);\n  }\n  return values.includes(pointerType);\n}\n\nfunction useLatestRef(value) {\n  const ref = useRef(value);\n  index(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n\nconst safePolygonIdentifier = 'data-floating-ui-safe-polygon';\nfunction getDelay(value, prop, pointerType) {\n  if (pointerType && !isMouseLikePointerType(pointerType)) {\n    return 0;\n  }\n  if (typeof value === 'number') {\n    return value;\n  }\n  return value == null ? void 0 : value[prop];\n}\n/**\n * Opens the floating element while hovering over the reference element, like\n * CSS `:hover`.\n * @see https://floating-ui.com/docs/useHover\n */\nconst useHover = function (context, _temp) {\n  let {\n    enabled = true,\n    delay = 0,\n    handleClose = null,\n    mouseOnly = false,\n    restMs = 0,\n    move = true\n  } = _temp === void 0 ? {} : _temp;\n  const {\n    open,\n    onOpenChange,\n    dataRef,\n    events,\n    elements: {\n      domReference,\n      floating\n    },\n    refs\n  } = context;\n  const tree = useFloatingTree();\n  const parentId = useFloatingParentNodeId();\n  const handleCloseRef = useLatestRef(handleClose);\n  const delayRef = useLatestRef(delay);\n  const pointerTypeRef = React.useRef();\n  const timeoutRef = React.useRef();\n  const handlerRef = React.useRef();\n  const restTimeoutRef = React.useRef();\n  const blockMouseMoveRef = React.useRef(true);\n  const performedPointerEventsMutationRef = React.useRef(false);\n  const unbindMouseMoveRef = React.useRef(() => {});\n  const isHoverOpen = React.useCallback(() => {\n    var _dataRef$current$open;\n    const type = (_dataRef$current$open = dataRef.current.openEvent) == null ? void 0 : _dataRef$current$open.type;\n    return (type == null ? void 0 : type.includes('mouse')) && type !== 'mousedown';\n  }, [dataRef]);\n\n  // When dismissing before opening, clear the delay timeouts to cancel it\n  // from showing.\n  React.useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n    function onDismiss() {\n      clearTimeout(timeoutRef.current);\n      clearTimeout(restTimeoutRef.current);\n      blockMouseMoveRef.current = true;\n    }\n    events.on('dismiss', onDismiss);\n    return () => {\n      events.off('dismiss', onDismiss);\n    };\n  }, [enabled, events]);\n  React.useEffect(() => {\n    if (!enabled || !handleCloseRef.current || !open) {\n      return;\n    }\n    function onLeave() {\n      if (isHoverOpen()) {\n        onOpenChange(false);\n      }\n    }\n    const html = getDocument(floating).documentElement;\n    html.addEventListener('mouseleave', onLeave);\n    return () => {\n      html.removeEventListener('mouseleave', onLeave);\n    };\n  }, [floating, open, onOpenChange, enabled, handleCloseRef, dataRef, isHoverOpen]);\n  const closeWithDelay = React.useCallback(function (runElseBranch) {\n    if (runElseBranch === void 0) {\n      runElseBranch = true;\n    }\n    const closeDelay = getDelay(delayRef.current, 'close', pointerTypeRef.current);\n    if (closeDelay && !handlerRef.current) {\n      clearTimeout(timeoutRef.current);\n      timeoutRef.current = setTimeout(() => onOpenChange(false), closeDelay);\n    } else if (runElseBranch) {\n      clearTimeout(timeoutRef.current);\n      onOpenChange(false);\n    }\n  }, [delayRef, onOpenChange]);\n  const cleanupMouseMoveHandler = React.useCallback(() => {\n    unbindMouseMoveRef.current();\n    handlerRef.current = undefined;\n  }, []);\n  const clearPointerEvents = React.useCallback(() => {\n    if (performedPointerEventsMutationRef.current) {\n      const body = getDocument(refs.floating.current).body;\n      body.style.pointerEvents = '';\n      body.removeAttribute(safePolygonIdentifier);\n      performedPointerEventsMutationRef.current = false;\n    }\n  }, [refs]);\n\n  // Registering the mouse events on the reference directly to bypass React's\n  // delegation system. If the cursor was on a disabled element and then entered\n  // the reference (no gap), `mouseenter` doesn't fire in the delegation system.\n  React.useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n    function isClickLikeOpenEvent() {\n      return dataRef.current.openEvent ? ['click', 'mousedown'].includes(dataRef.current.openEvent.type) : false;\n    }\n    function onMouseEnter(event) {\n      clearTimeout(timeoutRef.current);\n      blockMouseMoveRef.current = false;\n      if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current) || restMs > 0 && getDelay(delayRef.current, 'open') === 0) {\n        return;\n      }\n      dataRef.current.openEvent = event;\n      const openDelay = getDelay(delayRef.current, 'open', pointerTypeRef.current);\n      if (openDelay) {\n        timeoutRef.current = setTimeout(() => {\n          onOpenChange(true);\n        }, openDelay);\n      } else {\n        onOpenChange(true);\n      }\n    }\n    function onMouseLeave(event) {\n      if (isClickLikeOpenEvent()) {\n        return;\n      }\n      unbindMouseMoveRef.current();\n      const doc = getDocument(floating);\n      clearTimeout(restTimeoutRef.current);\n      if (handleCloseRef.current) {\n        // Prevent clearing `onScrollMouseLeave` timeout.\n        if (!open) {\n          clearTimeout(timeoutRef.current);\n        }\n        handlerRef.current = handleCloseRef.current({\n          ...context,\n          tree,\n          x: event.clientX,\n          y: event.clientY,\n          onClose() {\n            clearPointerEvents();\n            cleanupMouseMoveHandler();\n            closeWithDelay();\n          }\n        });\n        const handler = handlerRef.current;\n        doc.addEventListener('mousemove', handler);\n        unbindMouseMoveRef.current = () => {\n          doc.removeEventListener('mousemove', handler);\n        };\n        return;\n      }\n      closeWithDelay();\n    }\n\n    // Ensure the floating element closes after scrolling even if the pointer\n    // did not move.\n    // https://github.com/floating-ui/floating-ui/discussions/1692\n    function onScrollMouseLeave(event) {\n      if (isClickLikeOpenEvent()) {\n        return;\n      }\n      handleCloseRef.current == null ? void 0 : handleCloseRef.current({\n        ...context,\n        tree,\n        x: event.clientX,\n        y: event.clientY,\n        onClose() {\n          clearPointerEvents();\n          cleanupMouseMoveHandler();\n          closeWithDelay();\n        }\n      })(event);\n    }\n    if (isElement(domReference)) {\n      const ref = domReference;\n      open && ref.addEventListener('mouseleave', onScrollMouseLeave);\n      floating == null ? void 0 : floating.addEventListener('mouseleave', onScrollMouseLeave);\n      move && ref.addEventListener('mousemove', onMouseEnter, {\n        once: true\n      });\n      ref.addEventListener('mouseenter', onMouseEnter);\n      ref.addEventListener('mouseleave', onMouseLeave);\n      return () => {\n        open && ref.removeEventListener('mouseleave', onScrollMouseLeave);\n        floating == null ? void 0 : floating.removeEventListener('mouseleave', onScrollMouseLeave);\n        move && ref.removeEventListener('mousemove', onMouseEnter);\n        ref.removeEventListener('mouseenter', onMouseEnter);\n        ref.removeEventListener('mouseleave', onMouseLeave);\n      };\n    }\n  }, [domReference, floating, enabled, context, mouseOnly, restMs, move, closeWithDelay, cleanupMouseMoveHandler, clearPointerEvents, onOpenChange, open, tree, delayRef, handleCloseRef, dataRef]);\n\n  // Block pointer-events of every element other than the reference and floating\n  // while the floating element is open and has a `handleClose` handler. Also\n  // handles nested floating elements.\n  // https://github.com/floating-ui/floating-ui/issues/1722\n  index(() => {\n    var _handleCloseRef$curre;\n    if (!enabled) {\n      return;\n    }\n    if (open && (_handleCloseRef$curre = handleCloseRef.current) != null && _handleCloseRef$curre.__options.blockPointerEvents && isHoverOpen()) {\n      const body = getDocument(floating).body;\n      body.setAttribute(safePolygonIdentifier, '');\n      body.style.pointerEvents = 'none';\n      performedPointerEventsMutationRef.current = true;\n      if (isElement(domReference) && floating) {\n        var _tree$nodesRef$curren, _tree$nodesRef$curren2;\n        const ref = domReference;\n        const parentFloating = tree == null ? void 0 : (_tree$nodesRef$curren = tree.nodesRef.current.find(node => node.id === parentId)) == null ? void 0 : (_tree$nodesRef$curren2 = _tree$nodesRef$curren.context) == null ? void 0 : _tree$nodesRef$curren2.elements.floating;\n        if (parentFloating) {\n          parentFloating.style.pointerEvents = '';\n        }\n        ref.style.pointerEvents = 'auto';\n        floating.style.pointerEvents = 'auto';\n        return () => {\n          ref.style.pointerEvents = '';\n          floating.style.pointerEvents = '';\n        };\n      }\n    }\n  }, [enabled, open, parentId, floating, domReference, tree, handleCloseRef, dataRef, isHoverOpen]);\n  index(() => {\n    if (!open) {\n      pointerTypeRef.current = undefined;\n      cleanupMouseMoveHandler();\n      clearPointerEvents();\n    }\n  }, [open, cleanupMouseMoveHandler, clearPointerEvents]);\n  React.useEffect(() => {\n    return () => {\n      cleanupMouseMoveHandler();\n      clearTimeout(timeoutRef.current);\n      clearTimeout(restTimeoutRef.current);\n      clearPointerEvents();\n    };\n  }, [enabled, cleanupMouseMoveHandler, clearPointerEvents]);\n  return React.useMemo(() => {\n    if (!enabled) {\n      return {};\n    }\n    function setPointerRef(event) {\n      pointerTypeRef.current = event.pointerType;\n    }\n    return {\n      reference: {\n        onPointerDown: setPointerRef,\n        onPointerEnter: setPointerRef,\n        onMouseMove() {\n          if (open || restMs === 0) {\n            return;\n          }\n          clearTimeout(restTimeoutRef.current);\n          restTimeoutRef.current = setTimeout(() => {\n            if (!blockMouseMoveRef.current) {\n              onOpenChange(true);\n            }\n          }, restMs);\n        }\n      },\n      floating: {\n        onMouseEnter() {\n          clearTimeout(timeoutRef.current);\n        },\n        onMouseLeave() {\n          events.emit('dismiss', {\n            type: 'mouseLeave',\n            data: {\n              returnFocus: false\n            }\n          });\n          closeWithDelay(false);\n        }\n      }\n    };\n  }, [events, enabled, restMs, open, onOpenChange, closeWithDelay]);\n};\n\nconst FloatingDelayGroupContext = /*#__PURE__*/React.createContext({\n  delay: 0,\n  initialDelay: 0,\n  timeoutMs: 0,\n  currentId: null,\n  setCurrentId: () => {},\n  setState: () => {},\n  isInstantPhase: false\n});\nconst useDelayGroupContext = () => React.useContext(FloatingDelayGroupContext);\n\n/**\n * Provides context for a group of floating elements that should share a\n * `delay`.\n * @see https://floating-ui.com/docs/FloatingDelayGroup\n */\nconst FloatingDelayGroup = _ref => {\n  let {\n    children,\n    delay,\n    timeoutMs = 0\n  } = _ref;\n  const [state, setState] = React.useReducer((prev, next) => ({\n    ...prev,\n    ...next\n  }), {\n    delay,\n    timeoutMs,\n    initialDelay: delay,\n    currentId: null,\n    isInstantPhase: false\n  });\n  const initialCurrentIdRef = React.useRef(null);\n  const setCurrentId = React.useCallback(currentId => {\n    setState({\n      currentId\n    });\n  }, []);\n  index(() => {\n    if (state.currentId) {\n      if (initialCurrentIdRef.current === null) {\n        initialCurrentIdRef.current = state.currentId;\n      } else {\n        setState({\n          isInstantPhase: true\n        });\n      }\n    } else {\n      setState({\n        isInstantPhase: false\n      });\n      initialCurrentIdRef.current = null;\n    }\n  }, [state.currentId]);\n  return /*#__PURE__*/React.createElement(FloatingDelayGroupContext.Provider, {\n    value: React.useMemo(() => ({\n      ...state,\n      setState,\n      setCurrentId\n    }), [state, setState, setCurrentId])\n  }, children);\n};\nconst useDelayGroup = (_ref2, _ref3) => {\n  let {\n    open,\n    onOpenChange\n  } = _ref2;\n  let {\n    id\n  } = _ref3;\n  const {\n    currentId,\n    setCurrentId,\n    initialDelay,\n    setState,\n    timeoutMs\n  } = useDelayGroupContext();\n  React.useEffect(() => {\n    if (currentId) {\n      setState({\n        delay: {\n          open: 1,\n          close: getDelay(initialDelay, 'close')\n        }\n      });\n      if (currentId !== id) {\n        onOpenChange(false);\n      }\n    }\n  }, [id, onOpenChange, setState, currentId, initialDelay]);\n  React.useEffect(() => {\n    function unset() {\n      onOpenChange(false);\n      setState({\n        delay: initialDelay,\n        currentId: null\n      });\n    }\n    if (!open && currentId === id) {\n      if (timeoutMs) {\n        const timeout = window.setTimeout(unset, timeoutMs);\n        return () => {\n          clearTimeout(timeout);\n        };\n      } else {\n        unset();\n      }\n    }\n  }, [open, setState, currentId, id, onOpenChange, initialDelay, timeoutMs]);\n  React.useEffect(() => {\n    if (open) {\n      setCurrentId(id);\n    }\n  }, [open, setCurrentId, id]);\n};\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\n/**\n * Find the real active element. Traverses into shadowRoots.\n */\nfunction activeElement$1(doc) {\n  let activeElement = doc.activeElement;\n  while (((_activeElement = activeElement) == null ? void 0 : (_activeElement$shadow = _activeElement.shadowRoot) == null ? void 0 : _activeElement$shadow.activeElement) != null) {\n    var _activeElement, _activeElement$shadow;\n    activeElement = activeElement.shadowRoot.activeElement;\n  }\n  return activeElement;\n}\n\nfunction contains(parent, child) {\n  if (!parent || !child) {\n    return false;\n  }\n  const rootNode = child.getRootNode && child.getRootNode();\n\n  // First, attempt with faster native method\n  if (parent.contains(child)) {\n    return true;\n  }\n  // then fallback to custom implementation with Shadow DOM support\n  else if (rootNode && isShadowRoot(rootNode)) {\n    let next = child;\n    do {\n      if (next && parent === next) {\n        return true;\n      }\n      // @ts-ignore\n      next = next.parentNode || next.host;\n    } while (next);\n  }\n\n  // Give up, the result is false\n  return false;\n}\n\nlet rafId = 0;\nfunction enqueueFocus(el, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    preventScroll = false,\n    cancelPrevious = true,\n    sync = false\n  } = options;\n  cancelPrevious && cancelAnimationFrame(rafId);\n  const exec = () => el == null ? void 0 : el.focus({\n    preventScroll\n  });\n  if (sync) {\n    exec();\n  } else {\n    rafId = requestAnimationFrame(exec);\n  }\n}\n\nfunction getAncestors(nodes, id) {\n  var _nodes$find;\n  let allAncestors = [];\n  let currentParentId = (_nodes$find = nodes.find(node => node.id === id)) == null ? void 0 : _nodes$find.parentId;\n  while (currentParentId) {\n    const currentNode = nodes.find(node => node.id === currentParentId);\n    currentParentId = currentNode == null ? void 0 : currentNode.parentId;\n    if (currentNode) {\n      allAncestors = allAncestors.concat(currentNode);\n    }\n  }\n  return allAncestors;\n}\n\nfunction getChildren(nodes, id) {\n  let allChildren = nodes.filter(node => {\n    var _node$context;\n    return node.parentId === id && ((_node$context = node.context) == null ? void 0 : _node$context.open);\n  }) || [];\n  let currentChildren = allChildren;\n  while (currentChildren.length) {\n    currentChildren = nodes.filter(node => {\n      var _currentChildren;\n      return (_currentChildren = currentChildren) == null ? void 0 : _currentChildren.some(n => {\n        var _node$context2;\n        return node.parentId === n.id && ((_node$context2 = node.context) == null ? void 0 : _node$context2.open);\n      });\n    }) || [];\n    allChildren = allChildren.concat(currentChildren);\n  }\n  return allChildren;\n}\n\nfunction getTarget(event) {\n  if ('composedPath' in event) {\n    return event.composedPath()[0];\n  }\n\n  // TS thinks `event` is of type never as it assumes all browsers support\n  // `composedPath()`, but browsers without shadow DOM don't.\n  return event.target;\n}\n\nconst TYPEABLE_SELECTOR = \"input:not([type='hidden']):not([disabled]),\" + \"[contenteditable]:not([contenteditable='false']),textarea:not([disabled])\";\nfunction isTypeableElement(element) {\n  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);\n}\n\nfunction stopEvent(event) {\n  event.preventDefault();\n  event.stopPropagation();\n}\n\nconst getTabbableOptions = () => ({\n  getShadowRoot: true,\n  displayCheck:\n  // JSDOM does not support the `tabbable` library. To solve this we can\n  // check if `ResizeObserver` is a real function (not polyfilled), which\n  // determines if the current environment is JSDOM-like.\n  typeof ResizeObserver === 'function' && ResizeObserver.toString().includes('[native code]') ? 'full' : 'none'\n});\nfunction getTabbableIn(container, direction) {\n  const allTabbable = tabbable(container, getTabbableOptions());\n  if (direction === 'prev') {\n    allTabbable.reverse();\n  }\n  const activeIndex = allTabbable.indexOf(activeElement$1(getDocument(container)));\n  const nextTabbableElements = allTabbable.slice(activeIndex + 1);\n  return nextTabbableElements[0];\n}\nfunction getNextTabbable() {\n  return getTabbableIn(document.body, 'next');\n}\nfunction getPreviousTabbable() {\n  return getTabbableIn(document.body, 'prev');\n}\nfunction isOutsideEvent(event, container) {\n  const containerElement = container || event.currentTarget;\n  const relatedTarget = event.relatedTarget;\n  return !relatedTarget || !contains(containerElement, relatedTarget);\n}\nfunction disableFocusInside(container) {\n  const tabbableElements = tabbable(container, getTabbableOptions());\n  tabbableElements.forEach(element => {\n    element.dataset.tabindex = element.getAttribute('tabindex') || '';\n    element.setAttribute('tabindex', '-1');\n  });\n}\nfunction enableFocusInside(container) {\n  const elements = container.querySelectorAll('[data-tabindex]');\n  elements.forEach(element => {\n    const tabindex = element.dataset.tabindex;\n    delete element.dataset.tabindex;\n    if (tabindex) {\n      element.setAttribute('tabindex', tabindex);\n    } else {\n      element.removeAttribute('tabindex');\n    }\n  });\n}\n\n// `toString()` prevents bundlers from trying to `import { useInsertionEffect } from 'react'`\nconst useInsertionEffect = React[/*#__PURE__*/'useInsertionEffect'.toString()];\nconst useSafeInsertionEffect = useInsertionEffect || (fn => fn());\nfunction useEvent(callback) {\n  const ref = React.useRef(() => {\n    if (process.env.NODE_ENV !== \"production\") {\n      throw new Error('Cannot call an event handler while rendering.');\n    }\n  });\n  useSafeInsertionEffect(() => {\n    ref.current = callback;\n  });\n  return React.useCallback(function () {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n    return ref.current == null ? void 0 : ref.current(...args);\n  }, []);\n}\n\n// See Diego Haz's Sandbox for making this logic work well on Safari/iOS:\n// https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/FocusTrap.tsx\n\nconst HIDDEN_STYLES = {\n  border: 0,\n  clip: 'rect(0 0 0 0)',\n  height: '1px',\n  margin: '-1px',\n  overflow: 'hidden',\n  padding: 0,\n  position: 'fixed',\n  whiteSpace: 'nowrap',\n  width: '1px',\n  top: 0,\n  left: 0\n};\nlet activeElement;\nlet timeoutId;\nfunction setActiveElementOnTab(event) {\n  if (event.key === 'Tab') {\n    activeElement = event.target;\n    clearTimeout(timeoutId);\n  }\n}\nfunction isTabFocus(event) {\n  const result = activeElement === event.relatedTarget;\n  activeElement = event.relatedTarget;\n  clearTimeout(timeoutId);\n  return result;\n}\nconst FocusGuard = /*#__PURE__*/React.forwardRef(function FocusGuard(props, ref) {\n  const onFocus = useEvent(props.onFocus);\n  const [role, setRole] = React.useState();\n  index(() => {\n    if (isSafari()) {\n      // Unlike other screen readers such as NVDA and JAWS, the virtual cursor\n      // on VoiceOver does trigger the onFocus event, so we can use the focus\n      // trap element. On Safari, only buttons trigger the onFocus event.\n      // NB: \"group\" role in the Sandbox no longer appears to work, must be a\n      // button role.\n      setRole('button');\n    }\n    document.addEventListener('keydown', setActiveElementOnTab);\n    return () => {\n      document.removeEventListener('keydown', setActiveElementOnTab);\n    };\n  }, []);\n  return /*#__PURE__*/React.createElement(\"span\", _extends({}, props, {\n    ref: ref,\n    tabIndex: 0\n    // Role is only for VoiceOver\n    ,\n    role: role,\n    \"aria-hidden\": role ? undefined : true,\n    \"data-floating-ui-focus-guard\": \"\",\n    style: HIDDEN_STYLES,\n    onFocus: event => {\n      if (isSafari() && isMac() && !isTabFocus(event)) {\n        // On macOS we need to wait a little bit before moving\n        // focus again.\n        event.persist();\n        timeoutId = window.setTimeout(() => {\n          onFocus(event);\n        }, 50);\n      } else {\n        onFocus(event);\n      }\n    }\n  }));\n});\n\nconst PortalContext = /*#__PURE__*/React.createContext(null);\nconst useFloatingPortalNode = function (_temp) {\n  let {\n    id,\n    enabled = true\n  } = _temp === void 0 ? {} : _temp;\n  const [portalEl, setPortalEl] = React.useState(null);\n  const uniqueId = useId();\n  const portalContext = usePortalContext();\n  index(() => {\n    if (!enabled) {\n      return;\n    }\n    const rootNode = id ? document.getElementById(id) : null;\n    if (rootNode) {\n      rootNode.setAttribute('data-floating-ui-portal', '');\n      setPortalEl(rootNode);\n    } else {\n      const newPortalEl = document.createElement('div');\n      if (id !== '') {\n        newPortalEl.id = id || uniqueId;\n      }\n      newPortalEl.setAttribute('data-floating-ui-portal', '');\n      setPortalEl(newPortalEl);\n      const container = (portalContext == null ? void 0 : portalContext.portalNode) || document.body;\n      container.appendChild(newPortalEl);\n      return () => {\n        container.removeChild(newPortalEl);\n      };\n    }\n  }, [id, portalContext, uniqueId, enabled]);\n  return portalEl;\n};\n\n/**\n * Portals the floating element into a given container element — by default,\n * outside of the app root and into the body.\n * @see https://floating-ui.com/docs/FloatingPortal\n */\nconst FloatingPortal = _ref => {\n  let {\n    children,\n    id,\n    root = null,\n    preserveTabOrder = true\n  } = _ref;\n  const portalNode = useFloatingPortalNode({\n    id,\n    enabled: !root\n  });\n  const [focusManagerState, setFocusManagerState] = React.useState(null);\n  const beforeOutsideRef = React.useRef(null);\n  const afterOutsideRef = React.useRef(null);\n  const beforeInsideRef = React.useRef(null);\n  const afterInsideRef = React.useRef(null);\n  const shouldRenderGuards =\n  // The FocusManager and therefore floating element are currently open/\n  // rendered.\n  !!focusManagerState &&\n  // Guards are only for non-modal focus management.\n  !focusManagerState.modal && !!(root || portalNode) && preserveTabOrder;\n\n  // https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/TabbablePortal.tsx\n  React.useEffect(() => {\n    if (!portalNode || !preserveTabOrder || focusManagerState != null && focusManagerState.modal) {\n      return;\n    }\n\n    // Make sure elements inside the portal element are tabbable only when the\n    // portal has already been focused, either by tabbing into a focus trap\n    // element outside or using the mouse.\n    function onFocus(event) {\n      if (portalNode && isOutsideEvent(event)) {\n        const focusing = event.type === 'focusin';\n        const manageFocus = focusing ? enableFocusInside : disableFocusInside;\n        manageFocus(portalNode);\n      }\n    }\n    // Listen to the event on the capture phase so they run before the focus\n    // trap elements onFocus prop is called.\n    portalNode.addEventListener('focusin', onFocus, true);\n    portalNode.addEventListener('focusout', onFocus, true);\n    return () => {\n      portalNode.removeEventListener('focusin', onFocus, true);\n      portalNode.removeEventListener('focusout', onFocus, true);\n    };\n  }, [portalNode, preserveTabOrder, focusManagerState == null ? void 0 : focusManagerState.modal]);\n  return /*#__PURE__*/React.createElement(PortalContext.Provider, {\n    value: React.useMemo(() => ({\n      preserveTabOrder,\n      beforeOutsideRef,\n      afterOutsideRef,\n      beforeInsideRef,\n      afterInsideRef,\n      portalNode,\n      setFocusManagerState\n    }), [preserveTabOrder, portalNode])\n  }, shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"outside\",\n    ref: beforeOutsideRef,\n    onFocus: event => {\n      if (isOutsideEvent(event, portalNode)) {\n        var _beforeInsideRef$curr;\n        (_beforeInsideRef$curr = beforeInsideRef.current) == null ? void 0 : _beforeInsideRef$curr.focus();\n      } else {\n        const prevTabbable = getPreviousTabbable() || (focusManagerState == null ? void 0 : focusManagerState.refs.domReference.current);\n        prevTabbable == null ? void 0 : prevTabbable.focus();\n      }\n    }\n  }), shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(\"span\", {\n    \"aria-owns\": portalNode.id,\n    style: HIDDEN_STYLES\n  }), root ? /*#__PURE__*/createPortal(children, root) : portalNode ? /*#__PURE__*/createPortal(children, portalNode) : null, shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"outside\",\n    ref: afterOutsideRef,\n    onFocus: event => {\n      if (isOutsideEvent(event, portalNode)) {\n        var _afterInsideRef$curre;\n        (_afterInsideRef$curre = afterInsideRef.current) == null ? void 0 : _afterInsideRef$curre.focus();\n      } else {\n        const nextTabbable = getNextTabbable() || (focusManagerState == null ? void 0 : focusManagerState.refs.domReference.current);\n        nextTabbable == null ? void 0 : nextTabbable.focus();\n        (focusManagerState == null ? void 0 : focusManagerState.closeOnFocusOut) && (focusManagerState == null ? void 0 : focusManagerState.onOpenChange(false));\n      }\n    }\n  }));\n};\nconst usePortalContext = () => React.useContext(PortalContext);\n\nconst VisuallyHiddenDismiss = /*#__PURE__*/React.forwardRef(function VisuallyHiddenDismiss(props, ref) {\n  return /*#__PURE__*/React.createElement(\"button\", _extends({}, props, {\n    type: \"button\",\n    ref: ref,\n    tabIndex: -1,\n    style: HIDDEN_STYLES\n  }));\n});\n/**\n * Provides focus management for the floating element.\n * @see https://floating-ui.com/docs/FloatingFocusManager\n */\nfunction FloatingFocusManager(_ref) {\n  let {\n    context,\n    children,\n    order = ['content'],\n    guards = true,\n    initialFocus = 0,\n    returnFocus = true,\n    modal = true,\n    visuallyHiddenDismiss = false,\n    closeOnFocusOut = true\n  } = _ref;\n  const {\n    refs,\n    nodeId,\n    onOpenChange,\n    events,\n    dataRef,\n    elements: {\n      domReference,\n      floating\n    }\n  } = context;\n  const orderRef = useLatestRef(order);\n  const tree = useFloatingTree();\n  const portalContext = usePortalContext();\n  const [tabbableContentLength, setTabbableContentLength] = React.useState(null);\n\n  // Controlled by `useListNavigation`.\n  const ignoreInitialFocus = typeof initialFocus === 'number' && initialFocus < 0;\n  const startDismissButtonRef = React.useRef(null);\n  const endDismissButtonRef = React.useRef(null);\n  const preventReturnFocusRef = React.useRef(false);\n  const previouslyFocusedElementRef = React.useRef(null);\n  const isPointerDownRef = React.useRef(false);\n  const isInsidePortal = portalContext != null;\n\n  // If the reference is a combobox and is typeable (e.g. input/textarea),\n  // there are different focus semantics. The guards should not be rendered, but\n  // aria-hidden should be applied to all nodes still. Further, the visually\n  // hidden dismiss button should only appear at the end of the list, not the\n  // start.\n  const isTypeableCombobox = domReference && domReference.getAttribute('role') === 'combobox' && isTypeableElement(domReference);\n  const getTabbableContent = React.useCallback(function (container) {\n    if (container === void 0) {\n      container = floating;\n    }\n    return container ? tabbable(container, getTabbableOptions()) : [];\n  }, [floating]);\n  const getTabbableElements = React.useCallback(container => {\n    const content = getTabbableContent(container);\n    return orderRef.current.map(type => {\n      if (domReference && type === 'reference') {\n        return domReference;\n      }\n      if (floating && type === 'floating') {\n        return floating;\n      }\n      return content;\n    }).filter(Boolean).flat();\n  }, [domReference, floating, orderRef, getTabbableContent]);\n  React.useEffect(() => {\n    if (!modal) {\n      return;\n    }\n    function onKeyDown(event) {\n      if (event.key === 'Tab') {\n        // The focus guards have nothing to focus, so we need to stop the event.\n        if (getTabbableContent().length === 0 && !isTypeableCombobox) {\n          stopEvent(event);\n        }\n        const els = getTabbableElements();\n        const target = getTarget(event);\n        if (orderRef.current[0] === 'reference' && target === domReference) {\n          stopEvent(event);\n          if (event.shiftKey) {\n            enqueueFocus(els[els.length - 1]);\n          } else {\n            enqueueFocus(els[1]);\n          }\n        }\n        if (orderRef.current[1] === 'floating' && target === floating && event.shiftKey) {\n          stopEvent(event);\n          enqueueFocus(els[0]);\n        }\n      }\n    }\n    const doc = getDocument(floating);\n    doc.addEventListener('keydown', onKeyDown);\n    return () => {\n      doc.removeEventListener('keydown', onKeyDown);\n    };\n  }, [domReference, floating, modal, orderRef, refs, isTypeableCombobox, getTabbableContent, getTabbableElements]);\n  React.useEffect(() => {\n    if (!closeOnFocusOut) {\n      return;\n    }\n\n    // In Safari, buttons lose focus when pressing them.\n    function handlePointerDown() {\n      isPointerDownRef.current = true;\n      setTimeout(() => {\n        isPointerDownRef.current = false;\n      });\n    }\n    function handleFocusOutside(event) {\n      const relatedTarget = event.relatedTarget;\n      const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext == null ? void 0 : portalContext.portalNode, relatedTarget) || relatedTarget != null && relatedTarget.hasAttribute('data-floating-ui-focus-guard') || tree && (getChildren(tree.nodesRef.current, nodeId).find(node => {\n        var _node$context, _node$context2;\n        return contains((_node$context = node.context) == null ? void 0 : _node$context.elements.floating, relatedTarget) || contains((_node$context2 = node.context) == null ? void 0 : _node$context2.elements.domReference, relatedTarget);\n      }) || getAncestors(tree.nodesRef.current, nodeId).find(node => {\n        var _node$context3, _node$context4;\n        return ((_node$context3 = node.context) == null ? void 0 : _node$context3.elements.floating) === relatedTarget || ((_node$context4 = node.context) == null ? void 0 : _node$context4.elements.domReference) === relatedTarget;\n      })));\n\n      // Focus did not move inside the floating tree, and there are no tabbable\n      // portal guards to handle closing.\n      if (relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current &&\n      // Fix React 18 Strict Mode returnFocus due to double rendering.\n      relatedTarget !== previouslyFocusedElementRef.current) {\n        preventReturnFocusRef.current = true;\n        // On iOS VoiceOver, dismissing the nested submenu will cause the\n        // first item of the list to receive focus. Delaying it appears to fix\n        // the issue.\n        setTimeout(() => onOpenChange(false));\n      }\n    }\n    if (floating && isHTMLElement(domReference)) {\n      domReference.addEventListener('focusout', handleFocusOutside);\n      domReference.addEventListener('pointerdown', handlePointerDown);\n      !modal && floating.addEventListener('focusout', handleFocusOutside);\n      return () => {\n        domReference.removeEventListener('focusout', handleFocusOutside);\n        domReference.removeEventListener('pointerdown', handlePointerDown);\n        !modal && floating.removeEventListener('focusout', handleFocusOutside);\n      };\n    }\n  }, [domReference, floating, modal, nodeId, tree, portalContext, onOpenChange, closeOnFocusOut]);\n  React.useEffect(() => {\n    var _portalContext$portal;\n    // Don't hide portals nested within the parent portal.\n    const portalNodes = Array.from((portalContext == null ? void 0 : (_portalContext$portal = portalContext.portalNode) == null ? void 0 : _portalContext$portal.querySelectorAll('[data-floating-ui-portal]')) || []);\n    function getDismissButtons() {\n      return [startDismissButtonRef.current, endDismissButtonRef.current].filter(Boolean);\n    }\n    if (floating && modal) {\n      const insideNodes = [floating, ...portalNodes, ...getDismissButtons()];\n      const cleanup = hideOthers(orderRef.current.includes('reference') || isTypeableCombobox ? insideNodes.concat(domReference || []) : insideNodes);\n      return () => {\n        cleanup();\n      };\n    }\n  }, [domReference, floating, modal, orderRef, portalContext, isTypeableCombobox]);\n  React.useEffect(() => {\n    if (modal && !guards && floating) {\n      const tabIndexValues = [];\n      const options = getTabbableOptions();\n      const allTabbable = tabbable(getDocument(floating).body, options);\n      const floatingTabbable = getTabbableElements();\n\n      // Exclude all tabbable elements that are part of the order\n      const elements = allTabbable.filter(el => !floatingTabbable.includes(el));\n      elements.forEach((el, i) => {\n        tabIndexValues[i] = el.getAttribute('tabindex');\n        el.setAttribute('tabindex', '-1');\n      });\n      return () => {\n        elements.forEach((el, i) => {\n          const value = tabIndexValues[i];\n          if (value == null) {\n            el.removeAttribute('tabindex');\n          } else {\n            el.setAttribute('tabindex', value);\n          }\n        });\n      };\n    }\n  }, [floating, modal, guards, getTabbableElements]);\n  index(() => {\n    if (!floating) return;\n    const doc = getDocument(floating);\n    let returnFocusValue = returnFocus;\n    let preventReturnFocusScroll = false;\n    const previouslyFocusedElement = activeElement$1(doc);\n    const contextData = dataRef.current;\n    previouslyFocusedElementRef.current = previouslyFocusedElement;\n    const focusableElements = getTabbableElements(floating);\n    const elToFocus = (typeof initialFocus === 'number' ? focusableElements[initialFocus] : initialFocus.current) || floating;\n\n    // If the `useListNavigation` hook is active, always ignore `initialFocus`\n    // because it has its own handling of the initial focus.\n    !ignoreInitialFocus && enqueueFocus(elToFocus, {\n      preventScroll: elToFocus === floating\n    });\n\n    // Dismissing via outside press should always ignore `returnFocus` to\n    // prevent unwanted scrolling.\n    function onDismiss(payload) {\n      if (payload.type === 'escapeKey' && refs.domReference.current) {\n        previouslyFocusedElementRef.current = refs.domReference.current;\n      }\n      if (['referencePress', 'escapeKey'].includes(payload.type)) {\n        return;\n      }\n      const returnFocus = payload.data.returnFocus;\n      if (typeof returnFocus === 'object') {\n        returnFocusValue = true;\n        preventReturnFocusScroll = returnFocus.preventScroll;\n      } else {\n        returnFocusValue = returnFocus;\n      }\n    }\n    events.on('dismiss', onDismiss);\n    return () => {\n      events.off('dismiss', onDismiss);\n      if (contains(floating, activeElement$1(doc)) && refs.domReference.current) {\n        previouslyFocusedElementRef.current = refs.domReference.current;\n      }\n      if (returnFocusValue && isHTMLElement(previouslyFocusedElementRef.current) && !preventReturnFocusRef.current) {\n        // `isPointerDownRef.current` to avoid the focus ring from appearing on\n        // the reference element when click-toggling it.\n        if (!refs.domReference.current || isPointerDownRef.current) {\n          enqueueFocus(previouslyFocusedElementRef.current, {\n            // When dismissing nested floating elements, by the time the rAF has\n            // executed, the menus will all have been unmounted. When they try\n            // to get focused, the calls get ignored — leaving the root\n            // reference focused as desired.\n            cancelPrevious: false,\n            preventScroll: preventReturnFocusScroll\n          });\n        } else {\n          var _previouslyFocusedEle;\n          // If the user has specified a `keydown` listener that calls\n          // setOpen(false) (e.g. selecting an item and closing the floating\n          // element), then sync return focus causes `useClick` to immediately\n          // re-open it, unless they call `event.preventDefault()` in the\n          // `keydown` listener. This helps keep backwards compatibility with\n          // older examples.\n          contextData.__syncReturnFocus = true;\n\n          // In Safari, `useListNavigation` moves focus sync, so making this\n          // sync ensures the initial item remains focused despite this being\n          // invoked in Strict Mode due to double-invoked useEffects. This also\n          // has the positive side effect of closing a modally focus-managed\n          // <Menu> on `Tab` keydown to move naturally to the next focusable\n          // element.\n          (_previouslyFocusedEle = previouslyFocusedElementRef.current) == null ? void 0 : _previouslyFocusedEle.focus({\n            preventScroll: preventReturnFocusScroll\n          });\n          setTimeout(() => {\n            // This isn't an actual property the user should access, make sure\n            // it doesn't persist.\n            delete contextData.__syncReturnFocus;\n          });\n        }\n      }\n    };\n  }, [floating, getTabbableElements, initialFocus, returnFocus, dataRef, refs, events, ignoreInitialFocus]);\n\n  // Synchronize the `context` & `modal` value to the FloatingPortal context.\n  // It will decide whether or not it needs to render its own guards.\n  index(() => {\n    if (!portalContext) return;\n    portalContext.setFocusManagerState({\n      ...context,\n      modal,\n      closeOnFocusOut\n      // Not concerned about the <RT> generic type.\n    });\n\n    return () => {\n      portalContext.setFocusManagerState(null);\n    };\n  }, [portalContext, modal, closeOnFocusOut, context]);\n  index(() => {\n    if (ignoreInitialFocus || !floating) return;\n    function setState() {\n      setTabbableContentLength(getTabbableContent().length);\n    }\n    setState();\n    if (typeof MutationObserver === 'function') {\n      const observer = new MutationObserver(setState);\n      observer.observe(floating, {\n        childList: true,\n        subtree: true\n      });\n      return () => {\n        observer.disconnect();\n      };\n    }\n  }, [floating, getTabbableContent, ignoreInitialFocus, refs]);\n  const shouldRenderGuards = guards && (isInsidePortal || modal) && !isTypeableCombobox;\n  function renderDismissButton(location) {\n    return visuallyHiddenDismiss && modal ? /*#__PURE__*/React.createElement(VisuallyHiddenDismiss, {\n      ref: location === 'start' ? startDismissButtonRef : endDismissButtonRef,\n      onClick: () => onOpenChange(false)\n    }, typeof visuallyHiddenDismiss === 'string' ? visuallyHiddenDismiss : 'Dismiss') : null;\n  }\n  return /*#__PURE__*/React.createElement(React.Fragment, null, shouldRenderGuards && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"inside\",\n    ref: portalContext == null ? void 0 : portalContext.beforeInsideRef,\n    onFocus: event => {\n      if (modal) {\n        const els = getTabbableElements();\n        enqueueFocus(order[0] === 'reference' ? els[0] : els[els.length - 1]);\n      } else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {\n        preventReturnFocusRef.current = false;\n        if (isOutsideEvent(event, portalContext.portalNode)) {\n          const nextTabbable = getNextTabbable() || domReference;\n          nextTabbable == null ? void 0 : nextTabbable.focus();\n        } else {\n          var _portalContext$before;\n          (_portalContext$before = portalContext.beforeOutsideRef.current) == null ? void 0 : _portalContext$before.focus();\n        }\n      }\n    }\n  }), isTypeableCombobox ? null : renderDismissButton('start'), /*#__PURE__*/React.cloneElement(children, tabbableContentLength === 0 || order.includes('floating') ? {\n    tabIndex: 0\n  } : {}), renderDismissButton('end'), shouldRenderGuards && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"inside\",\n    ref: portalContext == null ? void 0 : portalContext.afterInsideRef,\n    onFocus: event => {\n      if (modal) {\n        enqueueFocus(getTabbableElements()[0]);\n      } else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {\n        preventReturnFocusRef.current = true;\n        if (isOutsideEvent(event, portalContext.portalNode)) {\n          const prevTabbable = getPreviousTabbable() || domReference;\n          prevTabbable == null ? void 0 : prevTabbable.focus();\n        } else {\n          var _portalContext$afterO;\n          (_portalContext$afterO = portalContext.afterOutsideRef.current) == null ? void 0 : _portalContext$afterO.focus();\n        }\n      }\n    }\n  }));\n}\n\nconst identifier = 'data-floating-ui-scroll-lock';\n\n/**\n * Provides base styling for a fixed overlay element to dim content or block\n * pointer events behind a floating element.\n * It's a regular `<div>`, so it can be styled via any CSS solution you prefer.\n * @see https://floating-ui.com/docs/FloatingOverlay\n */\nconst FloatingOverlay = /*#__PURE__*/React.forwardRef(function FloatingOverlay(_ref, ref) {\n  let {\n    lockScroll = false,\n    ...rest\n  } = _ref;\n  index(() => {\n    var _window$visualViewpor, _window$visualViewpor2;\n    if (!lockScroll) {\n      return;\n    }\n    const alreadyLocked = document.body.hasAttribute(identifier);\n    if (alreadyLocked) {\n      return;\n    }\n    document.body.setAttribute(identifier, '');\n\n    // RTL <body> scrollbar\n    const scrollbarX = Math.round(document.documentElement.getBoundingClientRect().left) + document.documentElement.scrollLeft;\n    const paddingProp = scrollbarX ? 'paddingLeft' : 'paddingRight';\n    const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;\n\n    // Only iOS doesn't respect `overflow: hidden` on document.body, and this\n    // technique has fewer side effects.\n    if (!/iP(hone|ad|od)|iOS/.test(getPlatform())) {\n      Object.assign(document.body.style, {\n        overflow: 'hidden',\n        [paddingProp]: scrollbarWidth + \"px\"\n      });\n      return () => {\n        document.body.removeAttribute(identifier);\n        Object.assign(document.body.style, {\n          overflow: '',\n          [paddingProp]: ''\n        });\n      };\n    }\n\n    // iOS 12 does not support `visualViewport`.\n    const offsetLeft = ((_window$visualViewpor = window.visualViewport) == null ? void 0 : _window$visualViewpor.offsetLeft) || 0;\n    const offsetTop = ((_window$visualViewpor2 = window.visualViewport) == null ? void 0 : _window$visualViewpor2.offsetTop) || 0;\n    const scrollX = window.pageXOffset;\n    const scrollY = window.pageYOffset;\n    Object.assign(document.body.style, {\n      position: 'fixed',\n      overflow: 'hidden',\n      top: -(scrollY - Math.floor(offsetTop)) + \"px\",\n      left: -(scrollX - Math.floor(offsetLeft)) + \"px\",\n      right: '0',\n      [paddingProp]: scrollbarWidth + \"px\"\n    });\n    return () => {\n      Object.assign(document.body.style, {\n        position: '',\n        overflow: '',\n        top: '',\n        left: '',\n        right: '',\n        [paddingProp]: ''\n      });\n      document.body.removeAttribute(identifier);\n      window.scrollTo(scrollX, scrollY);\n    };\n  }, [lockScroll]);\n  return /*#__PURE__*/React.createElement(\"div\", _extends({\n    ref: ref\n  }, rest, {\n    style: {\n      position: 'fixed',\n      overflow: 'auto',\n      top: 0,\n      right: 0,\n      bottom: 0,\n      left: 0,\n      ...rest.style\n    }\n  }));\n});\n\nfunction isButtonTarget(event) {\n  return isHTMLElement(event.target) && event.target.tagName === 'BUTTON';\n}\nfunction isSpaceIgnored(element) {\n  return isTypeableElement(element);\n}\n/**\n * Opens or closes the floating element when clicking the reference element.\n * @see https://floating-ui.com/docs/useClick\n */\nconst useClick = function (_ref, _temp) {\n  let {\n    open,\n    onOpenChange,\n    dataRef,\n    elements: {\n      domReference\n    }\n  } = _ref;\n  let {\n    enabled = true,\n    event: eventOption = 'click',\n    toggle = true,\n    ignoreMouse = false,\n    keyboardHandlers = true\n  } = _temp === void 0 ? {} : _temp;\n  const pointerTypeRef = React.useRef();\n  return React.useMemo(() => {\n    if (!enabled) {\n      return {};\n    }\n    return {\n      reference: {\n        onPointerDown(event) {\n          pointerTypeRef.current = event.pointerType;\n        },\n        onMouseDown(event) {\n          // Ignore all buttons except for the \"main\" button.\n          // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button\n          if (event.button !== 0) {\n            return;\n          }\n          if (isMouseLikePointerType(pointerTypeRef.current, true) && ignoreMouse) {\n            return;\n          }\n          if (eventOption === 'click') {\n            return;\n          }\n          if (open) {\n            if (toggle && (dataRef.current.openEvent ? dataRef.current.openEvent.type === 'mousedown' : true)) {\n              onOpenChange(false);\n            }\n          } else {\n            // Prevent stealing focus from the floating element\n            event.preventDefault();\n            onOpenChange(true);\n          }\n          dataRef.current.openEvent = event.nativeEvent;\n        },\n        onClick(event) {\n          if (dataRef.current.__syncReturnFocus) {\n            return;\n          }\n          if (eventOption === 'mousedown' && pointerTypeRef.current) {\n            pointerTypeRef.current = undefined;\n            return;\n          }\n          if (isMouseLikePointerType(pointerTypeRef.current, true) && ignoreMouse) {\n            return;\n          }\n          if (open) {\n            if (toggle && (dataRef.current.openEvent ? dataRef.current.openEvent.type === 'click' : true)) {\n              onOpenChange(false);\n            }\n          } else {\n            onOpenChange(true);\n          }\n          dataRef.current.openEvent = event.nativeEvent;\n        },\n        onKeyDown(event) {\n          pointerTypeRef.current = undefined;\n          if (!keyboardHandlers) {\n            return;\n          }\n          if (isButtonTarget(event)) {\n            return;\n          }\n          if (event.key === ' ' && !isSpaceIgnored(domReference)) {\n            // Prevent scrolling\n            event.preventDefault();\n          }\n          if (event.key === 'Enter') {\n            if (open) {\n              if (toggle) {\n                onOpenChange(false);\n              }\n            } else {\n              onOpenChange(true);\n            }\n          }\n        },\n        onKeyUp(event) {\n          if (!keyboardHandlers) {\n            return;\n          }\n          if (isButtonTarget(event) || isSpaceIgnored(domReference)) {\n            return;\n          }\n          if (event.key === ' ') {\n            if (open) {\n              if (toggle) {\n                onOpenChange(false);\n              }\n            } else {\n              onOpenChange(true);\n            }\n          }\n        }\n      }\n    };\n  }, [enabled, dataRef, eventOption, ignoreMouse, keyboardHandlers, domReference, toggle, open, onOpenChange]);\n};\n\n/**\n * Check whether the event.target is within the provided node. Uses event.composedPath if available for custom element support.\n *\n * @param event The event whose target/composedPath to check\n * @param node The node to check against\n * @returns Whether the event.target/composedPath is within the node.\n */\nfunction isEventTargetWithin(event, node) {\n  if (node == null) {\n    return false;\n  }\n  if ('composedPath' in event) {\n    return event.composedPath().includes(node);\n  }\n\n  // TS thinks `event` is of type never as it assumes all browsers support composedPath, but browsers without shadow dom don't\n  const e = event;\n  return e.target != null && node.contains(e.target);\n}\n\nconst bubbleHandlerKeys = {\n  pointerdown: 'onPointerDown',\n  mousedown: 'onMouseDown',\n  click: 'onClick'\n};\nconst captureHandlerKeys = {\n  pointerdown: 'onPointerDownCapture',\n  mousedown: 'onMouseDownCapture',\n  click: 'onClickCapture'\n};\nconst normalizeBubblesProp = function (bubbles) {\n  var _bubbles$escapeKey, _bubbles$outsidePress;\n  if (bubbles === void 0) {\n    bubbles = true;\n  }\n  return {\n    escapeKeyBubbles: typeof bubbles === 'boolean' ? bubbles : (_bubbles$escapeKey = bubbles.escapeKey) != null ? _bubbles$escapeKey : true,\n    outsidePressBubbles: typeof bubbles === 'boolean' ? bubbles : (_bubbles$outsidePress = bubbles.outsidePress) != null ? _bubbles$outsidePress : true\n  };\n};\n/**\n * Closes the floating element when a dismissal is requested — by default, when\n * the user presses the `escape` key or outside of the floating element.\n * @see https://floating-ui.com/docs/useDismiss\n */\nconst useDismiss = function (_ref, _temp) {\n  let {\n    open,\n    onOpenChange,\n    events,\n    nodeId,\n    elements: {\n      reference,\n      domReference,\n      floating\n    },\n    dataRef\n  } = _ref;\n  let {\n    enabled = true,\n    escapeKey = true,\n    outsidePress: unstable_outsidePress = true,\n    outsidePressEvent = 'pointerdown',\n    referencePress = false,\n    referencePressEvent = 'pointerdown',\n    ancestorScroll = false,\n    bubbles = true\n  } = _temp === void 0 ? {} : _temp;\n  const tree = useFloatingTree();\n  const nested = useFloatingParentNodeId() != null;\n  const outsidePressFn = useEvent(typeof unstable_outsidePress === 'function' ? unstable_outsidePress : () => false);\n  const outsidePress = typeof unstable_outsidePress === 'function' ? outsidePressFn : unstable_outsidePress;\n  const insideReactTreeRef = React.useRef(false);\n  const {\n    escapeKeyBubbles,\n    outsidePressBubbles\n  } = normalizeBubblesProp(bubbles);\n  React.useEffect(() => {\n    if (!open || !enabled) {\n      return;\n    }\n    dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;\n    dataRef.current.__outsidePressBubbles = outsidePressBubbles;\n    function onKeyDown(event) {\n      if (event.key === 'Escape') {\n        const children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];\n        if (children.length > 0) {\n          let shouldDismiss = true;\n          children.forEach(child => {\n            var _child$context;\n            if ((_child$context = child.context) != null && _child$context.open && !child.context.dataRef.current.__escapeKeyBubbles) {\n              shouldDismiss = false;\n              return;\n            }\n          });\n          if (!shouldDismiss) {\n            return;\n          }\n        }\n        events.emit('dismiss', {\n          type: 'escapeKey',\n          data: {\n            returnFocus: {\n              preventScroll: false\n            }\n          }\n        });\n        onOpenChange(false);\n      }\n    }\n    function onOutsidePress(event) {\n      // Given developers can stop the propagation of the synthetic event,\n      // we can only be confident with a positive value.\n      const insideReactTree = insideReactTreeRef.current;\n      insideReactTreeRef.current = false;\n      if (insideReactTree) {\n        return;\n      }\n      if (typeof outsidePress === 'function' && !outsidePress(event)) {\n        return;\n      }\n      const target = getTarget(event);\n\n      // Check if the click occurred on the scrollbar\n      if (isHTMLElement(target) && floating) {\n        const win = floating.ownerDocument.defaultView || window;\n        const canScrollX = target.scrollWidth > target.clientWidth;\n        const canScrollY = target.scrollHeight > target.clientHeight;\n        let xCond = canScrollY && event.offsetX > target.clientWidth;\n\n        // In some browsers it is possible to change the <body> (or window)\n        // scrollbar to the left side, but is very rare and is difficult to\n        // check for. Plus, for modal dialogs with backdrops, it is more\n        // important that the backdrop is checked but not so much the window.\n        if (canScrollY) {\n          const isRTL = win.getComputedStyle(target).direction === 'rtl';\n          if (isRTL) {\n            xCond = event.offsetX <= target.offsetWidth - target.clientWidth;\n          }\n        }\n        if (xCond || canScrollX && event.offsetY > target.clientHeight) {\n          return;\n        }\n      }\n      const targetIsInsideChildren = tree && getChildren(tree.nodesRef.current, nodeId).some(node => {\n        var _node$context;\n        return isEventTargetWithin(event, (_node$context = node.context) == null ? void 0 : _node$context.elements.floating);\n      });\n      if (isEventTargetWithin(event, floating) || isEventTargetWithin(event, domReference) || targetIsInsideChildren) {\n        return;\n      }\n      const children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];\n      if (children.length > 0) {\n        let shouldDismiss = true;\n        children.forEach(child => {\n          var _child$context2;\n          if ((_child$context2 = child.context) != null && _child$context2.open && !child.context.dataRef.current.__outsidePressBubbles) {\n            shouldDismiss = false;\n            return;\n          }\n        });\n        if (!shouldDismiss) {\n          return;\n        }\n      }\n      events.emit('dismiss', {\n        type: 'outsidePress',\n        data: {\n          returnFocus: nested ? {\n            preventScroll: true\n          } : isVirtualClick(event) || isVirtualPointerEvent(event)\n        }\n      });\n      onOpenChange(false);\n    }\n    function onScroll() {\n      onOpenChange(false);\n    }\n    const doc = getDocument(floating);\n    escapeKey && doc.addEventListener('keydown', onKeyDown);\n    outsidePress && doc.addEventListener(outsidePressEvent, onOutsidePress);\n    let ancestors = [];\n    if (ancestorScroll) {\n      if (isElement(domReference)) {\n        ancestors = getOverflowAncestors(domReference);\n      }\n      if (isElement(floating)) {\n        ancestors = ancestors.concat(getOverflowAncestors(floating));\n      }\n      if (!isElement(reference) && reference && reference.contextElement) {\n        ancestors = ancestors.concat(getOverflowAncestors(reference.contextElement));\n      }\n    }\n\n    // Ignore the visual viewport for scrolling dismissal (allow pinch-zoom)\n    ancestors = ancestors.filter(ancestor => {\n      var _doc$defaultView;\n      return ancestor !== ((_doc$defaultView = doc.defaultView) == null ? void 0 : _doc$defaultView.visualViewport);\n    });\n    ancestors.forEach(ancestor => {\n      ancestor.addEventListener('scroll', onScroll, {\n        passive: true\n      });\n    });\n    return () => {\n      escapeKey && doc.removeEventListener('keydown', onKeyDown);\n      outsidePress && doc.removeEventListener(outsidePressEvent, onOutsidePress);\n      ancestors.forEach(ancestor => {\n        ancestor.removeEventListener('scroll', onScroll);\n      });\n    };\n  }, [dataRef, floating, domReference, reference, escapeKey, outsidePress, outsidePressEvent, events, tree, nodeId, open, onOpenChange, ancestorScroll, enabled, escapeKeyBubbles, outsidePressBubbles, nested]);\n  React.useEffect(() => {\n    insideReactTreeRef.current = false;\n  }, [outsidePress, outsidePressEvent]);\n  return React.useMemo(() => {\n    if (!enabled) {\n      return {};\n    }\n    return {\n      reference: {\n        [bubbleHandlerKeys[referencePressEvent]]: () => {\n          if (referencePress) {\n            events.emit('dismiss', {\n              type: 'referencePress',\n              data: {\n                returnFocus: false\n              }\n            });\n            onOpenChange(false);\n          }\n        }\n      },\n      floating: {\n        [captureHandlerKeys[outsidePressEvent]]: () => {\n          insideReactTreeRef.current = true;\n        }\n      }\n    };\n  }, [enabled, events, referencePress, outsidePressEvent, referencePressEvent, onOpenChange]);\n};\n\n/**\n * Opens the floating element while the reference element has focus, like CSS\n * `:focus`.\n * @see https://floating-ui.com/docs/useFocus\n */\nconst useFocus = function (_ref, _temp) {\n  let {\n    open,\n    onOpenChange,\n    dataRef,\n    events,\n    refs,\n    elements: {\n      floating,\n      domReference\n    }\n  } = _ref;\n  let {\n    enabled = true,\n    keyboardOnly = true\n  } = _temp === void 0 ? {} : _temp;\n  const pointerTypeRef = React.useRef('');\n  const blockFocusRef = React.useRef(false);\n  const timeoutRef = React.useRef();\n  React.useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n    const doc = getDocument(floating);\n    const win = doc.defaultView || window;\n\n    // If the reference was focused and the user left the tab/window, and the\n    // floating element was not open, the focus should be blocked when they\n    // return to the tab/window.\n    function onBlur() {\n      if (!open && isHTMLElement(domReference) && domReference === activeElement$1(getDocument(domReference))) {\n        blockFocusRef.current = true;\n      }\n    }\n    win.addEventListener('blur', onBlur);\n    return () => {\n      win.removeEventListener('blur', onBlur);\n    };\n  }, [floating, domReference, open, enabled]);\n  React.useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n    function onDismiss(payload) {\n      if (payload.type === 'referencePress' || payload.type === 'escapeKey') {\n        blockFocusRef.current = true;\n      }\n    }\n    events.on('dismiss', onDismiss);\n    return () => {\n      events.off('dismiss', onDismiss);\n    };\n  }, [events, enabled]);\n  React.useEffect(() => {\n    return () => {\n      clearTimeout(timeoutRef.current);\n    };\n  }, []);\n  return React.useMemo(() => {\n    if (!enabled) {\n      return {};\n    }\n    return {\n      reference: {\n        onPointerDown(_ref2) {\n          let {\n            pointerType\n          } = _ref2;\n          pointerTypeRef.current = pointerType;\n          blockFocusRef.current = !!(pointerType && keyboardOnly);\n        },\n        onMouseLeave() {\n          blockFocusRef.current = false;\n        },\n        onFocus(event) {\n          var _dataRef$current$open;\n          if (blockFocusRef.current) {\n            return;\n          }\n\n          // Dismiss with click should ignore the subsequent `focus` trigger,\n          // but only if the click originated inside the reference element.\n          if (event.type === 'focus' && ((_dataRef$current$open = dataRef.current.openEvent) == null ? void 0 : _dataRef$current$open.type) === 'mousedown' && dataRef.current.openEvent && isEventTargetWithin(dataRef.current.openEvent, domReference)) {\n            return;\n          }\n          dataRef.current.openEvent = event.nativeEvent;\n          onOpenChange(true);\n        },\n        onBlur(event) {\n          blockFocusRef.current = false;\n          const relatedTarget = event.relatedTarget;\n\n          // Hit the non-modal focus management portal guard. Focus will be\n          // moved into the floating element immediately after.\n          const movedToFocusGuard = isElement(relatedTarget) && relatedTarget.hasAttribute('data-floating-ui-focus-guard') && relatedTarget.getAttribute('data-type') === 'outside';\n\n          // Wait for the window blur listener to fire.\n          timeoutRef.current = setTimeout(() => {\n            // When focusing the reference element (e.g. regular click), then\n            // clicking into the floating element, prevent it from hiding.\n            // Note: it must be focusable, e.g. `tabindex=\"-1\"`.\n            if (contains(refs.floating.current, relatedTarget) || contains(domReference, relatedTarget) || movedToFocusGuard) {\n              return;\n            }\n            onOpenChange(false);\n          });\n        }\n      }\n    };\n  }, [enabled, keyboardOnly, domReference, refs, dataRef, onOpenChange]);\n};\n\nlet isPreventScrollSupported = false;\nconst ARROW_UP = 'ArrowUp';\nconst ARROW_DOWN = 'ArrowDown';\nconst ARROW_LEFT = 'ArrowLeft';\nconst ARROW_RIGHT = 'ArrowRight';\nfunction isDifferentRow(index, cols, prevRow) {\n  return Math.floor(index / cols) !== prevRow;\n}\nfunction isIndexOutOfBounds(listRef, index) {\n  return index < 0 || index >= listRef.current.length;\n}\nfunction findNonDisabledIndex(listRef, _temp) {\n  let {\n    startingIndex = -1,\n    decrement = false,\n    disabledIndices,\n    amount = 1\n  } = _temp === void 0 ? {} : _temp;\n  const list = listRef.current;\n  let index = startingIndex;\n  do {\n    var _list$index, _list$index2;\n    index = index + (decrement ? -amount : amount);\n  } while (index >= 0 && index <= list.length - 1 && (disabledIndices ? disabledIndices.includes(index) : list[index] == null || ((_list$index = list[index]) == null ? void 0 : _list$index.hasAttribute('disabled')) || ((_list$index2 = list[index]) == null ? void 0 : _list$index2.getAttribute('aria-disabled')) === 'true'));\n  return index;\n}\nfunction doSwitch(orientation, vertical, horizontal) {\n  switch (orientation) {\n    case 'vertical':\n      return vertical;\n    case 'horizontal':\n      return horizontal;\n    default:\n      return vertical || horizontal;\n  }\n}\nfunction isMainOrientationKey(key, orientation) {\n  const vertical = key === ARROW_UP || key === ARROW_DOWN;\n  const horizontal = key === ARROW_LEFT || key === ARROW_RIGHT;\n  return doSwitch(orientation, vertical, horizontal);\n}\nfunction isMainOrientationToEndKey(key, orientation, rtl) {\n  const vertical = key === ARROW_DOWN;\n  const horizontal = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;\n  return doSwitch(orientation, vertical, horizontal) || key === 'Enter' || key == ' ' || key === '';\n}\nfunction isCrossOrientationOpenKey(key, orientation, rtl) {\n  const vertical = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;\n  const horizontal = key === ARROW_DOWN;\n  return doSwitch(orientation, vertical, horizontal);\n}\nfunction isCrossOrientationCloseKey(key, orientation, rtl) {\n  const vertical = rtl ? key === ARROW_RIGHT : key === ARROW_LEFT;\n  const horizontal = key === ARROW_UP;\n  return doSwitch(orientation, vertical, horizontal);\n}\nfunction getMinIndex(listRef, disabledIndices) {\n  return findNonDisabledIndex(listRef, {\n    disabledIndices\n  });\n}\nfunction getMaxIndex(listRef, disabledIndices) {\n  return findNonDisabledIndex(listRef, {\n    decrement: true,\n    startingIndex: listRef.current.length,\n    disabledIndices\n  });\n}\n/**\n * Adds arrow key-based navigation of a list of items, either using real DOM\n * focus or virtual focus.\n * @see https://floating-ui.com/docs/useListNavigation\n */\nconst useListNavigation = function (_ref, _temp2) {\n  let {\n    open,\n    onOpenChange,\n    refs,\n    elements: {\n      domReference\n    }\n  } = _ref;\n  let {\n    listRef,\n    activeIndex,\n    onNavigate: unstable_onNavigate = () => {},\n    enabled = true,\n    selectedIndex = null,\n    allowEscape = false,\n    loop = false,\n    nested = false,\n    rtl = false,\n    virtual = false,\n    focusItemOnOpen = 'auto',\n    focusItemOnHover = true,\n    openOnArrowKeyDown = true,\n    disabledIndices = undefined,\n    orientation = 'vertical',\n    cols = 1,\n    scrollItemIntoView = true\n  } = _temp2 === void 0 ? {\n    listRef: {\n      current: []\n    },\n    activeIndex: null,\n    onNavigate: () => {}\n  } : _temp2;\n  if (process.env.NODE_ENV !== \"production\") {\n    if (allowEscape) {\n      if (!loop) {\n        console.warn(['Floating UI: `useListNavigation` looping must be enabled to allow', 'escaping.'].join(' '));\n      }\n      if (!virtual) {\n        console.warn(['Floating UI: `useListNavigation` must be virtual to allow', 'escaping.'].join(' '));\n      }\n    }\n    if (orientation === 'vertical' && cols > 1) {\n      console.warn(['Floating UI: In grid list navigation mode (`cols` > 1), the', '`orientation` should be either \"horizontal\" or \"both\".'].join(' '));\n    }\n  }\n  const parentId = useFloatingParentNodeId();\n  const tree = useFloatingTree();\n  const onNavigate = useEvent(unstable_onNavigate);\n  const focusItemOnOpenRef = React.useRef(focusItemOnOpen);\n  const indexRef = React.useRef(selectedIndex != null ? selectedIndex : -1);\n  const keyRef = React.useRef(null);\n  const isPointerModalityRef = React.useRef(true);\n  const previousOnNavigateRef = React.useRef(onNavigate);\n  const previousOpenRef = React.useRef(open);\n  const forceSyncFocus = React.useRef(false);\n  const forceScrollIntoViewRef = React.useRef(false);\n  const disabledIndicesRef = useLatestRef(disabledIndices);\n  const latestOpenRef = useLatestRef(open);\n  const scrollItemIntoViewRef = useLatestRef(scrollItemIntoView);\n  const [activeId, setActiveId] = React.useState();\n  const focusItem = React.useCallback(function (listRef, indexRef, forceScrollIntoView) {\n    if (forceScrollIntoView === void 0) {\n      forceScrollIntoView = false;\n    }\n    const item = listRef.current[indexRef.current];\n    if (virtual) {\n      setActiveId(item == null ? void 0 : item.id);\n    } else {\n      enqueueFocus(item, {\n        preventScroll: true,\n        // Mac Safari does not move the virtual cursor unless the focus call\n        // is sync. However, for the very first focus call, we need to wait\n        // for the position to be ready in order to prevent unwanted\n        // scrolling. This means the virtual cursor will not move to the first\n        // item when first opening the floating element, but will on\n        // subsequent calls. `preventScroll` is supported in modern Safari,\n        // so we can use that instead.\n        // iOS Safari must be async or the first item will not be focused.\n        sync: isMac() && isSafari() ? isPreventScrollSupported || forceSyncFocus.current : false\n      });\n    }\n    requestAnimationFrame(() => {\n      const scrollIntoViewOptions = scrollItemIntoViewRef.current;\n      const shouldScrollIntoView = scrollIntoViewOptions && item && (forceScrollIntoView || !isPointerModalityRef.current);\n      if (shouldScrollIntoView) {\n        // JSDOM doesn't support `.scrollIntoView()` but it's widely supported\n        // by all browsers.\n        item.scrollIntoView == null ? void 0 : item.scrollIntoView(typeof scrollIntoViewOptions === 'boolean' ? {\n          block: 'nearest',\n          inline: 'nearest'\n        } : scrollIntoViewOptions);\n      }\n    });\n  }, [virtual, scrollItemIntoViewRef]);\n  index(() => {\n    document.createElement('div').focus({\n      get preventScroll() {\n        isPreventScrollSupported = true;\n        return false;\n      }\n    });\n  }, []);\n\n  // Sync `selectedIndex` to be the `activeIndex` upon opening the floating\n  // element. Also, reset `activeIndex` upon closing the floating element.\n  index(() => {\n    if (!enabled) {\n      return;\n    }\n    if (open) {\n      if (focusItemOnOpenRef.current && selectedIndex != null) {\n        // Regardless of the pointer modality, we want to ensure the selected\n        // item comes into view when the floating element is opened.\n        forceScrollIntoViewRef.current = true;\n        onNavigate(selectedIndex);\n      }\n    } else if (previousOpenRef.current) {\n      // Since the user can specify `onNavigate` conditionally\n      // (onNavigate: open ? setActiveIndex : setSelectedIndex),\n      // we store and call the previous function.\n      indexRef.current = -1;\n      previousOnNavigateRef.current(null);\n    }\n  }, [enabled, open, selectedIndex, onNavigate]);\n\n  // Sync `activeIndex` to be the focused item while the floating element is\n  // open.\n  index(() => {\n    if (!enabled) {\n      return;\n    }\n    if (open) {\n      if (activeIndex == null) {\n        forceSyncFocus.current = false;\n        if (selectedIndex != null) {\n          return;\n        }\n\n        // Reset while the floating element was open (e.g. the list changed).\n        if (previousOpenRef.current) {\n          indexRef.current = -1;\n          focusItem(listRef, indexRef);\n        }\n\n        // Initial sync.\n        if (!previousOpenRef.current && focusItemOnOpenRef.current && (keyRef.current != null || focusItemOnOpenRef.current === true && keyRef.current == null)) {\n          indexRef.current = keyRef.current == null || isMainOrientationToEndKey(keyRef.current, orientation, rtl) || nested ? getMinIndex(listRef, disabledIndicesRef.current) : getMaxIndex(listRef, disabledIndicesRef.current);\n          onNavigate(indexRef.current);\n        }\n      } else if (!isIndexOutOfBounds(listRef, activeIndex)) {\n        indexRef.current = activeIndex;\n        focusItem(listRef, indexRef, forceScrollIntoViewRef.current);\n        forceScrollIntoViewRef.current = false;\n      }\n    }\n  }, [enabled, open, activeIndex, selectedIndex, nested, listRef, orientation, rtl, onNavigate, focusItem, disabledIndicesRef]);\n\n  // Ensure the parent floating element has focus when a nested child closes\n  // to allow arrow key navigation to work after the pointer leaves the child.\n  index(() => {\n    if (!enabled) {\n      return;\n    }\n    if (previousOpenRef.current && !open) {\n      var _tree$nodesRef$curren, _tree$nodesRef$curren2;\n      const parentFloating = tree == null ? void 0 : (_tree$nodesRef$curren = tree.nodesRef.current.find(node => node.id === parentId)) == null ? void 0 : (_tree$nodesRef$curren2 = _tree$nodesRef$curren.context) == null ? void 0 : _tree$nodesRef$curren2.elements.floating;\n      if (parentFloating && !contains(parentFloating, activeElement$1(getDocument(parentFloating)))) {\n        parentFloating.focus({\n          preventScroll: true\n        });\n      }\n    }\n  }, [enabled, open, tree, parentId]);\n  index(() => {\n    keyRef.current = null;\n    previousOnNavigateRef.current = onNavigate;\n    previousOpenRef.current = open;\n  });\n  const hasActiveIndex = activeIndex != null;\n  const item = React.useMemo(() => {\n    function syncCurrentTarget(currentTarget) {\n      if (!open) return;\n      const index = listRef.current.indexOf(currentTarget);\n      if (index !== -1) {\n        onNavigate(index);\n      }\n    }\n    const props = {\n      onFocus(_ref2) {\n        let {\n          currentTarget\n        } = _ref2;\n        syncCurrentTarget(currentTarget);\n      },\n      onClick: _ref3 => {\n        let {\n          currentTarget\n        } = _ref3;\n        return currentTarget.focus({\n          preventScroll: true\n        });\n      },\n      // Safari\n      ...(focusItemOnHover && {\n        onMouseMove(_ref4) {\n          let {\n            currentTarget\n          } = _ref4;\n          syncCurrentTarget(currentTarget);\n        },\n        onPointerLeave() {\n          if (!isPointerModalityRef.current) {\n            return;\n          }\n          indexRef.current = -1;\n          focusItem(listRef, indexRef);\n\n          // Virtual cursor with VoiceOver on iOS needs this to be flushed\n          // synchronously or there is a glitch that prevents nested\n          // submenus from being accessible.\n          flushSync(() => onNavigate(null));\n          if (!virtual) {\n            var _refs$floating$curren;\n            // This also needs to be sync to prevent fast mouse movements\n            // from leaving behind a stale active item when landing on a\n            // disabled button item.\n            (_refs$floating$curren = refs.floating.current) == null ? void 0 : _refs$floating$curren.focus({\n              preventScroll: true\n            });\n          }\n        }\n      })\n    };\n    return props;\n  }, [open, refs, focusItem, focusItemOnHover, listRef, onNavigate, virtual]);\n  return React.useMemo(() => {\n    if (!enabled) {\n      return {};\n    }\n    const disabledIndices = disabledIndicesRef.current;\n    function onKeyDown(event) {\n      isPointerModalityRef.current = false;\n      forceSyncFocus.current = true;\n\n      // If the floating element is animating out, ignore navigation. Otherwise,\n      // the `activeIndex` gets set to 0 despite not being open so the next time\n      // the user ArrowDowns, the first item won't be focused.\n      if (!latestOpenRef.current && event.currentTarget === refs.floating.current) {\n        return;\n      }\n      if (nested && isCrossOrientationCloseKey(event.key, orientation, rtl)) {\n        stopEvent(event);\n        onOpenChange(false);\n        if (isHTMLElement(domReference)) {\n          domReference.focus();\n        }\n        return;\n      }\n      const currentIndex = indexRef.current;\n      const minIndex = getMinIndex(listRef, disabledIndices);\n      const maxIndex = getMaxIndex(listRef, disabledIndices);\n      if (event.key === 'Home') {\n        indexRef.current = minIndex;\n        onNavigate(indexRef.current);\n      }\n      if (event.key === 'End') {\n        indexRef.current = maxIndex;\n        onNavigate(indexRef.current);\n      }\n\n      // Grid navigation.\n      if (cols > 1) {\n        const prevIndex = indexRef.current;\n        if (event.key === ARROW_UP) {\n          stopEvent(event);\n          if (prevIndex === -1) {\n            indexRef.current = maxIndex;\n          } else {\n            indexRef.current = findNonDisabledIndex(listRef, {\n              startingIndex: prevIndex,\n              amount: cols,\n              decrement: true,\n              disabledIndices\n            });\n            if (loop && (prevIndex - cols < minIndex || indexRef.current < 0)) {\n              const col = prevIndex % cols;\n              const maxCol = maxIndex % cols;\n              const offset = maxIndex - (maxCol - col);\n              if (maxCol === col) {\n                indexRef.current = maxIndex;\n              } else {\n                indexRef.current = maxCol > col ? offset : offset - cols;\n              }\n            }\n          }\n          if (isIndexOutOfBounds(listRef, indexRef.current)) {\n            indexRef.current = prevIndex;\n          }\n          onNavigate(indexRef.current);\n        }\n        if (event.key === ARROW_DOWN) {\n          stopEvent(event);\n          if (prevIndex === -1) {\n            indexRef.current = minIndex;\n          } else {\n            indexRef.current = findNonDisabledIndex(listRef, {\n              startingIndex: prevIndex,\n              amount: cols,\n              disabledIndices\n            });\n            if (loop && prevIndex + cols > maxIndex) {\n              indexRef.current = findNonDisabledIndex(listRef, {\n                startingIndex: prevIndex % cols - cols,\n                amount: cols,\n                disabledIndices\n              });\n            }\n          }\n          if (isIndexOutOfBounds(listRef, indexRef.current)) {\n            indexRef.current = prevIndex;\n          }\n          onNavigate(indexRef.current);\n        }\n\n        // Remains on the same row/column.\n        if (orientation === 'both') {\n          const prevRow = Math.floor(prevIndex / cols);\n          if (event.key === ARROW_RIGHT) {\n            stopEvent(event);\n            if (prevIndex % cols !== cols - 1) {\n              indexRef.current = findNonDisabledIndex(listRef, {\n                startingIndex: prevIndex,\n                disabledIndices\n              });\n              if (loop && isDifferentRow(indexRef.current, cols, prevRow)) {\n                indexRef.current = findNonDisabledIndex(listRef, {\n                  startingIndex: prevIndex - prevIndex % cols - 1,\n                  disabledIndices\n                });\n              }\n            } else if (loop) {\n              indexRef.current = findNonDisabledIndex(listRef, {\n                startingIndex: prevIndex - prevIndex % cols - 1,\n                disabledIndices\n              });\n            }\n            if (isDifferentRow(indexRef.current, cols, prevRow)) {\n              indexRef.current = prevIndex;\n            }\n          }\n          if (event.key === ARROW_LEFT) {\n            stopEvent(event);\n            if (prevIndex % cols !== 0) {\n              indexRef.current = findNonDisabledIndex(listRef, {\n                startingIndex: prevIndex,\n                disabledIndices,\n                decrement: true\n              });\n              if (loop && isDifferentRow(indexRef.current, cols, prevRow)) {\n                indexRef.current = findNonDisabledIndex(listRef, {\n                  startingIndex: prevIndex + (cols - prevIndex % cols),\n                  decrement: true,\n                  disabledIndices\n                });\n              }\n            } else if (loop) {\n              indexRef.current = findNonDisabledIndex(listRef, {\n                startingIndex: prevIndex + (cols - prevIndex % cols),\n                decrement: true,\n                disabledIndices\n              });\n            }\n            if (isDifferentRow(indexRef.current, cols, prevRow)) {\n              indexRef.current = prevIndex;\n            }\n          }\n          const lastRow = Math.floor(maxIndex / cols) === prevRow;\n          if (isIndexOutOfBounds(listRef, indexRef.current)) {\n            if (loop && lastRow) {\n              indexRef.current = event.key === ARROW_LEFT ? maxIndex : findNonDisabledIndex(listRef, {\n                startingIndex: prevIndex - prevIndex % cols - 1,\n                disabledIndices\n              });\n            } else {\n              indexRef.current = prevIndex;\n            }\n          }\n          onNavigate(indexRef.current);\n          return;\n        }\n      }\n      if (isMainOrientationKey(event.key, orientation)) {\n        stopEvent(event);\n\n        // Reset the index if no item is focused.\n        if (open && !virtual && activeElement$1(event.currentTarget.ownerDocument) === event.currentTarget) {\n          indexRef.current = isMainOrientationToEndKey(event.key, orientation, rtl) ? minIndex : maxIndex;\n          onNavigate(indexRef.current);\n          return;\n        }\n        if (isMainOrientationToEndKey(event.key, orientation, rtl)) {\n          if (loop) {\n            indexRef.current = currentIndex >= maxIndex ? allowEscape && currentIndex !== listRef.current.length ? -1 : minIndex : findNonDisabledIndex(listRef, {\n              startingIndex: currentIndex,\n              disabledIndices\n            });\n          } else {\n            indexRef.current = Math.min(maxIndex, findNonDisabledIndex(listRef, {\n              startingIndex: currentIndex,\n              disabledIndices\n            }));\n          }\n        } else {\n          if (loop) {\n            indexRef.current = currentIndex <= minIndex ? allowEscape && currentIndex !== -1 ? listRef.current.length : maxIndex : findNonDisabledIndex(listRef, {\n              startingIndex: currentIndex,\n              decrement: true,\n              disabledIndices\n            });\n          } else {\n            indexRef.current = Math.max(minIndex, findNonDisabledIndex(listRef, {\n              startingIndex: currentIndex,\n              decrement: true,\n              disabledIndices\n            }));\n          }\n        }\n        if (isIndexOutOfBounds(listRef, indexRef.current)) {\n          onNavigate(null);\n        } else {\n          onNavigate(indexRef.current);\n        }\n      }\n    }\n    function checkVirtualMouse(event) {\n      if (focusItemOnOpen === 'auto' && isVirtualClick(event.nativeEvent)) {\n        focusItemOnOpenRef.current = true;\n      }\n    }\n    function checkVirtualPointer(event) {\n      // `pointerdown` fires first, reset the state then perform the checks.\n      focusItemOnOpenRef.current = focusItemOnOpen;\n      if (focusItemOnOpen === 'auto' && isVirtualPointerEvent(event.nativeEvent)) {\n        focusItemOnOpenRef.current = true;\n      }\n    }\n    const ariaActiveDescendantProp = virtual && open && hasActiveIndex && {\n      'aria-activedescendant': activeId\n    };\n    return {\n      reference: {\n        ...ariaActiveDescendantProp,\n        onKeyDown(event) {\n          isPointerModalityRef.current = false;\n          const isArrowKey = event.key.indexOf('Arrow') === 0;\n          if (virtual && open) {\n            return onKeyDown(event);\n          }\n\n          // If a floating element should not open on arrow key down, avoid\n          // setting `activeIndex` while it's closed.\n          if (!open && !openOnArrowKeyDown && isArrowKey) {\n            return;\n          }\n          const isNavigationKey = isArrowKey || event.key === 'Enter' || event.key === ' ' || event.key === '';\n          if (isNavigationKey) {\n            keyRef.current = event.key;\n          }\n          if (nested) {\n            if (isCrossOrientationOpenKey(event.key, orientation, rtl)) {\n              stopEvent(event);\n              if (open) {\n                indexRef.current = getMinIndex(listRef, disabledIndices);\n                onNavigate(indexRef.current);\n              } else {\n                onOpenChange(true);\n              }\n            }\n            return;\n          }\n          if (isMainOrientationKey(event.key, orientation)) {\n            if (selectedIndex != null) {\n              indexRef.current = selectedIndex;\n            }\n            stopEvent(event);\n            if (!open && openOnArrowKeyDown) {\n              onOpenChange(true);\n            } else {\n              onKeyDown(event);\n            }\n            if (open) {\n              onNavigate(indexRef.current);\n            }\n          }\n        },\n        onFocus() {\n          if (open) {\n            onNavigate(null);\n          }\n        },\n        onPointerDown: checkVirtualPointer,\n        onMouseDown: checkVirtualMouse,\n        onClick: checkVirtualMouse\n      },\n      floating: {\n        'aria-orientation': orientation === 'both' ? undefined : orientation,\n        ...ariaActiveDescendantProp,\n        onKeyDown,\n        onPointerMove() {\n          isPointerModalityRef.current = true;\n        }\n      },\n      item\n    };\n  }, [domReference, refs, activeId, disabledIndicesRef, latestOpenRef, listRef, enabled, orientation, rtl, virtual, open, hasActiveIndex, nested, selectedIndex, openOnArrowKeyDown, allowEscape, cols, loop, focusItemOnOpen, onNavigate, onOpenChange, item]);\n};\n\n/**\n * Merges an array of refs into a single memoized callback ref or `null`.\n * @see https://floating-ui.com/docs/useMergeRefs\n */\nfunction useMergeRefs(refs) {\n  return React.useMemo(() => {\n    if (refs.every(ref => ref == null)) {\n      return null;\n    }\n    return value => {\n      refs.forEach(ref => {\n        if (typeof ref === 'function') {\n          ref(value);\n        } else if (ref != null) {\n          ref.current = value;\n        }\n      });\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, refs);\n}\n\n/**\n * Adds base screen reader props to the reference and floating elements for a\n * given floating element `role`.\n * @see https://floating-ui.com/docs/useRole\n */\nconst useRole = function (_ref, _temp) {\n  let {\n    open\n  } = _ref;\n  let {\n    enabled = true,\n    role = 'dialog'\n  } = _temp === void 0 ? {} : _temp;\n  const rootId = useId();\n  const referenceId = useId();\n  return React.useMemo(() => {\n    const floatingProps = {\n      id: rootId,\n      role\n    };\n    if (!enabled) {\n      return {};\n    }\n    if (role === 'tooltip') {\n      return {\n        reference: {\n          'aria-describedby': open ? rootId : undefined\n        },\n        floating: floatingProps\n      };\n    }\n    return {\n      reference: {\n        'aria-expanded': open ? 'true' : 'false',\n        'aria-haspopup': role === 'alertdialog' ? 'dialog' : role,\n        'aria-controls': open ? rootId : undefined,\n        ...(role === 'listbox' && {\n          role: 'combobox'\n        }),\n        ...(role === 'menu' && {\n          id: referenceId\n        })\n      },\n      floating: {\n        ...floatingProps,\n        ...(role === 'menu' && {\n          'aria-labelledby': referenceId\n        })\n      }\n    };\n  }, [enabled, role, open, rootId, referenceId]);\n};\n\n// Converts a JS style key like `backgroundColor` to a CSS transition-property\n// like `background-color`.\nconst camelCaseToKebabCase = str => str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($, ofs) => (ofs ? '-' : '') + $.toLowerCase());\nfunction useDelayUnmount(open, durationMs) {\n  const [isMounted, setIsMounted] = React.useState(open);\n  if (open && !isMounted) {\n    setIsMounted(true);\n  }\n  React.useEffect(() => {\n    if (!open) {\n      const timeout = setTimeout(() => setIsMounted(false), durationMs);\n      return () => clearTimeout(timeout);\n    }\n  }, [open, durationMs]);\n  return isMounted;\n}\n/**\n * Provides a status string to apply CSS transitions to a floating element,\n * correctly handling placement-aware transitions.\n * @see https://floating-ui.com/docs/useTransition#usetransitionstatus\n */\nfunction useTransitionStatus(_ref, _temp) {\n  let {\n    open,\n    elements: {\n      floating\n    }\n  } = _ref;\n  let {\n    duration = 250\n  } = _temp === void 0 ? {} : _temp;\n  const isNumberDuration = typeof duration === 'number';\n  const closeDuration = (isNumberDuration ? duration : duration.close) || 0;\n  const [initiated, setInitiated] = React.useState(false);\n  const [status, setStatus] = React.useState('unmounted');\n  const isMounted = useDelayUnmount(open, closeDuration);\n\n  // `initiated` check prevents this `setState` call from breaking\n  // <FloatingPortal />. This call is necessary to ensure subsequent opens\n  // after the initial one allows the correct side animation to play when the\n  // placement has changed.\n  index(() => {\n    if (initiated && !isMounted) {\n      setStatus('unmounted');\n    }\n  }, [initiated, isMounted]);\n  index(() => {\n    if (!floating) return;\n    if (open) {\n      setStatus('initial');\n      const frame = requestAnimationFrame(() => {\n        setStatus('open');\n      });\n      return () => {\n        cancelAnimationFrame(frame);\n      };\n    } else {\n      setInitiated(true);\n      setStatus('close');\n    }\n  }, [open, floating]);\n  return {\n    isMounted,\n    status\n  };\n}\n/**\n * Provides styles to apply CSS transitions to a floating element, correctly\n * handling placement-aware transitions. Wrapper around `useTransitionStatus`.\n * @see https://floating-ui.com/docs/useTransition#usetransitionstyles\n */\nfunction useTransitionStyles(context, _temp2) {\n  let {\n    initial: unstable_initial = {\n      opacity: 0\n    },\n    open: unstable_open,\n    close: unstable_close,\n    common: unstable_common,\n    duration = 250\n  } = _temp2 === void 0 ? {} : _temp2;\n  const placement = context.placement;\n  const side = placement.split('-')[0];\n  const [styles, setStyles] = React.useState({});\n  const {\n    isMounted,\n    status\n  } = useTransitionStatus(context, {\n    duration\n  });\n  const initialRef = useLatestRef(unstable_initial);\n  const openRef = useLatestRef(unstable_open);\n  const closeRef = useLatestRef(unstable_close);\n  const commonRef = useLatestRef(unstable_common);\n  const isNumberDuration = typeof duration === 'number';\n  const openDuration = (isNumberDuration ? duration : duration.open) || 0;\n  const closeDuration = (isNumberDuration ? duration : duration.close) || 0;\n  index(() => {\n    const fnArgs = {\n      side,\n      placement\n    };\n    const initial = initialRef.current;\n    const close = closeRef.current;\n    const open = openRef.current;\n    const common = commonRef.current;\n    const initialStyles = typeof initial === 'function' ? initial(fnArgs) : initial;\n    const closeStyles = typeof close === 'function' ? close(fnArgs) : close;\n    const commonStyles = typeof common === 'function' ? common(fnArgs) : common;\n    const openStyles = (typeof open === 'function' ? open(fnArgs) : open) || Object.keys(initialStyles).reduce((acc, key) => {\n      acc[key] = '';\n      return acc;\n    }, {});\n    if (status === 'initial' || status === 'unmounted') {\n      setStyles(styles => ({\n        transitionProperty: styles.transitionProperty,\n        ...commonStyles,\n        ...initialStyles\n      }));\n    }\n    if (status === 'open') {\n      setStyles({\n        transitionProperty: Object.keys(openStyles).map(camelCaseToKebabCase).join(','),\n        transitionDuration: openDuration + \"ms\",\n        ...commonStyles,\n        ...openStyles\n      });\n    }\n    if (status === 'close') {\n      const styles = closeStyles || initialStyles;\n      setStyles({\n        transitionProperty: Object.keys(styles).map(camelCaseToKebabCase).join(','),\n        transitionDuration: closeDuration + \"ms\",\n        ...commonStyles,\n        ...styles\n      });\n    }\n  }, [side, placement, closeDuration, closeRef, initialRef, openRef, commonRef, openDuration, status]);\n  return {\n    isMounted,\n    styles\n  };\n}\n\n/**\n * Provides a matching callback that can be used to focus an item as the user\n * types, often used in tandem with `useListNavigation()`.\n * @see https://floating-ui.com/docs/useTypeahead\n */\nconst useTypeahead = function (_ref, _temp) {\n  var _ref2;\n  let {\n    open,\n    dataRef,\n    refs\n  } = _ref;\n  let {\n    listRef,\n    activeIndex,\n    onMatch: unstable_onMatch = () => {},\n    enabled = true,\n    findMatch = null,\n    resetMs = 1000,\n    ignoreKeys = [],\n    selectedIndex = null\n  } = _temp === void 0 ? {\n    listRef: {\n      current: []\n    },\n    activeIndex: null\n  } : _temp;\n  const timeoutIdRef = React.useRef();\n  const stringRef = React.useRef('');\n  const prevIndexRef = React.useRef((_ref2 = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref2 : -1);\n  const matchIndexRef = React.useRef(null);\n  const onMatch = useEvent(unstable_onMatch);\n  const findMatchRef = useLatestRef(findMatch);\n  const ignoreKeysRef = useLatestRef(ignoreKeys);\n  index(() => {\n    if (open) {\n      clearTimeout(timeoutIdRef.current);\n      matchIndexRef.current = null;\n      stringRef.current = '';\n    }\n  }, [open]);\n  index(() => {\n    // Sync arrow key navigation but not typeahead navigation.\n    if (open && stringRef.current === '') {\n      var _ref3;\n      prevIndexRef.current = (_ref3 = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref3 : -1;\n    }\n  }, [open, selectedIndex, activeIndex]);\n  return React.useMemo(() => {\n    if (!enabled) {\n      return {};\n    }\n    function onKeyDown(event) {\n      var _refs$floating$curren;\n      // Correctly scope nested non-portalled floating elements. Since the nested\n      // floating element is inside of the another, we find the closest role\n      // that indicates the floating element scope.\n      const target = getTarget(event.nativeEvent);\n      if (isElement(target) && (activeElement$1(getDocument(target)) !== event.currentTarget ? (_refs$floating$curren = refs.floating.current) != null && _refs$floating$curren.contains(target) ? target.closest('[role=\"dialog\"],[role=\"menu\"],[role=\"listbox\"],[role=\"tree\"],[role=\"grid\"]') !== event.currentTarget : false : !event.currentTarget.contains(target))) {\n        return;\n      }\n      if (stringRef.current.length > 0 && stringRef.current[0] !== ' ') {\n        dataRef.current.typing = true;\n        if (event.key === ' ') {\n          stopEvent(event);\n        }\n      }\n      const listContent = listRef.current;\n      if (listContent == null || ignoreKeysRef.current.includes(event.key) ||\n      // Character key.\n      event.key.length !== 1 ||\n      // Modifier key.\n      event.ctrlKey || event.metaKey || event.altKey) {\n        return;\n      }\n\n      // Bail out if the list contains a word like \"llama\" or \"aaron\". TODO:\n      // allow it in this case, too.\n      const allowRapidSuccessionOfFirstLetter = listContent.every(text => {\n        var _text$, _text$2;\n        return text ? ((_text$ = text[0]) == null ? void 0 : _text$.toLocaleLowerCase()) !== ((_text$2 = text[1]) == null ? void 0 : _text$2.toLocaleLowerCase()) : true;\n      });\n\n      // Allows the user to cycle through items that start with the same letter\n      // in rapid succession.\n      if (allowRapidSuccessionOfFirstLetter && stringRef.current === event.key) {\n        stringRef.current = '';\n        prevIndexRef.current = matchIndexRef.current;\n      }\n      stringRef.current += event.key;\n      clearTimeout(timeoutIdRef.current);\n      timeoutIdRef.current = setTimeout(() => {\n        stringRef.current = '';\n        prevIndexRef.current = matchIndexRef.current;\n        dataRef.current.typing = false;\n      }, resetMs);\n      const prevIndex = prevIndexRef.current;\n      const orderedList = [...listContent.slice((prevIndex || 0) + 1), ...listContent.slice(0, (prevIndex || 0) + 1)];\n      const str = findMatchRef.current ? findMatchRef.current(orderedList, stringRef.current) : orderedList.find(text => (text == null ? void 0 : text.toLocaleLowerCase().indexOf(stringRef.current.toLocaleLowerCase())) === 0);\n      const index = str ? listContent.indexOf(str) : -1;\n      if (index !== -1) {\n        onMatch(index);\n        matchIndexRef.current = index;\n      }\n    }\n    return {\n      reference: {\n        onKeyDown\n      },\n      floating: {\n        onKeyDown\n      }\n    };\n  }, [enabled, dataRef, listRef, resetMs, ignoreKeysRef, findMatchRef, onMatch, refs]);\n};\n\nfunction getArgsWithCustomFloatingHeight(state, height) {\n  return {\n    ...state,\n    rects: {\n      ...state.rects,\n      floating: {\n        ...state.rects.floating,\n        height\n      }\n    }\n  };\n}\n/**\n * Positions the floating element such that an inner element inside\n * of it is anchored to the reference element.\n * @see https://floating-ui.com/docs/inner\n */\nconst inner = props => ({\n  name: 'inner',\n  options: props,\n  async fn(state) {\n    const {\n      listRef,\n      overflowRef,\n      onFallbackChange,\n      offset: innerOffset = 0,\n      index = 0,\n      minItemsVisible = 4,\n      referenceOverflowThreshold = 0,\n      scrollRef,\n      ...detectOverflowOptions\n    } = props;\n    const {\n      rects,\n      elements: {\n        floating\n      }\n    } = state;\n    const item = listRef.current[index];\n    if (process.env.NODE_ENV !== \"production\") {\n      if (!state.placement.startsWith('bottom')) {\n        console.warn(['Floating UI: `placement` side must be \"bottom\" when using the', '`inner` middleware.'].join(' '));\n      }\n    }\n    if (!item) {\n      return {};\n    }\n    const nextArgs = {\n      ...state,\n      ...(await offset(-item.offsetTop - rects.reference.height / 2 - item.offsetHeight / 2 - innerOffset).fn(state))\n    };\n    const el = (scrollRef == null ? void 0 : scrollRef.current) || floating;\n    const overflow = await detectOverflow(getArgsWithCustomFloatingHeight(nextArgs, el.scrollHeight), detectOverflowOptions);\n    const refOverflow = await detectOverflow(nextArgs, {\n      ...detectOverflowOptions,\n      elementContext: 'reference'\n    });\n    const diffY = Math.max(0, overflow.top);\n    const nextY = nextArgs.y + diffY;\n    const maxHeight = Math.max(0, el.scrollHeight - diffY - Math.max(0, overflow.bottom));\n    el.style.maxHeight = maxHeight + \"px\";\n    el.scrollTop = diffY;\n\n    // There is not enough space, fallback to standard anchored positioning\n    if (onFallbackChange) {\n      if (el.offsetHeight < item.offsetHeight * Math.min(minItemsVisible, listRef.current.length - 1) - 1 || refOverflow.top >= -referenceOverflowThreshold || refOverflow.bottom >= -referenceOverflowThreshold) {\n        flushSync(() => onFallbackChange(true));\n      } else {\n        flushSync(() => onFallbackChange(false));\n      }\n    }\n    if (overflowRef) {\n      overflowRef.current = await detectOverflow(getArgsWithCustomFloatingHeight({\n        ...nextArgs,\n        y: nextY\n      }, el.offsetHeight), detectOverflowOptions);\n    }\n    return {\n      y: nextY\n    };\n  }\n});\n/**\n * Changes the `inner` middleware's `offset` upon a `wheel` event to\n * expand the floating element's height, revealing more list items.\n * @see https://floating-ui.com/docs/inner\n */\nconst useInnerOffset = (_ref, _ref2) => {\n  let {\n    open,\n    elements\n  } = _ref;\n  let {\n    enabled = true,\n    overflowRef,\n    scrollRef,\n    onChange: unstable_onChange\n  } = _ref2;\n  const onChange = useEvent(unstable_onChange);\n  const controlledScrollingRef = React.useRef(false);\n  const prevScrollTopRef = React.useRef(null);\n  const initialOverflowRef = React.useRef(null);\n  React.useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n    function onWheel(e) {\n      if (e.ctrlKey || !el || overflowRef.current == null) {\n        return;\n      }\n      const dY = e.deltaY;\n      const isAtTop = overflowRef.current.top >= -0.5;\n      const isAtBottom = overflowRef.current.bottom >= -0.5;\n      const remainingScroll = el.scrollHeight - el.clientHeight;\n      const sign = dY < 0 ? -1 : 1;\n      const method = dY < 0 ? 'max' : 'min';\n      if (el.scrollHeight <= el.clientHeight) {\n        return;\n      }\n      if (!isAtTop && dY > 0 || !isAtBottom && dY < 0) {\n        e.preventDefault();\n        flushSync(() => {\n          onChange(d => d + Math[method](dY, remainingScroll * sign));\n        });\n      } else if (/firefox/i.test(getUserAgent())) {\n        // Needed to propagate scrolling during momentum scrolling phase once\n        // it gets limited by the boundary. UX improvement, not critical.\n        el.scrollTop += dY;\n      }\n    }\n    const el = (scrollRef == null ? void 0 : scrollRef.current) || elements.floating;\n    if (open && el) {\n      el.addEventListener('wheel', onWheel);\n\n      // Wait for the position to be ready.\n      requestAnimationFrame(() => {\n        prevScrollTopRef.current = el.scrollTop;\n        if (overflowRef.current != null) {\n          initialOverflowRef.current = {\n            ...overflowRef.current\n          };\n        }\n      });\n      return () => {\n        prevScrollTopRef.current = null;\n        initialOverflowRef.current = null;\n        el.removeEventListener('wheel', onWheel);\n      };\n    }\n  }, [enabled, open, elements.floating, overflowRef, scrollRef, onChange]);\n  return React.useMemo(() => {\n    if (!enabled) {\n      return {};\n    }\n    return {\n      floating: {\n        onKeyDown() {\n          controlledScrollingRef.current = true;\n        },\n        onWheel() {\n          controlledScrollingRef.current = false;\n        },\n        onPointerMove() {\n          controlledScrollingRef.current = false;\n        },\n        onScroll() {\n          const el = (scrollRef == null ? void 0 : scrollRef.current) || elements.floating;\n          if (!overflowRef.current || !el || !controlledScrollingRef.current) {\n            return;\n          }\n          if (prevScrollTopRef.current !== null) {\n            const scrollDiff = el.scrollTop - prevScrollTopRef.current;\n            if (overflowRef.current.bottom < -0.5 && scrollDiff < -1 || overflowRef.current.top < -0.5 && scrollDiff > 1) {\n              flushSync(() => onChange(d => d + scrollDiff));\n            }\n          }\n\n          // [Firefox] Wait for the height change to have been applied.\n          requestAnimationFrame(() => {\n            prevScrollTopRef.current = el.scrollTop;\n          });\n        }\n      }\n    };\n  }, [enabled, overflowRef, elements.floating, scrollRef, onChange]);\n};\n\nfunction isPointInPolygon(point, polygon) {\n  const [x, y] = point;\n  let isInside = false;\n  const length = polygon.length;\n  for (let i = 0, j = length - 1; i < length; j = i++) {\n    const [xi, yi] = polygon[i] || [0, 0];\n    const [xj, yj] = polygon[j] || [0, 0];\n    const intersect = yi >= y !== yj >= y && x <= (xj - xi) * (y - yi) / (yj - yi) + xi;\n    if (intersect) {\n      isInside = !isInside;\n    }\n  }\n  return isInside;\n}\nfunction isInside(point, rect) {\n  return point[0] >= rect.x && point[0] <= rect.x + rect.width && point[1] >= rect.y && point[1] <= rect.y + rect.height;\n}\nfunction safePolygon(_temp) {\n  let {\n    restMs = 0,\n    buffer = 0.5,\n    blockPointerEvents = false\n  } = _temp === void 0 ? {} : _temp;\n  let timeoutId;\n  let isInsideRect = false;\n  let hasLanded = false;\n  const fn = _ref => {\n    let {\n      x,\n      y,\n      placement,\n      elements,\n      onClose,\n      nodeId,\n      tree\n    } = _ref;\n    return function onMouseMove(event) {\n      function close() {\n        clearTimeout(timeoutId);\n        onClose();\n      }\n      clearTimeout(timeoutId);\n      if (!elements.domReference || !elements.floating || placement == null || x == null || y == null) {\n        return;\n      }\n      const {\n        clientX,\n        clientY\n      } = event;\n      const clientPoint = [clientX, clientY];\n      const target = getTarget(event);\n      const isLeave = event.type === 'mouseleave';\n      const isOverFloatingEl = contains(elements.floating, target);\n      const isOverReferenceEl = contains(elements.domReference, target);\n      const refRect = elements.domReference.getBoundingClientRect();\n      const rect = elements.floating.getBoundingClientRect();\n      const side = placement.split('-')[0];\n      const cursorLeaveFromRight = x > rect.right - rect.width / 2;\n      const cursorLeaveFromBottom = y > rect.bottom - rect.height / 2;\n      const isOverReferenceRect = isInside(clientPoint, refRect);\n      if (isOverFloatingEl) {\n        hasLanded = true;\n        if (!isLeave) {\n          return;\n        }\n      }\n      if (isOverReferenceEl) {\n        hasLanded = false;\n      }\n      if (isOverReferenceEl && !isLeave) {\n        hasLanded = true;\n        return;\n      }\n\n      // Prevent overlapping floating element from being stuck in an open-close\n      // loop: https://github.com/floating-ui/floating-ui/issues/1910\n      if (isLeave && isElement(event.relatedTarget) && contains(elements.floating, event.relatedTarget)) {\n        return;\n      }\n\n      // If any nested child is open, abort.\n      if (tree && getChildren(tree.nodesRef.current, nodeId).some(_ref2 => {\n        let {\n          context\n        } = _ref2;\n        return context == null ? void 0 : context.open;\n      })) {\n        return;\n      }\n\n      // If the pointer is leaving from the opposite side, the \"buffer\" logic\n      // creates a point where the floating element remains open, but should be\n      // ignored.\n      // A constant of 1 handles floating point rounding errors.\n      if (side === 'top' && y >= refRect.bottom - 1 || side === 'bottom' && y <= refRect.top + 1 || side === 'left' && x >= refRect.right - 1 || side === 'right' && x <= refRect.left + 1) {\n        return close();\n      }\n\n      // Ignore when the cursor is within the rectangular trough between the\n      // two elements. Since the triangle is created from the cursor point,\n      // which can start beyond the ref element's edge, traversing back and\n      // forth from the ref to the floating element can cause it to close. This\n      // ensures it always remains open in that case.\n      let rectPoly = [];\n      switch (side) {\n        case 'top':\n          rectPoly = [[rect.left, refRect.top + 1], [rect.left, rect.bottom - 1], [rect.right, rect.bottom - 1], [rect.right, refRect.top + 1]];\n          isInsideRect = clientX >= rect.left && clientX <= rect.right && clientY >= rect.top && clientY <= refRect.top + 1;\n          break;\n        case 'bottom':\n          rectPoly = [[rect.left, rect.top + 1], [rect.left, refRect.bottom - 1], [rect.right, refRect.bottom - 1], [rect.right, rect.top + 1]];\n          isInsideRect = clientX >= rect.left && clientX <= rect.right && clientY >= refRect.bottom - 1 && clientY <= rect.bottom;\n          break;\n        case 'left':\n          rectPoly = [[rect.right - 1, rect.bottom], [rect.right - 1, rect.top], [refRect.left + 1, rect.top], [refRect.left + 1, rect.bottom]];\n          isInsideRect = clientX >= rect.left && clientX <= refRect.left + 1 && clientY >= rect.top && clientY <= rect.bottom;\n          break;\n        case 'right':\n          rectPoly = [[refRect.right - 1, rect.bottom], [refRect.right - 1, rect.top], [rect.left + 1, rect.top], [rect.left + 1, rect.bottom]];\n          isInsideRect = clientX >= refRect.right - 1 && clientX <= rect.right && clientY >= rect.top && clientY <= rect.bottom;\n          break;\n      }\n      function getPolygon(_ref3) {\n        let [x, y] = _ref3;\n        const isFloatingWider = rect.width > refRect.width;\n        const isFloatingTaller = rect.height > refRect.height;\n        switch (side) {\n          case 'top':\n            {\n              const cursorPointOne = [isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y + buffer + 1];\n              const cursorPointTwo = [isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y + buffer + 1];\n              const commonPoints = [[rect.left, cursorLeaveFromRight ? rect.bottom - buffer : isFloatingWider ? rect.bottom - buffer : rect.top], [rect.right, cursorLeaveFromRight ? isFloatingWider ? rect.bottom - buffer : rect.top : rect.bottom - buffer]];\n              return [cursorPointOne, cursorPointTwo, ...commonPoints];\n            }\n          case 'bottom':\n            {\n              const cursorPointOne = [isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y - buffer];\n              const cursorPointTwo = [isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y - buffer];\n              const commonPoints = [[rect.left, cursorLeaveFromRight ? rect.top + buffer : isFloatingWider ? rect.top + buffer : rect.bottom], [rect.right, cursorLeaveFromRight ? isFloatingWider ? rect.top + buffer : rect.bottom : rect.top + buffer]];\n              return [cursorPointOne, cursorPointTwo, ...commonPoints];\n            }\n          case 'left':\n            {\n              const cursorPointOne = [x + buffer + 1, isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const cursorPointTwo = [x + buffer + 1, isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const commonPoints = [[cursorLeaveFromBottom ? rect.right - buffer : isFloatingTaller ? rect.right - buffer : rect.left, rect.top], [cursorLeaveFromBottom ? isFloatingTaller ? rect.right - buffer : rect.left : rect.right - buffer, rect.bottom]];\n              return [...commonPoints, cursorPointOne, cursorPointTwo];\n            }\n          case 'right':\n            {\n              const cursorPointOne = [x - buffer, isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const cursorPointTwo = [x - buffer, isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const commonPoints = [[cursorLeaveFromBottom ? rect.left + buffer : isFloatingTaller ? rect.left + buffer : rect.right, rect.top], [cursorLeaveFromBottom ? isFloatingTaller ? rect.left + buffer : rect.right : rect.left + buffer, rect.bottom]];\n              return [cursorPointOne, cursorPointTwo, ...commonPoints];\n            }\n        }\n      }\n      const poly = isInsideRect ? rectPoly : getPolygon([x, y]);\n      if (isInsideRect) {\n        return;\n      } else if (hasLanded && !isOverReferenceRect) {\n        return close();\n      }\n      if (!isPointInPolygon([clientX, clientY], poly)) {\n        close();\n      } else if (restMs && !hasLanded) {\n        timeoutId = setTimeout(close, restMs);\n      }\n    };\n  };\n  fn.__options = {\n    blockPointerEvents\n  };\n  return fn;\n}\n\n/**\n * Provides data to position a floating element and context to add interactions.\n * @see https://floating-ui.com/docs/react\n */\nfunction useFloating(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    open = false,\n    onOpenChange: unstable_onOpenChange,\n    nodeId\n  } = options;\n  const position = useFloating$1(options);\n  const tree = useFloatingTree();\n  const domReferenceRef = React.useRef(null);\n  const dataRef = React.useRef({});\n  const events = React.useState(() => createPubSub())[0];\n  const [domReference, setDomReference] = React.useState(null);\n  const setPositionReference = React.useCallback(node => {\n    const positionReference = isElement(node) ? {\n      getBoundingClientRect: () => node.getBoundingClientRect(),\n      contextElement: node\n    } : node;\n    position.refs.setReference(positionReference);\n  }, [position.refs]);\n  const setReference = React.useCallback(node => {\n    if (isElement(node) || node === null) {\n      domReferenceRef.current = node;\n      setDomReference(node);\n    }\n\n    // Backwards-compatibility for passing a virtual element to `reference`\n    // after it has set the DOM reference.\n    if (isElement(position.refs.reference.current) || position.refs.reference.current === null ||\n    // Don't allow setting virtual elements using the old technique back to\n    // `null` to support `positionReference` + an unstable `reference`\n    // callback ref.\n    node !== null && !isElement(node)) {\n      position.refs.setReference(node);\n    }\n  }, [position.refs]);\n  const refs = React.useMemo(() => ({\n    ...position.refs,\n    setReference,\n    setPositionReference,\n    domReference: domReferenceRef\n  }), [position.refs, setReference, setPositionReference]);\n  const elements = React.useMemo(() => ({\n    ...position.elements,\n    domReference: domReference\n  }), [position.elements, domReference]);\n  const onOpenChange = useEvent(unstable_onOpenChange);\n  const context = React.useMemo(() => ({\n    ...position,\n    refs,\n    elements,\n    dataRef,\n    nodeId,\n    events,\n    open,\n    onOpenChange\n  }), [position, nodeId, events, open, onOpenChange, refs, elements]);\n  index(() => {\n    const node = tree == null ? void 0 : tree.nodesRef.current.find(node => node.id === nodeId);\n    if (node) {\n      node.context = context;\n    }\n  });\n  return React.useMemo(() => ({\n    ...position,\n    context,\n    refs,\n    reference: setReference,\n    positionReference: setPositionReference\n  }), [position, refs, context, setReference, setPositionReference]);\n}\n\nfunction mergeProps(userProps, propsList, elementKey) {\n  const map = new Map();\n  return {\n    ...(elementKey === 'floating' && {\n      tabIndex: -1\n    }),\n    ...userProps,\n    ...propsList.map(value => value ? value[elementKey] : null).concat(userProps).reduce((acc, props) => {\n      if (!props) {\n        return acc;\n      }\n      Object.entries(props).forEach(_ref => {\n        let [key, value] = _ref;\n        if (key.indexOf('on') === 0) {\n          if (!map.has(key)) {\n            map.set(key, []);\n          }\n          if (typeof value === 'function') {\n            var _map$get;\n            (_map$get = map.get(key)) == null ? void 0 : _map$get.push(value);\n            acc[key] = function () {\n              var _map$get2;\n              for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n                args[_key] = arguments[_key];\n              }\n              (_map$get2 = map.get(key)) == null ? void 0 : _map$get2.forEach(fn => fn(...args));\n            };\n          }\n        } else {\n          acc[key] = value;\n        }\n      });\n      return acc;\n    }, {})\n  };\n}\nconst useInteractions = function (propsList) {\n  if (propsList === void 0) {\n    propsList = [];\n  }\n  // The dependencies are a dynamic array, so we can't use the linter's\n  // suggestion to add it to the deps array.\n  const deps = propsList;\n  const getReferenceProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'reference'),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  deps);\n  const getFloatingProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'floating'),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  deps);\n  const getItemProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'item'),\n  // Granularly check for `item` changes, because the `getItemProps` getter\n  // should be as referentially stable as possible since it may be passed as\n  // a prop to many components. All `item` key values must therefore be\n  // memoized.\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  propsList.map(key => key == null ? void 0 : key.item));\n  return React.useMemo(() => ({\n    getReferenceProps,\n    getFloatingProps,\n    getItemProps\n  }), [getReferenceProps, getFloatingProps, getItemProps]);\n};\n\nexport { FloatingDelayGroup, FloatingFocusManager, FloatingNode, FloatingOverlay, FloatingPortal, FloatingTree, inner, safePolygon, useClick, useDelayGroup, useDelayGroupContext, useDismiss, useFloating, useFloatingNodeId, useFloatingParentNodeId, useFloatingPortalNode, useFloatingTree, useFocus, useHover, useId, useInnerOffset, useInteractions, useListNavigation, useMergeRefs, useRole, useTransitionStatus, useTransitionStyles, useTypeahead };\n","var __defProp = Object.defineProperty;\nvar __defProps = Object.defineProperties;\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));\nfunction horizontalSide(placement, arrowY, arrowOffset, arrowPosition) {\n  if (placement === \"center\" || arrowPosition === \"center\") {\n    return { top: arrowY };\n  }\n  if (placement === \"end\") {\n    return { bottom: arrowOffset };\n  }\n  if (placement === \"start\") {\n    return { top: arrowOffset };\n  }\n  return {};\n}\nfunction verticalSide(placement, arrowX, arrowOffset, arrowPosition, dir) {\n  if (placement === \"center\" || arrowPosition === \"center\") {\n    return { left: arrowX };\n  }\n  if (placement === \"end\") {\n    return { [dir === \"ltr\" ? \"right\" : \"left\"]: arrowOffset };\n  }\n  if (placement === \"start\") {\n    return { [dir === \"ltr\" ? \"left\" : \"right\"]: arrowOffset };\n  }\n  return {};\n}\nconst radiusByFloatingSide = {\n  bottom: \"borderTopLeftRadius\",\n  left: \"borderTopRightRadius\",\n  right: \"borderBottomLeftRadius\",\n  top: \"borderBottomRightRadius\"\n};\nfunction getArrowPositionStyles({\n  position,\n  withBorder,\n  arrowSize,\n  arrowOffset,\n  arrowRadius,\n  arrowPosition,\n  arrowX,\n  arrowY,\n  dir\n}) {\n  const [side, placement = \"center\"] = position.split(\"-\");\n  const baseStyles = {\n    width: arrowSize,\n    height: arrowSize,\n    transform: \"rotate(45deg)\",\n    position: \"absolute\",\n    [radiusByFloatingSide[side]]: arrowRadius\n  };\n  const arrowPlacement = withBorder ? -arrowSize / 2 - 1 : -arrowSize / 2;\n  if (side === \"left\") {\n    return __spreadProps(__spreadValues(__spreadValues({}, baseStyles), horizontalSide(placement, arrowY, arrowOffset, arrowPosition)), {\n      right: arrowPlacement,\n      borderLeft: 0,\n      borderBottom: 0\n    });\n  }\n  if (side === \"right\") {\n    return __spreadProps(__spreadValues(__spreadValues({}, baseStyles), horizontalSide(placement, arrowY, arrowOffset, arrowPosition)), {\n      left: arrowPlacement,\n      borderRight: 0,\n      borderTop: 0\n    });\n  }\n  if (side === \"top\") {\n    return __spreadProps(__spreadValues(__spreadValues({}, baseStyles), verticalSide(placement, arrowX, arrowOffset, arrowPosition, dir)), {\n      bottom: arrowPlacement,\n      borderTop: 0,\n      borderLeft: 0\n    });\n  }\n  if (side === \"bottom\") {\n    return __spreadProps(__spreadValues(__spreadValues({}, baseStyles), verticalSide(placement, arrowX, arrowOffset, arrowPosition, dir)), {\n      top: arrowPlacement,\n      borderBottom: 0,\n      borderRight: 0\n    });\n  }\n  return {};\n}\n\nexport { getArrowPositionStyles };\n//# sourceMappingURL=get-arrow-position-styles.js.map\n","import React, { forwardRef } from 'react';\nimport { useMantineTheme } from '@mantine/styles';\nimport { getArrowPositionStyles } from './get-arrow-position-styles.js';\n\nvar __defProp = Object.defineProperty;\nvar __defProps = Object.defineProperties;\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));\nvar __objRest = (source, exclude) => {\n  var target = {};\n  for (var prop in source)\n    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)\n      target[prop] = source[prop];\n  if (source != null && __getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(source)) {\n      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))\n        target[prop] = source[prop];\n    }\n  return target;\n};\nconst FloatingArrow = forwardRef((_a, ref) => {\n  var _b = _a, {\n    withBorder,\n    position,\n    arrowSize,\n    arrowOffset,\n    arrowRadius,\n    arrowPosition,\n    visible,\n    arrowX,\n    arrowY\n  } = _b, others = __objRest(_b, [\n    \"withBorder\",\n    \"position\",\n    \"arrowSize\",\n    \"arrowOffset\",\n    \"arrowRadius\",\n    \"arrowPosition\",\n    \"visible\",\n    \"arrowX\",\n    \"arrowY\"\n  ]);\n  const theme = useMantineTheme();\n  if (!visible) {\n    return null;\n  }\n  return /* @__PURE__ */ React.createElement(\"div\", __spreadProps(__spreadValues({}, others), {\n    ref,\n    style: getArrowPositionStyles({\n      withBorder,\n      position,\n      arrowSize,\n      arrowOffset,\n      arrowRadius,\n      arrowPosition,\n      dir: theme.dir,\n      arrowX,\n      arrowY\n    })\n  }));\n});\nFloatingArrow.displayName = \"@mantine/core/FloatingArrow\";\n\nexport { FloatingArrow };\n//# sourceMappingURL=FloatingArrow.js.map\n","function getFloatingPosition(dir, position) {\n  if (dir === \"rtl\" && (position.includes(\"right\") || position.includes(\"left\"))) {\n    const [side, placement] = position.split(\"-\");\n    const flippedPosition = side === \"right\" ? \"left\" : \"right\";\n    return placement === void 0 ? flippedPosition : `${flippedPosition}-${placement}`;\n  }\n  return position;\n}\n\nexport { getFloatingPosition };\n//# sourceMappingURL=get-floating-position.js.map\n","import { useState, useEffect } from 'react';\nimport { autoUpdate } from '@floating-ui/react';\nimport { useDidUpdate } from '@mantine/hooks';\n\nfunction useFloatingAutoUpdate({ opened, floating, positionDependencies }) {\n  const [delayedUpdate, setDelayedUpdate] = useState(0);\n  useEffect(() => {\n    if (floating.refs.reference.current && floating.refs.floating.current) {\n      return autoUpdate(floating.refs.reference.current, floating.refs.floating.current, floating.update);\n    }\n    return void 0;\n  }, [floating.refs.reference.current, floating.refs.floating.current, opened, delayedUpdate]);\n  useDidUpdate(() => {\n    floating.update();\n  }, positionDependencies);\n  useDidUpdate(() => {\n    setDelayedUpdate((c) => c + 1);\n  }, [opened]);\n}\n\nexport { useFloatingAutoUpdate };\n//# sourceMappingURL=use-floating-auto-update.js.map\n","import { useComponentDefaultProps } from '@mantine/styles';\nimport { useId } from '@mantine/hooks';\nimport { extractSystemStyles } from '../Box/style-system-props/extract-system-styles/extract-system-styles.js';\n\nvar __defProp = Object.defineProperty;\nvar __defProps = Object.defineProperties;\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));\nvar __objRest = (source, exclude) => {\n  var target = {};\n  for (var prop in source)\n    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)\n      target[prop] = source[prop];\n  if (source != null && __getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(source)) {\n      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))\n        target[prop] = source[prop];\n    }\n  return target;\n};\nfunction useInputProps(component, defaultProps, props) {\n  const _a = useComponentDefaultProps(component, defaultProps, props), {\n    label,\n    description,\n    error,\n    required,\n    classNames,\n    styles,\n    className,\n    unstyled,\n    __staticSelector,\n    sx,\n    errorProps,\n    labelProps,\n    descriptionProps,\n    wrapperProps: _wrapperProps,\n    id,\n    size,\n    style,\n    inputContainer,\n    inputWrapperOrder,\n    withAsterisk\n  } = _a, others = __objRest(_a, [\n    \"label\",\n    \"description\",\n    \"error\",\n    \"required\",\n    \"classNames\",\n    \"styles\",\n    \"className\",\n    \"unstyled\",\n    \"__staticSelector\",\n    \"sx\",\n    \"errorProps\",\n    \"labelProps\",\n    \"descriptionProps\",\n    \"wrapperProps\",\n    \"id\",\n    \"size\",\n    \"style\",\n    \"inputContainer\",\n    \"inputWrapperOrder\",\n    \"withAsterisk\"\n  ]);\n  const uid = useId(id);\n  const { systemStyles, rest } = extractSystemStyles(others);\n  const wrapperProps = __spreadValues({\n    label,\n    description,\n    error,\n    required,\n    classNames,\n    className,\n    __staticSelector,\n    sx,\n    errorProps,\n    labelProps,\n    descriptionProps,\n    unstyled,\n    styles,\n    id: uid,\n    size,\n    style,\n    inputContainer,\n    inputWrapperOrder,\n    withAsterisk\n  }, _wrapperProps);\n  return __spreadProps(__spreadValues({}, rest), {\n    classNames,\n    styles,\n    unstyled,\n    wrapperProps: __spreadValues(__spreadValues({}, wrapperProps), systemStyles),\n    inputProps: {\n      required,\n      classNames,\n      styles,\n      unstyled,\n      id: uid,\n      size,\n      __staticSelector,\n      invalid: !!error\n    }\n  });\n}\n\nexport { useInputProps };\n//# sourceMappingURL=use-input-props.js.map\n","import { useRef, useEffect } from 'react';\n\nconst DEFAULT_EVENTS = [\"mousedown\", \"touchstart\"];\nfunction useClickOutside(handler, events, nodes) {\n  const ref = useRef();\n  useEffect(() => {\n    const listener = (event) => {\n      const { target } = event != null ? event : {};\n      if (Array.isArray(nodes)) {\n        const shouldIgnore = (target == null ? void 0 : target.hasAttribute(\"data-ignore-outside-clicks\")) || !document.body.contains(target) && target.tagName !== \"HTML\";\n        const shouldTrigger = nodes.every((node) => !!node && !event.composedPath().includes(node));\n        shouldTrigger && !shouldIgnore && handler();\n      } else if (ref.current && !ref.current.contains(target)) {\n        handler();\n      }\n    };\n    (events || DEFAULT_EVENTS).forEach((fn) => document.addEventListener(fn, listener));\n    return () => {\n      (events || DEFAULT_EVENTS).forEach((fn) => document.removeEventListener(fn, listener));\n    };\n  }, [ref, handler, nodes]);\n  return ref;\n}\n\nexport { useClickOutside };\n//# sourceMappingURL=use-click-outside.js.map\n","import { useUncontrolled, useDidUpdate } from '@mantine/hooks';\nimport { useFloating, size, offset, shift, limitShift, flip, inline, arrow } from '@floating-ui/react';\nimport { useFloatingAutoUpdate } from '../Floating/use-floating-auto-update.js';\n\nfunction getPopoverMiddlewares(options) {\n  const middlewares = [offset(options.offset)];\n  if (options.middlewares.shift) {\n    middlewares.push(shift({ limiter: limitShift() }));\n  }\n  if (options.middlewares.flip) {\n    middlewares.push(flip());\n  }\n  if (options.middlewares.inline) {\n    middlewares.push(inline());\n  }\n  middlewares.push(arrow({ element: options.arrowRef, padding: options.arrowOffset }));\n  return middlewares;\n}\nfunction usePopover(options) {\n  const [_opened, setOpened] = useUncontrolled({\n    value: options.opened,\n    defaultValue: options.defaultOpened,\n    finalValue: false,\n    onChange: options.onChange\n  });\n  const onClose = () => {\n    var _a;\n    (_a = options.onClose) == null ? void 0 : _a.call(options);\n    setOpened(false);\n  };\n  const onToggle = () => {\n    var _a, _b;\n    if (_opened) {\n      (_a = options.onClose) == null ? void 0 : _a.call(options);\n      setOpened(false);\n    } else {\n      (_b = options.onOpen) == null ? void 0 : _b.call(options);\n      setOpened(true);\n    }\n  };\n  const floating = useFloating({\n    placement: options.position,\n    middleware: [\n      ...getPopoverMiddlewares(options),\n      ...options.width === \"target\" ? [\n        size({\n          apply({ rects }) {\n            var _a, _b;\n            Object.assign((_b = (_a = floating.refs.floating.current) == null ? void 0 : _a.style) != null ? _b : {}, {\n              width: `${rects.reference.width}px`\n            });\n          }\n        })\n      ] : []\n    ]\n  });\n  useFloatingAutoUpdate({\n    opened: options.opened,\n    positionDependencies: options.positionDependencies,\n    floating\n  });\n  useDidUpdate(() => {\n    var _a;\n    (_a = options.onPositionChange) == null ? void 0 : _a.call(options, floating.placement);\n  }, [floating.placement]);\n  return {\n    floating,\n    controlled: typeof options.opened === \"boolean\",\n    opened: _opened,\n    onClose,\n    onToggle\n  };\n}\n\nexport { usePopover };\n//# sourceMappingURL=use-popover.js.map\n","const POPOVER_ERRORS = {\n  context: \"Popover component was not found in the tree\",\n  children: \"Popover.Target component children should be an element or a component that accepts ref, fragments, strings, numbers and other primitive values are not supported\"\n};\n\nexport { POPOVER_ERRORS };\n//# sourceMappingURL=Popover.errors.js.map\n","import { createSafeContext } from '@mantine/utils';\nimport { POPOVER_ERRORS } from './Popover.errors.js';\n\nconst [PopoverContextProvider, usePopoverContext] = createSafeContext(POPOVER_ERRORS.context);\n\nexport { PopoverContextProvider, usePopoverContext };\n//# sourceMappingURL=Popover.context.js.map\n","import { forwardRef, cloneElement } from 'react';\nimport { useMergedRef } from '@mantine/hooks';\nimport { isElement } from '@mantine/utils';\nimport { useComponentDefaultProps, clsx } from '@mantine/styles';\nimport { usePopoverContext } from '../Popover.context.js';\nimport { POPOVER_ERRORS } from '../Popover.errors.js';\n\nvar __defProp = Object.defineProperty;\nvar __defProps = Object.defineProperties;\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));\nvar __objRest = (source, exclude) => {\n  var target = {};\n  for (var prop in source)\n    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)\n      target[prop] = source[prop];\n  if (source != null && __getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(source)) {\n      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))\n        target[prop] = source[prop];\n    }\n  return target;\n};\nconst defaultProps = {\n  refProp: \"ref\",\n  popupType: \"dialog\"\n};\nconst PopoverTarget = forwardRef((props, ref) => {\n  const _a = useComponentDefaultProps(\"PopoverTarget\", defaultProps, props), { children, refProp, popupType } = _a, others = __objRest(_a, [\"children\", \"refProp\", \"popupType\"]);\n  if (!isElement(children)) {\n    throw new Error(POPOVER_ERRORS.children);\n  }\n  const forwardedProps = others;\n  const ctx = usePopoverContext();\n  const targetRef = useMergedRef(ctx.reference, children.ref, ref);\n  const accessibleProps = ctx.withRoles ? {\n    \"aria-haspopup\": popupType,\n    \"aria-expanded\": ctx.opened,\n    \"aria-controls\": ctx.getDropdownId(),\n    id: ctx.getTargetId()\n  } : {};\n  return cloneElement(children, __spreadValues(__spreadProps(__spreadValues(__spreadValues(__spreadValues({}, forwardedProps), accessibleProps), ctx.targetProps), {\n    className: clsx(ctx.targetProps.className, forwardedProps.className, children.props.className),\n    [refProp]: targetRef\n  }), !ctx.controlled ? { onClick: ctx.onToggle } : null));\n});\nPopoverTarget.displayName = \"@mantine/core/PopoverTarget\";\n\nexport { PopoverTarget };\n//# sourceMappingURL=PopoverTarget.js.map\n","const noop = () => {\n};\n\nexport { noop };\n//# sourceMappingURL=noop.js.map\n","import { noop } from '../noop/noop.js';\n\nfunction closeOnEscape(callback, options = { active: true }) {\n  if (typeof callback !== \"function\" || !options.active) {\n    return options.onKeyDown || noop;\n  }\n  return (event) => {\n    var _a;\n    if (event.key === \"Escape\") {\n      callback(event);\n      (_a = options.onTrigger) == null ? void 0 : _a.call(options);\n    }\n  };\n}\n\nexport { closeOnEscape };\n//# sourceMappingURL=close-on-escape.js.map\n","import { createStyles } from '@mantine/styles';\n\nvar useStyles = createStyles((theme, { radius, shadow }) => ({\n  dropdown: {\n    position: \"absolute\",\n    backgroundColor: theme.white,\n    background: theme.colorScheme === \"dark\" ? theme.colors.dark[6] : theme.white,\n    border: `1px solid ${theme.colorScheme === \"dark\" ? theme.colors.dark[4] : theme.colors.gray[2]}`,\n    padding: `${theme.spacing.sm}px ${theme.spacing.md}px`,\n    boxShadow: theme.shadows[shadow] || shadow || \"none\",\n    borderRadius: theme.fn.radius(radius),\n    \"&:focus\": {\n      outline: 0\n    }\n  },\n  arrow: {\n    backgroundColor: \"inherit\",\n    border: `1px solid ${theme.colorScheme === \"dark\" ? theme.colors.dark[4] : theme.colors.gray[2]}`,\n    zIndex: 1\n  }\n}));\n\nexport default useStyles;\n//# sourceMappingURL=PopoverDropdown.styles.js.map\n","import { cloneElement } from 'react';\nimport { isElement } from '@mantine/utils';\nimport { useFocusTrap, useMergedRef } from '@mantine/hooks';\n\nfunction FocusTrap({\n  children,\n  active = true,\n  refProp = \"ref\"\n}) {\n  const focusTrapRef = useFocusTrap(active);\n  const ref = useMergedRef(focusTrapRef, children == null ? void 0 : children.ref);\n  if (!isElement(children)) {\n    return children;\n  }\n  return cloneElement(children, { [refProp]: ref });\n}\nFocusTrap.displayName = \"@mantine/core/FocusTrap\";\n\nexport { FocusTrap };\n//# sourceMappingURL=FocusTrap.js.map\n","import React from 'react';\nimport { useComponentDefaultProps } from '@mantine/styles';\nimport { closeOnEscape } from '@mantine/utils';\nimport { useFocusReturn } from '@mantine/hooks';\nimport { usePopoverContext } from '../Popover.context.js';\nimport useStyles from './PopoverDropdown.styles.js';\nimport { OptionalPortal } from '../../Portal/OptionalPortal.js';\nimport { Transition } from '../../Transition/Transition.js';\nimport { FocusTrap } from '../../FocusTrap/FocusTrap.js';\nimport { Box } from '../../Box/Box.js';\nimport { FloatingArrow } from '../../Floating/FloatingArrow/FloatingArrow.js';\n\nvar __defProp = Object.defineProperty;\nvar __defProps = Object.defineProperties;\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));\nvar __objRest = (source, exclude) => {\n  var target = {};\n  for (var prop in source)\n    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)\n      target[prop] = source[prop];\n  if (source != null && __getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(source)) {\n      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))\n        target[prop] = source[prop];\n    }\n  return target;\n};\nconst defaultProps = {};\nfunction PopoverDropdown(props) {\n  const _a = useComponentDefaultProps(\"PopoverDropdown\", defaultProps, props), { style, className, children, onKeyDownCapture } = _a, others = __objRest(_a, [\"style\", \"className\", \"children\", \"onKeyDownCapture\"]);\n  const ctx = usePopoverContext();\n  const { classes, cx } = useStyles({ radius: ctx.radius, shadow: ctx.shadow }, {\n    name: ctx.__staticSelector,\n    classNames: ctx.classNames,\n    styles: ctx.styles,\n    unstyled: ctx.unstyled\n  });\n  const returnFocus = useFocusReturn({\n    opened: ctx.opened,\n    shouldReturnFocus: ctx.returnFocus\n  });\n  const accessibleProps = ctx.withRoles ? {\n    \"aria-labelledby\": ctx.getTargetId(),\n    id: ctx.getDropdownId(),\n    role: \"dialog\"\n  } : {};\n  if (ctx.disabled) {\n    return null;\n  }\n  return /* @__PURE__ */ React.createElement(OptionalPortal, {\n    withinPortal: ctx.withinPortal\n  }, /* @__PURE__ */ React.createElement(Transition, {\n    mounted: ctx.opened,\n    transition: ctx.transition,\n    duration: ctx.transitionDuration,\n    exitDuration: typeof ctx.exitTransitionDuration === \"number\" ? ctx.exitTransitionDuration : ctx.transitionDuration\n  }, (transitionStyles) => {\n    var _a2, _b;\n    return /* @__PURE__ */ React.createElement(FocusTrap, {\n      active: ctx.trapFocus\n    }, /* @__PURE__ */ React.createElement(Box, __spreadValues(__spreadProps(__spreadValues({}, accessibleProps), {\n      tabIndex: -1,\n      key: ctx.placement,\n      ref: ctx.floating,\n      style: __spreadProps(__spreadValues(__spreadValues({}, style), transitionStyles), {\n        zIndex: ctx.zIndex,\n        top: (_a2 = ctx.y) != null ? _a2 : 0,\n        left: (_b = ctx.x) != null ? _b : 0,\n        width: ctx.width === \"target\" ? void 0 : ctx.width\n      }),\n      className: cx(classes.dropdown, className),\n      onKeyDownCapture: closeOnEscape(ctx.onClose, {\n        active: ctx.closeOnEscape,\n        onTrigger: returnFocus,\n        onKeyDown: onKeyDownCapture\n      }),\n      \"data-position\": ctx.placement\n    }), others), children, /* @__PURE__ */ React.createElement(FloatingArrow, {\n      ref: ctx.arrowRef,\n      arrowX: ctx.arrowX,\n      arrowY: ctx.arrowY,\n      visible: ctx.withArrow,\n      withBorder: true,\n      position: ctx.placement,\n      arrowSize: ctx.arrowSize,\n      arrowRadius: ctx.arrowRadius,\n      arrowOffset: ctx.arrowOffset,\n      arrowPosition: ctx.arrowPosition,\n      className: classes.arrow\n    })));\n  }));\n}\nPopoverDropdown.displayName = \"@mantine/core/PopoverDropdown\";\n\nexport { PopoverDropdown };\n//# sourceMappingURL=PopoverDropdown.js.map\n","import React, { useRef, useState, useCallback } from 'react';\nimport { useId, useClickOutside } from '@mantine/hooks';\nimport { getDefaultZIndex, useComponentDefaultProps, useMantineTheme } from '@mantine/styles';\nimport { usePopover } from './use-popover.js';\nimport { PopoverContextProvider } from './Popover.context.js';\nimport { PopoverTarget } from './PopoverTarget/PopoverTarget.js';\nimport { PopoverDropdown } from './PopoverDropdown/PopoverDropdown.js';\nimport { getFloatingPosition } from '../Floating/get-floating-position/get-floating-position.js';\n\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __objRest = (source, exclude) => {\n  var target = {};\n  for (var prop in source)\n    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)\n      target[prop] = source[prop];\n  if (source != null && __getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(source)) {\n      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))\n        target[prop] = source[prop];\n    }\n  return target;\n};\nconst defaultProps = {\n  position: \"bottom\",\n  offset: 8,\n  positionDependencies: [],\n  transition: \"fade\",\n  transitionDuration: 150,\n  middlewares: { flip: true, shift: true, inline: false },\n  arrowSize: 7,\n  arrowOffset: 5,\n  arrowRadius: 0,\n  arrowPosition: \"side\",\n  closeOnClickOutside: true,\n  withinPortal: false,\n  closeOnEscape: true,\n  trapFocus: false,\n  withRoles: true,\n  returnFocus: false,\n  clickOutsideEvents: [\"mousedown\", \"touchstart\"],\n  zIndex: getDefaultZIndex(\"popover\"),\n  __staticSelector: \"Popover\",\n  width: \"max-content\"\n};\nfunction Popover(props) {\n  var _b, _c, _d, _e, _f, _g;\n  const arrowRef = useRef(null);\n  const _a = useComponentDefaultProps(\"Popover\", defaultProps, props), {\n    children,\n    position,\n    offset,\n    onPositionChange,\n    positionDependencies,\n    opened,\n    transition,\n    transitionDuration,\n    width,\n    middlewares,\n    withArrow,\n    arrowSize,\n    arrowOffset,\n    arrowRadius,\n    arrowPosition,\n    unstyled,\n    classNames,\n    styles,\n    closeOnClickOutside,\n    withinPortal,\n    closeOnEscape,\n    clickOutsideEvents,\n    trapFocus,\n    onClose,\n    onOpen,\n    onChange,\n    zIndex,\n    radius,\n    shadow,\n    id,\n    defaultOpened,\n    exitTransitionDuration,\n    __staticSelector,\n    withRoles,\n    disabled,\n    returnFocus\n  } = _a, others = __objRest(_a, [\n    \"children\",\n    \"position\",\n    \"offset\",\n    \"onPositionChange\",\n    \"positionDependencies\",\n    \"opened\",\n    \"transition\",\n    \"transitionDuration\",\n    \"width\",\n    \"middlewares\",\n    \"withArrow\",\n    \"arrowSize\",\n    \"arrowOffset\",\n    \"arrowRadius\",\n    \"arrowPosition\",\n    \"unstyled\",\n    \"classNames\",\n    \"styles\",\n    \"closeOnClickOutside\",\n    \"withinPortal\",\n    \"closeOnEscape\",\n    \"clickOutsideEvents\",\n    \"trapFocus\",\n    \"onClose\",\n    \"onOpen\",\n    \"onChange\",\n    \"zIndex\",\n    \"radius\",\n    \"shadow\",\n    \"id\",\n    \"defaultOpened\",\n    \"exitTransitionDuration\",\n    \"__staticSelector\",\n    \"withRoles\",\n    \"disabled\",\n    \"returnFocus\"\n  ]);\n  const [targetNode, setTargetNode] = useState(null);\n  const [dropdownNode, setDropdownNode] = useState(null);\n  const uid = useId(id);\n  const theme = useMantineTheme();\n  const popover = usePopover({\n    middlewares,\n    width,\n    position: getFloatingPosition(theme.dir, position),\n    offset: offset + (withArrow ? arrowSize / 2 : 0),\n    arrowRef,\n    arrowOffset,\n    onPositionChange,\n    positionDependencies,\n    opened,\n    defaultOpened,\n    onChange,\n    onOpen,\n    onClose\n  });\n  useClickOutside(() => closeOnClickOutside && popover.onClose(), clickOutsideEvents, [\n    targetNode,\n    dropdownNode\n  ]);\n  const reference = useCallback((node) => {\n    setTargetNode(node);\n    popover.floating.reference(node);\n  }, [popover.floating.reference]);\n  const floating = useCallback((node) => {\n    setDropdownNode(node);\n    popover.floating.floating(node);\n  }, [popover.floating.floating]);\n  return /* @__PURE__ */ React.createElement(PopoverContextProvider, {\n    value: {\n      returnFocus,\n      disabled,\n      controlled: popover.controlled,\n      reference,\n      floating,\n      x: popover.floating.x,\n      y: popover.floating.y,\n      arrowX: (_d = (_c = (_b = popover.floating) == null ? void 0 : _b.middlewareData) == null ? void 0 : _c.arrow) == null ? void 0 : _d.x,\n      arrowY: (_g = (_f = (_e = popover.floating) == null ? void 0 : _e.middlewareData) == null ? void 0 : _f.arrow) == null ? void 0 : _g.y,\n      opened: popover.opened,\n      arrowRef,\n      transition,\n      transitionDuration,\n      exitTransitionDuration,\n      width,\n      withArrow,\n      arrowSize,\n      arrowOffset,\n      arrowRadius,\n      arrowPosition,\n      placement: popover.floating.placement,\n      trapFocus,\n      withinPortal,\n      zIndex,\n      radius,\n      shadow,\n      closeOnEscape,\n      onClose: popover.onClose,\n      onToggle: popover.onToggle,\n      getTargetId: () => `${uid}-target`,\n      getDropdownId: () => `${uid}-dropdown`,\n      withRoles,\n      targetProps: others,\n      __staticSelector,\n      classNames,\n      styles,\n      unstyled\n    }\n  }, children);\n}\nPopover.Target = PopoverTarget;\nPopover.Dropdown = PopoverDropdown;\nPopover.displayName = \"@mantine/core/Popover\";\n\nexport { Popover };\n//# sourceMappingURL=Popover.js.map\n","import {useCallback as $3vqmr$useCallback} from \"react\";\n\n\n/**\n * Set a given ref to a given value\n * This utility takes care of different types of refs: callback refs and RefObject(s)\n */ function $6ed0406888f73fc4$var$setRef(ref, value) {\n    if (typeof ref === 'function') ref(value);\n    else if (ref !== null && ref !== undefined) ref.current = value;\n}\n/**\n * A utility to compose multiple refs together\n * Accepts callback refs and RefObject(s)\n */ function $6ed0406888f73fc4$export$43e446d32b3d21af(...refs) {\n    return (node)=>refs.forEach((ref)=>$6ed0406888f73fc4$var$setRef(ref, node)\n        )\n    ;\n}\n/**\n * A custom hook that composes multiple refs\n * Accepts callback refs and RefObject(s)\n */ function $6ed0406888f73fc4$export$c7b2cbe3552a0d05(...refs) {\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    return $3vqmr$useCallback($6ed0406888f73fc4$export$43e446d32b3d21af(...refs), refs);\n}\n\n\n\n\nexport {$6ed0406888f73fc4$export$43e446d32b3d21af as composeRefs, $6ed0406888f73fc4$export$c7b2cbe3552a0d05 as useComposedRefs};\n//# sourceMappingURL=index.module.js.map\n","import $9IrjX$babelruntimehelpersesmextends from \"@babel/runtime/helpers/esm/extends\";\nimport {forwardRef as $9IrjX$forwardRef, Children as $9IrjX$Children, isValidElement as $9IrjX$isValidElement, createElement as $9IrjX$createElement, cloneElement as $9IrjX$cloneElement, Fragment as $9IrjX$Fragment} from \"react\";\nimport {composeRefs as $9IrjX$composeRefs} from \"@radix-ui/react-compose-refs\";\n\n\n\n\n/* -------------------------------------------------------------------------------------------------\n * Slot\n * -----------------------------------------------------------------------------------------------*/ const $5e63c961fc1ce211$export$8c6ed5c666ac1360 = /*#__PURE__*/ $9IrjX$forwardRef((props, forwardedRef)=>{\n    const { children: children , ...slotProps } = props;\n    const childrenArray = $9IrjX$Children.toArray(children);\n    const slottable = childrenArray.find($5e63c961fc1ce211$var$isSlottable);\n    if (slottable) {\n        // the new element to render is the one passed as a child of `Slottable`\n        const newElement = slottable.props.children;\n        const newChildren = childrenArray.map((child)=>{\n            if (child === slottable) {\n                // because the new element will be the one rendered, we are only interested\n                // in grabbing its children (`newElement.props.children`)\n                if ($9IrjX$Children.count(newElement) > 1) return $9IrjX$Children.only(null);\n                return /*#__PURE__*/ $9IrjX$isValidElement(newElement) ? newElement.props.children : null;\n            } else return child;\n        });\n        return /*#__PURE__*/ $9IrjX$createElement($5e63c961fc1ce211$var$SlotClone, $9IrjX$babelruntimehelpersesmextends({}, slotProps, {\n            ref: forwardedRef\n        }), /*#__PURE__*/ $9IrjX$isValidElement(newElement) ? /*#__PURE__*/ $9IrjX$cloneElement(newElement, undefined, newChildren) : null);\n    }\n    return /*#__PURE__*/ $9IrjX$createElement($5e63c961fc1ce211$var$SlotClone, $9IrjX$babelruntimehelpersesmextends({}, slotProps, {\n        ref: forwardedRef\n    }), children);\n});\n$5e63c961fc1ce211$export$8c6ed5c666ac1360.displayName = 'Slot';\n/* -------------------------------------------------------------------------------------------------\n * SlotClone\n * -----------------------------------------------------------------------------------------------*/ const $5e63c961fc1ce211$var$SlotClone = /*#__PURE__*/ $9IrjX$forwardRef((props, forwardedRef)=>{\n    const { children: children , ...slotProps } = props;\n    if (/*#__PURE__*/ $9IrjX$isValidElement(children)) return /*#__PURE__*/ $9IrjX$cloneElement(children, {\n        ...$5e63c961fc1ce211$var$mergeProps(slotProps, children.props),\n        ref: $9IrjX$composeRefs(forwardedRef, children.ref)\n    });\n    return $9IrjX$Children.count(children) > 1 ? $9IrjX$Children.only(null) : null;\n});\n$5e63c961fc1ce211$var$SlotClone.displayName = 'SlotClone';\n/* -------------------------------------------------------------------------------------------------\n * Slottable\n * -----------------------------------------------------------------------------------------------*/ const $5e63c961fc1ce211$export$d9f1ccf0bdb05d45 = ({ children: children  })=>{\n    return /*#__PURE__*/ $9IrjX$createElement($9IrjX$Fragment, null, children);\n};\n/* ---------------------------------------------------------------------------------------------- */ function $5e63c961fc1ce211$var$isSlottable(child) {\n    return /*#__PURE__*/ $9IrjX$isValidElement(child) && child.type === $5e63c961fc1ce211$export$d9f1ccf0bdb05d45;\n}\nfunction $5e63c961fc1ce211$var$mergeProps(slotProps, childProps) {\n    // all child props should override\n    const overrideProps = {\n        ...childProps\n    };\n    for(const propName in childProps){\n        const slotPropValue = slotProps[propName];\n        const childPropValue = childProps[propName];\n        const isHandler = /^on[A-Z]/.test(propName);\n        if (isHandler) {\n            // if the handler exists on both, we compose them\n            if (slotPropValue && childPropValue) overrideProps[propName] = (...args)=>{\n                childPropValue(...args);\n                slotPropValue(...args);\n            };\n            else if (slotPropValue) overrideProps[propName] = slotPropValue;\n        } else if (propName === 'style') overrideProps[propName] = {\n            ...slotPropValue,\n            ...childPropValue\n        };\n        else if (propName === 'className') overrideProps[propName] = [\n            slotPropValue,\n            childPropValue\n        ].filter(Boolean).join(' ');\n    }\n    return {\n        ...slotProps,\n        ...overrideProps\n    };\n}\nconst $5e63c961fc1ce211$export$be92b6f5f03c0fe9 = $5e63c961fc1ce211$export$8c6ed5c666ac1360;\n\n\n\n\nexport {$5e63c961fc1ce211$export$8c6ed5c666ac1360 as Slot, $5e63c961fc1ce211$export$d9f1ccf0bdb05d45 as Slottable, $5e63c961fc1ce211$export$be92b6f5f03c0fe9 as Root};\n//# sourceMappingURL=index.module.js.map\n","import $4q5Fq$babelruntimehelpersesmextends from \"@babel/runtime/helpers/esm/extends\";\nimport {forwardRef as $4q5Fq$forwardRef, useEffect as $4q5Fq$useEffect, createElement as $4q5Fq$createElement} from \"react\";\nimport {flushSync as $4q5Fq$flushSync} from \"react-dom\";\nimport {Slot as $4q5Fq$Slot} from \"@radix-ui/react-slot\";\n\n\n\n\n\nconst $8927f6f2acc4f386$var$NODES = [\n    'a',\n    'button',\n    'div',\n    'h2',\n    'h3',\n    'img',\n    'label',\n    'li',\n    'nav',\n    'ol',\n    'p',\n    'span',\n    'svg',\n    'ul'\n]; // Temporary while we await merge of this fix:\n// https://github.com/DefinitelyTyped/DefinitelyTyped/pull/55396\n// prettier-ignore\n/* -------------------------------------------------------------------------------------------------\n * Primitive\n * -----------------------------------------------------------------------------------------------*/ const $8927f6f2acc4f386$export$250ffa63cdc0d034 = $8927f6f2acc4f386$var$NODES.reduce((primitive, node)=>{\n    const Node = /*#__PURE__*/ $4q5Fq$forwardRef((props, forwardedRef)=>{\n        const { asChild: asChild , ...primitiveProps } = props;\n        const Comp = asChild ? $4q5Fq$Slot : node;\n        $4q5Fq$useEffect(()=>{\n            window[Symbol.for('radix-ui')] = true;\n        }, []);\n        return /*#__PURE__*/ $4q5Fq$createElement(Comp, $4q5Fq$babelruntimehelpersesmextends({}, primitiveProps, {\n            ref: forwardedRef\n        }));\n    });\n    Node.displayName = `Primitive.${node}`;\n    return {\n        ...primitive,\n        [node]: Node\n    };\n}, {});\n/* -------------------------------------------------------------------------------------------------\n * Utils\n * -----------------------------------------------------------------------------------------------*/ /**\n * Flush custom event dispatch\n * https://github.com/radix-ui/primitives/pull/1378\n *\n * React batches *all* event handlers since version 18, this introduces certain considerations when using custom event types.\n *\n * Internally, React prioritises events in the following order:\n *  - discrete\n *  - continuous\n *  - default\n *\n * https://github.com/facebook/react/blob/a8a4742f1c54493df00da648a3f9d26e3db9c8b5/packages/react-dom/src/events/ReactDOMEventListener.js#L294-L350\n *\n * `discrete` is an  important distinction as updates within these events are applied immediately.\n * React however, is not able to infer the priority of custom event types due to how they are detected internally.\n * Because of this, it's possible for updates from custom events to be unexpectedly batched when\n * dispatched by another `discrete` event.\n *\n * In order to ensure that updates from custom events are applied predictably, we need to manually flush the batch.\n * This utility should be used when dispatching a custom event from within another `discrete` event, this utility\n * is not nessesary when dispatching known event types, or if dispatching a custom type inside a non-discrete event.\n * For example:\n *\n * dispatching a known click 👎\n * target.dispatchEvent(new Event(‘click’))\n *\n * dispatching a custom type within a non-discrete event 👎\n * onScroll={(event) => event.target.dispatchEvent(new CustomEvent(‘customType’))}\n *\n * dispatching a custom type within a `discrete` event 👍\n * onPointerDown={(event) => dispatchDiscreteCustomEvent(event.target, new CustomEvent(‘customType’))}\n *\n * Note: though React classifies `focus`, `focusin` and `focusout` events as `discrete`, it's  not recommended to use\n * this utility with them. This is because it's possible for those handlers to be called implicitly during render\n * e.g. when focus is within a component as it is unmounted, or when managing focus on mount.\n */ function $8927f6f2acc4f386$export$6d1a0317bde7de7f(target, event) {\n    if (target) $4q5Fq$flushSync(()=>target.dispatchEvent(event)\n    );\n}\n/* -----------------------------------------------------------------------------------------------*/ const $8927f6f2acc4f386$export$be92b6f5f03c0fe9 = $8927f6f2acc4f386$export$250ffa63cdc0d034;\n\n\n\n\nexport {$8927f6f2acc4f386$export$250ffa63cdc0d034 as Primitive, $8927f6f2acc4f386$export$be92b6f5f03c0fe9 as Root, $8927f6f2acc4f386$export$6d1a0317bde7de7f as dispatchDiscreteCustomEvent};\n//# sourceMappingURL=index.module.js.map\n","import {useLayoutEffect as $dxlwH$useLayoutEffect} from \"react\";\n\n\n/**\n * On the server, React emits a warning when calling `useLayoutEffect`.\n * This is because neither `useLayoutEffect` nor `useEffect` run on the server.\n * We use this safe version which suppresses the warning by replacing it with a noop on the server.\n *\n * See: https://reactjs.org/docs/hooks-reference.html#uselayouteffect\n */ const $9f79659886946c16$export$e5c5a5f917a5871c = Boolean(globalThis === null || globalThis === void 0 ? void 0 : globalThis.document) ? $dxlwH$useLayoutEffect : ()=>{};\n\n\n\n\nexport {$9f79659886946c16$export$e5c5a5f917a5871c as useLayoutEffect};\n//# sourceMappingURL=index.module.js.map\n","import {Children as $iqq3r$Children, cloneElement as $iqq3r$cloneElement, useState as $iqq3r$useState, useRef as $iqq3r$useRef, useEffect as $iqq3r$useEffect, useCallback as $iqq3r$useCallback, useReducer as $iqq3r$useReducer} from \"react\";\nimport {flushSync as $iqq3r$flushSync} from \"react-dom\";\nimport {useComposedRefs as $iqq3r$useComposedRefs} from \"@radix-ui/react-compose-refs\";\nimport {useLayoutEffect as $iqq3r$useLayoutEffect} from \"@radix-ui/react-use-layout-effect\";\n\n\n\n\n\n\nfunction $fe963b355347cc68$export$3e6543de14f8614f(initialState, machine) {\n    return $iqq3r$useReducer((state, event)=>{\n        const nextState = machine[state][event];\n        return nextState !== null && nextState !== void 0 ? nextState : state;\n    }, initialState);\n}\n\n\nconst $921a889cee6df7e8$export$99c2b779aa4e8b8b = (props)=>{\n    const { present: present , children: children  } = props;\n    const presence = $921a889cee6df7e8$var$usePresence(present);\n    const child = typeof children === 'function' ? children({\n        present: presence.isPresent\n    }) : $iqq3r$Children.only(children);\n    const ref = $iqq3r$useComposedRefs(presence.ref, child.ref);\n    const forceMount = typeof children === 'function';\n    return forceMount || presence.isPresent ? /*#__PURE__*/ $iqq3r$cloneElement(child, {\n        ref: ref\n    }) : null;\n};\n$921a889cee6df7e8$export$99c2b779aa4e8b8b.displayName = 'Presence';\n/* -------------------------------------------------------------------------------------------------\n * usePresence\n * -----------------------------------------------------------------------------------------------*/ function $921a889cee6df7e8$var$usePresence(present) {\n    const [node1, setNode] = $iqq3r$useState();\n    const stylesRef = $iqq3r$useRef({});\n    const prevPresentRef = $iqq3r$useRef(present);\n    const prevAnimationNameRef = $iqq3r$useRef('none');\n    const initialState = present ? 'mounted' : 'unmounted';\n    const [state, send] = $fe963b355347cc68$export$3e6543de14f8614f(initialState, {\n        mounted: {\n            UNMOUNT: 'unmounted',\n            ANIMATION_OUT: 'unmountSuspended'\n        },\n        unmountSuspended: {\n            MOUNT: 'mounted',\n            ANIMATION_END: 'unmounted'\n        },\n        unmounted: {\n            MOUNT: 'mounted'\n        }\n    });\n    $iqq3r$useEffect(()=>{\n        const currentAnimationName = $921a889cee6df7e8$var$getAnimationName(stylesRef.current);\n        prevAnimationNameRef.current = state === 'mounted' ? currentAnimationName : 'none';\n    }, [\n        state\n    ]);\n    $iqq3r$useLayoutEffect(()=>{\n        const styles = stylesRef.current;\n        const wasPresent = prevPresentRef.current;\n        const hasPresentChanged = wasPresent !== present;\n        if (hasPresentChanged) {\n            const prevAnimationName = prevAnimationNameRef.current;\n            const currentAnimationName = $921a889cee6df7e8$var$getAnimationName(styles);\n            if (present) send('MOUNT');\n            else if (currentAnimationName === 'none' || (styles === null || styles === void 0 ? void 0 : styles.display) === 'none') // If there is no exit animation or the element is hidden, animations won't run\n            // so we unmount instantly\n            send('UNMOUNT');\n            else {\n                /**\n         * When `present` changes to `false`, we check changes to animation-name to\n         * determine whether an animation has started. We chose this approach (reading\n         * computed styles) because there is no `animationrun` event and `animationstart`\n         * fires after `animation-delay` has expired which would be too late.\n         */ const isAnimating = prevAnimationName !== currentAnimationName;\n                if (wasPresent && isAnimating) send('ANIMATION_OUT');\n                else send('UNMOUNT');\n            }\n            prevPresentRef.current = present;\n        }\n    }, [\n        present,\n        send\n    ]);\n    $iqq3r$useLayoutEffect(()=>{\n        if (node1) {\n            /**\n       * Triggering an ANIMATION_OUT during an ANIMATION_IN will fire an `animationcancel`\n       * event for ANIMATION_IN after we have entered `unmountSuspended` state. So, we\n       * make sure we only trigger ANIMATION_END for the currently active animation.\n       */ const handleAnimationEnd = (event)=>{\n                const currentAnimationName = $921a889cee6df7e8$var$getAnimationName(stylesRef.current);\n                const isCurrentAnimation = currentAnimationName.includes(event.animationName);\n                if (event.target === node1 && isCurrentAnimation) // With React 18 concurrency this update is applied\n                // a frame after the animation ends, creating a flash of visible content.\n                // By manually flushing we ensure they sync within a frame, removing the flash.\n                $iqq3r$flushSync(()=>send('ANIMATION_END')\n                );\n            };\n            const handleAnimationStart = (event)=>{\n                if (event.target === node1) // if animation occurred, store its name as the previous animation.\n                prevAnimationNameRef.current = $921a889cee6df7e8$var$getAnimationName(stylesRef.current);\n            };\n            node1.addEventListener('animationstart', handleAnimationStart);\n            node1.addEventListener('animationcancel', handleAnimationEnd);\n            node1.addEventListener('animationend', handleAnimationEnd);\n            return ()=>{\n                node1.removeEventListener('animationstart', handleAnimationStart);\n                node1.removeEventListener('animationcancel', handleAnimationEnd);\n                node1.removeEventListener('animationend', handleAnimationEnd);\n            };\n        } else // Transition to the unmounted state if the node is removed prematurely.\n        // We avoid doing so during cleanup as the node may change but still exist.\n        send('ANIMATION_END');\n    }, [\n        node1,\n        send\n    ]);\n    return {\n        isPresent: [\n            'mounted',\n            'unmountSuspended'\n        ].includes(state),\n        ref: $iqq3r$useCallback((node)=>{\n            if (node) stylesRef.current = getComputedStyle(node);\n            setNode(node);\n        }, [])\n    };\n}\n/* -----------------------------------------------------------------------------------------------*/ function $921a889cee6df7e8$var$getAnimationName(styles) {\n    return (styles === null || styles === void 0 ? void 0 : styles.animationName) || 'none';\n}\n\n\n\n\nexport {$921a889cee6df7e8$export$99c2b779aa4e8b8b as Presence};\n//# sourceMappingURL=index.module.js.map\n","import {createContext as $3bkAK$createContext, useMemo as $3bkAK$useMemo, createElement as $3bkAK$createElement, useContext as $3bkAK$useContext} from \"react\";\n\n\nfunction $c512c27ab02ef895$export$fd42f52fd3ae1109(rootComponentName, defaultContext) {\n    const Context = /*#__PURE__*/ $3bkAK$createContext(defaultContext);\n    function Provider(props) {\n        const { children: children , ...context } = props; // Only re-memoize when prop values change\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n        const value = $3bkAK$useMemo(()=>context\n        , Object.values(context));\n        return /*#__PURE__*/ $3bkAK$createElement(Context.Provider, {\n            value: value\n        }, children);\n    }\n    function useContext(consumerName) {\n        const context = $3bkAK$useContext(Context);\n        if (context) return context;\n        if (defaultContext !== undefined) return defaultContext; // if a defaultContext wasn't specified, it's a required context.\n        throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n    }\n    Provider.displayName = rootComponentName + 'Provider';\n    return [\n        Provider,\n        useContext\n    ];\n}\n/* -------------------------------------------------------------------------------------------------\n * createContextScope\n * -----------------------------------------------------------------------------------------------*/ function $c512c27ab02ef895$export$50c7b4e9d9f19c1(scopeName, createContextScopeDeps = []) {\n    let defaultContexts = [];\n    /* -----------------------------------------------------------------------------------------------\n   * createContext\n   * ---------------------------------------------------------------------------------------------*/ function $c512c27ab02ef895$export$fd42f52fd3ae1109(rootComponentName, defaultContext) {\n        const BaseContext = /*#__PURE__*/ $3bkAK$createContext(defaultContext);\n        const index = defaultContexts.length;\n        defaultContexts = [\n            ...defaultContexts,\n            defaultContext\n        ];\n        function Provider(props) {\n            const { scope: scope , children: children , ...context } = props;\n            const Context = (scope === null || scope === void 0 ? void 0 : scope[scopeName][index]) || BaseContext; // Only re-memoize when prop values change\n            // eslint-disable-next-line react-hooks/exhaustive-deps\n            const value = $3bkAK$useMemo(()=>context\n            , Object.values(context));\n            return /*#__PURE__*/ $3bkAK$createElement(Context.Provider, {\n                value: value\n            }, children);\n        }\n        function useContext(consumerName, scope) {\n            const Context = (scope === null || scope === void 0 ? void 0 : scope[scopeName][index]) || BaseContext;\n            const context = $3bkAK$useContext(Context);\n            if (context) return context;\n            if (defaultContext !== undefined) return defaultContext; // if a defaultContext wasn't specified, it's a required context.\n            throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n        }\n        Provider.displayName = rootComponentName + 'Provider';\n        return [\n            Provider,\n            useContext\n        ];\n    }\n    /* -----------------------------------------------------------------------------------------------\n   * createScope\n   * ---------------------------------------------------------------------------------------------*/ const createScope = ()=>{\n        const scopeContexts = defaultContexts.map((defaultContext)=>{\n            return /*#__PURE__*/ $3bkAK$createContext(defaultContext);\n        });\n        return function useScope(scope) {\n            const contexts = (scope === null || scope === void 0 ? void 0 : scope[scopeName]) || scopeContexts;\n            return $3bkAK$useMemo(()=>({\n                    [`__scope${scopeName}`]: {\n                        ...scope,\n                        [scopeName]: contexts\n                    }\n                })\n            , [\n                scope,\n                contexts\n            ]);\n        };\n    };\n    createScope.scopeName = scopeName;\n    return [\n        $c512c27ab02ef895$export$fd42f52fd3ae1109,\n        $c512c27ab02ef895$var$composeContextScopes(createScope, ...createContextScopeDeps)\n    ];\n}\n/* -------------------------------------------------------------------------------------------------\n * composeContextScopes\n * -----------------------------------------------------------------------------------------------*/ function $c512c27ab02ef895$var$composeContextScopes(...scopes) {\n    const baseScope = scopes[0];\n    if (scopes.length === 1) return baseScope;\n    const createScope1 = ()=>{\n        const scopeHooks = scopes.map((createScope)=>({\n                useScope: createScope(),\n                scopeName: createScope.scopeName\n            })\n        );\n        return function useComposedScopes(overrideScopes) {\n            const nextScopes1 = scopeHooks.reduce((nextScopes, { useScope: useScope , scopeName: scopeName  })=>{\n                // We are calling a hook inside a callback which React warns against to avoid inconsistent\n                // renders, however, scoping doesn't have render side effects so we ignore the rule.\n                // eslint-disable-next-line react-hooks/rules-of-hooks\n                const scopeProps = useScope(overrideScopes);\n                const currentScope = scopeProps[`__scope${scopeName}`];\n                return {\n                    ...nextScopes,\n                    ...currentScope\n                };\n            }, {});\n            return $3bkAK$useMemo(()=>({\n                    [`__scope${baseScope.scopeName}`]: nextScopes1\n                })\n            , [\n                nextScopes1\n            ]);\n        };\n    };\n    createScope1.scopeName = baseScope.scopeName;\n    return createScope1;\n}\n\n\n\n\nexport {$c512c27ab02ef895$export$fd42f52fd3ae1109 as createContext, $c512c27ab02ef895$export$50c7b4e9d9f19c1 as createContextScope};\n//# sourceMappingURL=index.module.js.map\n","import {useRef as $lwiWj$useRef, useEffect as $lwiWj$useEffect, useMemo as $lwiWj$useMemo} from \"react\";\n\n\n/**\n * A custom hook that converts a callback to a ref to avoid triggering re-renders when passed as a\n * prop or avoid re-executing effects when passed as a dependency\n */ function $b1b2314f5f9a1d84$export$25bec8c6f54ee79a(callback) {\n    const callbackRef = $lwiWj$useRef(callback);\n    $lwiWj$useEffect(()=>{\n        callbackRef.current = callback;\n    }); // https://github.com/facebook/react/issues/19240\n    return $lwiWj$useMemo(()=>(...args)=>{\n            var _callbackRef$current;\n            return (_callbackRef$current = callbackRef.current) === null || _callbackRef$current === void 0 ? void 0 : _callbackRef$current.call(callbackRef, ...args);\n        }\n    , []);\n}\n\n\n\n\nexport {$b1b2314f5f9a1d84$export$25bec8c6f54ee79a as useCallbackRef};\n//# sourceMappingURL=index.module.js.map\n","import {createContext as $7Gjcd$createContext, createElement as $7Gjcd$createElement, useContext as $7Gjcd$useContext} from \"react\";\n\n\nconst $f631663db3294ace$var$DirectionContext = /*#__PURE__*/ $7Gjcd$createContext(undefined);\n/* -------------------------------------------------------------------------------------------------\n * Direction\n * -----------------------------------------------------------------------------------------------*/ const $f631663db3294ace$export$c760c09fdd558351 = (props)=>{\n    const { dir: dir , children: children  } = props;\n    return /*#__PURE__*/ $7Gjcd$createElement($f631663db3294ace$var$DirectionContext.Provider, {\n        value: dir\n    }, children);\n};\n/* -----------------------------------------------------------------------------------------------*/ function $f631663db3294ace$export$b39126d51d94e6f3(localDir) {\n    const globalDir = $7Gjcd$useContext($f631663db3294ace$var$DirectionContext);\n    return localDir || globalDir || 'ltr';\n}\nconst $f631663db3294ace$export$2881499e37b75b9a = $f631663db3294ace$export$c760c09fdd558351;\n\n\n\n\nexport {$f631663db3294ace$export$b39126d51d94e6f3 as useDirection, $f631663db3294ace$export$2881499e37b75b9a as Provider, $f631663db3294ace$export$c760c09fdd558351 as DirectionProvider};\n//# sourceMappingURL=index.module.js.map\n","function $e42e1063c40fb3ef$export$b9ecd428b558ff10(originalEventHandler, ourEventHandler, { checkForDefaultPrevented: checkForDefaultPrevented = true  } = {}) {\n    return function handleEvent(event) {\n        originalEventHandler === null || originalEventHandler === void 0 || originalEventHandler(event);\n        if (checkForDefaultPrevented === false || !event.defaultPrevented) return ourEventHandler === null || ourEventHandler === void 0 ? void 0 : ourEventHandler(event);\n    };\n}\n\n\n\n\nexport {$e42e1063c40fb3ef$export$b9ecd428b558ff10 as composeEventHandlers};\n//# sourceMappingURL=index.module.js.map\n","import $fnFM9$babelruntimehelpersesmextends from \"@babel/runtime/helpers/esm/extends\";\nimport {forwardRef as $fnFM9$forwardRef, useState as $fnFM9$useState, createElement as $fnFM9$createElement, useRef as $fnFM9$useRef, Fragment as $fnFM9$Fragment, useEffect as $fnFM9$useEffect, useCallback as $fnFM9$useCallback, useReducer as $fnFM9$useReducer} from \"react\";\nimport {Primitive as $fnFM9$Primitive} from \"@radix-ui/react-primitive\";\nimport {Presence as $fnFM9$Presence} from \"@radix-ui/react-presence\";\nimport {createContextScope as $fnFM9$createContextScope} from \"@radix-ui/react-context\";\nimport {useComposedRefs as $fnFM9$useComposedRefs} from \"@radix-ui/react-compose-refs\";\nimport {useCallbackRef as $fnFM9$useCallbackRef} from \"@radix-ui/react-use-callback-ref\";\nimport {useDirection as $fnFM9$useDirection} from \"@radix-ui/react-direction\";\nimport {useLayoutEffect as $fnFM9$useLayoutEffect} from \"@radix-ui/react-use-layout-effect\";\nimport {clamp as $fnFM9$clamp} from \"@radix-ui/number\";\nimport {composeEventHandlers as $fnFM9$composeEventHandlers} from \"@radix-ui/primitive\";\n\n\n\n\n\n\n\n\n\n\n\n\n\nfunction $6c2e24571c90391f$export$3e6543de14f8614f(initialState, machine) {\n    return $fnFM9$useReducer((state, event)=>{\n        const nextState = machine[state][event];\n        return nextState !== null && nextState !== void 0 ? nextState : state;\n    }, initialState);\n}\n\n\n/* -------------------------------------------------------------------------------------------------\n * ScrollArea\n * -----------------------------------------------------------------------------------------------*/ const $57acba87d6e25586$var$SCROLL_AREA_NAME = 'ScrollArea';\nconst [$57acba87d6e25586$var$createScrollAreaContext, $57acba87d6e25586$export$488468afe3a6f2b1] = $fnFM9$createContextScope($57acba87d6e25586$var$SCROLL_AREA_NAME);\nconst [$57acba87d6e25586$var$ScrollAreaProvider, $57acba87d6e25586$var$useScrollAreaContext] = $57acba87d6e25586$var$createScrollAreaContext($57acba87d6e25586$var$SCROLL_AREA_NAME);\nconst $57acba87d6e25586$export$ccf8d8d7bbf3c2cc = /*#__PURE__*/ $fnFM9$forwardRef((props, forwardedRef)=>{\n    const { __scopeScrollArea: __scopeScrollArea , type: type = 'hover' , dir: dir , scrollHideDelay: scrollHideDelay = 600 , ...scrollAreaProps } = props;\n    const [scrollArea, setScrollArea] = $fnFM9$useState(null);\n    const [viewport, setViewport] = $fnFM9$useState(null);\n    const [content, setContent] = $fnFM9$useState(null);\n    const [scrollbarX, setScrollbarX] = $fnFM9$useState(null);\n    const [scrollbarY, setScrollbarY] = $fnFM9$useState(null);\n    const [cornerWidth, setCornerWidth] = $fnFM9$useState(0);\n    const [cornerHeight, setCornerHeight] = $fnFM9$useState(0);\n    const [scrollbarXEnabled, setScrollbarXEnabled] = $fnFM9$useState(false);\n    const [scrollbarYEnabled, setScrollbarYEnabled] = $fnFM9$useState(false);\n    const composedRefs = $fnFM9$useComposedRefs(forwardedRef, (node)=>setScrollArea(node)\n    );\n    const direction = $fnFM9$useDirection(dir);\n    return /*#__PURE__*/ $fnFM9$createElement($57acba87d6e25586$var$ScrollAreaProvider, {\n        scope: __scopeScrollArea,\n        type: type,\n        dir: direction,\n        scrollHideDelay: scrollHideDelay,\n        scrollArea: scrollArea,\n        viewport: viewport,\n        onViewportChange: setViewport,\n        content: content,\n        onContentChange: setContent,\n        scrollbarX: scrollbarX,\n        onScrollbarXChange: setScrollbarX,\n        scrollbarXEnabled: scrollbarXEnabled,\n        onScrollbarXEnabledChange: setScrollbarXEnabled,\n        scrollbarY: scrollbarY,\n        onScrollbarYChange: setScrollbarY,\n        scrollbarYEnabled: scrollbarYEnabled,\n        onScrollbarYEnabledChange: setScrollbarYEnabled,\n        onCornerWidthChange: setCornerWidth,\n        onCornerHeightChange: setCornerHeight\n    }, /*#__PURE__*/ $fnFM9$createElement($fnFM9$Primitive.div, $fnFM9$babelruntimehelpersesmextends({\n        dir: direction\n    }, scrollAreaProps, {\n        ref: composedRefs,\n        style: {\n            position: 'relative',\n            // Pass corner sizes as CSS vars to reduce re-renders of context consumers\n            ['--radix-scroll-area-corner-width']: cornerWidth + 'px',\n            ['--radix-scroll-area-corner-height']: cornerHeight + 'px',\n            ...props.style\n        }\n    })));\n});\n/*#__PURE__*/ Object.assign($57acba87d6e25586$export$ccf8d8d7bbf3c2cc, {\n    displayName: $57acba87d6e25586$var$SCROLL_AREA_NAME\n});\n/* -------------------------------------------------------------------------------------------------\n * ScrollAreaViewport\n * -----------------------------------------------------------------------------------------------*/ const $57acba87d6e25586$var$VIEWPORT_NAME = 'ScrollAreaViewport';\nconst $57acba87d6e25586$export$a21cbf9f11fca853 = /*#__PURE__*/ $fnFM9$forwardRef((props, forwardedRef)=>{\n    const { __scopeScrollArea: __scopeScrollArea , children: children , ...viewportProps } = props;\n    const context = $57acba87d6e25586$var$useScrollAreaContext($57acba87d6e25586$var$VIEWPORT_NAME, __scopeScrollArea);\n    const ref = $fnFM9$useRef(null);\n    const composedRefs = $fnFM9$useComposedRefs(forwardedRef, ref, context.onViewportChange);\n    return /*#__PURE__*/ $fnFM9$createElement($fnFM9$Fragment, null, /*#__PURE__*/ $fnFM9$createElement(\"style\", {\n        dangerouslySetInnerHTML: {\n            __html: `[data-radix-scroll-area-viewport]{scrollbar-width:none;-ms-overflow-style:none;-webkit-overflow-scrolling:touch;}[data-radix-scroll-area-viewport]::-webkit-scrollbar{display:none}`\n        }\n    }), /*#__PURE__*/ $fnFM9$createElement($fnFM9$Primitive.div, $fnFM9$babelruntimehelpersesmextends({\n        \"data-radix-scroll-area-viewport\": \"\"\n    }, viewportProps, {\n        ref: composedRefs,\n        style: {\n            /**\n       * We don't support `visible` because the intention is to have at least one scrollbar\n       * if this component is used and `visible` will behave like `auto` in that case\n       * https://developer.mozilla.org/en-US/docs/Web/CSS/overflowed#description\n       *\n       * We don't handle `auto` because the intention is for the native implementation\n       * to be hidden if using this component. We just want to ensure the node is scrollable\n       * so could have used either `scroll` or `auto` here. We picked `scroll` to prevent\n       * the browser from having to work out whether to render native scrollbars or not,\n       * we tell it to with the intention of hiding them in CSS.\n       */ overflowX: context.scrollbarXEnabled ? 'scroll' : 'hidden',\n            overflowY: context.scrollbarYEnabled ? 'scroll' : 'hidden',\n            ...props.style\n        }\n    }), /*#__PURE__*/ $fnFM9$createElement(\"div\", {\n        ref: context.onContentChange,\n        style: {\n            minWidth: '100%',\n            display: 'table'\n        }\n    }, children)));\n});\n/*#__PURE__*/ Object.assign($57acba87d6e25586$export$a21cbf9f11fca853, {\n    displayName: $57acba87d6e25586$var$VIEWPORT_NAME\n});\n/* -------------------------------------------------------------------------------------------------\n * ScrollAreaScrollbar\n * -----------------------------------------------------------------------------------------------*/ const $57acba87d6e25586$var$SCROLLBAR_NAME = 'ScrollAreaScrollbar';\nconst $57acba87d6e25586$export$2fabd85d0eba3c57 = /*#__PURE__*/ $fnFM9$forwardRef((props, forwardedRef)=>{\n    const { forceMount: forceMount , ...scrollbarProps } = props;\n    const context = $57acba87d6e25586$var$useScrollAreaContext($57acba87d6e25586$var$SCROLLBAR_NAME, props.__scopeScrollArea);\n    const { onScrollbarXEnabledChange: onScrollbarXEnabledChange , onScrollbarYEnabledChange: onScrollbarYEnabledChange  } = context;\n    const isHorizontal = props.orientation === 'horizontal';\n    $fnFM9$useEffect(()=>{\n        isHorizontal ? onScrollbarXEnabledChange(true) : onScrollbarYEnabledChange(true);\n        return ()=>{\n            isHorizontal ? onScrollbarXEnabledChange(false) : onScrollbarYEnabledChange(false);\n        };\n    }, [\n        isHorizontal,\n        onScrollbarXEnabledChange,\n        onScrollbarYEnabledChange\n    ]);\n    return context.type === 'hover' ? /*#__PURE__*/ $fnFM9$createElement($57acba87d6e25586$var$ScrollAreaScrollbarHover, $fnFM9$babelruntimehelpersesmextends({}, scrollbarProps, {\n        ref: forwardedRef,\n        forceMount: forceMount\n    })) : context.type === 'scroll' ? /*#__PURE__*/ $fnFM9$createElement($57acba87d6e25586$var$ScrollAreaScrollbarScroll, $fnFM9$babelruntimehelpersesmextends({}, scrollbarProps, {\n        ref: forwardedRef,\n        forceMount: forceMount\n    })) : context.type === 'auto' ? /*#__PURE__*/ $fnFM9$createElement($57acba87d6e25586$var$ScrollAreaScrollbarAuto, $fnFM9$babelruntimehelpersesmextends({}, scrollbarProps, {\n        ref: forwardedRef,\n        forceMount: forceMount\n    })) : context.type === 'always' ? /*#__PURE__*/ $fnFM9$createElement($57acba87d6e25586$var$ScrollAreaScrollbarVisible, $fnFM9$babelruntimehelpersesmextends({}, scrollbarProps, {\n        ref: forwardedRef\n    })) : null;\n});\n/*#__PURE__*/ Object.assign($57acba87d6e25586$export$2fabd85d0eba3c57, {\n    displayName: $57acba87d6e25586$var$SCROLLBAR_NAME\n});\n/* -----------------------------------------------------------------------------------------------*/ const $57acba87d6e25586$var$ScrollAreaScrollbarHover = /*#__PURE__*/ $fnFM9$forwardRef((props, forwardedRef)=>{\n    const { forceMount: forceMount , ...scrollbarProps } = props;\n    const context = $57acba87d6e25586$var$useScrollAreaContext($57acba87d6e25586$var$SCROLLBAR_NAME, props.__scopeScrollArea);\n    const [visible, setVisible] = $fnFM9$useState(false);\n    $fnFM9$useEffect(()=>{\n        const scrollArea = context.scrollArea;\n        let hideTimer = 0;\n        if (scrollArea) {\n            const handlePointerEnter = ()=>{\n                window.clearTimeout(hideTimer);\n                setVisible(true);\n            };\n            const handlePointerLeave = ()=>{\n                hideTimer = window.setTimeout(()=>setVisible(false)\n                , context.scrollHideDelay);\n            };\n            scrollArea.addEventListener('pointerenter', handlePointerEnter);\n            scrollArea.addEventListener('pointerleave', handlePointerLeave);\n            return ()=>{\n                window.clearTimeout(hideTimer);\n                scrollArea.removeEventListener('pointerenter', handlePointerEnter);\n                scrollArea.removeEventListener('pointerleave', handlePointerLeave);\n            };\n        }\n    }, [\n        context.scrollArea,\n        context.scrollHideDelay\n    ]);\n    return /*#__PURE__*/ $fnFM9$createElement($fnFM9$Presence, {\n        present: forceMount || visible\n    }, /*#__PURE__*/ $fnFM9$createElement($57acba87d6e25586$var$ScrollAreaScrollbarAuto, $fnFM9$babelruntimehelpersesmextends({\n        \"data-state\": visible ? 'visible' : 'hidden'\n    }, scrollbarProps, {\n        ref: forwardedRef\n    })));\n});\nconst $57acba87d6e25586$var$ScrollAreaScrollbarScroll = /*#__PURE__*/ $fnFM9$forwardRef((props, forwardedRef)=>{\n    const { forceMount: forceMount , ...scrollbarProps } = props;\n    const context = $57acba87d6e25586$var$useScrollAreaContext($57acba87d6e25586$var$SCROLLBAR_NAME, props.__scopeScrollArea);\n    const isHorizontal = props.orientation === 'horizontal';\n    const debounceScrollEnd = $57acba87d6e25586$var$useDebounceCallback(()=>send('SCROLL_END')\n    , 100);\n    const [state, send] = $6c2e24571c90391f$export$3e6543de14f8614f('hidden', {\n        hidden: {\n            SCROLL: 'scrolling'\n        },\n        scrolling: {\n            SCROLL_END: 'idle',\n            POINTER_ENTER: 'interacting'\n        },\n        interacting: {\n            SCROLL: 'interacting',\n            POINTER_LEAVE: 'idle'\n        },\n        idle: {\n            HIDE: 'hidden',\n            SCROLL: 'scrolling',\n            POINTER_ENTER: 'interacting'\n        }\n    });\n    $fnFM9$useEffect(()=>{\n        if (state === 'idle') {\n            const hideTimer = window.setTimeout(()=>send('HIDE')\n            , context.scrollHideDelay);\n            return ()=>window.clearTimeout(hideTimer)\n            ;\n        }\n    }, [\n        state,\n        context.scrollHideDelay,\n        send\n    ]);\n    $fnFM9$useEffect(()=>{\n        const viewport = context.viewport;\n        const scrollDirection = isHorizontal ? 'scrollLeft' : 'scrollTop';\n        if (viewport) {\n            let prevScrollPos = viewport[scrollDirection];\n            const handleScroll = ()=>{\n                const scrollPos = viewport[scrollDirection];\n                const hasScrollInDirectionChanged = prevScrollPos !== scrollPos;\n                if (hasScrollInDirectionChanged) {\n                    send('SCROLL');\n                    debounceScrollEnd();\n                }\n                prevScrollPos = scrollPos;\n            };\n            viewport.addEventListener('scroll', handleScroll);\n            return ()=>viewport.removeEventListener('scroll', handleScroll)\n            ;\n        }\n    }, [\n        context.viewport,\n        isHorizontal,\n        send,\n        debounceScrollEnd\n    ]);\n    return /*#__PURE__*/ $fnFM9$createElement($fnFM9$Presence, {\n        present: forceMount || state !== 'hidden'\n    }, /*#__PURE__*/ $fnFM9$createElement($57acba87d6e25586$var$ScrollAreaScrollbarVisible, $fnFM9$babelruntimehelpersesmextends({\n        \"data-state\": state === 'hidden' ? 'hidden' : 'visible'\n    }, scrollbarProps, {\n        ref: forwardedRef,\n        onPointerEnter: $fnFM9$composeEventHandlers(props.onPointerEnter, ()=>send('POINTER_ENTER')\n        ),\n        onPointerLeave: $fnFM9$composeEventHandlers(props.onPointerLeave, ()=>send('POINTER_LEAVE')\n        )\n    })));\n});\nconst $57acba87d6e25586$var$ScrollAreaScrollbarAuto = /*#__PURE__*/ $fnFM9$forwardRef((props, forwardedRef)=>{\n    const context = $57acba87d6e25586$var$useScrollAreaContext($57acba87d6e25586$var$SCROLLBAR_NAME, props.__scopeScrollArea);\n    const { forceMount: forceMount , ...scrollbarProps } = props;\n    const [visible, setVisible] = $fnFM9$useState(false);\n    const isHorizontal = props.orientation === 'horizontal';\n    const handleResize = $57acba87d6e25586$var$useDebounceCallback(()=>{\n        if (context.viewport) {\n            const isOverflowX = context.viewport.offsetWidth < context.viewport.scrollWidth;\n            const isOverflowY = context.viewport.offsetHeight < context.viewport.scrollHeight;\n            setVisible(isHorizontal ? isOverflowX : isOverflowY);\n        }\n    }, 10);\n    $57acba87d6e25586$var$useResizeObserver(context.viewport, handleResize);\n    $57acba87d6e25586$var$useResizeObserver(context.content, handleResize);\n    return /*#__PURE__*/ $fnFM9$createElement($fnFM9$Presence, {\n        present: forceMount || visible\n    }, /*#__PURE__*/ $fnFM9$createElement($57acba87d6e25586$var$ScrollAreaScrollbarVisible, $fnFM9$babelruntimehelpersesmextends({\n        \"data-state\": visible ? 'visible' : 'hidden'\n    }, scrollbarProps, {\n        ref: forwardedRef\n    })));\n});\n/* -----------------------------------------------------------------------------------------------*/ const $57acba87d6e25586$var$ScrollAreaScrollbarVisible = /*#__PURE__*/ $fnFM9$forwardRef((props, forwardedRef)=>{\n    const { orientation: orientation = 'vertical' , ...scrollbarProps } = props;\n    const context = $57acba87d6e25586$var$useScrollAreaContext($57acba87d6e25586$var$SCROLLBAR_NAME, props.__scopeScrollArea);\n    const thumbRef = $fnFM9$useRef(null);\n    const pointerOffsetRef = $fnFM9$useRef(0);\n    const [sizes, setSizes] = $fnFM9$useState({\n        content: 0,\n        viewport: 0,\n        scrollbar: {\n            size: 0,\n            paddingStart: 0,\n            paddingEnd: 0\n        }\n    });\n    const thumbRatio = $57acba87d6e25586$var$getThumbRatio(sizes.viewport, sizes.content);\n    const commonProps = {\n        ...scrollbarProps,\n        sizes: sizes,\n        onSizesChange: setSizes,\n        hasThumb: Boolean(thumbRatio > 0 && thumbRatio < 1),\n        onThumbChange: (thumb)=>thumbRef.current = thumb\n        ,\n        onThumbPointerUp: ()=>pointerOffsetRef.current = 0\n        ,\n        onThumbPointerDown: (pointerPos)=>pointerOffsetRef.current = pointerPos\n    };\n    function getScrollPosition(pointerPos, dir) {\n        return $57acba87d6e25586$var$getScrollPositionFromPointer(pointerPos, pointerOffsetRef.current, sizes, dir);\n    }\n    if (orientation === 'horizontal') return /*#__PURE__*/ $fnFM9$createElement($57acba87d6e25586$var$ScrollAreaScrollbarX, $fnFM9$babelruntimehelpersesmextends({}, commonProps, {\n        ref: forwardedRef,\n        onThumbPositionChange: ()=>{\n            if (context.viewport && thumbRef.current) {\n                const scrollPos = context.viewport.scrollLeft;\n                const offset = $57acba87d6e25586$var$getThumbOffsetFromScroll(scrollPos, sizes, context.dir);\n                thumbRef.current.style.transform = `translate3d(${offset}px, 0, 0)`;\n            }\n        },\n        onWheelScroll: (scrollPos)=>{\n            if (context.viewport) context.viewport.scrollLeft = scrollPos;\n        },\n        onDragScroll: (pointerPos)=>{\n            if (context.viewport) context.viewport.scrollLeft = getScrollPosition(pointerPos, context.dir);\n        }\n    }));\n    if (orientation === 'vertical') return /*#__PURE__*/ $fnFM9$createElement($57acba87d6e25586$var$ScrollAreaScrollbarY, $fnFM9$babelruntimehelpersesmextends({}, commonProps, {\n        ref: forwardedRef,\n        onThumbPositionChange: ()=>{\n            if (context.viewport && thumbRef.current) {\n                const scrollPos = context.viewport.scrollTop;\n                const offset = $57acba87d6e25586$var$getThumbOffsetFromScroll(scrollPos, sizes);\n                thumbRef.current.style.transform = `translate3d(0, ${offset}px, 0)`;\n            }\n        },\n        onWheelScroll: (scrollPos)=>{\n            if (context.viewport) context.viewport.scrollTop = scrollPos;\n        },\n        onDragScroll: (pointerPos)=>{\n            if (context.viewport) context.viewport.scrollTop = getScrollPosition(pointerPos);\n        }\n    }));\n    return null;\n});\n/* -----------------------------------------------------------------------------------------------*/ const $57acba87d6e25586$var$ScrollAreaScrollbarX = /*#__PURE__*/ $fnFM9$forwardRef((props, forwardedRef)=>{\n    const { sizes: sizes , onSizesChange: onSizesChange , ...scrollbarProps } = props;\n    const context = $57acba87d6e25586$var$useScrollAreaContext($57acba87d6e25586$var$SCROLLBAR_NAME, props.__scopeScrollArea);\n    const [computedStyle, setComputedStyle] = $fnFM9$useState();\n    const ref = $fnFM9$useRef(null);\n    const composeRefs = $fnFM9$useComposedRefs(forwardedRef, ref, context.onScrollbarXChange);\n    $fnFM9$useEffect(()=>{\n        if (ref.current) setComputedStyle(getComputedStyle(ref.current));\n    }, [\n        ref\n    ]);\n    return /*#__PURE__*/ $fnFM9$createElement($57acba87d6e25586$var$ScrollAreaScrollbarImpl, $fnFM9$babelruntimehelpersesmextends({\n        \"data-orientation\": \"horizontal\"\n    }, scrollbarProps, {\n        ref: composeRefs,\n        sizes: sizes,\n        style: {\n            bottom: 0,\n            left: context.dir === 'rtl' ? 'var(--radix-scroll-area-corner-width)' : 0,\n            right: context.dir === 'ltr' ? 'var(--radix-scroll-area-corner-width)' : 0,\n            ['--radix-scroll-area-thumb-width']: $57acba87d6e25586$var$getThumbSize(sizes) + 'px',\n            ...props.style\n        },\n        onThumbPointerDown: (pointerPos)=>props.onThumbPointerDown(pointerPos.x)\n        ,\n        onDragScroll: (pointerPos)=>props.onDragScroll(pointerPos.x)\n        ,\n        onWheelScroll: (event, maxScrollPos)=>{\n            if (context.viewport) {\n                const scrollPos = context.viewport.scrollLeft + event.deltaX;\n                props.onWheelScroll(scrollPos); // prevent window scroll when wheeling on scrollbar\n                if ($57acba87d6e25586$var$isScrollingWithinScrollbarBounds(scrollPos, maxScrollPos)) event.preventDefault();\n            }\n        },\n        onResize: ()=>{\n            if (ref.current && context.viewport && computedStyle) onSizesChange({\n                content: context.viewport.scrollWidth,\n                viewport: context.viewport.offsetWidth,\n                scrollbar: {\n                    size: ref.current.clientWidth,\n                    paddingStart: $57acba87d6e25586$var$toInt(computedStyle.paddingLeft),\n                    paddingEnd: $57acba87d6e25586$var$toInt(computedStyle.paddingRight)\n                }\n            });\n        }\n    }));\n});\nconst $57acba87d6e25586$var$ScrollAreaScrollbarY = /*#__PURE__*/ $fnFM9$forwardRef((props, forwardedRef)=>{\n    const { sizes: sizes , onSizesChange: onSizesChange , ...scrollbarProps } = props;\n    const context = $57acba87d6e25586$var$useScrollAreaContext($57acba87d6e25586$var$SCROLLBAR_NAME, props.__scopeScrollArea);\n    const [computedStyle, setComputedStyle] = $fnFM9$useState();\n    const ref = $fnFM9$useRef(null);\n    const composeRefs = $fnFM9$useComposedRefs(forwardedRef, ref, context.onScrollbarYChange);\n    $fnFM9$useEffect(()=>{\n        if (ref.current) setComputedStyle(getComputedStyle(ref.current));\n    }, [\n        ref\n    ]);\n    return /*#__PURE__*/ $fnFM9$createElement($57acba87d6e25586$var$ScrollAreaScrollbarImpl, $fnFM9$babelruntimehelpersesmextends({\n        \"data-orientation\": \"vertical\"\n    }, scrollbarProps, {\n        ref: composeRefs,\n        sizes: sizes,\n        style: {\n            top: 0,\n            right: context.dir === 'ltr' ? 0 : undefined,\n            left: context.dir === 'rtl' ? 0 : undefined,\n            bottom: 'var(--radix-scroll-area-corner-height)',\n            ['--radix-scroll-area-thumb-height']: $57acba87d6e25586$var$getThumbSize(sizes) + 'px',\n            ...props.style\n        },\n        onThumbPointerDown: (pointerPos)=>props.onThumbPointerDown(pointerPos.y)\n        ,\n        onDragScroll: (pointerPos)=>props.onDragScroll(pointerPos.y)\n        ,\n        onWheelScroll: (event, maxScrollPos)=>{\n            if (context.viewport) {\n                const scrollPos = context.viewport.scrollTop + event.deltaY;\n                props.onWheelScroll(scrollPos); // prevent window scroll when wheeling on scrollbar\n                if ($57acba87d6e25586$var$isScrollingWithinScrollbarBounds(scrollPos, maxScrollPos)) event.preventDefault();\n            }\n        },\n        onResize: ()=>{\n            if (ref.current && context.viewport && computedStyle) onSizesChange({\n                content: context.viewport.scrollHeight,\n                viewport: context.viewport.offsetHeight,\n                scrollbar: {\n                    size: ref.current.clientHeight,\n                    paddingStart: $57acba87d6e25586$var$toInt(computedStyle.paddingTop),\n                    paddingEnd: $57acba87d6e25586$var$toInt(computedStyle.paddingBottom)\n                }\n            });\n        }\n    }));\n});\n/* -----------------------------------------------------------------------------------------------*/ const [$57acba87d6e25586$var$ScrollbarProvider, $57acba87d6e25586$var$useScrollbarContext] = $57acba87d6e25586$var$createScrollAreaContext($57acba87d6e25586$var$SCROLLBAR_NAME);\nconst $57acba87d6e25586$var$ScrollAreaScrollbarImpl = /*#__PURE__*/ $fnFM9$forwardRef((props, forwardedRef)=>{\n    const { __scopeScrollArea: __scopeScrollArea , sizes: sizes , hasThumb: hasThumb , onThumbChange: onThumbChange , onThumbPointerUp: onThumbPointerUp , onThumbPointerDown: onThumbPointerDown , onThumbPositionChange: onThumbPositionChange , onDragScroll: onDragScroll , onWheelScroll: onWheelScroll , onResize: onResize , ...scrollbarProps } = props;\n    const context = $57acba87d6e25586$var$useScrollAreaContext($57acba87d6e25586$var$SCROLLBAR_NAME, __scopeScrollArea);\n    const [scrollbar, setScrollbar] = $fnFM9$useState(null);\n    const composeRefs = $fnFM9$useComposedRefs(forwardedRef, (node)=>setScrollbar(node)\n    );\n    const rectRef = $fnFM9$useRef(null);\n    const prevWebkitUserSelectRef = $fnFM9$useRef('');\n    const viewport = context.viewport;\n    const maxScrollPos = sizes.content - sizes.viewport;\n    const handleWheelScroll = $fnFM9$useCallbackRef(onWheelScroll);\n    const handleThumbPositionChange = $fnFM9$useCallbackRef(onThumbPositionChange);\n    const handleResize = $57acba87d6e25586$var$useDebounceCallback(onResize, 10);\n    function handleDragScroll(event) {\n        if (rectRef.current) {\n            const x = event.clientX - rectRef.current.left;\n            const y = event.clientY - rectRef.current.top;\n            onDragScroll({\n                x: x,\n                y: y\n            });\n        }\n    }\n    /**\n   * We bind wheel event imperatively so we can switch off passive\n   * mode for document wheel event to allow it to be prevented\n   */ $fnFM9$useEffect(()=>{\n        const handleWheel = (event)=>{\n            const element = event.target;\n            const isScrollbarWheel = scrollbar === null || scrollbar === void 0 ? void 0 : scrollbar.contains(element);\n            if (isScrollbarWheel) handleWheelScroll(event, maxScrollPos);\n        };\n        document.addEventListener('wheel', handleWheel, {\n            passive: false\n        });\n        return ()=>document.removeEventListener('wheel', handleWheel, {\n                passive: false\n            })\n        ;\n    }, [\n        viewport,\n        scrollbar,\n        maxScrollPos,\n        handleWheelScroll\n    ]);\n    /**\n   * Update thumb position on sizes change\n   */ $fnFM9$useEffect(handleThumbPositionChange, [\n        sizes,\n        handleThumbPositionChange\n    ]);\n    $57acba87d6e25586$var$useResizeObserver(scrollbar, handleResize);\n    $57acba87d6e25586$var$useResizeObserver(context.content, handleResize);\n    return /*#__PURE__*/ $fnFM9$createElement($57acba87d6e25586$var$ScrollbarProvider, {\n        scope: __scopeScrollArea,\n        scrollbar: scrollbar,\n        hasThumb: hasThumb,\n        onThumbChange: $fnFM9$useCallbackRef(onThumbChange),\n        onThumbPointerUp: $fnFM9$useCallbackRef(onThumbPointerUp),\n        onThumbPositionChange: handleThumbPositionChange,\n        onThumbPointerDown: $fnFM9$useCallbackRef(onThumbPointerDown)\n    }, /*#__PURE__*/ $fnFM9$createElement($fnFM9$Primitive.div, $fnFM9$babelruntimehelpersesmextends({}, scrollbarProps, {\n        ref: composeRefs,\n        style: {\n            position: 'absolute',\n            ...scrollbarProps.style\n        },\n        onPointerDown: $fnFM9$composeEventHandlers(props.onPointerDown, (event)=>{\n            const mainPointer = 0;\n            if (event.button === mainPointer) {\n                const element = event.target;\n                element.setPointerCapture(event.pointerId);\n                rectRef.current = scrollbar.getBoundingClientRect(); // pointer capture doesn't prevent text selection in Safari\n                // so we remove text selection manually when scrolling\n                prevWebkitUserSelectRef.current = document.body.style.webkitUserSelect;\n                document.body.style.webkitUserSelect = 'none';\n                handleDragScroll(event);\n            }\n        }),\n        onPointerMove: $fnFM9$composeEventHandlers(props.onPointerMove, handleDragScroll),\n        onPointerUp: $fnFM9$composeEventHandlers(props.onPointerUp, (event)=>{\n            const element = event.target;\n            if (element.hasPointerCapture(event.pointerId)) element.releasePointerCapture(event.pointerId);\n            document.body.style.webkitUserSelect = prevWebkitUserSelectRef.current;\n            rectRef.current = null;\n        })\n    })));\n});\n/* -------------------------------------------------------------------------------------------------\n * ScrollAreaThumb\n * -----------------------------------------------------------------------------------------------*/ const $57acba87d6e25586$var$THUMB_NAME = 'ScrollAreaThumb';\nconst $57acba87d6e25586$export$9fba1154677d7cd2 = /*#__PURE__*/ $fnFM9$forwardRef((props, forwardedRef)=>{\n    const { forceMount: forceMount , ...thumbProps } = props;\n    const scrollbarContext = $57acba87d6e25586$var$useScrollbarContext($57acba87d6e25586$var$THUMB_NAME, props.__scopeScrollArea);\n    return /*#__PURE__*/ $fnFM9$createElement($fnFM9$Presence, {\n        present: forceMount || scrollbarContext.hasThumb\n    }, /*#__PURE__*/ $fnFM9$createElement($57acba87d6e25586$var$ScrollAreaThumbImpl, $fnFM9$babelruntimehelpersesmextends({\n        ref: forwardedRef\n    }, thumbProps)));\n});\nconst $57acba87d6e25586$var$ScrollAreaThumbImpl = /*#__PURE__*/ $fnFM9$forwardRef((props, forwardedRef)=>{\n    const { __scopeScrollArea: __scopeScrollArea , style: style , ...thumbProps } = props;\n    const scrollAreaContext = $57acba87d6e25586$var$useScrollAreaContext($57acba87d6e25586$var$THUMB_NAME, __scopeScrollArea);\n    const scrollbarContext = $57acba87d6e25586$var$useScrollbarContext($57acba87d6e25586$var$THUMB_NAME, __scopeScrollArea);\n    const { onThumbPositionChange: onThumbPositionChange  } = scrollbarContext;\n    const composedRef = $fnFM9$useComposedRefs(forwardedRef, (node)=>scrollbarContext.onThumbChange(node)\n    );\n    const removeUnlinkedScrollListenerRef = $fnFM9$useRef();\n    const debounceScrollEnd = $57acba87d6e25586$var$useDebounceCallback(()=>{\n        if (removeUnlinkedScrollListenerRef.current) {\n            removeUnlinkedScrollListenerRef.current();\n            removeUnlinkedScrollListenerRef.current = undefined;\n        }\n    }, 100);\n    $fnFM9$useEffect(()=>{\n        const viewport = scrollAreaContext.viewport;\n        if (viewport) {\n            /**\n       * We only bind to native scroll event so we know when scroll starts and ends.\n       * When scroll starts we start a requestAnimationFrame loop that checks for\n       * changes to scroll position. That rAF loop triggers our thumb position change\n       * when relevant to avoid scroll-linked effects. We cancel the loop when scroll ends.\n       * https://developer.mozilla.org/en-US/docs/Mozilla/Performance/Scroll-linked_effects\n       */ const handleScroll = ()=>{\n                debounceScrollEnd();\n                if (!removeUnlinkedScrollListenerRef.current) {\n                    const listener = $57acba87d6e25586$var$addUnlinkedScrollListener(viewport, onThumbPositionChange);\n                    removeUnlinkedScrollListenerRef.current = listener;\n                    onThumbPositionChange();\n                }\n            };\n            onThumbPositionChange();\n            viewport.addEventListener('scroll', handleScroll);\n            return ()=>viewport.removeEventListener('scroll', handleScroll)\n            ;\n        }\n    }, [\n        scrollAreaContext.viewport,\n        debounceScrollEnd,\n        onThumbPositionChange\n    ]);\n    return /*#__PURE__*/ $fnFM9$createElement($fnFM9$Primitive.div, $fnFM9$babelruntimehelpersesmextends({\n        \"data-state\": scrollbarContext.hasThumb ? 'visible' : 'hidden'\n    }, thumbProps, {\n        ref: composedRef,\n        style: {\n            width: 'var(--radix-scroll-area-thumb-width)',\n            height: 'var(--radix-scroll-area-thumb-height)',\n            ...style\n        },\n        onPointerDownCapture: $fnFM9$composeEventHandlers(props.onPointerDownCapture, (event)=>{\n            const thumb = event.target;\n            const thumbRect = thumb.getBoundingClientRect();\n            const x = event.clientX - thumbRect.left;\n            const y = event.clientY - thumbRect.top;\n            scrollbarContext.onThumbPointerDown({\n                x: x,\n                y: y\n            });\n        }),\n        onPointerUp: $fnFM9$composeEventHandlers(props.onPointerUp, scrollbarContext.onThumbPointerUp)\n    }));\n});\n/*#__PURE__*/ Object.assign($57acba87d6e25586$export$9fba1154677d7cd2, {\n    displayName: $57acba87d6e25586$var$THUMB_NAME\n});\n/* -------------------------------------------------------------------------------------------------\n * ScrollAreaCorner\n * -----------------------------------------------------------------------------------------------*/ const $57acba87d6e25586$var$CORNER_NAME = 'ScrollAreaCorner';\nconst $57acba87d6e25586$export$56969d565df7cc4b = /*#__PURE__*/ $fnFM9$forwardRef((props, forwardedRef)=>{\n    const context = $57acba87d6e25586$var$useScrollAreaContext($57acba87d6e25586$var$CORNER_NAME, props.__scopeScrollArea);\n    const hasBothScrollbarsVisible = Boolean(context.scrollbarX && context.scrollbarY);\n    const hasCorner = context.type !== 'scroll' && hasBothScrollbarsVisible;\n    return hasCorner ? /*#__PURE__*/ $fnFM9$createElement($57acba87d6e25586$var$ScrollAreaCornerImpl, $fnFM9$babelruntimehelpersesmextends({}, props, {\n        ref: forwardedRef\n    })) : null;\n});\n/*#__PURE__*/ Object.assign($57acba87d6e25586$export$56969d565df7cc4b, {\n    displayName: $57acba87d6e25586$var$CORNER_NAME\n});\n/* -----------------------------------------------------------------------------------------------*/ const $57acba87d6e25586$var$ScrollAreaCornerImpl = /*#__PURE__*/ $fnFM9$forwardRef((props, forwardedRef)=>{\n    const { __scopeScrollArea: __scopeScrollArea , ...cornerProps } = props;\n    const context = $57acba87d6e25586$var$useScrollAreaContext($57acba87d6e25586$var$CORNER_NAME, __scopeScrollArea);\n    const [width1, setWidth] = $fnFM9$useState(0);\n    const [height1, setHeight] = $fnFM9$useState(0);\n    const hasSize = Boolean(width1 && height1);\n    $57acba87d6e25586$var$useResizeObserver(context.scrollbarX, ()=>{\n        var _context$scrollbarX;\n        const height = ((_context$scrollbarX = context.scrollbarX) === null || _context$scrollbarX === void 0 ? void 0 : _context$scrollbarX.offsetHeight) || 0;\n        context.onCornerHeightChange(height);\n        setHeight(height);\n    });\n    $57acba87d6e25586$var$useResizeObserver(context.scrollbarY, ()=>{\n        var _context$scrollbarY;\n        const width = ((_context$scrollbarY = context.scrollbarY) === null || _context$scrollbarY === void 0 ? void 0 : _context$scrollbarY.offsetWidth) || 0;\n        context.onCornerWidthChange(width);\n        setWidth(width);\n    });\n    return hasSize ? /*#__PURE__*/ $fnFM9$createElement($fnFM9$Primitive.div, $fnFM9$babelruntimehelpersesmextends({}, cornerProps, {\n        ref: forwardedRef,\n        style: {\n            width: width1,\n            height: height1,\n            position: 'absolute',\n            right: context.dir === 'ltr' ? 0 : undefined,\n            left: context.dir === 'rtl' ? 0 : undefined,\n            bottom: 0,\n            ...props.style\n        }\n    })) : null;\n});\n/* -----------------------------------------------------------------------------------------------*/ function $57acba87d6e25586$var$toInt(value) {\n    return value ? parseInt(value, 10) : 0;\n}\nfunction $57acba87d6e25586$var$getThumbRatio(viewportSize, contentSize) {\n    const ratio = viewportSize / contentSize;\n    return isNaN(ratio) ? 0 : ratio;\n}\nfunction $57acba87d6e25586$var$getThumbSize(sizes) {\n    const ratio = $57acba87d6e25586$var$getThumbRatio(sizes.viewport, sizes.content);\n    const scrollbarPadding = sizes.scrollbar.paddingStart + sizes.scrollbar.paddingEnd;\n    const thumbSize = (sizes.scrollbar.size - scrollbarPadding) * ratio; // minimum of 18 matches macOS minimum\n    return Math.max(thumbSize, 18);\n}\nfunction $57acba87d6e25586$var$getScrollPositionFromPointer(pointerPos, pointerOffset, sizes, dir = 'ltr') {\n    const thumbSizePx = $57acba87d6e25586$var$getThumbSize(sizes);\n    const thumbCenter = thumbSizePx / 2;\n    const offset = pointerOffset || thumbCenter;\n    const thumbOffsetFromEnd = thumbSizePx - offset;\n    const minPointerPos = sizes.scrollbar.paddingStart + offset;\n    const maxPointerPos = sizes.scrollbar.size - sizes.scrollbar.paddingEnd - thumbOffsetFromEnd;\n    const maxScrollPos = sizes.content - sizes.viewport;\n    const scrollRange = dir === 'ltr' ? [\n        0,\n        maxScrollPos\n    ] : [\n        maxScrollPos * -1,\n        0\n    ];\n    const interpolate = $57acba87d6e25586$var$linearScale([\n        minPointerPos,\n        maxPointerPos\n    ], scrollRange);\n    return interpolate(pointerPos);\n}\nfunction $57acba87d6e25586$var$getThumbOffsetFromScroll(scrollPos, sizes, dir = 'ltr') {\n    const thumbSizePx = $57acba87d6e25586$var$getThumbSize(sizes);\n    const scrollbarPadding = sizes.scrollbar.paddingStart + sizes.scrollbar.paddingEnd;\n    const scrollbar = sizes.scrollbar.size - scrollbarPadding;\n    const maxScrollPos = sizes.content - sizes.viewport;\n    const maxThumbPos = scrollbar - thumbSizePx;\n    const scrollClampRange = dir === 'ltr' ? [\n        0,\n        maxScrollPos\n    ] : [\n        maxScrollPos * -1,\n        0\n    ];\n    const scrollWithoutMomentum = $fnFM9$clamp(scrollPos, scrollClampRange);\n    const interpolate = $57acba87d6e25586$var$linearScale([\n        0,\n        maxScrollPos\n    ], [\n        0,\n        maxThumbPos\n    ]);\n    return interpolate(scrollWithoutMomentum);\n} // https://github.com/tmcw-up-for-adoption/simple-linear-scale/blob/master/index.js\nfunction $57acba87d6e25586$var$linearScale(input, output) {\n    return (value)=>{\n        if (input[0] === input[1] || output[0] === output[1]) return output[0];\n        const ratio = (output[1] - output[0]) / (input[1] - input[0]);\n        return output[0] + ratio * (value - input[0]);\n    };\n}\nfunction $57acba87d6e25586$var$isScrollingWithinScrollbarBounds(scrollPos, maxScrollPos) {\n    return scrollPos > 0 && scrollPos < maxScrollPos;\n} // Custom scroll handler to avoid scroll-linked effects\n// https://developer.mozilla.org/en-US/docs/Mozilla/Performance/Scroll-linked_effects\nconst $57acba87d6e25586$var$addUnlinkedScrollListener = (node, handler = ()=>{})=>{\n    let prevPosition = {\n        left: node.scrollLeft,\n        top: node.scrollTop\n    };\n    let rAF = 0;\n    (function loop() {\n        const position = {\n            left: node.scrollLeft,\n            top: node.scrollTop\n        };\n        const isHorizontalScroll = prevPosition.left !== position.left;\n        const isVerticalScroll = prevPosition.top !== position.top;\n        if (isHorizontalScroll || isVerticalScroll) handler();\n        prevPosition = position;\n        rAF = window.requestAnimationFrame(loop);\n    })();\n    return ()=>window.cancelAnimationFrame(rAF)\n    ;\n};\nfunction $57acba87d6e25586$var$useDebounceCallback(callback, delay) {\n    const handleCallback = $fnFM9$useCallbackRef(callback);\n    const debounceTimerRef = $fnFM9$useRef(0);\n    $fnFM9$useEffect(()=>()=>window.clearTimeout(debounceTimerRef.current)\n    , []);\n    return $fnFM9$useCallback(()=>{\n        window.clearTimeout(debounceTimerRef.current);\n        debounceTimerRef.current = window.setTimeout(handleCallback, delay);\n    }, [\n        handleCallback,\n        delay\n    ]);\n}\nfunction $57acba87d6e25586$var$useResizeObserver(element, onResize) {\n    const handleResize = $fnFM9$useCallbackRef(onResize);\n    $fnFM9$useLayoutEffect(()=>{\n        let rAF = 0;\n        if (element) {\n            /**\n       * Resize Observer will throw an often benign error that says `ResizeObserver loop\n       * completed with undelivered notifications`. This means that ResizeObserver was not\n       * able to deliver all observations within a single animation frame, so we use\n       * `requestAnimationFrame` to ensure we don't deliver unnecessary observations.\n       * Further reading: https://github.com/WICG/resize-observer/issues/38\n       */ const resizeObserver = new ResizeObserver(()=>{\n                cancelAnimationFrame(rAF);\n                rAF = window.requestAnimationFrame(handleResize);\n            });\n            resizeObserver.observe(element);\n            return ()=>{\n                window.cancelAnimationFrame(rAF);\n                resizeObserver.unobserve(element);\n            };\n        }\n    }, [\n        element,\n        handleResize\n    ]);\n}\n/* -----------------------------------------------------------------------------------------------*/ const $57acba87d6e25586$export$be92b6f5f03c0fe9 = $57acba87d6e25586$export$ccf8d8d7bbf3c2cc;\nconst $57acba87d6e25586$export$d5c6c08dc2d3ca7 = $57acba87d6e25586$export$a21cbf9f11fca853;\nconst $57acba87d6e25586$export$9a4e88b92edfce6b = $57acba87d6e25586$export$2fabd85d0eba3c57;\nconst $57acba87d6e25586$export$6521433ed15a34db = $57acba87d6e25586$export$9fba1154677d7cd2;\nconst $57acba87d6e25586$export$ac61190d9fc311a9 = $57acba87d6e25586$export$56969d565df7cc4b;\n\n\n\n\nexport {$57acba87d6e25586$export$488468afe3a6f2b1 as createScrollAreaScope, $57acba87d6e25586$export$ccf8d8d7bbf3c2cc as ScrollArea, $57acba87d6e25586$export$a21cbf9f11fca853 as ScrollAreaViewport, $57acba87d6e25586$export$2fabd85d0eba3c57 as ScrollAreaScrollbar, $57acba87d6e25586$export$9fba1154677d7cd2 as ScrollAreaThumb, $57acba87d6e25586$export$56969d565df7cc4b as ScrollAreaCorner, $57acba87d6e25586$export$be92b6f5f03c0fe9 as Root, $57acba87d6e25586$export$d5c6c08dc2d3ca7 as Viewport, $57acba87d6e25586$export$9a4e88b92edfce6b as Scrollbar, $57acba87d6e25586$export$6521433ed15a34db as Thumb, $57acba87d6e25586$export$ac61190d9fc311a9 as Corner};\n//# sourceMappingURL=index.module.js.map\n","function $ae6933e535247d3d$export$7d15b64cf5a3a4c4(value, [min, max]) {\n    return Math.min(max, Math.max(min, value));\n}\n\n\n\n\nexport {$ae6933e535247d3d$export$7d15b64cf5a3a4c4 as clamp};\n//# sourceMappingURL=index.module.js.map\n","import { createStyles } from '@mantine/styles';\n\nvar useStyles = createStyles((theme, { scrollbarSize, offsetScrollbars, scrollbarHovered, hidden }, getRef) => ({\n  root: {\n    overflow: \"hidden\"\n  },\n  viewport: {\n    width: \"100%\",\n    height: \"100%\",\n    paddingRight: offsetScrollbars ? scrollbarSize : void 0,\n    paddingBottom: offsetScrollbars ? scrollbarSize : void 0\n  },\n  scrollbar: {\n    display: hidden ? \"none\" : \"flex\",\n    userSelect: \"none\",\n    touchAction: \"none\",\n    boxSizing: \"border-box\",\n    padding: scrollbarSize / 5,\n    transition: \"background-color 150ms ease, opacity 150ms ease\",\n    \"&:hover\": {\n      backgroundColor: theme.colorScheme === \"dark\" ? theme.colors.dark[8] : theme.colors.gray[0],\n      [`& .${getRef(\"thumb\")}`]: {\n        backgroundColor: theme.colorScheme === \"dark\" ? theme.fn.rgba(theme.white, 0.5) : theme.fn.rgba(theme.black, 0.5)\n      }\n    },\n    '&[data-orientation=\"vertical\"]': {\n      width: scrollbarSize\n    },\n    '&[data-orientation=\"horizontal\"]': {\n      flexDirection: \"column\",\n      height: scrollbarSize\n    },\n    '&[data-state=\"hidden\"]': {\n      display: \"none\",\n      opacity: 0\n    }\n  },\n  thumb: {\n    ref: getRef(\"thumb\"),\n    flex: 1,\n    backgroundColor: theme.colorScheme === \"dark\" ? theme.fn.rgba(theme.white, 0.4) : theme.fn.rgba(theme.black, 0.4),\n    borderRadius: scrollbarSize,\n    position: \"relative\",\n    transition: \"background-color 150ms ease\",\n    display: hidden ? \"none\" : void 0,\n    overflow: \"hidden\",\n    \"&::before\": {\n      content: '\"\"',\n      position: \"absolute\",\n      top: \"50%\",\n      left: \"50%\",\n      transform: \"translate(-50%, -50%)\",\n      width: \"100%\",\n      height: \"100%\",\n      minWidth: 44,\n      minHeight: 44\n    }\n  },\n  corner: {\n    backgroundColor: theme.colorScheme === \"dark\" ? theme.colors.dark[6] : theme.colors.gray[0],\n    transition: \"opacity 150ms ease\",\n    opacity: scrollbarHovered ? 1 : 0,\n    display: hidden ? \"none\" : void 0\n  }\n}));\n\nexport default useStyles;\n//# sourceMappingURL=ScrollArea.styles.js.map\n","import React, { forwardRef, useState } from 'react';\nimport * as RadixScrollArea from '@radix-ui/react-scroll-area';\nimport { useComponentDefaultProps, useMantineTheme } from '@mantine/styles';\nimport { packSx } from '@mantine/utils';\nimport useStyles from './ScrollArea.styles.js';\nimport { Box } from '../Box/Box.js';\n\nvar __defProp = Object.defineProperty;\nvar __defProps = Object.defineProperties;\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));\nvar __objRest = (source, exclude) => {\n  var target = {};\n  for (var prop in source)\n    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)\n      target[prop] = source[prop];\n  if (source != null && __getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(source)) {\n      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))\n        target[prop] = source[prop];\n    }\n  return target;\n};\nconst defaultProps = {\n  scrollbarSize: 12,\n  scrollHideDelay: 1e3,\n  type: \"hover\",\n  offsetScrollbars: false\n};\nconst _ScrollArea = forwardRef((props, ref) => {\n  const _a = useComponentDefaultProps(\"ScrollArea\", defaultProps, props), {\n    children,\n    className,\n    classNames,\n    styles,\n    scrollbarSize,\n    scrollHideDelay,\n    type,\n    dir,\n    offsetScrollbars,\n    viewportRef,\n    onScrollPositionChange,\n    unstyled,\n    viewportProps\n  } = _a, others = __objRest(_a, [\n    \"children\",\n    \"className\",\n    \"classNames\",\n    \"styles\",\n    \"scrollbarSize\",\n    \"scrollHideDelay\",\n    \"type\",\n    \"dir\",\n    \"offsetScrollbars\",\n    \"viewportRef\",\n    \"onScrollPositionChange\",\n    \"unstyled\",\n    \"viewportProps\"\n  ]);\n  const [scrollbarHovered, setScrollbarHovered] = useState(false);\n  const theme = useMantineTheme();\n  const { classes, cx } = useStyles({ scrollbarSize, offsetScrollbars, scrollbarHovered, hidden: type === \"never\" }, { name: \"ScrollArea\", classNames, styles, unstyled });\n  return /* @__PURE__ */ React.createElement(RadixScrollArea.Root, {\n    type: type === \"never\" ? \"always\" : type,\n    scrollHideDelay,\n    dir: dir || theme.dir,\n    ref,\n    asChild: true\n  }, /* @__PURE__ */ React.createElement(Box, __spreadValues({\n    className: cx(classes.root, className)\n  }, others), /* @__PURE__ */ React.createElement(RadixScrollArea.Viewport, __spreadProps(__spreadValues({}, viewportProps), {\n    className: classes.viewport,\n    ref: viewportRef,\n    onScroll: typeof onScrollPositionChange === \"function\" ? ({ currentTarget }) => onScrollPositionChange({\n      x: currentTarget.scrollLeft,\n      y: currentTarget.scrollTop\n    }) : void 0\n  }), children), /* @__PURE__ */ React.createElement(RadixScrollArea.Scrollbar, {\n    orientation: \"horizontal\",\n    className: classes.scrollbar,\n    forceMount: true,\n    onMouseEnter: () => setScrollbarHovered(true),\n    onMouseLeave: () => setScrollbarHovered(false)\n  }, /* @__PURE__ */ React.createElement(RadixScrollArea.Thumb, {\n    className: classes.thumb\n  })), /* @__PURE__ */ React.createElement(RadixScrollArea.Scrollbar, {\n    orientation: \"vertical\",\n    className: classes.scrollbar,\n    forceMount: true,\n    onMouseEnter: () => setScrollbarHovered(true),\n    onMouseLeave: () => setScrollbarHovered(false)\n  }, /* @__PURE__ */ React.createElement(RadixScrollArea.Thumb, {\n    className: classes.thumb\n  })), /* @__PURE__ */ React.createElement(RadixScrollArea.Corner, {\n    className: classes.corner\n  })));\n});\nconst ScrollAreaAutosize = forwardRef((props, ref) => {\n  const _a = useComponentDefaultProps(\"ScrollAreaAutosize\", defaultProps, props), {\n    maxHeight,\n    children,\n    classNames,\n    styles,\n    scrollbarSize,\n    scrollHideDelay,\n    type,\n    dir,\n    offsetScrollbars,\n    viewportRef,\n    onScrollPositionChange,\n    unstyled,\n    sx\n  } = _a, others = __objRest(_a, [\n    \"maxHeight\",\n    \"children\",\n    \"classNames\",\n    \"styles\",\n    \"scrollbarSize\",\n    \"scrollHideDelay\",\n    \"type\",\n    \"dir\",\n    \"offsetScrollbars\",\n    \"viewportRef\",\n    \"onScrollPositionChange\",\n    \"unstyled\",\n    \"sx\"\n  ]);\n  return /* @__PURE__ */ React.createElement(Box, __spreadProps(__spreadValues({}, others), {\n    ref,\n    sx: [{ display: \"flex\", maxHeight }, ...packSx(sx)]\n  }), /* @__PURE__ */ React.createElement(Box, {\n    sx: { display: \"flex\", flexDirection: \"column\", flex: 1 }\n  }, /* @__PURE__ */ React.createElement(_ScrollArea, {\n    classNames,\n    styles,\n    scrollHideDelay,\n    scrollbarSize,\n    type,\n    dir,\n    offsetScrollbars,\n    viewportRef,\n    onScrollPositionChange,\n    unstyled\n  }, children)));\n});\nScrollAreaAutosize.displayName = \"@mantine/core/ScrollAreaAutosize\";\n_ScrollArea.displayName = \"@mantine/core/ScrollArea\";\n_ScrollArea.Autosize = ScrollAreaAutosize;\nconst ScrollArea = _ScrollArea;\n\nexport { ScrollArea, _ScrollArea };\n//# sourceMappingURL=ScrollArea.js.map\n","import React, { forwardRef } from 'react';\nimport { useComponentDefaultProps } from '@mantine/styles';\nimport { Box } from '../Box/Box.js';\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __objRest = (source, exclude) => {\n  var target = {};\n  for (var prop in source)\n    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)\n      target[prop] = source[prop];\n  if (source != null && __getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(source)) {\n      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))\n        target[prop] = source[prop];\n    }\n  return target;\n};\nconst defaultProps = {\n  w: 0,\n  h: 0\n};\nconst Space = forwardRef((props, ref) => {\n  const _a = useComponentDefaultProps(\"Space\", defaultProps, props), { w, h } = _a, others = __objRest(_a, [\"w\", \"h\"]);\n  return /* @__PURE__ */ React.createElement(Box, __spreadValues({\n    ref,\n    w,\n    miw: w,\n    h,\n    mih: h\n  }, others));\n});\nSpace.displayName = \"@mantine/core/Space\";\n\nexport { Space };\n//# sourceMappingURL=Space.js.map\n","import React, { forwardRef } from 'react';\nimport { useInputProps } from '../Input/use-input-props.js';\nimport { Input } from '../Input/Input.js';\n\nvar __defProp = Object.defineProperty;\nvar __defProps = Object.defineProperties;\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));\nvar __objRest = (source, exclude) => {\n  var target = {};\n  for (var prop in source)\n    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)\n      target[prop] = source[prop];\n  if (source != null && __getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(source)) {\n      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))\n        target[prop] = source[prop];\n    }\n  return target;\n};\nconst defaultProps = {\n  type: \"text\",\n  size: \"sm\",\n  __staticSelector: \"TextInput\"\n};\nconst TextInput = forwardRef((props, ref) => {\n  const _a = useInputProps(\"TextInput\", defaultProps, props), { inputProps, wrapperProps } = _a, others = __objRest(_a, [\"inputProps\", \"wrapperProps\"]);\n  return /* @__PURE__ */ React.createElement(Input.Wrapper, __spreadValues({}, wrapperProps), /* @__PURE__ */ React.createElement(Input, __spreadProps(__spreadValues(__spreadValues({}, inputProps), others), {\n    ref\n  })));\n});\nTextInput.displayName = \"@mantine/core/TextInput\";\n\nexport { TextInput };\n//# sourceMappingURL=TextInput.js.map\n","function zodResolver(schema) {\n  return (values) => {\n    const parsed = schema.safeParse(values);\n    if (parsed.success) {\n      return {};\n    }\n    const results = {};\n    parsed.error.errors.forEach((error) => {\n      results[error.path.join(\".\")] = error.message;\n    });\n    return results;\n  };\n}\n\nexport { zodResolver };\n//# sourceMappingURL=zod-resolver.js.map\n","import React from 'react';\n\nfunction isElement(value) {\n  if (Array.isArray(value) || value === null) {\n    return false;\n  }\n  if (typeof value === \"object\") {\n    if (value.type === React.Fragment) {\n      return false;\n    }\n    return true;\n  }\n  return false;\n}\n\nexport { isElement };\n//# sourceMappingURL=is-element.js.map\n","(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :\n  typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactErrorBoundary = {}, global.React));\n})(this, (function (exports, React) { 'use strict';\n\n  function _interopNamespace(e) {\n    if (e && e.__esModule) return e;\n    var n = Object.create(null);\n    if (e) {\n      Object.keys(e).forEach(function (k) {\n        if (k !== 'default') {\n          var d = Object.getOwnPropertyDescriptor(e, k);\n          Object.defineProperty(n, k, d.get ? d : {\n            enumerable: true,\n            get: function () { return e[k]; }\n          });\n        }\n      });\n    }\n    n[\"default\"] = e;\n    return Object.freeze(n);\n  }\n\n  var React__namespace = /*#__PURE__*/_interopNamespace(React);\n\n  function _setPrototypeOf(o, p) {\n    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n      o.__proto__ = p;\n      return o;\n    };\n\n    return _setPrototypeOf(o, p);\n  }\n\n  function _inheritsLoose(subClass, superClass) {\n    subClass.prototype = Object.create(superClass.prototype);\n    subClass.prototype.constructor = subClass;\n    _setPrototypeOf(subClass, superClass);\n  }\n\n  var changedArray = function changedArray(a, b) {\n    if (a === void 0) {\n      a = [];\n    }\n\n    if (b === void 0) {\n      b = [];\n    }\n\n    return a.length !== b.length || a.some(function (item, index) {\n      return !Object.is(item, b[index]);\n    });\n  };\n\n  var initialState = {\n    error: null\n  };\n\n  var ErrorBoundary = /*#__PURE__*/function (_React$Component) {\n    _inheritsLoose(ErrorBoundary, _React$Component);\n\n    function ErrorBoundary() {\n      var _this;\n\n      for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {\n        _args[_key] = arguments[_key];\n      }\n\n      _this = _React$Component.call.apply(_React$Component, [this].concat(_args)) || this;\n      _this.state = initialState;\n\n      _this.resetErrorBoundary = function () {\n        var _this$props;\n\n        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n          args[_key2] = arguments[_key2];\n        }\n\n        _this.props.onReset == null ? void 0 : (_this$props = _this.props).onReset.apply(_this$props, args);\n\n        _this.reset();\n      };\n\n      return _this;\n    }\n\n    ErrorBoundary.getDerivedStateFromError = function getDerivedStateFromError(error) {\n      return {\n        error: error\n      };\n    };\n\n    var _proto = ErrorBoundary.prototype;\n\n    _proto.reset = function reset() {\n      this.setState(initialState);\n    };\n\n    _proto.componentDidCatch = function componentDidCatch(error, info) {\n      var _this$props$onError, _this$props2;\n\n      (_this$props$onError = (_this$props2 = this.props).onError) == null ? void 0 : _this$props$onError.call(_this$props2, error, info);\n    };\n\n    _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {\n      var error = this.state.error;\n      var resetKeys = this.props.resetKeys; // There's an edge case where if the thing that triggered the error\n      // happens to *also* be in the resetKeys array, we'd end up resetting\n      // the error boundary immediately. This would likely trigger a second\n      // error to be thrown.\n      // So we make sure that we don't check the resetKeys on the first call\n      // of cDU after the error is set\n\n      if (error !== null && prevState.error !== null && changedArray(prevProps.resetKeys, resetKeys)) {\n        var _this$props$onResetKe, _this$props3;\n\n        (_this$props$onResetKe = (_this$props3 = this.props).onResetKeysChange) == null ? void 0 : _this$props$onResetKe.call(_this$props3, prevProps.resetKeys, resetKeys);\n        this.reset();\n      }\n    };\n\n    _proto.render = function render() {\n      var error = this.state.error;\n      var _this$props4 = this.props,\n          fallbackRender = _this$props4.fallbackRender,\n          FallbackComponent = _this$props4.FallbackComponent,\n          fallback = _this$props4.fallback;\n\n      if (error !== null) {\n        var _props = {\n          error: error,\n          resetErrorBoundary: this.resetErrorBoundary\n        };\n\n        if ( /*#__PURE__*/React__namespace.isValidElement(fallback)) {\n          return fallback;\n        } else if (typeof fallbackRender === 'function') {\n          return fallbackRender(_props);\n        } else if (FallbackComponent) {\n          return /*#__PURE__*/React__namespace.createElement(FallbackComponent, _props);\n        } else {\n          throw new Error('react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop');\n        }\n      }\n\n      return this.props.children;\n    };\n\n    return ErrorBoundary;\n  }(React__namespace.Component);\n\n  function withErrorBoundary(Component, errorBoundaryProps) {\n    var Wrapped = function Wrapped(props) {\n      return /*#__PURE__*/React__namespace.createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React__namespace.createElement(Component, props));\n    }; // Format for display in DevTools\n\n\n    var name = Component.displayName || Component.name || 'Unknown';\n    Wrapped.displayName = \"withErrorBoundary(\" + name + \")\";\n    return Wrapped;\n  }\n\n  function useErrorHandler(givenError) {\n    var _React$useState = React__namespace.useState(null),\n        error = _React$useState[0],\n        setError = _React$useState[1];\n\n    if (givenError != null) throw givenError;\n    if (error != null) throw error;\n    return setError;\n  }\n  /*\n  eslint\n    @typescript-eslint/sort-type-union-intersection-members: \"off\",\n    @typescript-eslint/no-throw-literal: \"off\",\n    @typescript-eslint/prefer-nullish-coalescing: \"off\"\n  */\n\n  exports.ErrorBoundary = ErrorBoundary;\n  exports.useErrorHandler = useErrorHandler;\n  exports.withErrorBoundary = withErrorBoundary;\n\n  Object.defineProperty(exports, '__esModule', { value: true });\n\n}));\n//# sourceMappingURL=react-error-boundary.umd.js.map\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","import { getSideAxis, getAlignmentAxis, getAxisLength, getSide, getAlignment, evaluate, getPaddingObject, rectToClientRect, min, clamp, placements, getAlignmentSides, getOppositeAlignmentPlacement, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, sides, max, getOppositeAxis } from '@floating-ui/utils';\nexport { rectToClientRect } from '@floating-ui/utils';\n\nfunction computeCoordsFromPlacement(_ref, placement, rtl) {\n  let {\n    reference,\n    floating\n  } = _ref;\n  const sideAxis = getSideAxis(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const alignLength = getAxisLength(alignmentAxis);\n  const side = getSide(placement);\n  const isVertical = sideAxis === 'y';\n  const commonX = reference.x + reference.width / 2 - floating.width / 2;\n  const commonY = reference.y + reference.height / 2 - floating.height / 2;\n  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;\n  let coords;\n  switch (side) {\n    case 'top':\n      coords = {\n        x: commonX,\n        y: reference.y - floating.height\n      };\n      break;\n    case 'bottom':\n      coords = {\n        x: commonX,\n        y: reference.y + reference.height\n      };\n      break;\n    case 'right':\n      coords = {\n        x: reference.x + reference.width,\n        y: commonY\n      };\n      break;\n    case 'left':\n      coords = {\n        x: reference.x - floating.width,\n        y: commonY\n      };\n      break;\n    default:\n      coords = {\n        x: reference.x,\n        y: reference.y\n      };\n  }\n  switch (getAlignment(placement)) {\n    case 'start':\n      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n    case 'end':\n      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n  }\n  return coords;\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n *\n * This export does not have any `platform` interface logic. You will need to\n * write one for the platform you are using Floating UI with.\n */\nconst computePosition = async (reference, floating, config) => {\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform\n  } = config;\n  const validMiddleware = middleware.filter(Boolean);\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));\n  let rects = await platform.getElementRects({\n    reference,\n    floating,\n    strategy\n  });\n  let {\n    x,\n    y\n  } = computeCoordsFromPlacement(rects, placement, rtl);\n  let statefulPlacement = placement;\n  let middlewareData = {};\n  let resetCount = 0;\n  for (let i = 0; i < validMiddleware.length; i++) {\n    const {\n      name,\n      fn\n    } = validMiddleware[i];\n    const {\n      x: nextX,\n      y: nextY,\n      data,\n      reset\n    } = await fn({\n      x,\n      y,\n      initialPlacement: placement,\n      placement: statefulPlacement,\n      strategy,\n      middlewareData,\n      rects,\n      platform,\n      elements: {\n        reference,\n        floating\n      }\n    });\n    x = nextX != null ? nextX : x;\n    y = nextY != null ? nextY : y;\n    middlewareData = {\n      ...middlewareData,\n      [name]: {\n        ...middlewareData[name],\n        ...data\n      }\n    };\n    if (reset && resetCount <= 50) {\n      resetCount++;\n      if (typeof reset === 'object') {\n        if (reset.placement) {\n          statefulPlacement = reset.placement;\n        }\n        if (reset.rects) {\n          rects = reset.rects === true ? await platform.getElementRects({\n            reference,\n            floating,\n            strategy\n          }) : reset.rects;\n        }\n        ({\n          x,\n          y\n        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));\n      }\n      i = -1;\n    }\n  }\n  return {\n    x,\n    y,\n    placement: statefulPlacement,\n    strategy,\n    middlewareData\n  };\n};\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nasync function detectOverflow(state, options) {\n  var _await$platform$isEle;\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    x,\n    y,\n    platform,\n    rects,\n    elements,\n    strategy\n  } = state;\n  const {\n    boundary = 'clippingAncestors',\n    rootBoundary = 'viewport',\n    elementContext = 'floating',\n    altBoundary = false,\n    padding = 0\n  } = evaluate(options, state);\n  const paddingObject = getPaddingObject(padding);\n  const altContext = elementContext === 'floating' ? 'reference' : 'floating';\n  const element = elements[altBoundary ? altContext : elementContext];\n  const clippingClientRect = rectToClientRect(await platform.getClippingRect({\n    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),\n    boundary,\n    rootBoundary,\n    strategy\n  }));\n  const rect = elementContext === 'floating' ? {\n    x,\n    y,\n    width: rects.floating.width,\n    height: rects.floating.height\n  } : rects.reference;\n  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));\n  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {\n    x: 1,\n    y: 1\n  } : {\n    x: 1,\n    y: 1\n  };\n  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  }) : rect);\n  return {\n    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,\n    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,\n    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,\n    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x\n  };\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => ({\n  name: 'arrow',\n  options,\n  async fn(state) {\n    const {\n      x,\n      y,\n      placement,\n      rects,\n      platform,\n      elements,\n      middlewareData\n    } = state;\n    // Since `element` is required, we don't Partial<> the type.\n    const {\n      element,\n      padding = 0\n    } = evaluate(options, state) || {};\n    if (element == null) {\n      return {};\n    }\n    const paddingObject = getPaddingObject(padding);\n    const coords = {\n      x,\n      y\n    };\n    const axis = getAlignmentAxis(placement);\n    const length = getAxisLength(axis);\n    const arrowDimensions = await platform.getDimensions(element);\n    const isYAxis = axis === 'y';\n    const minProp = isYAxis ? 'top' : 'left';\n    const maxProp = isYAxis ? 'bottom' : 'right';\n    const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';\n    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];\n    const startDiff = coords[axis] - rects.reference[axis];\n    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));\n    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;\n\n    // DOM platform can return `window` as the `offsetParent`.\n    if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {\n      clientSize = elements.floating[clientProp] || rects.floating[length];\n    }\n    const centerToReference = endDiff / 2 - startDiff / 2;\n\n    // If the padding is large enough that it causes the arrow to no longer be\n    // centered, modify the padding so that it is centered.\n    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;\n    const minPadding = min(paddingObject[minProp], largestPossiblePadding);\n    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);\n\n    // Make sure the arrow doesn't overflow the floating element if the center\n    // point is outside the floating element's bounds.\n    const min$1 = minPadding;\n    const max = clientSize - arrowDimensions[length] - maxPadding;\n    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;\n    const offset = clamp(min$1, center, max);\n\n    // If the reference is small enough that the arrow's padding causes it to\n    // to point to nothing for an aligned placement, adjust the offset of the\n    // floating element itself. To ensure `shift()` continues to take action,\n    // a single reset is performed when this is true.\n    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;\n    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;\n    return {\n      [axis]: coords[axis] + alignmentOffset,\n      data: {\n        [axis]: offset,\n        centerOffset: center - offset - alignmentOffset,\n        ...(shouldAddOffset && {\n          alignmentOffset\n        })\n      },\n      reset: shouldAddOffset\n    };\n  }\n});\n\nfunction getPlacementList(alignment, autoAlignment, allowedPlacements) {\n  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);\n  return allowedPlacementsSortedByAlignment.filter(placement => {\n    if (alignment) {\n      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);\n    }\n    return true;\n  });\n}\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'autoPlacement',\n    options,\n    async fn(state) {\n      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;\n      const {\n        rects,\n        middlewareData,\n        placement,\n        platform,\n        elements\n      } = state;\n      const {\n        crossAxis = false,\n        alignment,\n        allowedPlacements = placements,\n        autoAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;\n      const currentPlacement = placements$1[currentIndex];\n      if (currentPlacement == null) {\n        return {};\n      }\n      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));\n\n      // Make `computeCoords` start from the right place.\n      if (placement !== currentPlacement) {\n        return {\n          reset: {\n            placement: placements$1[0]\n          }\n        };\n      }\n      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];\n      const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {\n        placement: currentPlacement,\n        overflows: currentOverflows\n      }];\n      const nextPlacement = placements$1[currentIndex + 1];\n\n      // There are more placements to check.\n      if (nextPlacement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: nextPlacement\n          }\n        };\n      }\n      const placementsSortedByMostSpace = allOverflows.map(d => {\n        const alignment = getAlignment(d.placement);\n        return [d.placement, alignment && crossAxis ?\n        // Check along the mainAxis and main crossAxis side.\n        d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :\n        // Check only the mainAxis.\n        d.overflows[0], d.overflows];\n      }).sort((a, b) => a[1] - b[1]);\n      const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,\n      // Aligned placements should not check their opposite crossAxis\n      // side.\n      getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));\n      const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];\n      if (resetPlacement !== placement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: resetPlacement\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'flip',\n    options,\n    async fn(state) {\n      var _middlewareData$arrow, _middlewareData$flip;\n      const {\n        placement,\n        middlewareData,\n        rects,\n        initialPlacement,\n        platform,\n        elements\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true,\n        fallbackPlacements: specifiedFallbackPlacements,\n        fallbackStrategy = 'bestFit',\n        fallbackAxisSideDirection = 'none',\n        flipAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n\n      // If a reset by the arrow was caused due to an alignment offset being\n      // added, we should skip any logic now since `flip()` has already done its\n      // work.\n      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643\n      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      const side = getSide(placement);\n      const initialSideAxis = getSideAxis(initialPlacement);\n      const isBasePlacement = getSide(initialPlacement) === initialPlacement;\n      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));\n      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';\n      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {\n        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));\n      }\n      const placements = [initialPlacement, ...fallbackPlacements];\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const overflows = [];\n      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];\n      if (checkMainAxis) {\n        overflows.push(overflow[side]);\n      }\n      if (checkCrossAxis) {\n        const sides = getAlignmentSides(placement, rects, rtl);\n        overflows.push(overflow[sides[0]], overflow[sides[1]]);\n      }\n      overflowsData = [...overflowsData, {\n        placement,\n        overflows\n      }];\n\n      // One or more sides is overflowing.\n      if (!overflows.every(side => side <= 0)) {\n        var _middlewareData$flip2, _overflowsData$filter;\n        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;\n        const nextPlacement = placements[nextIndex];\n        if (nextPlacement) {\n          // Try next placement and re-run the lifecycle.\n          return {\n            data: {\n              index: nextIndex,\n              overflows: overflowsData\n            },\n            reset: {\n              placement: nextPlacement\n            }\n          };\n        }\n\n        // First, find the candidates that fit on the mainAxis side of overflow,\n        // then find the placement that fits the best on the main crossAxis side.\n        let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;\n\n        // Otherwise fallback.\n        if (!resetPlacement) {\n          switch (fallbackStrategy) {\n            case 'bestFit':\n              {\n                var _overflowsData$filter2;\n                const placement = (_overflowsData$filter2 = overflowsData.filter(d => {\n                  if (hasFallbackAxisSideDirection) {\n                    const currentSideAxis = getSideAxis(d.placement);\n                    return currentSideAxis === initialSideAxis ||\n                    // Create a bias to the `y` side axis due to horizontal\n                    // reading directions favoring greater width.\n                    currentSideAxis === 'y';\n                  }\n                  return true;\n                }).map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];\n                if (placement) {\n                  resetPlacement = placement;\n                }\n                break;\n              }\n            case 'initialPlacement':\n              resetPlacement = initialPlacement;\n              break;\n          }\n        }\n        if (placement !== resetPlacement) {\n          return {\n            reset: {\n              placement: resetPlacement\n            }\n          };\n        }\n      }\n      return {};\n    }\n  };\n};\n\nfunction getSideOffsets(overflow, rect) {\n  return {\n    top: overflow.top - rect.height,\n    right: overflow.right - rect.width,\n    bottom: overflow.bottom - rect.height,\n    left: overflow.left - rect.width\n  };\n}\nfunction isAnySideFullyClipped(overflow) {\n  return sides.some(side => overflow[side] >= 0);\n}\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'hide',\n    options,\n    async fn(state) {\n      const {\n        rects\n      } = state;\n      const {\n        strategy = 'referenceHidden',\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      switch (strategy) {\n        case 'referenceHidden':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              elementContext: 'reference'\n            });\n            const offsets = getSideOffsets(overflow, rects.reference);\n            return {\n              data: {\n                referenceHiddenOffsets: offsets,\n                referenceHidden: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        case 'escaped':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              altBoundary: true\n            });\n            const offsets = getSideOffsets(overflow, rects.floating);\n            return {\n              data: {\n                escapedOffsets: offsets,\n                escaped: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        default:\n          {\n            return {};\n          }\n      }\n    }\n  };\n};\n\nfunction getBoundingRect(rects) {\n  const minX = min(...rects.map(rect => rect.left));\n  const minY = min(...rects.map(rect => rect.top));\n  const maxX = max(...rects.map(rect => rect.right));\n  const maxY = max(...rects.map(rect => rect.bottom));\n  return {\n    x: minX,\n    y: minY,\n    width: maxX - minX,\n    height: maxY - minY\n  };\n}\nfunction getRectsByLine(rects) {\n  const sortedRects = rects.slice().sort((a, b) => a.y - b.y);\n  const groups = [];\n  let prevRect = null;\n  for (let i = 0; i < sortedRects.length; i++) {\n    const rect = sortedRects[i];\n    if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {\n      groups.push([rect]);\n    } else {\n      groups[groups.length - 1].push(rect);\n    }\n    prevRect = rect;\n  }\n  return groups.map(rect => rectToClientRect(getBoundingRect(rect)));\n}\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'inline',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        elements,\n        rects,\n        platform,\n        strategy\n      } = state;\n      // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a\n      // ClientRect's bounds, despite the event listener being triggered. A\n      // padding of 2 seems to handle this issue.\n      const {\n        padding = 2,\n        x,\n        y\n      } = evaluate(options, state);\n      const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);\n      const clientRects = getRectsByLine(nativeClientRects);\n      const fallback = rectToClientRect(getBoundingRect(nativeClientRects));\n      const paddingObject = getPaddingObject(padding);\n      function getBoundingClientRect() {\n        // There are two rects and they are disjoined.\n        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {\n          // Find the first rect in which the point is fully inside.\n          return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;\n        }\n\n        // There are 2 or more connected rects.\n        if (clientRects.length >= 2) {\n          if (getSideAxis(placement) === 'y') {\n            const firstRect = clientRects[0];\n            const lastRect = clientRects[clientRects.length - 1];\n            const isTop = getSide(placement) === 'top';\n            const top = firstRect.top;\n            const bottom = lastRect.bottom;\n            const left = isTop ? firstRect.left : lastRect.left;\n            const right = isTop ? firstRect.right : lastRect.right;\n            const width = right - left;\n            const height = bottom - top;\n            return {\n              top,\n              bottom,\n              left,\n              right,\n              width,\n              height,\n              x: left,\n              y: top\n            };\n          }\n          const isLeftSide = getSide(placement) === 'left';\n          const maxRight = max(...clientRects.map(rect => rect.right));\n          const minLeft = min(...clientRects.map(rect => rect.left));\n          const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);\n          const top = measureRects[0].top;\n          const bottom = measureRects[measureRects.length - 1].bottom;\n          const left = minLeft;\n          const right = maxRight;\n          const width = right - left;\n          const height = bottom - top;\n          return {\n            top,\n            bottom,\n            left,\n            right,\n            width,\n            height,\n            x: left,\n            y: top\n          };\n        }\n        return fallback;\n      }\n      const resetRects = await platform.getElementRects({\n        reference: {\n          getBoundingClientRect\n        },\n        floating: elements.floating,\n        strategy\n      });\n      if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {\n        return {\n          reset: {\n            rects: resetRects\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n// For type backwards-compatibility, the `OffsetOptions` type was also\n// Derivable.\n\nasync function convertValueToCoords(state, options) {\n  const {\n    placement,\n    platform,\n    elements\n  } = state;\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n  const side = getSide(placement);\n  const alignment = getAlignment(placement);\n  const isVertical = getSideAxis(placement) === 'y';\n  const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;\n  const crossAxisMulti = rtl && isVertical ? -1 : 1;\n  const rawValue = evaluate(options, state);\n\n  // eslint-disable-next-line prefer-const\n  let {\n    mainAxis,\n    crossAxis,\n    alignmentAxis\n  } = typeof rawValue === 'number' ? {\n    mainAxis: rawValue,\n    crossAxis: 0,\n    alignmentAxis: null\n  } : {\n    mainAxis: rawValue.mainAxis || 0,\n    crossAxis: rawValue.crossAxis || 0,\n    alignmentAxis: rawValue.alignmentAxis\n  };\n  if (alignment && typeof alignmentAxis === 'number') {\n    crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;\n  }\n  return isVertical ? {\n    x: crossAxis * crossAxisMulti,\n    y: mainAxis * mainAxisMulti\n  } : {\n    x: mainAxis * mainAxisMulti,\n    y: crossAxis * crossAxisMulti\n  };\n}\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = function (options) {\n  if (options === void 0) {\n    options = 0;\n  }\n  return {\n    name: 'offset',\n    options,\n    async fn(state) {\n      var _middlewareData$offse, _middlewareData$arrow;\n      const {\n        x,\n        y,\n        placement,\n        middlewareData\n      } = state;\n      const diffCoords = await convertValueToCoords(state, options);\n\n      // If the placement is the same and the arrow caused an alignment offset\n      // then we don't need to change the positioning coordinates.\n      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      return {\n        x: x + diffCoords.x,\n        y: y + diffCoords.y,\n        data: {\n          ...diffCoords,\n          placement\n        }\n      };\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'shift',\n    options,\n    async fn(state) {\n      const {\n        x,\n        y,\n        placement\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = false,\n        limiter = {\n          fn: _ref => {\n            let {\n              x,\n              y\n            } = _ref;\n            return {\n              x,\n              y\n            };\n          }\n        },\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const crossAxis = getSideAxis(getSide(placement));\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      if (checkMainAxis) {\n        const minSide = mainAxis === 'y' ? 'top' : 'left';\n        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';\n        const min = mainAxisCoord + overflow[minSide];\n        const max = mainAxisCoord - overflow[maxSide];\n        mainAxisCoord = clamp(min, mainAxisCoord, max);\n      }\n      if (checkCrossAxis) {\n        const minSide = crossAxis === 'y' ? 'top' : 'left';\n        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';\n        const min = crossAxisCoord + overflow[minSide];\n        const max = crossAxisCoord - overflow[maxSide];\n        crossAxisCoord = clamp(min, crossAxisCoord, max);\n      }\n      const limitedCoords = limiter.fn({\n        ...state,\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      });\n      return {\n        ...limitedCoords,\n        data: {\n          x: limitedCoords.x - x,\n          y: limitedCoords.y - y,\n          enabled: {\n            [mainAxis]: checkMainAxis,\n            [crossAxis]: checkCrossAxis\n          }\n        }\n      };\n    }\n  };\n};\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    options,\n    fn(state) {\n      const {\n        x,\n        y,\n        placement,\n        rects,\n        middlewareData\n      } = state;\n      const {\n        offset = 0,\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const crossAxis = getSideAxis(placement);\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      const rawOffset = evaluate(offset, state);\n      const computedOffset = typeof rawOffset === 'number' ? {\n        mainAxis: rawOffset,\n        crossAxis: 0\n      } : {\n        mainAxis: 0,\n        crossAxis: 0,\n        ...rawOffset\n      };\n      if (checkMainAxis) {\n        const len = mainAxis === 'y' ? 'height' : 'width';\n        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;\n        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;\n        if (mainAxisCoord < limitMin) {\n          mainAxisCoord = limitMin;\n        } else if (mainAxisCoord > limitMax) {\n          mainAxisCoord = limitMax;\n        }\n      }\n      if (checkCrossAxis) {\n        var _middlewareData$offse, _middlewareData$offse2;\n        const len = mainAxis === 'y' ? 'width' : 'height';\n        const isOriginSide = ['top', 'left'].includes(getSide(placement));\n        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);\n        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);\n        if (crossAxisCoord < limitMin) {\n          crossAxisCoord = limitMin;\n        } else if (crossAxisCoord > limitMax) {\n          crossAxisCoord = limitMax;\n        }\n      }\n      return {\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      };\n    }\n  };\n};\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'size',\n    options,\n    async fn(state) {\n      var _state$middlewareData, _state$middlewareData2;\n      const {\n        placement,\n        rects,\n        platform,\n        elements\n      } = state;\n      const {\n        apply = () => {},\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const side = getSide(placement);\n      const alignment = getAlignment(placement);\n      const isYAxis = getSideAxis(placement) === 'y';\n      const {\n        width,\n        height\n      } = rects.floating;\n      let heightSide;\n      let widthSide;\n      if (side === 'top' || side === 'bottom') {\n        heightSide = side;\n        widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';\n      } else {\n        widthSide = side;\n        heightSide = alignment === 'end' ? 'top' : 'bottom';\n      }\n      const maximumClippingHeight = height - overflow.top - overflow.bottom;\n      const maximumClippingWidth = width - overflow.left - overflow.right;\n      const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);\n      const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);\n      const noShift = !state.middlewareData.shift;\n      let availableHeight = overflowAvailableHeight;\n      let availableWidth = overflowAvailableWidth;\n      if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) {\n        availableWidth = maximumClippingWidth;\n      }\n      if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) {\n        availableHeight = maximumClippingHeight;\n      }\n      if (noShift && !alignment) {\n        const xMin = max(overflow.left, 0);\n        const xMax = max(overflow.right, 0);\n        const yMin = max(overflow.top, 0);\n        const yMax = max(overflow.bottom, 0);\n        if (isYAxis) {\n          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));\n        } else {\n          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));\n        }\n      }\n      await apply({\n        ...state,\n        availableWidth,\n        availableHeight\n      });\n      const nextDimensions = await platform.getDimensions(elements.floating);\n      if (width !== nextDimensions.width || height !== nextDimensions.height) {\n        return {\n          reset: {\n            rects: true\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\nexport { arrow, autoPlacement, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, shift, size };\n","import { rectToClientRect, detectOverflow as detectOverflow$1, offset as offset$1, autoPlacement as autoPlacement$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, arrow as arrow$1, inline as inline$1, limitShift as limitShift$1, computePosition as computePosition$1 } from '@floating-ui/core';\nimport { round, createCoords, max, min, floor } from '@floating-ui/utils';\nimport { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getFrameElement, 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\nfunction rectsAreEqual(a, b) {\n  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;\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 elementRectForRootMargin = element.getBoundingClientRect();\n    const {\n      left,\n      top,\n      width,\n      height\n    } = elementRectForRootMargin;\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      if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {\n        // It's possible that even though the ratio is reported as 1, the\n        // element is not actually fully within the IntersectionObserver's root\n        // area anymore. This can happen under performance constraints. This may\n        // be a bug in the browser's IntersectionObserver implementation. To\n        // work around this, we compare the element's bounding rect now with\n        // what it was at the time we created the IntersectionObserver. If they\n        // are not equal then the element moved, so we refresh.\n        refresh();\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 && !rectsAreEqual(prevRefRect, nextRefRect)) {\n      update();\n    }\n    prevRefRect = nextRefRect;\n    frameId = requestAnimationFrame(frameLoop);\n  }\n  update();\n  return () => {\n    var _resizeObserver2;\n    ancestors.forEach(ancestor => {\n      ancestorScroll && ancestor.removeEventListener('scroll', update);\n      ancestorResize && ancestor.removeEventListener('resize', update);\n    });\n    cleanupIo == null || cleanupIo();\n    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();\n    resizeObserver = null;\n    if (animationFrame) {\n      cancelAnimationFrame(frameId);\n    }\n  };\n}\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nconst detectOverflow = detectOverflow$1;\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = offset$1;\n\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = autoPlacement$1;\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = shift$1;\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = flip$1;\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = size$1;\n\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = hide$1;\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = arrow$1;\n\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = inline$1;\n\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = limitShift$1;\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n */\nconst computePosition = (reference, floating, options) => {\n  // This caches the expensive `getClippingElementAncestors` function so that\n  // multiple lifecycle resets re-use the same result. It only lives for a\n  // single call. If other functions become expensive, we can add them as well.\n  const cache = new Map();\n  const mergedOptions = {\n    platform,\n    ...options\n  };\n  const platformWithCache = {\n    ...mergedOptions.platform,\n    _c: cache\n  };\n  return computePosition$1(reference, floating, {\n    ...mergedOptions,\n    platform: platformWithCache\n  });\n};\n\nexport { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, platform, shift, size };\n","function hasWindow() {\n  return typeof window !== 'undefined';\n}\nfunction getNodeName(node) {\n  if (isNode(node)) {\n    return (node.nodeName || '').toLowerCase();\n  }\n  // Mocked nodes in testing environments may not be instances of Node. By\n  // returning `#document` an infinite loop won't occur.\n  // https://github.com/floating-ui/floating-ui/issues/2317\n  return '#document';\n}\nfunction getWindow(node) {\n  var _node$ownerDocument;\n  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;\n}\nfunction getDocumentElement(node) {\n  var _ref;\n  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;\n}\nfunction isNode(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof Node || value instanceof getWindow(value).Node;\n}\nfunction isElement(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof Element || value instanceof getWindow(value).Element;\n}\nfunction isHTMLElement(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;\n}\nfunction isShadowRoot(value) {\n  if (!hasWindow() || typeof ShadowRoot === 'undefined') {\n    return false;\n  }\n  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;\n}\nfunction isOverflowElement(element) {\n  const {\n    overflow,\n    overflowX,\n    overflowY,\n    display\n  } = getComputedStyle(element);\n  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);\n}\nfunction isTableElement(element) {\n  return ['table', 'td', 'th'].includes(getNodeName(element));\n}\nfunction isTopLayer(element) {\n  return [':popover-open', ':modal'].some(selector => {\n    try {\n      return element.matches(selector);\n    } catch (e) {\n      return false;\n    }\n  });\n}\nfunction isContainingBlock(elementOrCss) {\n  const webkit = isWebKit();\n  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  // https://drafts.csswg.org/css-transforms-2/#individual-transforms\n  return ['transform', 'translate', 'scale', 'rotate', 'perspective'].some(value => css[value] ? css[value] !== 'none' : false) || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'translate', 'scale', 'rotate', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));\n}\nfunction getContainingBlock(element) {\n  let currentNode = getParentNode(element);\n  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    if (isContainingBlock(currentNode)) {\n      return currentNode;\n    } else if (isTopLayer(currentNode)) {\n      return null;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  return null;\n}\nfunction isWebKit() {\n  if (typeof CSS === 'undefined' || !CSS.supports) return false;\n  return CSS.supports('-webkit-backdrop-filter', 'none');\n}\nfunction isLastTraversableNode(node) {\n  return ['html', 'body', '#document'].includes(getNodeName(node));\n}\nfunction getComputedStyle(element) {\n  return getWindow(element).getComputedStyle(element);\n}\nfunction getNodeScroll(element) {\n  if (isElement(element)) {\n    return {\n      scrollLeft: element.scrollLeft,\n      scrollTop: element.scrollTop\n    };\n  }\n  return {\n    scrollLeft: element.scrollX,\n    scrollTop: element.scrollY\n  };\n}\nfunction getParentNode(node) {\n  if (getNodeName(node) === 'html') {\n    return node;\n  }\n  const result =\n  // Step into the shadow DOM of the parent of a slotted node.\n  node.assignedSlot ||\n  // DOM Element detected.\n  node.parentNode ||\n  // ShadowRoot detected.\n  isShadowRoot(node) && node.host ||\n  // Fallback.\n  getDocumentElement(node);\n  return isShadowRoot(result) ? result.host : result;\n}\nfunction getNearestOverflowAncestor(node) {\n  const parentNode = getParentNode(node);\n  if (isLastTraversableNode(parentNode)) {\n    return node.ownerDocument ? node.ownerDocument.body : node.body;\n  }\n  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {\n    return parentNode;\n  }\n  return getNearestOverflowAncestor(parentNode);\n}\nfunction getOverflowAncestors(node, list, traverseIframes) {\n  var _node$ownerDocument2;\n  if (list === void 0) {\n    list = [];\n  }\n  if (traverseIframes === void 0) {\n    traverseIframes = true;\n  }\n  const scrollableAncestor = getNearestOverflowAncestor(node);\n  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);\n  const win = getWindow(scrollableAncestor);\n  if (isBody) {\n    const frameElement = getFrameElement(win);\n    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);\n  }\n  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));\n}\nfunction getFrameElement(win) {\n  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;\n}\n\nexport { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isTopLayer, isWebKit };\n"],"names":["arrow","options","element","padding","name","fn","args","value","Object","prototype","hasOwnProperty","call","current","index","document","useLayoutEffect","useEffect","deepEqual","a","b","toString","length","i","keys","Array","isArray","key","$$typeof","useLatestRef","ref","useFloating","placement","strategy","middleware","platform","whileElementsMounted","open","data","setData","x","y","middlewareData","isPositioned","latestMiddleware","setLatestMiddleware","referenceRef","floatingRef","dataRef","whileElementsMountedRef","platformRef","reference","_setReference","floating","_setFloating","setReference","node","setFloating","update","config","then","fullData","isMountedRef","refs","elements","serverHandoffComplete","count","genId","useId","id","setId","undefined","createPubSub","map","Map","emit","event","_map$get","get","forEach","handler","on","listener","set","off","filter","l","FloatingNodeContext","FloatingTreeContext","useFloatingParentNodeId","_React$useContext","useFloatingTree","getDocument","ownerDocument","getPlatform","uaData","navigator","userAgentData","getUserAgent","brands","_ref","brand","version","join","userAgent","getWindow","defaultView","window","isElement","Element","isHTMLElement","HTMLElement","isVirtualClick","mozInputSource","isTrusted","androidRe","test","pointerType","type","buttons","detail","isVirtualPointerEvent","width","height","pressure","isMouseLikePointerType","strict","values","push","includes","useRef","safePolygonIdentifier","getDelay","prop","useHover","context","_temp","enabled","delay","handleClose","mouseOnly","restMs","move","onOpenChange","events","domReference","tree","parentId","handleCloseRef","delayRef","pointerTypeRef","timeoutRef","handlerRef","restTimeoutRef","blockMouseMoveRef","performedPointerEventsMutationRef","unbindMouseMoveRef","isHoverOpen","_dataRef$current$open","openEvent","onDismiss","clearTimeout","onLeave","html","documentElement","addEventListener","removeEventListener","closeWithDelay","runElseBranch","closeDelay","setTimeout","cleanupMouseMoveHandler","clearPointerEvents","body","style","pointerEvents","removeAttribute","onScrollMouseLeave","onMouseEnter","once","onMouseLeave","isClickLikeOpenEvent","openDelay","doc","clientX","clientY","onClose","_handleCloseRef$curre","__options","blockPointerEvents","setAttribute","_tree$nodesRef$curren","_tree$nodesRef$curren2","parentFloating","nodesRef","find","setPointerRef","onPointerDown","onPointerEnter","onMouseMove","returnFocus","FloatingDelayGroupContext","initialDelay","timeoutMs","currentId","setCurrentId","setState","isInstantPhase","useDelayGroupContext","FloatingDelayGroup","children","state","prev","next","initialCurrentIdRef","Provider","useDelayGroup","_ref2","_ref3","close","unset","timeout","activeElement$1","activeElement","_activeElement","_activeElement$shadow","shadowRoot","contains","parent","child","rootNode","getRootNode","ShadowRoot","parentNode","host","getChildren","nodes","allChildren","_node$context","currentChildren","_currentChildren","some","n","_node$context2","concat","getTarget","composedPath","target","useSafeInsertionEffect","useEvent","callback","_len","arguments","_key","isEventTargetWithin","e","bubbleHandlerKeys","pointerdown","mousedown","click","captureHandlerKeys","useDismiss","nodeId","escapeKey","outsidePress","unstable_outsidePress","outsidePressEvent","referencePress","referencePressEvent","ancestorScroll","bubbles","nested","outsidePressFn","insideReactTreeRef","escapeKeyBubbles","outsidePressBubbles","_bubbles$escapeKey","_bubbles$outsidePress","normalizeBubblesProp","onKeyDown","shouldDismiss","_child$context","__escapeKeyBubbles","preventScroll","onOutsidePress","insideReactTree","win","canScrollX","scrollWidth","clientWidth","canScrollY","scrollHeight","clientHeight","xCond","offsetX","getComputedStyle","direction","offsetWidth","offsetY","targetIsInsideChildren","_child$context2","__outsidePressBubbles","onScroll","ancestors","contextElement","ancestor","_doc$defaultView","visualViewport","passive","useFocus","keyboardOnly","blockFocusRef","onBlur","payload","onFocus","nativeEvent","relatedTarget","movedToFocusGuard","hasAttribute","getAttribute","useRole","role","rootId","referenceId","floatingProps","unstable_onOpenChange","position","domReferenceRef","setDomReference","setPositionReference","positionReference","getBoundingClientRect","mergeProps","userProps","propsList","elementKey","tabIndex","reduce","acc","props","entries","indexOf","has","_map$get2","useInteractions","deps","getReferenceProps","getFloatingProps","getItemProps","item","__defProp","defineProperty","__defProps","defineProperties","__getOwnPropDescs","getOwnPropertyDescriptors","__getOwnPropSymbols","getOwnPropertySymbols","__hasOwnProp","__propIsEnum","propertyIsEnumerable","__defNormalProp","obj","enumerable","configurable","writable","__spreadValues","__spreadProps","horizontalSide","arrowY","arrowOffset","arrowPosition","top","bottom","verticalSide","arrowX","dir","left","radiusByFloatingSide","right","getArrowPositionStyles","withBorder","arrowSize","arrowRadius","side","split","baseStyles","transform","arrowPlacement","borderLeft","borderBottom","borderRight","borderTop","FloatingArrow","forwardRef","_a","_b","visible","others","source","exclude","__objRest","theme","displayName","getFloatingPosition","flippedPosition","useFloatingAutoUpdate","opened","positionDependencies","delayedUpdate","setDelayedUpdate","useState","c","useInputProps","component","defaultProps","label","description","error","required","classNames","styles","className","unstyled","__staticSelector","sx","errorProps","labelProps","descriptionProps","wrapperProps","_wrapperProps","size","inputContainer","inputWrapperOrder","withAsterisk","uid","systemStyles","rest","inputProps","invalid","DEFAULT_EVENTS","getPopoverMiddlewares","middlewares","offset","shift","limiter","flip","inline","arrowRef","POPOVER_ERRORS","PopoverContextProvider","usePopoverContext","refProp","popupType","PopoverTarget","Error","forwardedProps","ctx","targetRef","accessibleProps","withRoles","getDropdownId","getTargetId","cloneElement","targetProps","controlled","onClick","onToggle","noop","closeOnEscape","active","onTrigger","radius","shadow","dropdown","backgroundColor","white","background","colorScheme","colors","dark","border","gray","spacing","sm","md","boxShadow","shadows","borderRadius","outline","zIndex","FocusTrap","focusTrapRef","PopoverDropdown","onKeyDownCapture","classes","cx","u","shouldReturnFocus","disabled","OptionalPortal","withinPortal","Transition","mounted","transition","duration","transitionDuration","exitDuration","exitTransitionDuration","transitionStyles","_a2","trapFocus","Box","withArrow","closeOnClickOutside","clickOutsideEvents","Popover","_c","_d","_e","_f","_g","onPositionChange","onOpen","onChange","defaultOpened","targetNode","setTargetNode","dropdownNode","setDropdownNode","popover","_opened","setOpened","defaultValue","finalValue","apply","rects","assign","usePopover","shouldIgnore","tagName","every","useClickOutside","useCallback","Target","Dropdown","$6ed0406888f73fc4$export$43e446d32b3d21af","$6ed0406888f73fc4$var$setRef","$6ed0406888f73fc4$export$c7b2cbe3552a0d05","$5e63c961fc1ce211$export$8c6ed5c666ac1360","forwardedRef","slotProps","childrenArray","toArray","slottable","$5e63c961fc1ce211$var$isSlottable","newElement","newChildren","only","$5e63c961fc1ce211$var$SlotClone","$5e63c961fc1ce211$var$mergeProps","$5e63c961fc1ce211$export$d9f1ccf0bdb05d45","childProps","overrideProps","propName","slotPropValue","childPropValue","Boolean","$8927f6f2acc4f386$export$250ffa63cdc0d034","primitive","Node","asChild","primitiveProps","Comp","Symbol","for","$9f79659886946c16$export$e5c5a5f917a5871c","globalThis","$921a889cee6df7e8$export$99c2b779aa4e8b8b","present","presence","node1","setNode","stylesRef","prevPresentRef","prevAnimationNameRef","initialState","send","machine","nextState","$fe963b355347cc68$export$3e6543de14f8614f","UNMOUNT","ANIMATION_OUT","unmountSuspended","MOUNT","ANIMATION_END","unmounted","currentAnimationName","$921a889cee6df7e8$var$getAnimationName","wasPresent","prevAnimationName","display","isAnimating","handleAnimationEnd","isCurrentAnimation","animationName","handleAnimationStart","isPresent","$921a889cee6df7e8$var$usePresence","$c512c27ab02ef895$var$composeContextScopes","scopes","baseScope","createScope1","scopeHooks","createScope","useScope","scopeName","overrideScopes","nextScopes1","nextScopes","$b1b2314f5f9a1d84$export$25bec8c6f54ee79a","callbackRef","_callbackRef$current","$f631663db3294ace$var$DirectionContext","$e42e1063c40fb3ef$export$b9ecd428b558ff10","originalEventHandler","ourEventHandler","checkForDefaultPrevented","defaultPrevented","$57acba87d6e25586$var$SCROLL_AREA_NAME","$57acba87d6e25586$var$createScrollAreaContext","$57acba87d6e25586$export$488468afe3a6f2b1","createContextScopeDeps","defaultContexts","scopeContexts","defaultContext","scope","contexts","rootComponentName","BaseContext","Context","consumerName","$57acba87d6e25586$var$ScrollAreaProvider","$57acba87d6e25586$var$useScrollAreaContext","$57acba87d6e25586$export$ccf8d8d7bbf3c2cc","__scopeScrollArea","scrollHideDelay","scrollAreaProps","scrollArea","setScrollArea","viewport","setViewport","content","setContent","scrollbarX","setScrollbarX","scrollbarY","setScrollbarY","cornerWidth","setCornerWidth","cornerHeight","setCornerHeight","scrollbarXEnabled","setScrollbarXEnabled","scrollbarYEnabled","setScrollbarYEnabled","composedRefs","localDir","globalDir","onViewportChange","onContentChange","onScrollbarXChange","onScrollbarXEnabledChange","onScrollbarYChange","onScrollbarYEnabledChange","onCornerWidthChange","onCornerHeightChange","div","$57acba87d6e25586$var$VIEWPORT_NAME","$57acba87d6e25586$export$a21cbf9f11fca853","viewportProps","dangerouslySetInnerHTML","__html","overflowX","overflowY","minWidth","$57acba87d6e25586$var$SCROLLBAR_NAME","$57acba87d6e25586$export$2fabd85d0eba3c57","forceMount","scrollbarProps","isHorizontal","orientation","$57acba87d6e25586$var$ScrollAreaScrollbarHover","$57acba87d6e25586$var$ScrollAreaScrollbarScroll","$57acba87d6e25586$var$ScrollAreaScrollbarAuto","$57acba87d6e25586$var$ScrollAreaScrollbarVisible","setVisible","hideTimer","handlePointerEnter","handlePointerLeave","debounceScrollEnd","$57acba87d6e25586$var$useDebounceCallback","hidden","SCROLL","scrolling","SCROLL_END","POINTER_ENTER","interacting","POINTER_LEAVE","idle","HIDE","scrollDirection","prevScrollPos","handleScroll","scrollPos","onPointerLeave","handleResize","isOverflowX","isOverflowY","offsetHeight","$57acba87d6e25586$var$useResizeObserver","thumbRef","pointerOffsetRef","sizes","setSizes","scrollbar","paddingStart","paddingEnd","thumbRatio","$57acba87d6e25586$var$getThumbRatio","commonProps","onSizesChange","hasThumb","onThumbChange","thumb","onThumbPointerUp","onThumbPointerDown","pointerPos","getScrollPosition","pointerOffset","thumbSizePx","$57acba87d6e25586$var$getThumbSize","thumbCenter","thumbOffsetFromEnd","minPointerPos","maxPointerPos","maxScrollPos","$57acba87d6e25586$var$linearScale","interpolate","$57acba87d6e25586$var$getScrollPositionFromPointer","$57acba87d6e25586$var$ScrollAreaScrollbarX","onThumbPositionChange","$57acba87d6e25586$var$getThumbOffsetFromScroll","scrollLeft","onWheelScroll","onDragScroll","$57acba87d6e25586$var$ScrollAreaScrollbarY","scrollTop","computedStyle","setComputedStyle","composeRefs","$57acba87d6e25586$var$ScrollAreaScrollbarImpl","deltaX","$57acba87d6e25586$var$isScrollingWithinScrollbarBounds","preventDefault","onResize","$57acba87d6e25586$var$toInt","paddingLeft","paddingRight","deltaY","paddingTop","paddingBottom","$57acba87d6e25586$var$ScrollbarProvider","$57acba87d6e25586$var$useScrollbarContext","setScrollbar","rectRef","prevWebkitUserSelectRef","handleWheelScroll","handleThumbPositionChange","handleDragScroll","handleWheel","button","setPointerCapture","pointerId","webkitUserSelect","onPointerMove","onPointerUp","hasPointerCapture","releasePointerCapture","$57acba87d6e25586$var$THUMB_NAME","$57acba87d6e25586$export$9fba1154677d7cd2","thumbProps","scrollbarContext","$57acba87d6e25586$var$ScrollAreaThumbImpl","scrollAreaContext","composedRef","removeUnlinkedScrollListenerRef","$57acba87d6e25586$var$addUnlinkedScrollListener","onPointerDownCapture","thumbRect","$57acba87d6e25586$var$CORNER_NAME","$57acba87d6e25586$export$56969d565df7cc4b","hasBothScrollbarsVisible","$57acba87d6e25586$var$ScrollAreaCornerImpl","cornerProps","width1","setWidth","height1","setHeight","hasSize","_context$scrollbarX","_context$scrollbarY","parseInt","viewportSize","contentSize","ratio","isNaN","scrollbarPadding","thumbSize","Math","max","maxThumbPos","scrollWithoutMomentum","min","input","output","prevPosition","rAF","loop","isHorizontalScroll","isVerticalScroll","requestAnimationFrame","cancelAnimationFrame","handleCallback","debounceTimerRef","resizeObserver","ResizeObserver","observe","unobserve","$57acba87d6e25586$export$be92b6f5f03c0fe9","$57acba87d6e25586$export$d5c6c08dc2d3ca7","$57acba87d6e25586$export$9a4e88b92edfce6b","$57acba87d6e25586$export$6521433ed15a34db","$57acba87d6e25586$export$ac61190d9fc311a9","scrollbarSize","offsetScrollbars","scrollbarHovered","getRef","root","overflow","userSelect","touchAction","boxSizing","rgba","black","flexDirection","opacity","flex","minHeight","corner","_ScrollArea","viewportRef","onScrollPositionChange","setScrollbarHovered","currentTarget","ScrollAreaAutosize","maxHeight","Autosize","ScrollArea","w","h","Space","miw","mih","TextInput","I","Wrapper","zodResolver","schema","parsed","safeParse","success","results","errors","path","message","exports","React","_interopNamespace","__esModule","create","k","d","getOwnPropertyDescriptor","freeze","React__namespace","_setPrototypeOf","o","p","setPrototypeOf","__proto__","_inheritsLoose","subClass","superClass","constructor","changedArray","is","ErrorBoundary","_React$Component","_this","_args","this","resetErrorBoundary","_this$props","_len2","_key2","onReset","reset","getDerivedStateFromError","_proto","componentDidCatch","info","_this$props$onError","_this$props2","onError","componentDidUpdate","prevProps","prevState","_this$props$onResetKe","_this$props3","resetKeys","onResetKeysChange","render","_this$props4","fallbackRender","FallbackComponent","fallback","_props","isValidElement","createElement","Component","withErrorBoundary","errorBoundaryProps","Wrapped","useErrorHandler","givenError","_React$useState","setError","factory","round","floor","createCoords","v","oppositeSideMap","oppositeAlignmentMap","start","end","clamp","param","getOppositeAxis","axis","getAxisLength","getSideAxis","getAlignmentAxis","replace","alignment","getOppositePlacement","getPaddingObject","expandPaddingObject","rectToClientRect","rect","computeCoordsFromPlacement","rtl","sideAxis","alignmentAxis","alignLength","isVertical","commonX","commonY","commonAlign","coords","async","detectOverflow","_await$platform$isEle","boundary","rootBoundary","elementContext","altBoundary","paddingObject","clippingClientRect","getClippingRect","getDocumentElement","offsetParent","getOffsetParent","offsetScale","getScale","elementClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","getBoundingRect","minX","minY","getCssDimensions","css","parseFloat","hasOffset","shouldFallback","$","unwrapElement","domElement","Number","isFinite","noOffsets","getVisualOffsets","offsetLeft","offsetTop","includeScale","isFixedStrategy","clientRect","scale","visualOffsets","isFixed","floatingOffsetParent","shouldAddVisualOffsets","offsetWin","currentWin","currentIFrame","iframeScale","iframeRect","clientLeft","clientTop","getWindowScrollBarX","leftScroll","getHTMLOffset","scroll","ignoreScrollbarX","htmlRect","getClientRectFromClippingAncestor","clippingAncestor","visualViewportBased","getViewportRect","getDocumentRect","getInnerBoundingClientRect","hasFixedPositionAncestor","stopNode","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsets","offsetRect","htmlOffset","isStaticPositioned","getTrueOffsetParent","polyfill","rawOffsetParent","svgOffsetParent","topLayer","elementClippingAncestors","cache","cachedResult","result","el","currentContainingBlockComputedStyle","elementIsFixed","currentNode","currentNodeIsContaining","getClippingElementAncestors","clippingAncestors","firstClippingAncestor","clippingRect","accRect","getElementRects","getOffsetParentFn","getDimensionsFn","getDimensions","floatingDimensions","getClientRects","from","isRTL","rectsAreEqual","autoUpdate","ancestorResize","elementResize","layoutShift","IntersectionObserver","animationFrame","referenceEl","cleanupIo","onMove","timeoutId","io","cleanup","_io","disconnect","refresh","skip","threshold","elementRectForRootMargin","rootMargin","isFirstUpdate","handleObserve","intersectionRatio","observeMove","frameId","reobserveFrame","firstEntry","_resizeObserver","prevRefRect","frameLoop","nextRefRect","_resizeObserver2","_middlewareData$offse","_middlewareData$arrow","diffCoords","mainAxisMulti","crossAxisMulti","rawValue","mainAxis","crossAxis","convertValueToCoords","alignmentOffset","checkMainAxis","checkCrossAxis","detectOverflowOptions","mainAxisCoord","crossAxisCoord","maxSide","limitedCoords","_middlewareData$flip","initialPlacement","fallbackPlacements","specifiedFallbackPlacements","fallbackStrategy","fallbackAxisSideDirection","flipAlignment","initialSideAxis","isBasePlacement","oppositePlacement","getExpandedPlacements","hasFallbackAxisSideDirection","list","isStart","lr","rl","tb","bt","getSideList","getOppositeAxisPlacements","placements","overflows","overflowsData","sides","mainAlignmentSide","_middlewareData$flip2","_overflowsData$filter","nextIndex","nextPlacement","resetPlacement","sort","_overflowsData$filter2","currentSideAxis","_state$middlewareData","_state$middlewareData2","isYAxis","heightSide","widthSide","maximumClippingHeight","maximumClippingWidth","overflowAvailableHeight","overflowAvailableWidth","noShift","availableHeight","availableWidth","xMin","xMax","yMin","yMax","nextDimensions","arrowDimensions","minProp","maxProp","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","centerToReference","largestPossiblePadding","minPadding","maxPadding","min$1","center","shouldAddOffset","centerOffset","nativeClientRects","clientRects","sortedRects","slice","groups","prevRect","getRectsByLine","resetRects","firstRect","lastRect","isTop","isLeftSide","maxRight","minLeft","measureRects","rawOffset","computedOffset","len","limitMin","limitMax","_middlewareData$offse2","isOriginSide","mergedOptions","platformWithCache","validMiddleware","statefulPlacement","resetCount","nextX","nextY","computePosition","hasWindow","getNodeName","isNode","nodeName","toLowerCase","_node$ownerDocument","isShadowRoot","isOverflowElement","isTableElement","isTopLayer","selector","matches","isContainingBlock","elementOrCss","webkit","isWebKit","containerType","backdropFilter","willChange","contain","getContainingBlock","getParentNode","isLastTraversableNode","CSS","supports","getNodeScroll","scrollX","scrollY","assignedSlot","getNearestOverflowAncestor","getOverflowAncestors","traverseIframes","_node$ownerDocument2","scrollableAncestor","isBody","frameElement","getFrameElement","getPrototypeOf"],"sourceRoot":""}