{"version":3,"file":"static/chunks/7368-0a9d8861377e88ab.js","mappings":"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","sources":["webpack://_N_E/./node_modules/@radix-ui/react-use-escape-keydown/dist/index.mjs","webpack://_N_E/./node_modules/@radix-ui/react-dismissable-layer/dist/index.mjs","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/utils/dist/floating-ui.utils.dom.mjs","webpack://_N_E/./node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs","webpack://_N_E/./node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs","webpack://_N_E/./node_modules/@radix-ui/react-arrow/dist/index.mjs","webpack://_N_E/./node_modules/@radix-ui/react-use-size/dist/index.mjs","webpack://_N_E/./node_modules/@radix-ui/react-popper/dist/index.mjs","webpack://_N_E/./node_modules/@radix-ui/react-portal/dist/index.mjs"],"sourcesContent":["import {useEffect as $hPSQ5$useEffect} from \"react\";\nimport {useCallbackRef as $hPSQ5$useCallbackRef} from \"@radix-ui/react-use-callback-ref\";\n\n\n\n/**\n * Listens for when the escape key is down\n */ function $addc16e1bbe58fd0$export$3a72a57244d6e765(onEscapeKeyDownProp, ownerDocument = globalThis === null || globalThis === void 0 ? void 0 : globalThis.document) {\n    const onEscapeKeyDown = $hPSQ5$useCallbackRef(onEscapeKeyDownProp);\n    $hPSQ5$useEffect(()=>{\n        const handleKeyDown = (event)=>{\n            if (event.key === 'Escape') onEscapeKeyDown(event);\n        };\n        ownerDocument.addEventListener('keydown', handleKeyDown);\n        return ()=>ownerDocument.removeEventListener('keydown', handleKeyDown)\n        ;\n    }, [\n        onEscapeKeyDown,\n        ownerDocument\n    ]);\n}\n\n\n\n\nexport {$addc16e1bbe58fd0$export$3a72a57244d6e765 as useEscapeKeydown};\n//# sourceMappingURL=index.mjs.map\n","import $kqwpH$babelruntimehelpersesmextends from \"@babel/runtime/helpers/esm/extends\";\nimport {createContext as $kqwpH$createContext, forwardRef as $kqwpH$forwardRef, useContext as $kqwpH$useContext, useState as $kqwpH$useState, useEffect as $kqwpH$useEffect, createElement as $kqwpH$createElement, useRef as $kqwpH$useRef} from \"react\";\nimport {composeEventHandlers as $kqwpH$composeEventHandlers} from \"@radix-ui/primitive\";\nimport {Primitive as $kqwpH$Primitive, dispatchDiscreteCustomEvent as $kqwpH$dispatchDiscreteCustomEvent} from \"@radix-ui/react-primitive\";\nimport {useComposedRefs as $kqwpH$useComposedRefs} from \"@radix-ui/react-compose-refs\";\nimport {useCallbackRef as $kqwpH$useCallbackRef} from \"@radix-ui/react-use-callback-ref\";\nimport {useEscapeKeydown as $kqwpH$useEscapeKeydown} from \"@radix-ui/react-use-escape-keydown\";\n\n\n\n\n\n\n\n\n/* -------------------------------------------------------------------------------------------------\n * DismissableLayer\n * -----------------------------------------------------------------------------------------------*/ const $5cb92bef7577960e$var$DISMISSABLE_LAYER_NAME = 'DismissableLayer';\nconst $5cb92bef7577960e$var$CONTEXT_UPDATE = 'dismissableLayer.update';\nconst $5cb92bef7577960e$var$POINTER_DOWN_OUTSIDE = 'dismissableLayer.pointerDownOutside';\nconst $5cb92bef7577960e$var$FOCUS_OUTSIDE = 'dismissableLayer.focusOutside';\nlet $5cb92bef7577960e$var$originalBodyPointerEvents;\nconst $5cb92bef7577960e$var$DismissableLayerContext = /*#__PURE__*/ $kqwpH$createContext({\n    layers: new Set(),\n    layersWithOutsidePointerEventsDisabled: new Set(),\n    branches: new Set()\n});\nconst $5cb92bef7577960e$export$177fb62ff3ec1f22 = /*#__PURE__*/ $kqwpH$forwardRef((props, forwardedRef)=>{\n    var _node$ownerDocument;\n    const { disableOutsidePointerEvents: disableOutsidePointerEvents = false , onEscapeKeyDown: onEscapeKeyDown , onPointerDownOutside: onPointerDownOutside , onFocusOutside: onFocusOutside , onInteractOutside: onInteractOutside , onDismiss: onDismiss , ...layerProps } = props;\n    const context = $kqwpH$useContext($5cb92bef7577960e$var$DismissableLayerContext);\n    const [node1, setNode] = $kqwpH$useState(null);\n    const ownerDocument = (_node$ownerDocument = node1 === null || node1 === void 0 ? void 0 : node1.ownerDocument) !== null && _node$ownerDocument !== void 0 ? _node$ownerDocument : globalThis === null || globalThis === void 0 ? void 0 : globalThis.document;\n    const [, force] = $kqwpH$useState({});\n    const composedRefs = $kqwpH$useComposedRefs(forwardedRef, (node)=>setNode(node)\n    );\n    const layers = Array.from(context.layers);\n    const [highestLayerWithOutsidePointerEventsDisabled] = [\n        ...context.layersWithOutsidePointerEventsDisabled\n    ].slice(-1); // prettier-ignore\n    const highestLayerWithOutsidePointerEventsDisabledIndex = layers.indexOf(highestLayerWithOutsidePointerEventsDisabled); // prettier-ignore\n    const index = node1 ? layers.indexOf(node1) : -1;\n    const isBodyPointerEventsDisabled = context.layersWithOutsidePointerEventsDisabled.size > 0;\n    const isPointerEventsEnabled = index >= highestLayerWithOutsidePointerEventsDisabledIndex;\n    const pointerDownOutside = $5cb92bef7577960e$var$usePointerDownOutside((event)=>{\n        const target = event.target;\n        const isPointerDownOnBranch = [\n            ...context.branches\n        ].some((branch)=>branch.contains(target)\n        );\n        if (!isPointerEventsEnabled || isPointerDownOnBranch) return;\n        onPointerDownOutside === null || onPointerDownOutside === void 0 || onPointerDownOutside(event);\n        onInteractOutside === null || onInteractOutside === void 0 || onInteractOutside(event);\n        if (!event.defaultPrevented) onDismiss === null || onDismiss === void 0 || onDismiss();\n    }, ownerDocument);\n    const focusOutside = $5cb92bef7577960e$var$useFocusOutside((event)=>{\n        const target = event.target;\n        const isFocusInBranch = [\n            ...context.branches\n        ].some((branch)=>branch.contains(target)\n        );\n        if (isFocusInBranch) return;\n        onFocusOutside === null || onFocusOutside === void 0 || onFocusOutside(event);\n        onInteractOutside === null || onInteractOutside === void 0 || onInteractOutside(event);\n        if (!event.defaultPrevented) onDismiss === null || onDismiss === void 0 || onDismiss();\n    }, ownerDocument);\n    $kqwpH$useEscapeKeydown((event)=>{\n        const isHighestLayer = index === context.layers.size - 1;\n        if (!isHighestLayer) return;\n        onEscapeKeyDown === null || onEscapeKeyDown === void 0 || onEscapeKeyDown(event);\n        if (!event.defaultPrevented && onDismiss) {\n            event.preventDefault();\n            onDismiss();\n        }\n    }, ownerDocument);\n    $kqwpH$useEffect(()=>{\n        if (!node1) return;\n        if (disableOutsidePointerEvents) {\n            if (context.layersWithOutsidePointerEventsDisabled.size === 0) {\n                $5cb92bef7577960e$var$originalBodyPointerEvents = ownerDocument.body.style.pointerEvents;\n                ownerDocument.body.style.pointerEvents = 'none';\n            }\n            context.layersWithOutsidePointerEventsDisabled.add(node1);\n        }\n        context.layers.add(node1);\n        $5cb92bef7577960e$var$dispatchUpdate();\n        return ()=>{\n            if (disableOutsidePointerEvents && context.layersWithOutsidePointerEventsDisabled.size === 1) ownerDocument.body.style.pointerEvents = $5cb92bef7577960e$var$originalBodyPointerEvents;\n        };\n    }, [\n        node1,\n        ownerDocument,\n        disableOutsidePointerEvents,\n        context\n    ]);\n    /**\n   * We purposefully prevent combining this effect with the `disableOutsidePointerEvents` effect\n   * because a change to `disableOutsidePointerEvents` would remove this layer from the stack\n   * and add it to the end again so the layering order wouldn't be _creation order_.\n   * We only want them to be removed from context stacks when unmounted.\n   */ $kqwpH$useEffect(()=>{\n        return ()=>{\n            if (!node1) return;\n            context.layers.delete(node1);\n            context.layersWithOutsidePointerEventsDisabled.delete(node1);\n            $5cb92bef7577960e$var$dispatchUpdate();\n        };\n    }, [\n        node1,\n        context\n    ]);\n    $kqwpH$useEffect(()=>{\n        const handleUpdate = ()=>force({})\n        ;\n        document.addEventListener($5cb92bef7577960e$var$CONTEXT_UPDATE, handleUpdate);\n        return ()=>document.removeEventListener($5cb92bef7577960e$var$CONTEXT_UPDATE, handleUpdate)\n        ;\n    }, []);\n    return /*#__PURE__*/ $kqwpH$createElement($kqwpH$Primitive.div, $kqwpH$babelruntimehelpersesmextends({}, layerProps, {\n        ref: composedRefs,\n        style: {\n            pointerEvents: isBodyPointerEventsDisabled ? isPointerEventsEnabled ? 'auto' : 'none' : undefined,\n            ...props.style\n        },\n        onFocusCapture: $kqwpH$composeEventHandlers(props.onFocusCapture, focusOutside.onFocusCapture),\n        onBlurCapture: $kqwpH$composeEventHandlers(props.onBlurCapture, focusOutside.onBlurCapture),\n        onPointerDownCapture: $kqwpH$composeEventHandlers(props.onPointerDownCapture, pointerDownOutside.onPointerDownCapture)\n    }));\n});\n/*#__PURE__*/ Object.assign($5cb92bef7577960e$export$177fb62ff3ec1f22, {\n    displayName: $5cb92bef7577960e$var$DISMISSABLE_LAYER_NAME\n});\n/* -------------------------------------------------------------------------------------------------\n * DismissableLayerBranch\n * -----------------------------------------------------------------------------------------------*/ const $5cb92bef7577960e$var$BRANCH_NAME = 'DismissableLayerBranch';\nconst $5cb92bef7577960e$export$4d5eb2109db14228 = /*#__PURE__*/ $kqwpH$forwardRef((props, forwardedRef)=>{\n    const context = $kqwpH$useContext($5cb92bef7577960e$var$DismissableLayerContext);\n    const ref = $kqwpH$useRef(null);\n    const composedRefs = $kqwpH$useComposedRefs(forwardedRef, ref);\n    $kqwpH$useEffect(()=>{\n        const node = ref.current;\n        if (node) {\n            context.branches.add(node);\n            return ()=>{\n                context.branches.delete(node);\n            };\n        }\n    }, [\n        context.branches\n    ]);\n    return /*#__PURE__*/ $kqwpH$createElement($kqwpH$Primitive.div, $kqwpH$babelruntimehelpersesmextends({}, props, {\n        ref: composedRefs\n    }));\n});\n/*#__PURE__*/ Object.assign($5cb92bef7577960e$export$4d5eb2109db14228, {\n    displayName: $5cb92bef7577960e$var$BRANCH_NAME\n});\n/* -----------------------------------------------------------------------------------------------*/ /**\n * Listens for `pointerdown` outside a react subtree. We use `pointerdown` rather than `pointerup`\n * to mimic layer dismissing behaviour present in OS.\n * Returns props to pass to the node we want to check for outside events.\n */ function $5cb92bef7577960e$var$usePointerDownOutside(onPointerDownOutside, ownerDocument = globalThis === null || globalThis === void 0 ? void 0 : globalThis.document) {\n    const handlePointerDownOutside = $kqwpH$useCallbackRef(onPointerDownOutside);\n    const isPointerInsideReactTreeRef = $kqwpH$useRef(false);\n    const handleClickRef = $kqwpH$useRef(()=>{});\n    $kqwpH$useEffect(()=>{\n        const handlePointerDown = (event)=>{\n            if (event.target && !isPointerInsideReactTreeRef.current) {\n                const eventDetail = {\n                    originalEvent: event\n                };\n                function handleAndDispatchPointerDownOutsideEvent() {\n                    $5cb92bef7577960e$var$handleAndDispatchCustomEvent($5cb92bef7577960e$var$POINTER_DOWN_OUTSIDE, handlePointerDownOutside, eventDetail, {\n                        discrete: true\n                    });\n                }\n                /**\n         * On touch devices, we need to wait for a click event because browsers implement\n         * a ~350ms delay between the time the user stops touching the display and when the\n         * browser executres events. We need to ensure we don't reactivate pointer-events within\n         * this timeframe otherwise the browser may execute events that should have been prevented.\n         *\n         * Additionally, this also lets us deal automatically with cancellations when a click event\n         * isn't raised because the page was considered scrolled/drag-scrolled, long-pressed, etc.\n         *\n         * This is why we also continuously remove the previous listener, because we cannot be\n         * certain that it was raised, and therefore cleaned-up.\n         */ if (event.pointerType === 'touch') {\n                    ownerDocument.removeEventListener('click', handleClickRef.current);\n                    handleClickRef.current = handleAndDispatchPointerDownOutsideEvent;\n                    ownerDocument.addEventListener('click', handleClickRef.current, {\n                        once: true\n                    });\n                } else handleAndDispatchPointerDownOutsideEvent();\n            } else // We need to remove the event listener in case the outside click has been canceled.\n            // See: https://github.com/radix-ui/primitives/issues/2171\n            ownerDocument.removeEventListener('click', handleClickRef.current);\n            isPointerInsideReactTreeRef.current = false;\n        };\n        /**\n     * if this hook executes in a component that mounts via a `pointerdown` event, the event\n     * would bubble up to the document and trigger a `pointerDownOutside` event. We avoid\n     * this by delaying the event listener registration on the document.\n     * This is not React specific, but rather how the DOM works, ie:\n     * ```\n     * button.addEventListener('pointerdown', () => {\n     *   console.log('I will log');\n     *   document.addEventListener('pointerdown', () => {\n     *     console.log('I will also log');\n     *   })\n     * });\n     */ const timerId = window.setTimeout(()=>{\n            ownerDocument.addEventListener('pointerdown', handlePointerDown);\n        }, 0);\n        return ()=>{\n            window.clearTimeout(timerId);\n            ownerDocument.removeEventListener('pointerdown', handlePointerDown);\n            ownerDocument.removeEventListener('click', handleClickRef.current);\n        };\n    }, [\n        ownerDocument,\n        handlePointerDownOutside\n    ]);\n    return {\n        // ensures we check React component tree (not just DOM tree)\n        onPointerDownCapture: ()=>isPointerInsideReactTreeRef.current = true\n    };\n}\n/**\n * Listens for when focus happens outside a react subtree.\n * Returns props to pass to the root (node) of the subtree we want to check.\n */ function $5cb92bef7577960e$var$useFocusOutside(onFocusOutside, ownerDocument = globalThis === null || globalThis === void 0 ? void 0 : globalThis.document) {\n    const handleFocusOutside = $kqwpH$useCallbackRef(onFocusOutside);\n    const isFocusInsideReactTreeRef = $kqwpH$useRef(false);\n    $kqwpH$useEffect(()=>{\n        const handleFocus = (event)=>{\n            if (event.target && !isFocusInsideReactTreeRef.current) {\n                const eventDetail = {\n                    originalEvent: event\n                };\n                $5cb92bef7577960e$var$handleAndDispatchCustomEvent($5cb92bef7577960e$var$FOCUS_OUTSIDE, handleFocusOutside, eventDetail, {\n                    discrete: false\n                });\n            }\n        };\n        ownerDocument.addEventListener('focusin', handleFocus);\n        return ()=>ownerDocument.removeEventListener('focusin', handleFocus)\n        ;\n    }, [\n        ownerDocument,\n        handleFocusOutside\n    ]);\n    return {\n        onFocusCapture: ()=>isFocusInsideReactTreeRef.current = true\n        ,\n        onBlurCapture: ()=>isFocusInsideReactTreeRef.current = false\n    };\n}\nfunction $5cb92bef7577960e$var$dispatchUpdate() {\n    const event = new CustomEvent($5cb92bef7577960e$var$CONTEXT_UPDATE);\n    document.dispatchEvent(event);\n}\nfunction $5cb92bef7577960e$var$handleAndDispatchCustomEvent(name, handler, detail, { discrete: discrete  }) {\n    const target = detail.originalEvent.target;\n    const event = new CustomEvent(name, {\n        bubbles: false,\n        cancelable: true,\n        detail: detail\n    });\n    if (handler) target.addEventListener(name, handler, {\n        once: true\n    });\n    if (discrete) $kqwpH$dispatchDiscreteCustomEvent(target, event);\n    else target.dispatchEvent(event);\n}\nconst $5cb92bef7577960e$export$be92b6f5f03c0fe9 = $5cb92bef7577960e$export$177fb62ff3ec1f22;\nconst $5cb92bef7577960e$export$aecb2ddcb55c95be = $5cb92bef7577960e$export$4d5eb2109db14228;\n\n\n\n\nexport {$5cb92bef7577960e$export$177fb62ff3ec1f22 as DismissableLayer, $5cb92bef7577960e$export$4d5eb2109db14228 as DismissableLayerBranch, $5cb92bef7577960e$export$be92b6f5f03c0fe9 as Root, $5cb92bef7577960e$export$aecb2ddcb55c95be as Branch};\n//# sourceMappingURL=index.mjs.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  return {\n    ...rect,\n    top: rect.y,\n    left: rect.x,\n    right: rect.x + rect.width,\n    bottom: rect.y + rect.height\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    ...rects.floating,\n    x,\n    y\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 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      if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== 'none') {\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$map$so;\n                const placement = (_overflowsData$map$so = overflowsData.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$map$so[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  let {\n    mainAxis,\n    crossAxis,\n    alignmentAxis\n  } = typeof rawValue === 'number' ? {\n    mainAxis: rawValue,\n    crossAxis: 0,\n    alignmentAxis: null\n  } : {\n    mainAxis: 0,\n    crossAxis: 0,\n    alignmentAxis: null,\n    ...rawValue\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        }\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      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 overflowAvailableHeight = height - overflow[heightSide];\n      const overflowAvailableWidth = width - overflow[widthSide];\n      const noShift = !state.middlewareData.shift;\n      let availableHeight = overflowAvailableHeight;\n      let availableWidth = overflowAvailableWidth;\n      if (isYAxis) {\n        const maximumClippingWidth = width - overflow.left - overflow.right;\n        availableWidth = alignment || noShift ? min(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;\n      } else {\n        const maximumClippingHeight = height - overflow.top - overflow.bottom;\n        availableHeight = alignment || noShift ? min(overflowAvailableHeight, maximumClippingHeight) : 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","function 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  return value instanceof Node || value instanceof getWindow(value).Node;\n}\nfunction isElement(value) {\n  return value instanceof Element || value instanceof getWindow(value).Element;\n}\nfunction isHTMLElement(value) {\n  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;\n}\nfunction isShadowRoot(value) {\n  // Browsers without `ShadowRoot` support.\n  if (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 isContainingBlock(element) {\n  const webkit = isWebKit();\n  const css = getComputedStyle(element);\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));\n}\nfunction getContainingBlock(element) {\n  let currentNode = getParentNode(element);\n  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    if (isContainingBlock(currentNode)) {\n      return currentNode;\n    } else {\n      currentNode = getParentNode(currentNode);\n    }\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.pageXOffset,\n    scrollTop: element.pageYOffset\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    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);\n  }\n  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));\n}\n\nexport { getComputedStyle, getContainingBlock, getDocumentElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isWebKit };\n","import { rectToClientRect, 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';\nexport { detectOverflow, offset } from '@floating-ui/core';\nimport { round, createCoords, max, min, floor } from '@floating-ui/utils';\nimport { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getDocumentElement, getNodeName, isOverflowElement, getNodeScroll, 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 = currentWin.frameElement;\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 = currentWin.frameElement;\n    }\n  }\n  return rectToClientRect({\n    width,\n    height,\n    x,\n    y\n  });\n}\n\nconst topLayerSelectors = [':popover-open', ':modal'];\nfunction isTopLayer(floating) {\n  return topLayerSelectors.some(selector => {\n    try {\n      return floating.matches(selector);\n    } catch (e) {\n      return false;\n    }\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  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,\n    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y\n  };\n}\n\nfunction getClientRects(element) {\n  return Array.from(element.getClientRects());\n}\n\nfunction getWindowScrollBarX(element) {\n  // If <html> has a CSS width greater than the viewport, then this will be\n  // incorrect for RTL.\n  return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;\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      ...clippingAncestor,\n      x: clippingAncestor.x - visualOffsets.x,\n      y: clippingAncestor.y - visualOffsets.y\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' ? 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      offsets.x = getWindowScrollBarX(documentElement);\n    }\n  }\n  const x = rect.left + scroll.scrollLeft - offsets.x;\n  const y = rect.top + scroll.scrollTop - offsets.y;\n  return {\n    x,\n    y,\n    width: rect.width,\n    height: rect.height\n  };\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  return element.offsetParent;\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 window = getWindow(element);\n  if (!isHTMLElement(element) || isTopLayer(element)) {\n    return window;\n  }\n  let offsetParent = getTrueOffsetParent(element, polyfill);\n  while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === 'static') {\n    offsetParent = getTrueOffsetParent(offsetParent, polyfill);\n  }\n  if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) {\n    return window;\n  }\n  return offsetParent || getContainingBlock(element) || window;\n}\n\nconst getElementRects = async function (data) {\n  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;\n  const getDimensionsFn = this.getDimensions;\n  return {\n    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),\n    floating: {\n      x: 0,\n      y: 0,\n      ...(await getDimensionsFn(data.floating))\n    }\n  };\n};\n\nfunction isRTL(element) {\n  return getComputedStyle(element).direction === 'rtl';\n}\n\nconst platform = {\n  convertOffsetParentRelativeRectToViewportRelativeRect,\n  getDocumentElement,\n  getClippingRect,\n  getOffsetParent,\n  getElementRects,\n  getClientRects,\n  getDimensions,\n  getScale,\n  isElement,\n  isRTL\n};\n\n// https://samthor.au/2021/observing-dom/\nfunction observeMove(element, onMove) {\n  let io = null;\n  let timeoutId;\n  const root = getDocumentElement(element);\n  function cleanup() {\n    var _io;\n    clearTimeout(timeoutId);\n    (_io = io) == null || _io.disconnect();\n    io = null;\n  }\n  function refresh(skip, threshold) {\n    if (skip === void 0) {\n      skip = false;\n    }\n    if (threshold === void 0) {\n      threshold = 1;\n    }\n    cleanup();\n    const {\n      left,\n      top,\n      width,\n      height\n    } = element.getBoundingClientRect();\n    if (!skip) {\n      onMove();\n    }\n    if (!width || !height) {\n      return;\n    }\n    const insetTop = floor(top);\n    const insetRight = floor(root.clientWidth - (left + width));\n    const insetBottom = floor(root.clientHeight - (top + height));\n    const insetLeft = floor(left);\n    const rootMargin = -insetTop + \"px \" + -insetRight + \"px \" + -insetBottom + \"px \" + -insetLeft + \"px\";\n    const options = {\n      rootMargin,\n      threshold: max(0, min(1, threshold)) || 1\n    };\n    let isFirstUpdate = true;\n    function handleObserve(entries) {\n      const ratio = entries[0].intersectionRatio;\n      if (ratio !== threshold) {\n        if (!isFirstUpdate) {\n          return refresh();\n        }\n        if (!ratio) {\n          timeoutId = setTimeout(() => {\n            refresh(false, 1e-7);\n          }, 100);\n        } else {\n          refresh(false, ratio);\n        }\n      }\n      isFirstUpdate = false;\n    }\n\n    // Older browsers don't support a `document` as the root and will throw an\n    // error.\n    try {\n      io = new IntersectionObserver(handleObserve, {\n        ...options,\n        // Handle <iframe>s\n        root: root.ownerDocument\n      });\n    } catch (e) {\n      io = new IntersectionObserver(handleObserve, options);\n    }\n    io.observe(element);\n  }\n  refresh(true);\n  return cleanup;\n}\n\n/**\n * Automatically updates the position of the floating element when necessary.\n * Should only be called when the floating element is mounted on the DOM or\n * visible on the screen.\n * @returns cleanup function that should be invoked when the floating element is\n * removed from the DOM or hidden from the screen.\n * @see https://floating-ui.com/docs/autoUpdate\n */\nfunction autoUpdate(reference, floating, update, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    ancestorScroll = true,\n    ancestorResize = true,\n    elementResize = typeof ResizeObserver === 'function',\n    layoutShift = typeof IntersectionObserver === 'function',\n    animationFrame = false\n  } = options;\n  const referenceEl = unwrapElement(reference);\n  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];\n  ancestors.forEach(ancestor => {\n    ancestorScroll && ancestor.addEventListener('scroll', update, {\n      passive: true\n    });\n    ancestorResize && ancestor.addEventListener('resize', update);\n  });\n  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;\n  let reobserveFrame = -1;\n  let resizeObserver = null;\n  if (elementResize) {\n    resizeObserver = new ResizeObserver(_ref => {\n      let [firstEntry] = _ref;\n      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {\n        // Prevent update loops when using the `size` middleware.\n        // https://github.com/floating-ui/floating-ui/issues/1740\n        resizeObserver.unobserve(floating);\n        cancelAnimationFrame(reobserveFrame);\n        reobserveFrame = requestAnimationFrame(() => {\n          var _resizeObserver;\n          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);\n        });\n      }\n      update();\n    });\n    if (referenceEl && !animationFrame) {\n      resizeObserver.observe(referenceEl);\n    }\n    resizeObserver.observe(floating);\n  }\n  let frameId;\n  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;\n  if (animationFrame) {\n    frameLoop();\n  }\n  function frameLoop() {\n    const nextRefRect = getBoundingClientRect(reference);\n    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {\n      update();\n    }\n    prevRefRect = nextRefRect;\n    frameId = requestAnimationFrame(frameLoop);\n  }\n  update();\n  return () => {\n    var _resizeObserver2;\n    ancestors.forEach(ancestor => {\n      ancestorScroll && ancestor.removeEventListener('scroll', update);\n      ancestorResize && ancestor.removeEventListener('resize', update);\n    });\n    cleanupIo == null || cleanupIo();\n    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();\n    resizeObserver = null;\n    if (animationFrame) {\n      cancelAnimationFrame(frameId);\n    }\n  };\n}\n\n/**\n * 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, flip, hide, inline, limitShift, platform, shift, size };\n","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 * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * This wraps the core `arrow` middleware to allow React refs as the element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => {\n  function isRef(value) {\n    return {}.hasOwnProperty.call(value, 'current');\n  }\n  return {\n    name: 'arrow',\n    options,\n    fn(state) {\n      const {\n        element,\n        padding\n      } = typeof options === 'function' ? options(state) : options;\n      if (element && isRef(element)) {\n        if (element.current != null) {\n          return arrow$1({\n            element: element.current,\n            padding\n          }).fn(state);\n        }\n        return {};\n      }\n      if (element) {\n        return arrow$1({\n          element,\n          padding\n        }).fn(state);\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;\n  let i;\n  let keys;\n  if (a && b && typeof a === 'object') {\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length !== b.length) return false;\n      for (i = length; i-- !== 0;) {\n        if (!deepEqual(a[i], b[i])) {\n          return false;\n        }\n      }\n      return true;\n    }\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) {\n      return false;\n    }\n    for (i = length; i-- !== 0;) {\n      if (!{}.hasOwnProperty.call(b, keys[i])) {\n        return false;\n      }\n    }\n    for (i = length; i-- !== 0;) {\n      const key = keys[i];\n      if (key === '_owner' && a.$$typeof) {\n        continue;\n      }\n      if (!deepEqual(a[key], b[key])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  // biome-ignore lint/suspicious/noSelfCompare: in source\n  return a !== a && b !== b;\n}\n\nfunction getDPR(element) {\n  if (typeof window === 'undefined') {\n    return 1;\n  }\n  const win = element.ownerDocument.defaultView || window;\n  return win.devicePixelRatio || 1;\n}\n\nfunction roundByDPR(element, value) {\n  const dpr = getDPR(element);\n  return Math.round(value * dpr) / dpr;\n}\n\nfunction useLatestRef(value) {\n  const ref = React.useRef(value);\n  index(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n\n/**\n * Provides data to position a floating element.\n * @see https://floating-ui.com/docs/useFloating\n */\nfunction useFloating(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform,\n    elements: {\n      reference: externalReference,\n      floating: externalFloating\n    } = {},\n    transform = true,\n    whileElementsMounted,\n    open\n  } = options;\n  const [data, setData] = React.useState({\n    x: 0,\n    y: 0,\n    strategy,\n    placement,\n    middlewareData: {},\n    isPositioned: false\n  });\n  const [latestMiddleware, setLatestMiddleware] = React.useState(middleware);\n  if (!deepEqual(latestMiddleware, middleware)) {\n    setLatestMiddleware(middleware);\n  }\n  const [_reference, _setReference] = React.useState(null);\n  const [_floating, _setFloating] = React.useState(null);\n  const setReference = React.useCallback(node => {\n    if (node !== referenceRef.current) {\n      referenceRef.current = node;\n      _setReference(node);\n    }\n  }, []);\n  const setFloating = React.useCallback(node => {\n    if (node !== floatingRef.current) {\n      floatingRef.current = node;\n      _setFloating(node);\n    }\n  }, []);\n  const referenceEl = externalReference || _reference;\n  const floatingEl = externalFloating || _floating;\n  const referenceRef = React.useRef(null);\n  const floatingRef = React.useRef(null);\n  const dataRef = React.useRef(data);\n  const hasWhileElementsMounted = whileElementsMounted != null;\n  const whileElementsMountedRef = useLatestRef(whileElementsMounted);\n  const platformRef = useLatestRef(platform);\n  const 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\n  // biome-ignore lint/correctness/useExhaustiveDependencies: `hasWhileElementsMounted` is intentionally included.\n  index(() => {\n    if (referenceEl) referenceRef.current = referenceEl;\n    if (floatingEl) floatingRef.current = floatingEl;\n    if (referenceEl && floatingEl) {\n      if (whileElementsMountedRef.current) {\n        return whileElementsMountedRef.current(referenceEl, floatingEl, update);\n      }\n      update();\n    }\n  }, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);\n  const refs = React.useMemo(() => ({\n    reference: referenceRef,\n    floating: floatingRef,\n    setReference,\n    setFloating\n  }), [setReference, setFloating]);\n  const elements = React.useMemo(() => ({\n    reference: referenceEl,\n    floating: floatingEl\n  }), [referenceEl, floatingEl]);\n  const floatingStyles = React.useMemo(() => {\n    const initialStyles = {\n      position: strategy,\n      left: 0,\n      top: 0\n    };\n    if (!elements.floating) {\n      return initialStyles;\n    }\n    const x = roundByDPR(elements.floating, data.x);\n    const y = roundByDPR(elements.floating, data.y);\n    if (transform) {\n      return {\n        ...initialStyles,\n        transform: \"translate(\" + x + \"px, \" + y + \"px)\",\n        ...(getDPR(elements.floating) >= 1.5 && {\n          willChange: 'transform'\n        })\n      };\n    }\n    return {\n      position: strategy,\n      left: x,\n      top: y\n    };\n  }, [strategy, transform, elements.floating, data.x, data.y]);\n  return React.useMemo(() => ({\n    ...data,\n    update,\n    refs,\n    elements,\n    floatingStyles\n  }), [data, update, refs, elements, floatingStyles]);\n}\n\nexport { arrow, useFloating };\n","import $jbnEx$babelruntimehelpersesmextends from \"@babel/runtime/helpers/esm/extends\";\nimport {forwardRef as $jbnEx$forwardRef, createElement as $jbnEx$createElement} from \"react\";\nimport {Primitive as $jbnEx$Primitive} from \"@radix-ui/react-primitive\";\n\n\n\n\n/* -------------------------------------------------------------------------------------------------\n * Arrow\n * -----------------------------------------------------------------------------------------------*/ const $7e8f5cd07187803e$var$NAME = 'Arrow';\nconst $7e8f5cd07187803e$export$21b07c8f274aebd5 = /*#__PURE__*/ $jbnEx$forwardRef((props, forwardedRef)=>{\n    const { children: children , width: width = 10 , height: height = 5 , ...arrowProps } = props;\n    return /*#__PURE__*/ $jbnEx$createElement($jbnEx$Primitive.svg, $jbnEx$babelruntimehelpersesmextends({}, arrowProps, {\n        ref: forwardedRef,\n        width: width,\n        height: height,\n        viewBox: \"0 0 30 10\",\n        preserveAspectRatio: \"none\"\n    }), props.asChild ? children : /*#__PURE__*/ $jbnEx$createElement(\"polygon\", {\n        points: \"0,0 30,0 15,10\"\n    }));\n});\n/*#__PURE__*/ Object.assign($7e8f5cd07187803e$export$21b07c8f274aebd5, {\n    displayName: $7e8f5cd07187803e$var$NAME\n});\n/* -----------------------------------------------------------------------------------------------*/ const $7e8f5cd07187803e$export$be92b6f5f03c0fe9 = $7e8f5cd07187803e$export$21b07c8f274aebd5;\n\n\n\n\nexport {$7e8f5cd07187803e$export$21b07c8f274aebd5 as Arrow, $7e8f5cd07187803e$export$be92b6f5f03c0fe9 as Root};\n//# sourceMappingURL=index.mjs.map\n","import {useState as $9gyGR$useState} from \"react\";\nimport {useLayoutEffect as $9gyGR$useLayoutEffect} from \"@radix-ui/react-use-layout-effect\";\n\n\n\nfunction $db6c3485150b8e66$export$1ab7ae714698c4b8(element) {\n    const [size, setSize] = $9gyGR$useState(undefined);\n    $9gyGR$useLayoutEffect(()=>{\n        if (element) {\n            // provide size as early as possible\n            setSize({\n                width: element.offsetWidth,\n                height: element.offsetHeight\n            });\n            const resizeObserver = new ResizeObserver((entries)=>{\n                if (!Array.isArray(entries)) return;\n                 // Since we only observe the one element, we don't need to loop over the\n                // array\n                if (!entries.length) return;\n                const entry = entries[0];\n                let width;\n                let height;\n                if ('borderBoxSize' in entry) {\n                    const borderSizeEntry = entry['borderBoxSize']; // iron out differences between browsers\n                    const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;\n                    width = borderSize['inlineSize'];\n                    height = borderSize['blockSize'];\n                } else {\n                    // for browsers that don't support `borderBoxSize`\n                    // we calculate it ourselves to get the correct border box.\n                    width = element.offsetWidth;\n                    height = element.offsetHeight;\n                }\n                setSize({\n                    width: width,\n                    height: height\n                });\n            });\n            resizeObserver.observe(element, {\n                box: 'border-box'\n            });\n            return ()=>resizeObserver.unobserve(element)\n            ;\n        } else // We only want to reset to `undefined` when the element becomes `null`,\n        // not if it changes to another element.\n        setSize(undefined);\n    }, [\n        element\n    ]);\n    return size;\n}\n\n\n\n\nexport {$db6c3485150b8e66$export$1ab7ae714698c4b8 as useSize};\n//# sourceMappingURL=index.mjs.map\n","import $kY93V$babelruntimehelpersesmextends from \"@babel/runtime/helpers/esm/extends\";\nimport {useState as $kY93V$useState, createElement as $kY93V$createElement, forwardRef as $kY93V$forwardRef, useRef as $kY93V$useRef, useEffect as $kY93V$useEffect} from \"react\";\nimport {useFloating as $kY93V$useFloating, autoUpdate as $kY93V$autoUpdate, offset as $kY93V$offset, shift as $kY93V$shift, limitShift as $kY93V$limitShift, flip as $kY93V$flip, size as $kY93V$size, arrow as $kY93V$arrow, hide as $kY93V$hide} from \"@floating-ui/react-dom\";\nimport {Root as $kY93V$Root} from \"@radix-ui/react-arrow\";\nimport {useComposedRefs as $kY93V$useComposedRefs} from \"@radix-ui/react-compose-refs\";\nimport {createContextScope as $kY93V$createContextScope} from \"@radix-ui/react-context\";\nimport {Primitive as $kY93V$Primitive} from \"@radix-ui/react-primitive\";\nimport {useCallbackRef as $kY93V$useCallbackRef} from \"@radix-ui/react-use-callback-ref\";\nimport {useLayoutEffect as $kY93V$useLayoutEffect} from \"@radix-ui/react-use-layout-effect\";\nimport {useSize as $kY93V$useSize} from \"@radix-ui/react-use-size\";\n\n\n\n\n\n\n\n\n\n\n\nconst $cf1ac5d9fe0e8206$export$36f0086da09c4b9f = [\n    'top',\n    'right',\n    'bottom',\n    'left'\n];\nconst $cf1ac5d9fe0e8206$export$3671ffab7b302fc9 = [\n    'start',\n    'center',\n    'end'\n];\n/* -------------------------------------------------------------------------------------------------\n * Popper\n * -----------------------------------------------------------------------------------------------*/ const $cf1ac5d9fe0e8206$var$POPPER_NAME = 'Popper';\nconst [$cf1ac5d9fe0e8206$var$createPopperContext, $cf1ac5d9fe0e8206$export$722aac194ae923] = $kY93V$createContextScope($cf1ac5d9fe0e8206$var$POPPER_NAME);\nconst [$cf1ac5d9fe0e8206$var$PopperProvider, $cf1ac5d9fe0e8206$var$usePopperContext] = $cf1ac5d9fe0e8206$var$createPopperContext($cf1ac5d9fe0e8206$var$POPPER_NAME);\nconst $cf1ac5d9fe0e8206$export$badac9ada3a0bdf9 = (props)=>{\n    const { __scopePopper: __scopePopper , children: children  } = props;\n    const [anchor, setAnchor] = $kY93V$useState(null);\n    return /*#__PURE__*/ $kY93V$createElement($cf1ac5d9fe0e8206$var$PopperProvider, {\n        scope: __scopePopper,\n        anchor: anchor,\n        onAnchorChange: setAnchor\n    }, children);\n};\n/*#__PURE__*/ Object.assign($cf1ac5d9fe0e8206$export$badac9ada3a0bdf9, {\n    displayName: $cf1ac5d9fe0e8206$var$POPPER_NAME\n});\n/* -------------------------------------------------------------------------------------------------\n * PopperAnchor\n * -----------------------------------------------------------------------------------------------*/ const $cf1ac5d9fe0e8206$var$ANCHOR_NAME = 'PopperAnchor';\nconst $cf1ac5d9fe0e8206$export$ecd4e1ccab6ed6d = /*#__PURE__*/ $kY93V$forwardRef((props, forwardedRef)=>{\n    const { __scopePopper: __scopePopper , virtualRef: virtualRef , ...anchorProps } = props;\n    const context = $cf1ac5d9fe0e8206$var$usePopperContext($cf1ac5d9fe0e8206$var$ANCHOR_NAME, __scopePopper);\n    const ref = $kY93V$useRef(null);\n    const composedRefs = $kY93V$useComposedRefs(forwardedRef, ref);\n    $kY93V$useEffect(()=>{\n        // Consumer can anchor the popper to something that isn't\n        // a DOM node e.g. pointer position, so we override the\n        // `anchorRef` with their virtual ref in this case.\n        context.onAnchorChange((virtualRef === null || virtualRef === void 0 ? void 0 : virtualRef.current) || ref.current);\n    });\n    return virtualRef ? null : /*#__PURE__*/ $kY93V$createElement($kY93V$Primitive.div, $kY93V$babelruntimehelpersesmextends({}, anchorProps, {\n        ref: composedRefs\n    }));\n});\n/*#__PURE__*/ Object.assign($cf1ac5d9fe0e8206$export$ecd4e1ccab6ed6d, {\n    displayName: $cf1ac5d9fe0e8206$var$ANCHOR_NAME\n});\n/* -------------------------------------------------------------------------------------------------\n * PopperContent\n * -----------------------------------------------------------------------------------------------*/ const $cf1ac5d9fe0e8206$var$CONTENT_NAME = 'PopperContent';\nconst [$cf1ac5d9fe0e8206$var$PopperContentProvider, $cf1ac5d9fe0e8206$var$useContentContext] = $cf1ac5d9fe0e8206$var$createPopperContext($cf1ac5d9fe0e8206$var$CONTENT_NAME);\nconst $cf1ac5d9fe0e8206$export$bc4ae5855d3c4fc = /*#__PURE__*/ $kY93V$forwardRef((props, forwardedRef)=>{\n    var _arrowSize$width, _arrowSize$height, _middlewareData$arrow, _middlewareData$arrow2, _middlewareData$arrow3, _middlewareData$trans, _middlewareData$trans2, _middlewareData$hide;\n    const { __scopePopper: __scopePopper , side: side = 'bottom' , sideOffset: sideOffset = 0 , align: align = 'center' , alignOffset: alignOffset = 0 , arrowPadding: arrowPadding = 0 , avoidCollisions: avoidCollisions = true , collisionBoundary: collisionBoundary = [] , collisionPadding: collisionPaddingProp = 0 , sticky: sticky = 'partial' , hideWhenDetached: hideWhenDetached = false , updatePositionStrategy: updatePositionStrategy = 'optimized' , onPlaced: onPlaced , ...contentProps } = props;\n    const context = $cf1ac5d9fe0e8206$var$usePopperContext($cf1ac5d9fe0e8206$var$CONTENT_NAME, __scopePopper);\n    const [content, setContent] = $kY93V$useState(null);\n    const composedRefs = $kY93V$useComposedRefs(forwardedRef, (node)=>setContent(node)\n    );\n    const [arrow, setArrow] = $kY93V$useState(null);\n    const arrowSize = $kY93V$useSize(arrow);\n    const arrowWidth = (_arrowSize$width = arrowSize === null || arrowSize === void 0 ? void 0 : arrowSize.width) !== null && _arrowSize$width !== void 0 ? _arrowSize$width : 0;\n    const arrowHeight = (_arrowSize$height = arrowSize === null || arrowSize === void 0 ? void 0 : arrowSize.height) !== null && _arrowSize$height !== void 0 ? _arrowSize$height : 0;\n    const desiredPlacement = side + (align !== 'center' ? '-' + align : '');\n    const collisionPadding = typeof collisionPaddingProp === 'number' ? collisionPaddingProp : {\n        top: 0,\n        right: 0,\n        bottom: 0,\n        left: 0,\n        ...collisionPaddingProp\n    };\n    const boundary = Array.isArray(collisionBoundary) ? collisionBoundary : [\n        collisionBoundary\n    ];\n    const hasExplicitBoundaries = boundary.length > 0;\n    const detectOverflowOptions = {\n        padding: collisionPadding,\n        boundary: boundary.filter($cf1ac5d9fe0e8206$var$isNotNull),\n        // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries\n        altBoundary: hasExplicitBoundaries\n    };\n    const { refs: refs , floatingStyles: floatingStyles , placement: placement , isPositioned: isPositioned , middlewareData: middlewareData  } = $kY93V$useFloating({\n        // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues\n        strategy: 'fixed',\n        placement: desiredPlacement,\n        whileElementsMounted: (...args)=>{\n            const cleanup = $kY93V$autoUpdate(...args, {\n                animationFrame: updatePositionStrategy === 'always'\n            });\n            return cleanup;\n        },\n        elements: {\n            reference: context.anchor\n        },\n        middleware: [\n            $kY93V$offset({\n                mainAxis: sideOffset + arrowHeight,\n                alignmentAxis: alignOffset\n            }),\n            avoidCollisions && $kY93V$shift({\n                mainAxis: true,\n                crossAxis: false,\n                limiter: sticky === 'partial' ? $kY93V$limitShift() : undefined,\n                ...detectOverflowOptions\n            }),\n            avoidCollisions && $kY93V$flip({\n                ...detectOverflowOptions\n            }),\n            $kY93V$size({\n                ...detectOverflowOptions,\n                apply: ({ elements: elements , rects: rects , availableWidth: availableWidth , availableHeight: availableHeight  })=>{\n                    const { width: anchorWidth , height: anchorHeight  } = rects.reference;\n                    const contentStyle = elements.floating.style;\n                    contentStyle.setProperty('--radix-popper-available-width', `${availableWidth}px`);\n                    contentStyle.setProperty('--radix-popper-available-height', `${availableHeight}px`);\n                    contentStyle.setProperty('--radix-popper-anchor-width', `${anchorWidth}px`);\n                    contentStyle.setProperty('--radix-popper-anchor-height', `${anchorHeight}px`);\n                }\n            }),\n            arrow && $kY93V$arrow({\n                element: arrow,\n                padding: arrowPadding\n            }),\n            $cf1ac5d9fe0e8206$var$transformOrigin({\n                arrowWidth: arrowWidth,\n                arrowHeight: arrowHeight\n            }),\n            hideWhenDetached && $kY93V$hide({\n                strategy: 'referenceHidden',\n                ...detectOverflowOptions\n            })\n        ]\n    });\n    const [placedSide, placedAlign] = $cf1ac5d9fe0e8206$var$getSideAndAlignFromPlacement(placement);\n    const handlePlaced = $kY93V$useCallbackRef(onPlaced);\n    $kY93V$useLayoutEffect(()=>{\n        if (isPositioned) handlePlaced === null || handlePlaced === void 0 || handlePlaced();\n    }, [\n        isPositioned,\n        handlePlaced\n    ]);\n    const arrowX = (_middlewareData$arrow = middlewareData.arrow) === null || _middlewareData$arrow === void 0 ? void 0 : _middlewareData$arrow.x;\n    const arrowY = (_middlewareData$arrow2 = middlewareData.arrow) === null || _middlewareData$arrow2 === void 0 ? void 0 : _middlewareData$arrow2.y;\n    const cannotCenterArrow = ((_middlewareData$arrow3 = middlewareData.arrow) === null || _middlewareData$arrow3 === void 0 ? void 0 : _middlewareData$arrow3.centerOffset) !== 0;\n    const [contentZIndex, setContentZIndex] = $kY93V$useState();\n    $kY93V$useLayoutEffect(()=>{\n        if (content) setContentZIndex(window.getComputedStyle(content).zIndex);\n    }, [\n        content\n    ]);\n    return /*#__PURE__*/ $kY93V$createElement(\"div\", {\n        ref: refs.setFloating,\n        \"data-radix-popper-content-wrapper\": \"\",\n        style: {\n            ...floatingStyles,\n            transform: isPositioned ? floatingStyles.transform : 'translate(0, -200%)',\n            // keep off the page when measuring\n            minWidth: 'max-content',\n            zIndex: contentZIndex,\n            ['--radix-popper-transform-origin']: [\n                (_middlewareData$trans = middlewareData.transformOrigin) === null || _middlewareData$trans === void 0 ? void 0 : _middlewareData$trans.x,\n                (_middlewareData$trans2 = middlewareData.transformOrigin) === null || _middlewareData$trans2 === void 0 ? void 0 : _middlewareData$trans2.y\n            ].join(' ')\n        } // Floating UI interally calculates logical alignment based the `dir` attribute on\n        ,\n        dir: props.dir\n    }, /*#__PURE__*/ $kY93V$createElement($cf1ac5d9fe0e8206$var$PopperContentProvider, {\n        scope: __scopePopper,\n        placedSide: placedSide,\n        onArrowChange: setArrow,\n        arrowX: arrowX,\n        arrowY: arrowY,\n        shouldHideArrow: cannotCenterArrow\n    }, /*#__PURE__*/ $kY93V$createElement($kY93V$Primitive.div, $kY93V$babelruntimehelpersesmextends({\n        \"data-side\": placedSide,\n        \"data-align\": placedAlign\n    }, contentProps, {\n        ref: composedRefs,\n        style: {\n            ...contentProps.style,\n            // if the PopperContent hasn't been placed yet (not all measurements done)\n            // we prevent animations so that users's animation don't kick in too early referring wrong sides\n            animation: !isPositioned ? 'none' : undefined,\n            // hide the content if using the hide middleware and should be hidden\n            opacity: (_middlewareData$hide = middlewareData.hide) !== null && _middlewareData$hide !== void 0 && _middlewareData$hide.referenceHidden ? 0 : undefined\n        }\n    }))));\n});\n/*#__PURE__*/ Object.assign($cf1ac5d9fe0e8206$export$bc4ae5855d3c4fc, {\n    displayName: $cf1ac5d9fe0e8206$var$CONTENT_NAME\n});\n/* -------------------------------------------------------------------------------------------------\n * PopperArrow\n * -----------------------------------------------------------------------------------------------*/ const $cf1ac5d9fe0e8206$var$ARROW_NAME = 'PopperArrow';\nconst $cf1ac5d9fe0e8206$var$OPPOSITE_SIDE = {\n    top: 'bottom',\n    right: 'left',\n    bottom: 'top',\n    left: 'right'\n};\nconst $cf1ac5d9fe0e8206$export$79d62cd4e10a3fd0 = /*#__PURE__*/ $kY93V$forwardRef(function $cf1ac5d9fe0e8206$export$79d62cd4e10a3fd0(props, forwardedRef) {\n    const { __scopePopper: __scopePopper , ...arrowProps } = props;\n    const contentContext = $cf1ac5d9fe0e8206$var$useContentContext($cf1ac5d9fe0e8206$var$ARROW_NAME, __scopePopper);\n    const baseSide = $cf1ac5d9fe0e8206$var$OPPOSITE_SIDE[contentContext.placedSide];\n    return(/*#__PURE__*/ // we have to use an extra wrapper because `ResizeObserver` (used by `useSize`)\n    // doesn't report size as we'd expect on SVG elements.\n    // it reports their bounding box which is effectively the largest path inside the SVG.\n    $kY93V$createElement(\"span\", {\n        ref: contentContext.onArrowChange,\n        style: {\n            position: 'absolute',\n            left: contentContext.arrowX,\n            top: contentContext.arrowY,\n            [baseSide]: 0,\n            transformOrigin: {\n                top: '',\n                right: '0 0',\n                bottom: 'center 0',\n                left: '100% 0'\n            }[contentContext.placedSide],\n            transform: {\n                top: 'translateY(100%)',\n                right: 'translateY(50%) rotate(90deg) translateX(-50%)',\n                bottom: `rotate(180deg)`,\n                left: 'translateY(50%) rotate(-90deg) translateX(50%)'\n            }[contentContext.placedSide],\n            visibility: contentContext.shouldHideArrow ? 'hidden' : undefined\n        }\n    }, /*#__PURE__*/ $kY93V$createElement($kY93V$Root, $kY93V$babelruntimehelpersesmextends({}, arrowProps, {\n        ref: forwardedRef,\n        style: {\n            ...arrowProps.style,\n            // ensures the element can be measured correctly (mostly for if SVG)\n            display: 'block'\n        }\n    }))));\n});\n/*#__PURE__*/ Object.assign($cf1ac5d9fe0e8206$export$79d62cd4e10a3fd0, {\n    displayName: $cf1ac5d9fe0e8206$var$ARROW_NAME\n});\n/* -----------------------------------------------------------------------------------------------*/ function $cf1ac5d9fe0e8206$var$isNotNull(value) {\n    return value !== null;\n}\nconst $cf1ac5d9fe0e8206$var$transformOrigin = (options)=>({\n        name: 'transformOrigin',\n        options: options,\n        fn (data) {\n            var _middlewareData$arrow4, _middlewareData$arrow5, _middlewareData$arrow6, _middlewareData$arrow7, _middlewareData$arrow8;\n            const { placement: placement , rects: rects , middlewareData: middlewareData  } = data;\n            const cannotCenterArrow = ((_middlewareData$arrow4 = middlewareData.arrow) === null || _middlewareData$arrow4 === void 0 ? void 0 : _middlewareData$arrow4.centerOffset) !== 0;\n            const isArrowHidden = cannotCenterArrow;\n            const arrowWidth = isArrowHidden ? 0 : options.arrowWidth;\n            const arrowHeight = isArrowHidden ? 0 : options.arrowHeight;\n            const [placedSide, placedAlign] = $cf1ac5d9fe0e8206$var$getSideAndAlignFromPlacement(placement);\n            const noArrowAlign = {\n                start: '0%',\n                center: '50%',\n                end: '100%'\n            }[placedAlign];\n            const arrowXCenter = ((_middlewareData$arrow5 = (_middlewareData$arrow6 = middlewareData.arrow) === null || _middlewareData$arrow6 === void 0 ? void 0 : _middlewareData$arrow6.x) !== null && _middlewareData$arrow5 !== void 0 ? _middlewareData$arrow5 : 0) + arrowWidth / 2;\n            const arrowYCenter = ((_middlewareData$arrow7 = (_middlewareData$arrow8 = middlewareData.arrow) === null || _middlewareData$arrow8 === void 0 ? void 0 : _middlewareData$arrow8.y) !== null && _middlewareData$arrow7 !== void 0 ? _middlewareData$arrow7 : 0) + arrowHeight / 2;\n            let x = '';\n            let y = '';\n            if (placedSide === 'bottom') {\n                x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;\n                y = `${-arrowHeight}px`;\n            } else if (placedSide === 'top') {\n                x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;\n                y = `${rects.floating.height + arrowHeight}px`;\n            } else if (placedSide === 'right') {\n                x = `${-arrowHeight}px`;\n                y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;\n            } else if (placedSide === 'left') {\n                x = `${rects.floating.width + arrowHeight}px`;\n                y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;\n            }\n            return {\n                data: {\n                    x: x,\n                    y: y\n                }\n            };\n        }\n    })\n;\nfunction $cf1ac5d9fe0e8206$var$getSideAndAlignFromPlacement(placement) {\n    const [side, align = 'center'] = placement.split('-');\n    return [\n        side,\n        align\n    ];\n}\nconst $cf1ac5d9fe0e8206$export$be92b6f5f03c0fe9 = $cf1ac5d9fe0e8206$export$badac9ada3a0bdf9;\nconst $cf1ac5d9fe0e8206$export$b688253958b8dfe7 = $cf1ac5d9fe0e8206$export$ecd4e1ccab6ed6d;\nconst $cf1ac5d9fe0e8206$export$7c6e2c02157bb7d2 = $cf1ac5d9fe0e8206$export$bc4ae5855d3c4fc;\nconst $cf1ac5d9fe0e8206$export$21b07c8f274aebd5 = $cf1ac5d9fe0e8206$export$79d62cd4e10a3fd0;\n\n\n\n\nexport {$cf1ac5d9fe0e8206$export$722aac194ae923 as createPopperScope, $cf1ac5d9fe0e8206$export$badac9ada3a0bdf9 as Popper, $cf1ac5d9fe0e8206$export$ecd4e1ccab6ed6d as PopperAnchor, $cf1ac5d9fe0e8206$export$bc4ae5855d3c4fc as PopperContent, $cf1ac5d9fe0e8206$export$79d62cd4e10a3fd0 as PopperArrow, $cf1ac5d9fe0e8206$export$be92b6f5f03c0fe9 as Root, $cf1ac5d9fe0e8206$export$b688253958b8dfe7 as Anchor, $cf1ac5d9fe0e8206$export$7c6e2c02157bb7d2 as Content, $cf1ac5d9fe0e8206$export$21b07c8f274aebd5 as Arrow, $cf1ac5d9fe0e8206$export$36f0086da09c4b9f as SIDE_OPTIONS, $cf1ac5d9fe0e8206$export$3671ffab7b302fc9 as ALIGN_OPTIONS};\n//# sourceMappingURL=index.mjs.map\n","import $7SXl2$babelruntimehelpersesmextends from \"@babel/runtime/helpers/esm/extends\";\nimport {forwardRef as $7SXl2$forwardRef, createElement as $7SXl2$createElement} from \"react\";\nimport $7SXl2$reactdom from \"react-dom\";\nimport {Primitive as $7SXl2$Primitive} from \"@radix-ui/react-primitive\";\n\n\n\n\n\n/* -------------------------------------------------------------------------------------------------\n * Portal\n * -----------------------------------------------------------------------------------------------*/ const $f1701beae083dbae$var$PORTAL_NAME = 'Portal';\nconst $f1701beae083dbae$export$602eac185826482c = /*#__PURE__*/ $7SXl2$forwardRef((props, forwardedRef)=>{\n    var _globalThis$document;\n    const { container: container = globalThis === null || globalThis === void 0 ? void 0 : (_globalThis$document = globalThis.document) === null || _globalThis$document === void 0 ? void 0 : _globalThis$document.body , ...portalProps } = props;\n    return container ? /*#__PURE__*/ $7SXl2$reactdom.createPortal(/*#__PURE__*/ $7SXl2$createElement($7SXl2$Primitive.div, $7SXl2$babelruntimehelpersesmextends({}, portalProps, {\n        ref: forwardedRef\n    })), container) : null;\n});\n/*#__PURE__*/ Object.assign($f1701beae083dbae$export$602eac185826482c, {\n    displayName: $f1701beae083dbae$var$PORTAL_NAME\n});\n/* -----------------------------------------------------------------------------------------------*/ const $f1701beae083dbae$export$be92b6f5f03c0fe9 = $f1701beae083dbae$export$602eac185826482c;\n\n\n\n\nexport {$f1701beae083dbae$export$602eac185826482c as Portal, $f1701beae083dbae$export$be92b6f5f03c0fe9 as Root};\n//# sourceMappingURL=index.mjs.map\n"],"names":["$5cb92bef7577960e$var$originalBodyPointerEvents","$5cb92bef7577960e$var$CONTEXT_UPDATE","$5cb92bef7577960e$var$DismissableLayerContext","react","createContext","layers","Set","layersWithOutsidePointerEventsDisabled","branches","$5cb92bef7577960e$export$177fb62ff3ec1f22","forwardRef","props","forwardedRef","_node$ownerDocument","disableOutsidePointerEvents","onEscapeKeyDown","onPointerDownOutside","onFocusOutside","onInteractOutside","onDismiss","layerProps","context","useContext","node1","setNode","useState","ownerDocument","globalThis","document","force","composedRefs","react_compose_refs_dist","e","node","Array","from","highestLayerWithOutsidePointerEventsDisabled","slice","highestLayerWithOutsidePointerEventsDisabledIndex","indexOf","index","isBodyPointerEventsDisabled","size","isPointerEventsEnabled","pointerDownOutside","$5cb92bef7577960e$var$usePointerDownOutside","handlePointerDownOutside","react_use_callback_ref_dist","W","isPointerInsideReactTreeRef","useRef","handleClickRef","useEffect","handlePointerDown","event","target","current","eventDetail","originalEvent","handleAndDispatchPointerDownOutsideEvent","$5cb92bef7577960e$var$handleAndDispatchCustomEvent","discrete","pointerType","removeEventListener","addEventListener","once","timerId","window","setTimeout","clearTimeout","onPointerDownCapture","isPointerDownOnBranch","some","branch","contains","defaultPrevented","focusOutside","$5cb92bef7577960e$var$useFocusOutside","handleFocusOutside","isFocusInsideReactTreeRef","handleFocus","onFocusCapture","onBlurCapture","$addc16e1bbe58fd0$export$3a72a57244d6e765","onEscapeKeyDownProp","handleKeyDown","key","preventDefault","body","style","pointerEvents","add","$5cb92bef7577960e$var$dispatchUpdate","delete","handleUpdate","createElement","react_primitive_dist","WV","div","esm_extends","Z","ref","undefined","dist","M","CustomEvent","dispatchEvent","name","handler","detail","bubbles","cancelable","jH","sides","floating_ui_utils_min","Math","min","floating_ui_utils_max","max","round","floor","createCoords","v","x","y","oppositeSideMap","left","right","bottom","top","oppositeAlignmentMap","start","end","floating_ui_utils_evaluate","value","param","floating_ui_utils_getSide","placement","split","floating_ui_utils_getAlignment","getOppositeAxis","axis","getAxisLength","floating_ui_utils_getSideAxis","includes","floating_ui_utils_getOppositeAlignmentPlacement","replace","alignment","getOppositePlacement","side","floating_ui_utils_getPaddingObject","padding","floating_ui_utils_rectToClientRect","rect","width","height","computeCoordsFromPlacement","_ref","rtl","coords","reference","floating","sideAxis","alignmentAxis","alignLength","isVertical","commonX","commonY","commonAlign","computePosition","config","strategy","middleware","platform","validMiddleware","filter","Boolean","isRTL","rects","getElementRects","statefulPlacement","middlewareData","resetCount","i","length","fn","nextX","nextY","data","reset","initialPlacement","elements","detectOverflow","state","options","_await$platform$isEle","boundary","rootBoundary","elementContext","altBoundary","paddingObject","element","clippingClientRect","getClippingRect","isElement","contextElement","getDocumentElement","offsetParent","getOffsetParent","offsetScale","getScale","elementClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","getSideOffsets","overflow","isAnySideFullyClipped","convertValueToCoords","mainAxisMulti","crossAxisMulti","rawValue","mainAxis","crossAxis","getNodeName","nodeName","toLowerCase","getWindow","defaultView","isNode","documentElement","Node","Element","isHTMLElement","HTMLElement","isShadowRoot","ShadowRoot","isOverflowElement","overflowX","overflowY","display","getComputedStyle","test","isContainingBlock","webkit","isWebKit","css","transform","perspective","containerType","backdropFilter","willChange","contain","CSS","supports","isLastTraversableNode","getNodeScroll","scrollLeft","scrollTop","pageXOffset","pageYOffset","getParentNode","result","assignedSlot","parentNode","host","getOverflowAncestors","list","traverseIframes","_node$ownerDocument2","scrollableAncestor","getNearestOverflowAncestor","isBody","win","concat","visualViewport","frameElement","getCssDimensions","parseFloat","hasOffset","offsetWidth","offsetHeight","shouldFallback","$","unwrapElement","domElement","getBoundingClientRect","Number","isFinite","noOffsets","getVisualOffsets","offsetLeft","offsetTop","includeScale","isFixedStrategy","isFixed","clientRect","scale","visualOffsets","shouldAddVisualOffsets","floatingOffsetParent","offsetWin","currentWin","currentIFrame","iframeScale","iframeRect","clientLeft","paddingLeft","clientTop","paddingTop","topLayerSelectors","isTopLayer","selector","matches","getWindowScrollBarX","getClientRectFromClippingAncestor","clippingAncestor","getViewportRect","html","clientWidth","clientHeight","visualViewportBased","getDocumentRect","scroll","scrollWidth","scrollHeight","direction","getInnerBoundingClientRect","getTrueOffsetParent","polyfill","position","getContainingBlock","currentNode","getOffsetParentFn","getDimensionsFn","getDimensions","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsets","offsetRect","topLayer","clippingAncestors","getClippingElementAncestors","cache","cachedResult","get","el","currentContainingBlockComputedStyle","elementIsFixed","computedStyle","currentNodeIsContaining","hasFixedPositionAncestor","stopNode","ancestor","set","_c","firstClippingAncestor","clippingRect","reduce","accRect","getClientRects","floating_ui_dom_arrow","arrowDimensions","isYAxis","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","largestPossiblePadding","minPadding","maxPadding","center","offset","shouldAddOffset","arrow","alignmentOffset","centerOffset","floating_ui_dom_computePosition","Map","mergedOptions","platformWithCache","floating_ui_react_dom_arrow","hasOwnProperty","call","useLayoutEffect","deepEqual","a","b","keys","toString","isArray","Object","$$typeof","getDPR","devicePixelRatio","roundByDPR","dpr","useLatestRef","$7e8f5cd07187803e$export$21b07c8f274aebd5","children","arrowProps","svg","viewBox","preserveAspectRatio","asChild","points","$cf1ac5d9fe0e8206$var$POPPER_NAME","$cf1ac5d9fe0e8206$var$createPopperContext","$cf1ac5d9fe0e8206$export$722aac194ae923","react_context_dist","$cf1ac5d9fe0e8206$var$PopperProvider","$cf1ac5d9fe0e8206$var$usePopperContext","$cf1ac5d9fe0e8206$export$ecd4e1ccab6ed6d","__scopePopper","virtualRef","anchorProps","onAnchorChange","$cf1ac5d9fe0e8206$var$CONTENT_NAME","$cf1ac5d9fe0e8206$var$PopperContentProvider","$cf1ac5d9fe0e8206$var$useContentContext","$cf1ac5d9fe0e8206$export$bc4ae5855d3c4fc","_arrowSize$width","_arrowSize$height","_middlewareData$arrow","_middlewareData$arrow2","_middlewareData$arrow3","_middlewareData$trans","_middlewareData$trans2","_middlewareData$hide","sideOffset","align","alignOffset","arrowPadding","avoidCollisions","collisionBoundary","collisionPadding","collisionPaddingProp","sticky","hideWhenDetached","updatePositionStrategy","onPlaced","contentProps","content","setContent","setArrow","arrowSize","$db6c3485150b8e66$export$1ab7ae714698c4b8","setSize","react_use_layout_effect_dist","resizeObserver","ResizeObserver","entries","entry","borderSizeEntry","borderSize","observe","box","unobserve","arrowWidth","arrowHeight","hasExplicitBoundaries","detectOverflowOptions","$cf1ac5d9fe0e8206$var$isNotNull","refs","floatingStyles","isPositioned","useFloating","externalReference","externalFloating","whileElementsMounted","open","setData","latestMiddleware","setLatestMiddleware","_reference","_setReference","_floating","_setFloating","setReference","useCallback","referenceRef","setFloating","floatingRef","referenceEl","floatingEl","dataRef","hasWhileElementsMounted","whileElementsMountedRef","platformRef","update","then","fullData","isMountedRef","react_dom","flushSync","useMemo","initialStyles","args","autoUpdate","frameId","ancestorScroll","ancestorResize","elementResize","layoutShift","IntersectionObserver","animationFrame","ancestors","forEach","passive","cleanupIo","observeMove","onMove","timeoutId","io","root","cleanup","_io","disconnect","refresh","skip","threshold","insetTop","insetRight","rootMargin","isFirstUpdate","handleObserve","ratio","intersectionRatio","reobserveFrame","firstEntry","cancelAnimationFrame","requestAnimationFrame","_resizeObserver","prevRefRect","frameLoop","nextRefRect","_resizeObserver2","anchor","_middlewareData$offse","diffCoords","limiter","checkMainAxis","checkCrossAxis","mainAxisCoord","crossAxisCoord","rawOffset","computedOffset","len","limitMin","limitMax","_middlewareData$offse2","isOriginSide","minSide","maxSide","limitedCoords","_middlewareData$flip","_middlewareData$flip2","_overflowsData$filter","_overflowsData$map$so","fallbackPlacements","specifiedFallbackPlacements","fallbackStrategy","fallbackAxisSideDirection","flipAlignment","isBasePlacement","getExpandedPlacements","oppositePlacement","push","getOppositeAxisPlacements","getSideList","isStart","lr","rl","map","placements","overflows","overflowsData","flip","floating_ui_utils_getAlignmentSides","mainAlignmentSide","every","nextIndex","nextPlacement","resetPlacement","d","sort","acc","apply","availableWidth","availableHeight","anchorWidth","anchorHeight","contentStyle","setProperty","heightSide","widthSide","overflowAvailableHeight","overflowAvailableWidth","noShift","shift","maximumClippingWidth","maximumClippingHeight","xMin","xMax","yMin","yMax","nextDimensions","$cf1ac5d9fe0e8206$var$transformOrigin","referenceHiddenOffsets","referenceHidden","escapedOffsets","escaped","placedSide","placedAlign","$cf1ac5d9fe0e8206$var$getSideAndAlignFromPlacement","handlePlaced","arrowX","arrowY","cannotCenterArrow","contentZIndex","setContentZIndex","zIndex","minWidth","transformOrigin","join","dir","scope","onArrowChange","shouldHideArrow","animation","opacity","hide","$cf1ac5d9fe0e8206$var$OPPOSITE_SIDE","$cf1ac5d9fe0e8206$export$79d62cd4e10a3fd0","contentContext","baseSide","visibility","_middlewareData$arrow4","_middlewareData$arrow5","_middlewareData$arrow6","_middlewareData$arrow7","_middlewareData$arrow8","isArrowHidden","noArrowAlign","arrowXCenter","arrowYCenter","$cf1ac5d9fe0e8206$export$be92b6f5f03c0fe9","setAnchor","$cf1ac5d9fe0e8206$export$b688253958b8dfe7","$cf1ac5d9fe0e8206$export$7c6e2c02157bb7d2","$cf1ac5d9fe0e8206$export$21b07c8f274aebd5","$f1701beae083dbae$export$602eac185826482c","react__WEBPACK_IMPORTED_MODULE_0__","_globalThis$document","container","portalProps","react_dom__WEBPACK_IMPORTED_MODULE_1__","createPortal","_radix_ui_react_primitive__WEBPACK_IMPORTED_MODULE_2__","_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_3__"],"sourceRoot":""}