{"version":3,"file":"js/4802-5a0a11ba83163a384d7a.js","mappings":"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","sources":["webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@radix-ui_primitive@1.1.0/node_modules/@radix-ui/primitive/dist/index.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@radix-ui_react-compose-refs@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-compose-refs/dist/index.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@radix-ui_react-context@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-context/dist/index.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@radix-ui_react-dismissable-layer@1.1.0_@types_react@18.3.5_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@radix-ui/react-dismissable-layer/dist/index.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@radix-ui_react-use-escape-keydown@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-use-escape-keydown/dist/index.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@radix-ui_react-id@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-id/dist/index.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@floating-ui_utils@0.2.7/node_modules/@floating-ui/utils/dist/floating-ui.utils.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@floating-ui_core@1.6.7/node_modules/@floating-ui/core/dist/floating-ui.core.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@floating-ui_utils@0.2.7/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@floating-ui_dom@1.6.10/node_modules/@floating-ui/dom/dist/floating-ui.dom.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@floating-ui_react-dom@2.1.1_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@radix-ui_react-arrow@1.1.0_@types_react@18.3.5_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@radix-ui/react-arrow/dist/index.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@radix-ui_react-popper@1.2.0_@types_react@18.3.5_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@radix-ui/react-popper/dist/index.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@radix-ui_react-portal@1.1.1_@types_react@18.3.5_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@radix-ui/react-portal/dist/index.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@radix-ui_react-presence@1.1.0_@types_react@18.3.5_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@radix-ui/react-presence/dist/index.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@radix-ui_react-primitive@2.0.0_@types_react@18.3.5_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@radix-ui/react-primitive/dist/index.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@radix-ui_react-slot@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-slot/dist/index.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@radix-ui_react-use-callback-ref@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-use-callback-ref/dist/index.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@radix-ui_react-use-controllable-state@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-use-controllable-state/dist/index.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@radix-ui_react-use-layout-effect@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-use-layout-effect/dist/index.js","webpack://app/./node_modules/@lacedltd/laced-components/dist/_externals/.pnpm/@radix-ui_react-use-size@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-use-size/dist/index.js","webpack://app/./node_modules/react/cjs/react-jsx-runtime.production.min.js","webpack://app/./node_modules/react/jsx-runtime.js"],"sourcesContent":["// packages/core/primitive/src/primitive.tsx\nfunction composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {\n  return function handleEvent(event) {\n    originalEventHandler?.(event);\n    if (checkForDefaultPrevented === false || !event.defaultPrevented) {\n      return ourEventHandler?.(event);\n    }\n  };\n}\n\nexport { composeEventHandlers };\n//# sourceMappingURL=index.js.map\n","import * as React from 'react';\n\n// packages/react/compose-refs/src/composeRefs.tsx\nfunction setRef(ref, value) {\n  if (typeof ref === \"function\") {\n    ref(value);\n  } else if (ref !== null && ref !== void 0) {\n    ref.current = value;\n  }\n}\nfunction composeRefs(...refs) {\n  return (node) => refs.forEach((ref) => setRef(ref, node));\n}\nfunction useComposedRefs(...refs) {\n  return React.useCallback(composeRefs(...refs), refs);\n}\n\nexport { composeRefs, useComposedRefs };\n//# sourceMappingURL=index.js.map\n","import * as React from 'react';\nimport { jsx } from 'react/jsx-runtime';\n\n// packages/react/context/src/createContext.tsx\nfunction createContext2(rootComponentName, defaultContext) {\n  const Context = React.createContext(defaultContext);\n  function Provider(props) {\n    const { children, ...context } = props;\n    const value = React.useMemo(() => context, Object.values(context));\n    return /* @__PURE__ */ jsx(Context.Provider, { value, children });\n  }\n  function useContext2(consumerName) {\n    const context = React.useContext(Context);\n    if (context) return context;\n    if (defaultContext !== void 0) return defaultContext;\n    throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n  }\n  Provider.displayName = rootComponentName + \"Provider\";\n  return [Provider, useContext2];\n}\nfunction createContextScope(scopeName, createContextScopeDeps = []) {\n  let defaultContexts = [];\n  function createContext3(rootComponentName, defaultContext) {\n    const BaseContext = React.createContext(defaultContext);\n    const index = defaultContexts.length;\n    defaultContexts = [...defaultContexts, defaultContext];\n    function Provider(props) {\n      const { scope, children, ...context } = props;\n      const Context = scope?.[scopeName][index] || BaseContext;\n      const value = React.useMemo(() => context, Object.values(context));\n      return /* @__PURE__ */ jsx(Context.Provider, { value, children });\n    }\n    function useContext2(consumerName, scope) {\n      const Context = scope?.[scopeName][index] || BaseContext;\n      const context = React.useContext(Context);\n      if (context) return context;\n      if (defaultContext !== void 0) return defaultContext;\n      throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n    }\n    Provider.displayName = rootComponentName + \"Provider\";\n    return [Provider, useContext2];\n  }\n  const createScope = () => {\n    const scopeContexts = defaultContexts.map((defaultContext) => {\n      return React.createContext(defaultContext);\n    });\n    return function useScope(scope) {\n      const contexts = scope?.[scopeName] || scopeContexts;\n      return React.useMemo(\n        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),\n        [scope, contexts]\n      );\n    };\n  };\n  createScope.scopeName = scopeName;\n  return [createContext3, composeContextScopes(createScope, ...createContextScopeDeps)];\n}\nfunction composeContextScopes(...scopes) {\n  const baseScope = scopes[0];\n  if (scopes.length === 1) return baseScope;\n  const createScope = () => {\n    const scopeHooks = scopes.map((createScope2) => ({\n      useScope: createScope2(),\n      scopeName: createScope2.scopeName\n    }));\n    return function useComposedScopes(overrideScopes) {\n      const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {\n        const scopeProps = useScope(overrideScopes);\n        const currentScope = scopeProps[`__scope${scopeName}`];\n        return { ...nextScopes2, ...currentScope };\n      }, {});\n      return React.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);\n    };\n  };\n  createScope.scopeName = baseScope.scopeName;\n  return createScope;\n}\n\nexport { createContext2 as createContext, createContextScope };\n//# sourceMappingURL=index.js.map\n","import * as React from 'react';\nimport { composeEventHandlers } from '../../../../../@radix-ui_primitive@1.1.0/node_modules/@radix-ui/primitive/dist/index.js';\nimport { Primitive, dispatchDiscreteCustomEvent } from '../../../../../@radix-ui_react-primitive@2.0.0_@types_react@18.3.5_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@radix-ui/react-primitive/dist/index.js';\nimport { useComposedRefs } from '../../../../../@radix-ui_react-compose-refs@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-compose-refs/dist/index.js';\nimport { useCallbackRef } from '../../../../../@radix-ui_react-use-callback-ref@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-use-callback-ref/dist/index.js';\nimport { useEscapeKeydown } from '../../../../../@radix-ui_react-use-escape-keydown@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-use-escape-keydown/dist/index.js';\nimport { jsx } from 'react/jsx-runtime';\n\nvar DISMISSABLE_LAYER_NAME = \"DismissableLayer\";\nvar CONTEXT_UPDATE = \"dismissableLayer.update\";\nvar POINTER_DOWN_OUTSIDE = \"dismissableLayer.pointerDownOutside\";\nvar FOCUS_OUTSIDE = \"dismissableLayer.focusOutside\";\nvar originalBodyPointerEvents;\nvar DismissableLayerContext = React.createContext({\n  layers: /* @__PURE__ */ new Set(),\n  layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),\n  branches: /* @__PURE__ */ new Set()\n});\nvar DismissableLayer = React.forwardRef(\n  (props, forwardedRef) => {\n    const {\n      disableOutsidePointerEvents = false,\n      onEscapeKeyDown,\n      onPointerDownOutside,\n      onFocusOutside,\n      onInteractOutside,\n      onDismiss,\n      ...layerProps\n    } = props;\n    const context = React.useContext(DismissableLayerContext);\n    const [node, setNode] = React.useState(null);\n    const ownerDocument = node?.ownerDocument ?? globalThis?.document;\n    const [, force] = React.useState({});\n    const composedRefs = useComposedRefs(forwardedRef, (node2) => setNode(node2));\n    const layers = Array.from(context.layers);\n    const [highestLayerWithOutsidePointerEventsDisabled] = [...context.layersWithOutsidePointerEventsDisabled].slice(-1);\n    const highestLayerWithOutsidePointerEventsDisabledIndex = layers.indexOf(highestLayerWithOutsidePointerEventsDisabled);\n    const index = node ? layers.indexOf(node) : -1;\n    const isBodyPointerEventsDisabled = context.layersWithOutsidePointerEventsDisabled.size > 0;\n    const isPointerEventsEnabled = index >= highestLayerWithOutsidePointerEventsDisabledIndex;\n    const pointerDownOutside = usePointerDownOutside((event) => {\n      const target = event.target;\n      const isPointerDownOnBranch = [...context.branches].some((branch) => branch.contains(target));\n      if (!isPointerEventsEnabled || isPointerDownOnBranch) return;\n      onPointerDownOutside?.(event);\n      onInteractOutside?.(event);\n      if (!event.defaultPrevented) onDismiss?.();\n    }, ownerDocument);\n    const focusOutside = useFocusOutside((event) => {\n      const target = event.target;\n      const isFocusInBranch = [...context.branches].some((branch) => branch.contains(target));\n      if (isFocusInBranch) return;\n      onFocusOutside?.(event);\n      onInteractOutside?.(event);\n      if (!event.defaultPrevented) onDismiss?.();\n    }, ownerDocument);\n    useEscapeKeydown((event) => {\n      const isHighestLayer = index === context.layers.size - 1;\n      if (!isHighestLayer) return;\n      onEscapeKeyDown?.(event);\n      if (!event.defaultPrevented && onDismiss) {\n        event.preventDefault();\n        onDismiss();\n      }\n    }, ownerDocument);\n    React.useEffect(() => {\n      if (!node) return;\n      if (disableOutsidePointerEvents) {\n        if (context.layersWithOutsidePointerEventsDisabled.size === 0) {\n          originalBodyPointerEvents = ownerDocument.body.style.pointerEvents;\n          ownerDocument.body.style.pointerEvents = \"none\";\n        }\n        context.layersWithOutsidePointerEventsDisabled.add(node);\n      }\n      context.layers.add(node);\n      dispatchUpdate();\n      return () => {\n        if (disableOutsidePointerEvents && context.layersWithOutsidePointerEventsDisabled.size === 1) {\n          ownerDocument.body.style.pointerEvents = originalBodyPointerEvents;\n        }\n      };\n    }, [node, ownerDocument, disableOutsidePointerEvents, context]);\n    React.useEffect(() => {\n      return () => {\n        if (!node) return;\n        context.layers.delete(node);\n        context.layersWithOutsidePointerEventsDisabled.delete(node);\n        dispatchUpdate();\n      };\n    }, [node, context]);\n    React.useEffect(() => {\n      const handleUpdate = () => force({});\n      document.addEventListener(CONTEXT_UPDATE, handleUpdate);\n      return () => document.removeEventListener(CONTEXT_UPDATE, handleUpdate);\n    }, []);\n    return /* @__PURE__ */ jsx(\n      Primitive.div,\n      {\n        ...layerProps,\n        ref: composedRefs,\n        style: {\n          pointerEvents: isBodyPointerEventsDisabled ? isPointerEventsEnabled ? \"auto\" : \"none\" : void 0,\n          ...props.style\n        },\n        onFocusCapture: composeEventHandlers(props.onFocusCapture, focusOutside.onFocusCapture),\n        onBlurCapture: composeEventHandlers(props.onBlurCapture, focusOutside.onBlurCapture),\n        onPointerDownCapture: composeEventHandlers(\n          props.onPointerDownCapture,\n          pointerDownOutside.onPointerDownCapture\n        )\n      }\n    );\n  }\n);\nDismissableLayer.displayName = DISMISSABLE_LAYER_NAME;\nvar BRANCH_NAME = \"DismissableLayerBranch\";\nvar DismissableLayerBranch = React.forwardRef((props, forwardedRef) => {\n  const context = React.useContext(DismissableLayerContext);\n  const ref = React.useRef(null);\n  const composedRefs = useComposedRefs(forwardedRef, ref);\n  React.useEffect(() => {\n    const node = ref.current;\n    if (node) {\n      context.branches.add(node);\n      return () => {\n        context.branches.delete(node);\n      };\n    }\n  }, [context.branches]);\n  return /* @__PURE__ */ jsx(Primitive.div, { ...props, ref: composedRefs });\n});\nDismissableLayerBranch.displayName = BRANCH_NAME;\nfunction usePointerDownOutside(onPointerDownOutside, ownerDocument = globalThis?.document) {\n  const handlePointerDownOutside = useCallbackRef(onPointerDownOutside);\n  const isPointerInsideReactTreeRef = React.useRef(false);\n  const handleClickRef = React.useRef(() => {\n  });\n  React.useEffect(() => {\n    const handlePointerDown = (event) => {\n      if (event.target && !isPointerInsideReactTreeRef.current) {\n        let handleAndDispatchPointerDownOutsideEvent2 = function() {\n          handleAndDispatchCustomEvent(\n            POINTER_DOWN_OUTSIDE,\n            handlePointerDownOutside,\n            eventDetail,\n            { discrete: true }\n          );\n        };\n        const eventDetail = { originalEvent: event };\n        if (event.pointerType === \"touch\") {\n          ownerDocument.removeEventListener(\"click\", handleClickRef.current);\n          handleClickRef.current = handleAndDispatchPointerDownOutsideEvent2;\n          ownerDocument.addEventListener(\"click\", handleClickRef.current, { once: true });\n        } else {\n          handleAndDispatchPointerDownOutsideEvent2();\n        }\n      } else {\n        ownerDocument.removeEventListener(\"click\", handleClickRef.current);\n      }\n      isPointerInsideReactTreeRef.current = false;\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  }, [ownerDocument, handlePointerDownOutside]);\n  return {\n    // ensures we check React component tree (not just DOM tree)\n    onPointerDownCapture: () => isPointerInsideReactTreeRef.current = true\n  };\n}\nfunction useFocusOutside(onFocusOutside, ownerDocument = globalThis?.document) {\n  const handleFocusOutside = useCallbackRef(onFocusOutside);\n  const isFocusInsideReactTreeRef = React.useRef(false);\n  React.useEffect(() => {\n    const handleFocus = (event) => {\n      if (event.target && !isFocusInsideReactTreeRef.current) {\n        const eventDetail = { originalEvent: event };\n        handleAndDispatchCustomEvent(FOCUS_OUTSIDE, handleFocusOutside, eventDetail, {\n          discrete: false\n        });\n      }\n    };\n    ownerDocument.addEventListener(\"focusin\", handleFocus);\n    return () => ownerDocument.removeEventListener(\"focusin\", handleFocus);\n  }, [ownerDocument, handleFocusOutside]);\n  return {\n    onFocusCapture: () => isFocusInsideReactTreeRef.current = true,\n    onBlurCapture: () => isFocusInsideReactTreeRef.current = false\n  };\n}\nfunction dispatchUpdate() {\n  const event = new CustomEvent(CONTEXT_UPDATE);\n  document.dispatchEvent(event);\n}\nfunction handleAndDispatchCustomEvent(name, handler, detail, { discrete }) {\n  const target = detail.originalEvent.target;\n  const event = new CustomEvent(name, { bubbles: false, cancelable: true, detail });\n  if (handler) target.addEventListener(name, handler, { once: true });\n  if (discrete) {\n    dispatchDiscreteCustomEvent(target, event);\n  } else {\n    target.dispatchEvent(event);\n  }\n}\nvar Root = DismissableLayer;\nvar Branch = DismissableLayerBranch;\n\nexport { Branch, DismissableLayer, DismissableLayerBranch, Root };\n//# sourceMappingURL=index.js.map\n","import * as React from 'react';\nimport { useCallbackRef } from '../../../../../@radix-ui_react-use-callback-ref@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-use-callback-ref/dist/index.js';\n\n// packages/react/use-escape-keydown/src/useEscapeKeydown.tsx\nfunction useEscapeKeydown(onEscapeKeyDownProp, ownerDocument = globalThis?.document) {\n  const onEscapeKeyDown = useCallbackRef(onEscapeKeyDownProp);\n  React.useEffect(() => {\n    const handleKeyDown = (event) => {\n      if (event.key === \"Escape\") {\n        onEscapeKeyDown(event);\n      }\n    };\n    ownerDocument.addEventListener(\"keydown\", handleKeyDown, { capture: true });\n    return () => ownerDocument.removeEventListener(\"keydown\", handleKeyDown, { capture: true });\n  }, [onEscapeKeyDown, ownerDocument]);\n}\n\nexport { useEscapeKeydown };\n//# sourceMappingURL=index.js.map\n","import * as React from 'react';\nimport { useLayoutEffect as useLayoutEffect2 } from '../../../../../@radix-ui_react-use-layout-effect@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-use-layout-effect/dist/index.js';\n\n// packages/react/id/src/id.tsx\nvar useReactId = React[\"useId\".toString()] || (() => void 0);\nvar count = 0;\nfunction useId(deterministicId) {\n  const [id, setId] = React.useState(useReactId());\n  useLayoutEffect2(() => {\n    setId((reactId) => reactId ?? String(count++));\n  }, [deterministicId]);\n  return (id ? `radix-${id}` : \"\");\n}\n\nexport { useId };\n//# sourceMappingURL=index.js.map\n","/**\n * Custom positioning reference element.\n * @see https://floating-ui.com/docs/virtual-elements\n */\n\nconst sides = ['top', 'right', 'bottom', 'left'];\nconst min = Math.min;\nconst max = Math.max;\nconst round = Math.round;\nconst floor = Math.floor;\nconst createCoords = v => ({\n  x: v,\n  y: v\n});\nconst oppositeSideMap = {\n  left: 'right',\n  right: 'left',\n  bottom: 'top',\n  top: 'bottom'\n};\nconst oppositeAlignmentMap = {\n  start: 'end',\n  end: 'start'\n};\nfunction clamp(start, value, end) {\n  return max(start, min(value, end));\n}\nfunction evaluate(value, param) {\n  return typeof value === 'function' ? value(param) : value;\n}\nfunction getSide(placement) {\n  return placement.split('-')[0];\n}\nfunction getAlignment(placement) {\n  return placement.split('-')[1];\n}\nfunction getOppositeAxis(axis) {\n  return axis === 'x' ? 'y' : 'x';\n}\nfunction getAxisLength(axis) {\n  return axis === 'y' ? 'height' : 'width';\n}\nfunction getSideAxis(placement) {\n  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';\n}\nfunction getAlignmentAxis(placement) {\n  return getOppositeAxis(getSideAxis(placement));\n}\nfunction getAlignmentSides(placement, rects, rtl) {\n  if (rtl === void 0) {\n    rtl = false;\n  }\n  const alignment = getAlignment(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const length = getAxisLength(alignmentAxis);\n  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';\n  if (rects.reference[length] > rects.floating[length]) {\n    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);\n  }\n  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];\n}\nfunction getExpandedPlacements(placement) {\n  const oppositePlacement = getOppositePlacement(placement);\n  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];\n}\nfunction getOppositeAlignmentPlacement(placement) {\n  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);\n}\nfunction getSideList(side, isStart, rtl) {\n  const lr = ['left', 'right'];\n  const rl = ['right', 'left'];\n  const tb = ['top', 'bottom'];\n  const bt = ['bottom', 'top'];\n  switch (side) {\n    case 'top':\n    case 'bottom':\n      if (rtl) return isStart ? rl : lr;\n      return isStart ? lr : rl;\n    case 'left':\n    case 'right':\n      return isStart ? tb : bt;\n    default:\n      return [];\n  }\n}\nfunction getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {\n  const alignment = getAlignment(placement);\n  let list = getSideList(getSide(placement), direction === 'start', rtl);\n  if (alignment) {\n    list = list.map(side => side + \"-\" + alignment);\n    if (flipAlignment) {\n      list = list.concat(list.map(getOppositeAlignmentPlacement));\n    }\n  }\n  return list;\n}\nfunction getOppositePlacement(placement) {\n  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);\n}\nfunction expandPaddingObject(padding) {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0,\n    ...padding\n  };\n}\nfunction getPaddingObject(padding) {\n  return typeof padding !== 'number' ? expandPaddingObject(padding) : {\n    top: padding,\n    right: padding,\n    bottom: padding,\n    left: padding\n  };\n}\nfunction rectToClientRect(rect) {\n  const {\n    x,\n    y,\n    width,\n    height\n  } = rect;\n  return {\n    width,\n    height,\n    top: y,\n    left: x,\n    right: x + width,\n    bottom: y + height,\n    x,\n    y\n  };\n}\n\nexport { clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, rectToClientRect, round, sides };\n//# sourceMappingURL=floating-ui.utils.js.map\n","import { evaluate, getSide, getSideAxis, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, getAlignmentSides, clamp, getAlignment, min, max, getAlignmentAxis, getPaddingObject, rectToClientRect, sides, getOppositeAxis, getAxisLength } from '../../../../../@floating-ui_utils@0.2.7/node_modules/@floating-ui/utils/dist/floating-ui.utils.js';\n\nfunction computeCoordsFromPlacement(_ref, placement, rtl) {\n  let {\n    reference,\n    floating\n  } = _ref;\n  const sideAxis = getSideAxis(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const alignLength = getAxisLength(alignmentAxis);\n  const side = getSide(placement);\n  const isVertical = sideAxis === 'y';\n  const commonX = reference.x + reference.width / 2 - floating.width / 2;\n  const commonY = reference.y + reference.height / 2 - floating.height / 2;\n  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;\n  let coords;\n  switch (side) {\n    case 'top':\n      coords = {\n        x: commonX,\n        y: reference.y - floating.height\n      };\n      break;\n    case 'bottom':\n      coords = {\n        x: commonX,\n        y: reference.y + reference.height\n      };\n      break;\n    case 'right':\n      coords = {\n        x: reference.x + reference.width,\n        y: commonY\n      };\n      break;\n    case 'left':\n      coords = {\n        x: reference.x - floating.width,\n        y: commonY\n      };\n      break;\n    default:\n      coords = {\n        x: reference.x,\n        y: reference.y\n      };\n  }\n  switch (getAlignment(placement)) {\n    case 'start':\n      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n    case 'end':\n      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n  }\n  return coords;\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n *\n * This export does not have any `platform` interface logic. You will need to\n * write one for the platform you are using Floating UI with.\n */\nconst computePosition = async (reference, floating, config) => {\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform\n  } = config;\n  const validMiddleware = middleware.filter(Boolean);\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));\n  let rects = await platform.getElementRects({\n    reference,\n    floating,\n    strategy\n  });\n  let {\n    x,\n    y\n  } = computeCoordsFromPlacement(rects, placement, rtl);\n  let statefulPlacement = placement;\n  let middlewareData = {};\n  let resetCount = 0;\n  for (let i = 0; i < validMiddleware.length; i++) {\n    const {\n      name,\n      fn\n    } = validMiddleware[i];\n    const {\n      x: nextX,\n      y: nextY,\n      data,\n      reset\n    } = await fn({\n      x,\n      y,\n      initialPlacement: placement,\n      placement: statefulPlacement,\n      strategy,\n      middlewareData,\n      rects,\n      platform,\n      elements: {\n        reference,\n        floating\n      }\n    });\n    x = nextX != null ? nextX : x;\n    y = nextY != null ? nextY : y;\n    middlewareData = {\n      ...middlewareData,\n      [name]: {\n        ...middlewareData[name],\n        ...data\n      }\n    };\n    if (reset && resetCount <= 50) {\n      resetCount++;\n      if (typeof reset === 'object') {\n        if (reset.placement) {\n          statefulPlacement = reset.placement;\n        }\n        if (reset.rects) {\n          rects = reset.rects === true ? await platform.getElementRects({\n            reference,\n            floating,\n            strategy\n          }) : reset.rects;\n        }\n        ({\n          x,\n          y\n        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));\n      }\n      i = -1;\n    }\n  }\n  return {\n    x,\n    y,\n    placement: statefulPlacement,\n    strategy,\n    middlewareData\n  };\n};\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nasync function detectOverflow(state, options) {\n  var _await$platform$isEle;\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    x,\n    y,\n    platform,\n    rects,\n    elements,\n    strategy\n  } = state;\n  const {\n    boundary = 'clippingAncestors',\n    rootBoundary = 'viewport',\n    elementContext = 'floating',\n    altBoundary = false,\n    padding = 0\n  } = evaluate(options, state);\n  const paddingObject = getPaddingObject(padding);\n  const altContext = elementContext === 'floating' ? 'reference' : 'floating';\n  const element = elements[altBoundary ? altContext : elementContext];\n  const clippingClientRect = rectToClientRect(await platform.getClippingRect({\n    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),\n    boundary,\n    rootBoundary,\n    strategy\n  }));\n  const rect = elementContext === 'floating' ? {\n    x,\n    y,\n    width: rects.floating.width,\n    height: rects.floating.height\n  } : rects.reference;\n  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));\n  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {\n    x: 1,\n    y: 1\n  } : {\n    x: 1,\n    y: 1\n  };\n  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  }) : rect);\n  return {\n    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,\n    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,\n    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,\n    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x\n  };\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => ({\n  name: 'arrow',\n  options,\n  async fn(state) {\n    const {\n      x,\n      y,\n      placement,\n      rects,\n      platform,\n      elements,\n      middlewareData\n    } = state;\n    // Since `element` is required, we don't Partial<> the type.\n    const {\n      element,\n      padding = 0\n    } = evaluate(options, state) || {};\n    if (element == null) {\n      return {};\n    }\n    const paddingObject = getPaddingObject(padding);\n    const coords = {\n      x,\n      y\n    };\n    const axis = getAlignmentAxis(placement);\n    const length = getAxisLength(axis);\n    const arrowDimensions = await platform.getDimensions(element);\n    const isYAxis = axis === 'y';\n    const minProp = isYAxis ? 'top' : 'left';\n    const maxProp = isYAxis ? 'bottom' : 'right';\n    const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';\n    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];\n    const startDiff = coords[axis] - rects.reference[axis];\n    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));\n    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;\n\n    // DOM platform can return `window` as the `offsetParent`.\n    if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {\n      clientSize = elements.floating[clientProp] || rects.floating[length];\n    }\n    const centerToReference = endDiff / 2 - startDiff / 2;\n\n    // If the padding is large enough that it causes the arrow to no longer be\n    // centered, modify the padding so that it is centered.\n    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;\n    const minPadding = min(paddingObject[minProp], largestPossiblePadding);\n    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);\n\n    // Make sure the arrow doesn't overflow the floating element if the center\n    // point is outside the floating element's bounds.\n    const min$1 = minPadding;\n    const max = clientSize - arrowDimensions[length] - maxPadding;\n    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;\n    const offset = clamp(min$1, center, max);\n\n    // If the reference is small enough that the arrow's padding causes it to\n    // to point to nothing for an aligned placement, adjust the offset of the\n    // floating element itself. To ensure `shift()` continues to take action,\n    // a single reset is performed when this is true.\n    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;\n    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;\n    return {\n      [axis]: coords[axis] + alignmentOffset,\n      data: {\n        [axis]: offset,\n        centerOffset: center - offset - alignmentOffset,\n        ...(shouldAddOffset && {\n          alignmentOffset\n        })\n      },\n      reset: shouldAddOffset\n    };\n  }\n});\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'flip',\n    options,\n    async fn(state) {\n      var _middlewareData$arrow, _middlewareData$flip;\n      const {\n        placement,\n        middlewareData,\n        rects,\n        initialPlacement,\n        platform,\n        elements\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true,\n        fallbackPlacements: specifiedFallbackPlacements,\n        fallbackStrategy = 'bestFit',\n        fallbackAxisSideDirection = 'none',\n        flipAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n\n      // If a reset by the arrow was caused due to an alignment offset being\n      // added, we should skip any logic now since `flip()` has already done its\n      // work.\n      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643\n      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      const side = getSide(placement);\n      const initialSideAxis = getSideAxis(initialPlacement);\n      const isBasePlacement = getSide(initialPlacement) === initialPlacement;\n      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));\n      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';\n      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {\n        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));\n      }\n      const placements = [initialPlacement, ...fallbackPlacements];\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const overflows = [];\n      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];\n      if (checkMainAxis) {\n        overflows.push(overflow[side]);\n      }\n      if (checkCrossAxis) {\n        const sides = getAlignmentSides(placement, rects, rtl);\n        overflows.push(overflow[sides[0]], overflow[sides[1]]);\n      }\n      overflowsData = [...overflowsData, {\n        placement,\n        overflows\n      }];\n\n      // One or more sides is overflowing.\n      if (!overflows.every(side => side <= 0)) {\n        var _middlewareData$flip2, _overflowsData$filter;\n        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;\n        const nextPlacement = placements[nextIndex];\n        if (nextPlacement) {\n          // Try next placement and re-run the lifecycle.\n          return {\n            data: {\n              index: nextIndex,\n              overflows: overflowsData\n            },\n            reset: {\n              placement: nextPlacement\n            }\n          };\n        }\n\n        // First, find the candidates that fit on the mainAxis side of overflow,\n        // then find the placement that fits the best on the main crossAxis side.\n        let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;\n\n        // Otherwise fallback.\n        if (!resetPlacement) {\n          switch (fallbackStrategy) {\n            case 'bestFit':\n              {\n                var _overflowsData$filter2;\n                const placement = (_overflowsData$filter2 = overflowsData.filter(d => {\n                  if (hasFallbackAxisSideDirection) {\n                    const currentSideAxis = getSideAxis(d.placement);\n                    return currentSideAxis === initialSideAxis ||\n                    // Create a bias to the `y` side axis due to horizontal\n                    // reading directions favoring greater width.\n                    currentSideAxis === 'y';\n                  }\n                  return true;\n                }).map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];\n                if (placement) {\n                  resetPlacement = placement;\n                }\n                break;\n              }\n            case 'initialPlacement':\n              resetPlacement = initialPlacement;\n              break;\n          }\n        }\n        if (placement !== resetPlacement) {\n          return {\n            reset: {\n              placement: resetPlacement\n            }\n          };\n        }\n      }\n      return {};\n    }\n  };\n};\n\nfunction getSideOffsets(overflow, rect) {\n  return {\n    top: overflow.top - rect.height,\n    right: overflow.right - rect.width,\n    bottom: overflow.bottom - rect.height,\n    left: overflow.left - rect.width\n  };\n}\nfunction isAnySideFullyClipped(overflow) {\n  return sides.some(side => overflow[side] >= 0);\n}\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'hide',\n    options,\n    async fn(state) {\n      const {\n        rects\n      } = state;\n      const {\n        strategy = 'referenceHidden',\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      switch (strategy) {\n        case 'referenceHidden':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              elementContext: 'reference'\n            });\n            const offsets = getSideOffsets(overflow, rects.reference);\n            return {\n              data: {\n                referenceHiddenOffsets: offsets,\n                referenceHidden: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        case 'escaped':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              altBoundary: true\n            });\n            const offsets = getSideOffsets(overflow, rects.floating);\n            return {\n              data: {\n                escapedOffsets: offsets,\n                escaped: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        default:\n          {\n            return {};\n          }\n      }\n    }\n  };\n};\n\n// For type backwards-compatibility, the `OffsetOptions` type was also\n// Derivable.\n\nasync function convertValueToCoords(state, options) {\n  const {\n    placement,\n    platform,\n    elements\n  } = state;\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n  const side = getSide(placement);\n  const alignment = getAlignment(placement);\n  const isVertical = getSideAxis(placement) === 'y';\n  const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;\n  const crossAxisMulti = rtl && isVertical ? -1 : 1;\n  const rawValue = evaluate(options, state);\n\n  // eslint-disable-next-line prefer-const\n  let {\n    mainAxis,\n    crossAxis,\n    alignmentAxis\n  } = typeof rawValue === 'number' ? {\n    mainAxis: rawValue,\n    crossAxis: 0,\n    alignmentAxis: null\n  } : {\n    mainAxis: 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 maximumClippingHeight = height - overflow.top - overflow.bottom;\n      const maximumClippingWidth = width - overflow.left - overflow.right;\n      const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);\n      const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);\n      const noShift = !state.middlewareData.shift;\n      let availableHeight = overflowAvailableHeight;\n      let availableWidth = overflowAvailableWidth;\n      if (isYAxis) {\n        availableWidth = alignment || noShift ? min(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;\n      } else {\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, computePosition, detectOverflow, flip, hide, limitShift, offset, rectToClientRect, shift, size };\n//# sourceMappingURL=floating-ui.core.js.map\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 isTopLayer(element) {\n  return [':popover-open', ':modal'].some(selector => {\n    try {\n      return element.matches(selector);\n    } catch (e) {\n      return false;\n    }\n  });\n}\nfunction isContainingBlock(elementOrCss) {\n  const webkit = isWebKit();\n  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));\n}\nfunction getContainingBlock(element) {\n  let currentNode = getParentNode(element);\n  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    if (isContainingBlock(currentNode)) {\n      return currentNode;\n    } else if (isTopLayer(currentNode)) {\n      return null;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  return null;\n}\nfunction isWebKit() {\n  if (typeof CSS === 'undefined' || !CSS.supports) return false;\n  return CSS.supports('-webkit-backdrop-filter', 'none');\n}\nfunction isLastTraversableNode(node) {\n  return ['html', 'body', '#document'].includes(getNodeName(node));\n}\nfunction getComputedStyle(element) {\n  return getWindow(element).getComputedStyle(element);\n}\nfunction getNodeScroll(element) {\n  if (isElement(element)) {\n    return {\n      scrollLeft: element.scrollLeft,\n      scrollTop: element.scrollTop\n    };\n  }\n  return {\n    scrollLeft: element.scrollX,\n    scrollTop: element.scrollY\n  };\n}\nfunction getParentNode(node) {\n  if (getNodeName(node) === 'html') {\n    return node;\n  }\n  const result =\n  // Step into the shadow DOM of the parent of a slotted node.\n  node.assignedSlot ||\n  // DOM Element detected.\n  node.parentNode ||\n  // ShadowRoot detected.\n  isShadowRoot(node) && node.host ||\n  // Fallback.\n  getDocumentElement(node);\n  return isShadowRoot(result) ? result.host : result;\n}\nfunction getNearestOverflowAncestor(node) {\n  const parentNode = getParentNode(node);\n  if (isLastTraversableNode(parentNode)) {\n    return node.ownerDocument ? node.ownerDocument.body : node.body;\n  }\n  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {\n    return parentNode;\n  }\n  return getNearestOverflowAncestor(parentNode);\n}\nfunction getOverflowAncestors(node, list, traverseIframes) {\n  var _node$ownerDocument2;\n  if (list === void 0) {\n    list = [];\n  }\n  if (traverseIframes === void 0) {\n    traverseIframes = true;\n  }\n  const scrollableAncestor = getNearestOverflowAncestor(node);\n  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);\n  const win = getWindow(scrollableAncestor);\n  if (isBody) {\n    const frameElement = getFrameElement(win);\n    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);\n  }\n  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));\n}\nfunction getFrameElement(win) {\n  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;\n}\n\nexport { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isTopLayer, isWebKit };\n//# sourceMappingURL=floating-ui.utils.dom.js.map\n","import { offset as offset$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, computePosition as computePosition$1, arrow as arrow$1, limitShift as limitShift$1 } from '../../../../../@floating-ui_core@1.6.7/node_modules/@floating-ui/core/dist/floating-ui.core.js';\nimport { createCoords, rectToClientRect, round, floor, max, min } from '../../../../../@floating-ui_utils@0.2.7/node_modules/@floating-ui/utils/dist/floating-ui.utils.js';\nimport { getOverflowAncestors, isElement, getWindow, getFrameElement, getComputedStyle, getDocumentElement, isHTMLElement, isWebKit, isTopLayer, getNodeName, isOverflowElement, getNodeScroll, getParentNode, isLastTraversableNode, isTableElement, isContainingBlock, getContainingBlock } from '../../../../../@floating-ui_utils@0.2.7/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js';\n\nfunction getCssDimensions(element) {\n  const css = getComputedStyle(element);\n  // In testing environments, the `width` and `height` properties are empty\n  // strings for SVG elements, returning NaN. Fallback to `0` in this case.\n  let width = parseFloat(css.width) || 0;\n  let height = parseFloat(css.height) || 0;\n  const hasOffset = isHTMLElement(element);\n  const offsetWidth = hasOffset ? element.offsetWidth : width;\n  const offsetHeight = hasOffset ? element.offsetHeight : height;\n  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;\n  if (shouldFallback) {\n    width = offsetWidth;\n    height = offsetHeight;\n  }\n  return {\n    width,\n    height,\n    $: shouldFallback\n  };\n}\n\nfunction unwrapElement(element) {\n  return !isElement(element) ? element.contextElement : element;\n}\n\nfunction getScale(element) {\n  const domElement = unwrapElement(element);\n  if (!isHTMLElement(domElement)) {\n    return createCoords(1);\n  }\n  const rect = domElement.getBoundingClientRect();\n  const {\n    width,\n    height,\n    $\n  } = getCssDimensions(domElement);\n  let x = ($ ? round(rect.width) : rect.width) / width;\n  let y = ($ ? round(rect.height) : rect.height) / height;\n\n  // 0, NaN, or Infinity should always fallback to 1.\n\n  if (!x || !Number.isFinite(x)) {\n    x = 1;\n  }\n  if (!y || !Number.isFinite(y)) {\n    y = 1;\n  }\n  return {\n    x,\n    y\n  };\n}\n\nconst noOffsets = /*#__PURE__*/createCoords(0);\nfunction getVisualOffsets(element) {\n  const win = getWindow(element);\n  if (!isWebKit() || !win.visualViewport) {\n    return noOffsets;\n  }\n  return {\n    x: win.visualViewport.offsetLeft,\n    y: win.visualViewport.offsetTop\n  };\n}\nfunction shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {\n  if (isFixed === void 0) {\n    isFixed = false;\n  }\n  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {\n    return false;\n  }\n  return isFixed;\n}\n\nfunction getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {\n  if (includeScale === void 0) {\n    includeScale = false;\n  }\n  if (isFixedStrategy === void 0) {\n    isFixedStrategy = false;\n  }\n  const clientRect = element.getBoundingClientRect();\n  const domElement = unwrapElement(element);\n  let scale = createCoords(1);\n  if (includeScale) {\n    if (offsetParent) {\n      if (isElement(offsetParent)) {\n        scale = getScale(offsetParent);\n      }\n    } else {\n      scale = getScale(element);\n    }\n  }\n  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);\n  let x = (clientRect.left + visualOffsets.x) / scale.x;\n  let y = (clientRect.top + visualOffsets.y) / scale.y;\n  let width = clientRect.width / scale.x;\n  let height = clientRect.height / scale.y;\n  if (domElement) {\n    const win = getWindow(domElement);\n    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;\n    let currentWin = win;\n    let currentIFrame = getFrameElement(currentWin);\n    while (currentIFrame && offsetParent && offsetWin !== currentWin) {\n      const iframeScale = getScale(currentIFrame);\n      const iframeRect = currentIFrame.getBoundingClientRect();\n      const css = getComputedStyle(currentIFrame);\n      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;\n      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;\n      x *= iframeScale.x;\n      y *= iframeScale.y;\n      width *= iframeScale.x;\n      height *= iframeScale.y;\n      x += left;\n      y += top;\n      currentWin = getWindow(currentIFrame);\n      currentIFrame = getFrameElement(currentWin);\n    }\n  }\n  return rectToClientRect({\n    width,\n    height,\n    x,\n    y\n  });\n}\n\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' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);\n  const clippingAncestors = [...elementClippingAncestors, rootBoundary];\n  const firstClippingAncestor = clippingAncestors[0];\n  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {\n    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);\n    accRect.top = max(rect.top, accRect.top);\n    accRect.right = min(rect.right, accRect.right);\n    accRect.bottom = min(rect.bottom, accRect.bottom);\n    accRect.left = max(rect.left, accRect.left);\n    return accRect;\n  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));\n  return {\n    width: clippingRect.right - clippingRect.left,\n    height: clippingRect.bottom - clippingRect.top,\n    x: clippingRect.left,\n    y: clippingRect.top\n  };\n}\n\nfunction getDimensions(element) {\n  const {\n    width,\n    height\n  } = getCssDimensions(element);\n  return {\n    width,\n    height\n  };\n}\n\nfunction getRectRelativeToOffsetParent(element, offsetParent, strategy) {\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n  const isFixed = strategy === 'fixed';\n  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  const offsets = createCoords(0);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isOffsetParentAnElement) {\n      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    } else if (documentElement) {\n      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 isStaticPositioned(element) {\n  return getComputedStyle(element).position === 'static';\n}\n\nfunction getTrueOffsetParent(element, polyfill) {\n  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {\n    return null;\n  }\n  if (polyfill) {\n    return polyfill(element);\n  }\n  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 win = getWindow(element);\n  if (isTopLayer(element)) {\n    return win;\n  }\n  if (!isHTMLElement(element)) {\n    let svgOffsetParent = getParentNode(element);\n    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {\n      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {\n        return svgOffsetParent;\n      }\n      svgOffsetParent = getParentNode(svgOffsetParent);\n    }\n    return win;\n  }\n  let offsetParent = getTrueOffsetParent(element, polyfill);\n  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {\n    offsetParent = getTrueOffsetParent(offsetParent, polyfill);\n  }\n  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {\n    return win;\n  }\n  return offsetParent || getContainingBlock(element) || win;\n}\n\nconst getElementRects = async function (data) {\n  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;\n  const getDimensionsFn = this.getDimensions;\n  const floatingDimensions = await getDimensionsFn(data.floating);\n  return {\n    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),\n    floating: {\n      x: 0,\n      y: 0,\n      width: floatingDimensions.width,\n      height: floatingDimensions.height\n    }\n  };\n};\n\nfunction isRTL(element) {\n  return getComputedStyle(element).direction === 'rtl';\n}\n\nconst platform = {\n  convertOffsetParentRelativeRectToViewportRelativeRect,\n  getDocumentElement,\n  getClippingRect,\n  getOffsetParent,\n  getElementRects,\n  getClientRects,\n  getDimensions,\n  getScale,\n  isElement,\n  isRTL\n};\n\n// https://samthor.au/2021/observing-dom/\nfunction observeMove(element, onMove) {\n  let io = null;\n  let timeoutId;\n  const root = getDocumentElement(element);\n  function cleanup() {\n    var _io;\n    clearTimeout(timeoutId);\n    (_io = io) == null || _io.disconnect();\n    io = null;\n  }\n  function refresh(skip, threshold) {\n    if (skip === void 0) {\n      skip = false;\n    }\n    if (threshold === void 0) {\n      threshold = 1;\n    }\n    cleanup();\n    const {\n      left,\n      top,\n      width,\n      height\n    } = element.getBoundingClientRect();\n    if (!skip) {\n      onMove();\n    }\n    if (!width || !height) {\n      return;\n    }\n    const insetTop = floor(top);\n    const insetRight = floor(root.clientWidth - (left + width));\n    const insetBottom = floor(root.clientHeight - (top + height));\n    const insetLeft = floor(left);\n    const rootMargin = -insetTop + \"px \" + -insetRight + \"px \" + -insetBottom + \"px \" + -insetLeft + \"px\";\n    const options = {\n      rootMargin,\n      threshold: max(0, min(1, threshold)) || 1\n    };\n    let isFirstUpdate = true;\n    function handleObserve(entries) {\n      const ratio = entries[0].intersectionRatio;\n      if (ratio !== threshold) {\n        if (!isFirstUpdate) {\n          return refresh();\n        }\n        if (!ratio) {\n          // If the reference is clipped, the ratio is 0. Throttle the refresh\n          // to prevent an infinite loop of updates.\n          timeoutId = setTimeout(() => {\n            refresh(false, 1e-7);\n          }, 1000);\n        } else {\n          refresh(false, ratio);\n        }\n      }\n      isFirstUpdate = false;\n    }\n\n    // Older browsers don't support a `document` as the root and will throw an\n    // error.\n    try {\n      io = new IntersectionObserver(handleObserve, {\n        ...options,\n        // Handle <iframe>s\n        root: root.ownerDocument\n      });\n    } catch (e) {\n      io = new IntersectionObserver(handleObserve, options);\n    }\n    io.observe(element);\n  }\n  refresh(true);\n  return cleanup;\n}\n\n/**\n * Automatically updates the position of the floating element when necessary.\n * Should only be called when the floating element is mounted on the DOM or\n * visible on the screen.\n * @returns cleanup function that should be invoked when the floating element is\n * removed from the DOM or hidden from the screen.\n * @see https://floating-ui.com/docs/autoUpdate\n */\nfunction autoUpdate(reference, floating, update, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    ancestorScroll = true,\n    ancestorResize = true,\n    elementResize = typeof ResizeObserver === 'function',\n    layoutShift = typeof IntersectionObserver === 'function',\n    animationFrame = false\n  } = options;\n  const referenceEl = unwrapElement(reference);\n  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];\n  ancestors.forEach(ancestor => {\n    ancestorScroll && ancestor.addEventListener('scroll', update, {\n      passive: true\n    });\n    ancestorResize && ancestor.addEventListener('resize', update);\n  });\n  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;\n  let reobserveFrame = -1;\n  let resizeObserver = null;\n  if (elementResize) {\n    resizeObserver = new ResizeObserver(_ref => {\n      let [firstEntry] = _ref;\n      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {\n        // Prevent update loops when using the `size` middleware.\n        // https://github.com/floating-ui/floating-ui/issues/1740\n        resizeObserver.unobserve(floating);\n        cancelAnimationFrame(reobserveFrame);\n        reobserveFrame = requestAnimationFrame(() => {\n          var _resizeObserver;\n          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);\n        });\n      }\n      update();\n    });\n    if (referenceEl && !animationFrame) {\n      resizeObserver.observe(referenceEl);\n    }\n    resizeObserver.observe(floating);\n  }\n  let frameId;\n  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;\n  if (animationFrame) {\n    frameLoop();\n  }\n  function frameLoop() {\n    const nextRefRect = getBoundingClientRect(reference);\n    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {\n      update();\n    }\n    prevRefRect = nextRefRect;\n    frameId = requestAnimationFrame(frameLoop);\n  }\n  update();\n  return () => {\n    var _resizeObserver2;\n    ancestors.forEach(ancestor => {\n      ancestorScroll && ancestor.removeEventListener('scroll', update);\n      ancestorResize && ancestor.removeEventListener('resize', update);\n    });\n    cleanupIo == null || cleanupIo();\n    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();\n    resizeObserver = null;\n    if (animationFrame) {\n      cancelAnimationFrame(frameId);\n    }\n  };\n}\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = offset$1;\n\n/**\n * Optimizes the visibility of the floating element by 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 * 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, autoUpdate, computePosition, flip, getOverflowAncestors, hide, limitShift, offset, platform, shift, size };\n//# sourceMappingURL=floating-ui.dom.js.map\n","import { computePosition, offset as offset$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, arrow as arrow$2, limitShift as limitShift$1 } from '../../../../../@floating-ui_dom@1.6.10/node_modules/@floating-ui/dom/dist/floating-ui.dom.js';\nexport { autoUpdate, platform } from '../../../../../@floating-ui_dom@1.6.10/node_modules/@floating-ui/dom/dist/floating-ui.dom.js';\nimport * as React from 'react';\nimport { useLayoutEffect, useEffect } from 'react';\nimport * as ReactDOM from 'react-dom';\n\nvar index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\n\n// Fork of `fast-deep-equal` that only does the comparisons we need and compares\n// functions\nfunction deepEqual(a, b) {\n  if (a === b) {\n    return true;\n  }\n  if (typeof a !== typeof b) {\n    return false;\n  }\n  if (typeof a === 'function' && a.toString() === b.toString()) {\n    return true;\n  }\n  let length;\n  let i;\n  let keys;\n  if (a && b && typeof a === 'object') {\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length !== b.length) return false;\n      for (i = length; i-- !== 0;) {\n        if (!deepEqual(a[i], b[i])) {\n          return false;\n        }\n      }\n      return true;\n    }\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) {\n      return false;\n    }\n    for (i = length; i-- !== 0;) {\n      if (!{}.hasOwnProperty.call(b, keys[i])) {\n        return false;\n      }\n    }\n    for (i = length; i-- !== 0;) {\n      const key = keys[i];\n      if (key === '_owner' && a.$$typeof) {\n        continue;\n      }\n      if (!deepEqual(a[key], b[key])) {\n        return false;\n      }\n    }\n    return true;\n  }\n  return a !== a && b !== b;\n}\n\nfunction getDPR(element) {\n  if (typeof window === 'undefined') {\n    return 1;\n  }\n  const win = element.ownerDocument.defaultView || window;\n  return win.devicePixelRatio || 1;\n}\n\nfunction roundByDPR(element, value) {\n  const dpr = getDPR(element);\n  return Math.round(value * dpr) / dpr;\n}\n\nfunction useLatestRef(value) {\n  const ref = React.useRef(value);\n  index(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n\n/**\n * Provides data to position a floating element.\n * @see https://floating-ui.com/docs/useFloating\n */\nfunction useFloating(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform,\n    elements: {\n      reference: externalReference,\n      floating: externalFloating\n    } = {},\n    transform = true,\n    whileElementsMounted,\n    open\n  } = options;\n  const [data, setData] = React.useState({\n    x: 0,\n    y: 0,\n    strategy,\n    placement,\n    middlewareData: {},\n    isPositioned: false\n  });\n  const [latestMiddleware, setLatestMiddleware] = React.useState(middleware);\n  if (!deepEqual(latestMiddleware, middleware)) {\n    setLatestMiddleware(middleware);\n  }\n  const [_reference, _setReference] = React.useState(null);\n  const [_floating, _setFloating] = React.useState(null);\n  const setReference = React.useCallback(node => {\n    if (node !== referenceRef.current) {\n      referenceRef.current = node;\n      _setReference(node);\n    }\n  }, []);\n  const setFloating = React.useCallback(node => {\n    if (node !== floatingRef.current) {\n      floatingRef.current = node;\n      _setFloating(node);\n    }\n  }, []);\n  const referenceEl = externalReference || _reference;\n  const floatingEl = externalFloating || _floating;\n  const referenceRef = React.useRef(null);\n  const floatingRef = React.useRef(null);\n  const dataRef = React.useRef(data);\n  const hasWhileElementsMounted = whileElementsMounted != null;\n  const whileElementsMountedRef = useLatestRef(whileElementsMounted);\n  const platformRef = useLatestRef(platform);\n  const update = React.useCallback(() => {\n    if (!referenceRef.current || !floatingRef.current) {\n      return;\n    }\n    const config = {\n      placement,\n      strategy,\n      middleware: latestMiddleware\n    };\n    if (platformRef.current) {\n      config.platform = platformRef.current;\n    }\n    computePosition(referenceRef.current, floatingRef.current, config).then(data => {\n      const fullData = {\n        ...data,\n        isPositioned: true\n      };\n      if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {\n        dataRef.current = fullData;\n        ReactDOM.flushSync(() => {\n          setData(fullData);\n        });\n      }\n    });\n  }, [latestMiddleware, placement, strategy, platformRef]);\n  index(() => {\n    if (open === false && dataRef.current.isPositioned) {\n      dataRef.current.isPositioned = false;\n      setData(data => ({\n        ...data,\n        isPositioned: false\n      }));\n    }\n  }, [open]);\n  const isMountedRef = React.useRef(false);\n  index(() => {\n    isMountedRef.current = true;\n    return () => {\n      isMountedRef.current = false;\n    };\n  }, []);\n  index(() => {\n    if (referenceEl) referenceRef.current = referenceEl;\n    if (floatingEl) floatingRef.current = floatingEl;\n    if (referenceEl && floatingEl) {\n      if (whileElementsMountedRef.current) {\n        return whileElementsMountedRef.current(referenceEl, floatingEl, update);\n      }\n      update();\n    }\n  }, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);\n  const refs = React.useMemo(() => ({\n    reference: referenceRef,\n    floating: floatingRef,\n    setReference,\n    setFloating\n  }), [setReference, setFloating]);\n  const elements = React.useMemo(() => ({\n    reference: referenceEl,\n    floating: floatingEl\n  }), [referenceEl, floatingEl]);\n  const floatingStyles = React.useMemo(() => {\n    const initialStyles = {\n      position: strategy,\n      left: 0,\n      top: 0\n    };\n    if (!elements.floating) {\n      return initialStyles;\n    }\n    const x = roundByDPR(elements.floating, data.x);\n    const y = roundByDPR(elements.floating, data.y);\n    if (transform) {\n      return {\n        ...initialStyles,\n        transform: \"translate(\" + x + \"px, \" + y + \"px)\",\n        ...(getDPR(elements.floating) >= 1.5 && {\n          willChange: 'transform'\n        })\n      };\n    }\n    return {\n      position: strategy,\n      left: x,\n      top: y\n    };\n  }, [strategy, transform, elements.floating, data.x, data.y]);\n  return React.useMemo(() => ({\n    ...data,\n    update,\n    refs,\n    elements,\n    floatingStyles\n  }), [data, update, refs, elements, floatingStyles]);\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * This wraps the core `arrow` middleware to allow React refs as the element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow$1 = options => {\n  function isRef(value) {\n    return {}.hasOwnProperty.call(value, 'current');\n  }\n  return {\n    name: 'arrow',\n    options,\n    fn(state) {\n      const {\n        element,\n        padding\n      } = typeof options === 'function' ? options(state) : options;\n      if (element && isRef(element)) {\n        if (element.current != null) {\n          return arrow$2({\n            element: element.current,\n            padding\n          }).fn(state);\n        }\n        return {};\n      }\n      if (element) {\n        return arrow$2({\n          element,\n          padding\n        }).fn(state);\n      }\n      return {};\n    }\n  };\n};\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = (options, deps) => ({\n  ...offset$1(options),\n  options: [options, deps]\n});\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = (options, deps) => ({\n  ...shift$1(options),\n  options: [options, deps]\n});\n\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = (options, deps) => ({\n  ...limitShift$1(options),\n  options: [options, deps]\n});\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = (options, deps) => ({\n  ...flip$1(options),\n  options: [options, deps]\n});\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = (options, deps) => ({\n  ...size$1(options),\n  options: [options, deps]\n});\n\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = (options, deps) => ({\n  ...hide$1(options),\n  options: [options, deps]\n});\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * This wraps the core `arrow` middleware to allow React refs as the element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = (options, deps) => ({\n  ...arrow$1(options),\n  options: [options, deps]\n});\n\nexport { arrow, computePosition, flip, hide, limitShift, offset, shift, size, useFloating };\n//# sourceMappingURL=floating-ui.react-dom.js.map\n","import * as React from 'react';\nimport { Primitive } from '../../../../../@radix-ui_react-primitive@2.0.0_@types_react@18.3.5_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@radix-ui/react-primitive/dist/index.js';\nimport { jsx } from 'react/jsx-runtime';\n\n// packages/react/arrow/src/Arrow.tsx\nvar NAME = \"Arrow\";\nvar Arrow = React.forwardRef((props, forwardedRef) => {\n  const { children, width = 10, height = 5, ...arrowProps } = props;\n  return /* @__PURE__ */ jsx(\n    Primitive.svg,\n    {\n      ...arrowProps,\n      ref: forwardedRef,\n      width,\n      height,\n      viewBox: \"0 0 30 10\",\n      preserveAspectRatio: \"none\",\n      children: props.asChild ? children : /* @__PURE__ */ jsx(\"polygon\", { points: \"0,0 30,0 15,10\" })\n    }\n  );\n});\nArrow.displayName = NAME;\nvar Root = Arrow;\n\nexport { Arrow, Root };\n//# sourceMappingURL=index.js.map\n","import * as React from 'react';\nimport { useFloating, offset, shift, flip, size, arrow, hide, limitShift } from '../../../../../@floating-ui_react-dom@2.1.1_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.js';\nimport { Root } from '../../../../../@radix-ui_react-arrow@1.1.0_@types_react@18.3.5_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@radix-ui/react-arrow/dist/index.js';\nimport { useComposedRefs } from '../../../../../@radix-ui_react-compose-refs@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-compose-refs/dist/index.js';\nimport { createContextScope } from '../../../../../@radix-ui_react-context@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-context/dist/index.js';\nimport { Primitive } from '../../../../../@radix-ui_react-primitive@2.0.0_@types_react@18.3.5_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@radix-ui/react-primitive/dist/index.js';\nimport { useCallbackRef } from '../../../../../@radix-ui_react-use-callback-ref@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-use-callback-ref/dist/index.js';\nimport { useLayoutEffect as useLayoutEffect2 } from '../../../../../@radix-ui_react-use-layout-effect@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-use-layout-effect/dist/index.js';\nimport { useSize } from '../../../../../@radix-ui_react-use-size@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-use-size/dist/index.js';\nimport { jsx } from 'react/jsx-runtime';\nimport { autoUpdate } from '../../../../../@floating-ui_dom@1.6.10/node_modules/@floating-ui/dom/dist/floating-ui.dom.js';\n\nvar POPPER_NAME = \"Popper\";\nvar [createPopperContext, createPopperScope] = createContextScope(POPPER_NAME);\nvar [PopperProvider, usePopperContext] = createPopperContext(POPPER_NAME);\nvar Popper = (props) => {\n  const { __scopePopper, children } = props;\n  const [anchor, setAnchor] = React.useState(null);\n  return /* @__PURE__ */ jsx(PopperProvider, { scope: __scopePopper, anchor, onAnchorChange: setAnchor, children });\n};\nPopper.displayName = POPPER_NAME;\nvar ANCHOR_NAME = \"PopperAnchor\";\nvar PopperAnchor = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopePopper, virtualRef, ...anchorProps } = props;\n    const context = usePopperContext(ANCHOR_NAME, __scopePopper);\n    const ref = React.useRef(null);\n    const composedRefs = useComposedRefs(forwardedRef, ref);\n    React.useEffect(() => {\n      context.onAnchorChange(virtualRef?.current || ref.current);\n    });\n    return virtualRef ? null : /* @__PURE__ */ jsx(Primitive.div, { ...anchorProps, ref: composedRefs });\n  }\n);\nPopperAnchor.displayName = ANCHOR_NAME;\nvar CONTENT_NAME = \"PopperContent\";\nvar [PopperContentProvider, useContentContext] = createPopperContext(CONTENT_NAME);\nvar PopperContent = React.forwardRef(\n  (props, forwardedRef) => {\n    const {\n      __scopePopper,\n      side = \"bottom\",\n      sideOffset = 0,\n      align = \"center\",\n      alignOffset = 0,\n      arrowPadding = 0,\n      avoidCollisions = true,\n      collisionBoundary = [],\n      collisionPadding: collisionPaddingProp = 0,\n      sticky = \"partial\",\n      hideWhenDetached = false,\n      updatePositionStrategy = \"optimized\",\n      onPlaced,\n      ...contentProps\n    } = props;\n    const context = usePopperContext(CONTENT_NAME, __scopePopper);\n    const [content, setContent] = React.useState(null);\n    const composedRefs = useComposedRefs(forwardedRef, (node) => setContent(node));\n    const [arrow$1, setArrow] = React.useState(null);\n    const arrowSize = useSize(arrow$1);\n    const arrowWidth = arrowSize?.width ?? 0;\n    const arrowHeight = arrowSize?.height ?? 0;\n    const desiredPlacement = side + (align !== \"center\" ? \"-\" + align : \"\");\n    const collisionPadding = typeof collisionPaddingProp === \"number\" ? collisionPaddingProp : { top: 0, right: 0, bottom: 0, left: 0, ...collisionPaddingProp };\n    const boundary = Array.isArray(collisionBoundary) ? collisionBoundary : [collisionBoundary];\n    const hasExplicitBoundaries = boundary.length > 0;\n    const detectOverflowOptions = {\n      padding: collisionPadding,\n      boundary: boundary.filter(isNotNull),\n      // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries\n      altBoundary: hasExplicitBoundaries\n    };\n    const { refs, floatingStyles, placement, isPositioned, middlewareData } = 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 = autoUpdate(...args, {\n          animationFrame: updatePositionStrategy === \"always\"\n        });\n        return cleanup;\n      },\n      elements: {\n        reference: context.anchor\n      },\n      middleware: [\n        offset({ mainAxis: sideOffset + arrowHeight, alignmentAxis: alignOffset }),\n        avoidCollisions && shift({\n          mainAxis: true,\n          crossAxis: false,\n          limiter: sticky === \"partial\" ? limitShift() : void 0,\n          ...detectOverflowOptions\n        }),\n        avoidCollisions && flip({ ...detectOverflowOptions }),\n        size({\n          ...detectOverflowOptions,\n          apply: ({ elements, rects, availableWidth, 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$1 && arrow({ element: arrow$1, padding: arrowPadding }),\n        transformOrigin({ arrowWidth, arrowHeight }),\n        hideWhenDetached && hide({ strategy: \"referenceHidden\", ...detectOverflowOptions })\n      ]\n    });\n    const [placedSide, placedAlign] = getSideAndAlignFromPlacement(placement);\n    const handlePlaced = useCallbackRef(onPlaced);\n    useLayoutEffect2(() => {\n      if (isPositioned) {\n        handlePlaced?.();\n      }\n    }, [isPositioned, handlePlaced]);\n    const arrowX = middlewareData.arrow?.x;\n    const arrowY = middlewareData.arrow?.y;\n    const cannotCenterArrow = middlewareData.arrow?.centerOffset !== 0;\n    const [contentZIndex, setContentZIndex] = React.useState();\n    useLayoutEffect2(() => {\n      if (content) setContentZIndex(window.getComputedStyle(content).zIndex);\n    }, [content]);\n    return /* @__PURE__ */ jsx(\n      \"div\",\n      {\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.transformOrigin?.x,\n            middlewareData.transformOrigin?.y\n          ].join(\" \"),\n          // hide the content if using the hide middleware and should be hidden\n          // set visibility to hidden and disable pointer events so the UI behaves\n          // as if the PopperContent isn't there at all\n          ...middlewareData.hide?.referenceHidden && {\n            visibility: \"hidden\",\n            pointerEvents: \"none\"\n          }\n        },\n        dir: props.dir,\n        children: /* @__PURE__ */ jsx(\n          PopperContentProvider,\n          {\n            scope: __scopePopper,\n            placedSide,\n            onArrowChange: setArrow,\n            arrowX,\n            arrowY,\n            shouldHideArrow: cannotCenterArrow,\n            children: /* @__PURE__ */ jsx(\n              Primitive.div,\n              {\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\" : void 0\n                }\n              }\n            )\n          }\n        )\n      }\n    );\n  }\n);\nPopperContent.displayName = CONTENT_NAME;\nvar ARROW_NAME = \"PopperArrow\";\nvar OPPOSITE_SIDE = {\n  top: \"bottom\",\n  right: \"left\",\n  bottom: \"top\",\n  left: \"right\"\n};\nvar PopperArrow = React.forwardRef(function PopperArrow2(props, forwardedRef) {\n  const { __scopePopper, ...arrowProps } = props;\n  const contentContext = useContentContext(ARROW_NAME, __scopePopper);\n  const baseSide = OPPOSITE_SIDE[contentContext.placedSide];\n  return (\n    // 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    /* @__PURE__ */ jsx(\n      \"span\",\n      {\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\" : void 0\n        },\n        children: /* @__PURE__ */ jsx(\n          Root,\n          {\n            ...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      }\n    )\n  );\n});\nPopperArrow.displayName = ARROW_NAME;\nfunction isNotNull(value) {\n  return value !== null;\n}\nvar transformOrigin = (options) => ({\n  name: \"transformOrigin\",\n  options,\n  fn(data) {\n    const { placement, rects, middlewareData } = data;\n    const cannotCenterArrow = middlewareData.arrow?.centerOffset !== 0;\n    const isArrowHidden = cannotCenterArrow;\n    const arrowWidth = isArrowHidden ? 0 : options.arrowWidth;\n    const arrowHeight = isArrowHidden ? 0 : options.arrowHeight;\n    const [placedSide, placedAlign] = getSideAndAlignFromPlacement(placement);\n    const noArrowAlign = { start: \"0%\", center: \"50%\", end: \"100%\" }[placedAlign];\n    const arrowXCenter = (middlewareData.arrow?.x ?? 0) + arrowWidth / 2;\n    const arrowYCenter = (middlewareData.arrow?.y ?? 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 { data: { x, y } };\n  }\n});\nfunction getSideAndAlignFromPlacement(placement) {\n  const [side, align = \"center\"] = placement.split(\"-\");\n  return [side, align];\n}\nvar Root2 = Popper;\nvar Anchor = PopperAnchor;\nvar Content = PopperContent;\nvar Arrow = PopperArrow;\n\nexport { Anchor, Arrow, Content, Popper, PopperAnchor, PopperArrow, PopperContent, Root2 as Root, createPopperScope };\n//# sourceMappingURL=index.js.map\n","import * as React from 'react';\nimport ReactDOM__default from 'react-dom';\nimport { Primitive } from '../../../../../@radix-ui_react-primitive@2.0.0_@types_react@18.3.5_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@radix-ui/react-primitive/dist/index.js';\nimport { useLayoutEffect as useLayoutEffect2 } from '../../../../../@radix-ui_react-use-layout-effect@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-use-layout-effect/dist/index.js';\nimport { jsx } from 'react/jsx-runtime';\n\nvar PORTAL_NAME = \"Portal\";\nvar Portal = React.forwardRef((props, forwardedRef) => {\n  const { container: containerProp, ...portalProps } = props;\n  const [mounted, setMounted] = React.useState(false);\n  useLayoutEffect2(() => setMounted(true), []);\n  const container = containerProp || mounted && globalThis?.document?.body;\n  return container ? ReactDOM__default.createPortal(/* @__PURE__ */ jsx(Primitive.div, { ...portalProps, ref: forwardedRef }), container) : null;\n});\nPortal.displayName = PORTAL_NAME;\n\nexport { Portal };\n//# sourceMappingURL=index.js.map\n","import * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { useComposedRefs } from '../../../../../@radix-ui_react-compose-refs@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-compose-refs/dist/index.js';\nimport { useLayoutEffect as useLayoutEffect2 } from '../../../../../@radix-ui_react-use-layout-effect@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-use-layout-effect/dist/index.js';\n\nfunction useStateMachine(initialState, machine) {\n  return React.useReducer((state, event) => {\n    const nextState = machine[state][event];\n    return nextState ?? state;\n  }, initialState);\n}\n\n// packages/react/presence/src/Presence.tsx\nvar Presence = (props) => {\n  const { present, children } = props;\n  const presence = usePresence(present);\n  const child = typeof children === \"function\" ? children({ present: presence.isPresent }) : React.Children.only(children);\n  const ref = useComposedRefs(presence.ref, getElementRef(child));\n  const forceMount = typeof children === \"function\";\n  return forceMount || presence.isPresent ? React.cloneElement(child, { ref }) : null;\n};\nPresence.displayName = \"Presence\";\nfunction usePresence(present) {\n  const [node, setNode] = React.useState();\n  const stylesRef = React.useRef({});\n  const prevPresentRef = React.useRef(present);\n  const prevAnimationNameRef = React.useRef(\"none\");\n  const initialState = present ? \"mounted\" : \"unmounted\";\n  const [state, send] = useStateMachine(initialState, {\n    mounted: {\n      UNMOUNT: \"unmounted\",\n      ANIMATION_OUT: \"unmountSuspended\"\n    },\n    unmountSuspended: {\n      MOUNT: \"mounted\",\n      ANIMATION_END: \"unmounted\"\n    },\n    unmounted: {\n      MOUNT: \"mounted\"\n    }\n  });\n  React.useEffect(() => {\n    const currentAnimationName = getAnimationName(stylesRef.current);\n    prevAnimationNameRef.current = state === \"mounted\" ? currentAnimationName : \"none\";\n  }, [state]);\n  useLayoutEffect2(() => {\n    const styles = stylesRef.current;\n    const wasPresent = prevPresentRef.current;\n    const hasPresentChanged = wasPresent !== present;\n    if (hasPresentChanged) {\n      const prevAnimationName = prevAnimationNameRef.current;\n      const currentAnimationName = getAnimationName(styles);\n      if (present) {\n        send(\"MOUNT\");\n      } else if (currentAnimationName === \"none\" || styles?.display === \"none\") {\n        send(\"UNMOUNT\");\n      } else {\n        const isAnimating = prevAnimationName !== currentAnimationName;\n        if (wasPresent && isAnimating) {\n          send(\"ANIMATION_OUT\");\n        } else {\n          send(\"UNMOUNT\");\n        }\n      }\n      prevPresentRef.current = present;\n    }\n  }, [present, send]);\n  useLayoutEffect2(() => {\n    if (node) {\n      const handleAnimationEnd = (event) => {\n        const currentAnimationName = getAnimationName(stylesRef.current);\n        const isCurrentAnimation = currentAnimationName.includes(event.animationName);\n        if (event.target === node && isCurrentAnimation) {\n          ReactDOM.flushSync(() => send(\"ANIMATION_END\"));\n        }\n      };\n      const handleAnimationStart = (event) => {\n        if (event.target === node) {\n          prevAnimationNameRef.current = getAnimationName(stylesRef.current);\n        }\n      };\n      node.addEventListener(\"animationstart\", handleAnimationStart);\n      node.addEventListener(\"animationcancel\", handleAnimationEnd);\n      node.addEventListener(\"animationend\", handleAnimationEnd);\n      return () => {\n        node.removeEventListener(\"animationstart\", handleAnimationStart);\n        node.removeEventListener(\"animationcancel\", handleAnimationEnd);\n        node.removeEventListener(\"animationend\", handleAnimationEnd);\n      };\n    } else {\n      send(\"ANIMATION_END\");\n    }\n  }, [node, send]);\n  return {\n    isPresent: [\"mounted\", \"unmountSuspended\"].includes(state),\n    ref: React.useCallback((node2) => {\n      if (node2) stylesRef.current = getComputedStyle(node2);\n      setNode(node2);\n    }, [])\n  };\n}\nfunction getAnimationName(styles) {\n  return styles?.animationName || \"none\";\n}\nfunction getElementRef(element) {\n  let getter = Object.getOwnPropertyDescriptor(element.props, \"ref\")?.get;\n  let mayWarn = getter && \"isReactWarning\" in getter && getter.isReactWarning;\n  if (mayWarn) {\n    return element.ref;\n  }\n  getter = Object.getOwnPropertyDescriptor(element, \"ref\")?.get;\n  mayWarn = getter && \"isReactWarning\" in getter && getter.isReactWarning;\n  if (mayWarn) {\n    return element.props.ref;\n  }\n  return element.props.ref || element.ref;\n}\n\nexport { Presence };\n//# sourceMappingURL=index.js.map\n","import * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { Slot } from '../../../../../@radix-ui_react-slot@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-slot/dist/index.js';\nimport { jsx } from 'react/jsx-runtime';\n\n// packages/react/primitive/src/Primitive.tsx\nvar NODES = [\n  \"a\",\n  \"button\",\n  \"div\",\n  \"form\",\n  \"h2\",\n  \"h3\",\n  \"img\",\n  \"input\",\n  \"label\",\n  \"li\",\n  \"nav\",\n  \"ol\",\n  \"p\",\n  \"span\",\n  \"svg\",\n  \"ul\"\n];\nvar Primitive = NODES.reduce((primitive, node) => {\n  const Node = React.forwardRef((props, forwardedRef) => {\n    const { asChild, ...primitiveProps } = props;\n    const Comp = asChild ? Slot : node;\n    if (typeof window !== \"undefined\") {\n      window[Symbol.for(\"radix-ui\")] = true;\n    }\n    return /* @__PURE__ */ jsx(Comp, { ...primitiveProps, ref: forwardedRef });\n  });\n  Node.displayName = `Primitive.${node}`;\n  return { ...primitive, [node]: Node };\n}, {});\nfunction dispatchDiscreteCustomEvent(target, event) {\n  if (target) ReactDOM.flushSync(() => target.dispatchEvent(event));\n}\n\nexport { Primitive, dispatchDiscreteCustomEvent };\n//# sourceMappingURL=index.js.map\n","import * as React from 'react';\nimport { composeRefs } from '../../../../../@radix-ui_react-compose-refs@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-compose-refs/dist/index.js';\nimport { jsx, Fragment } from 'react/jsx-runtime';\n\n// packages/react/slot/src/Slot.tsx\nvar Slot = React.forwardRef((props, forwardedRef) => {\n  const { children, ...slotProps } = props;\n  const childrenArray = React.Children.toArray(children);\n  const slottable = childrenArray.find(isSlottable);\n  if (slottable) {\n    const newElement = slottable.props.children;\n    const newChildren = childrenArray.map((child) => {\n      if (child === slottable) {\n        if (React.Children.count(newElement) > 1) return React.Children.only(null);\n        return React.isValidElement(newElement) ? newElement.props.children : null;\n      } else {\n        return child;\n      }\n    });\n    return /* @__PURE__ */ jsx(SlotClone, { ...slotProps, ref: forwardedRef, children: React.isValidElement(newElement) ? React.cloneElement(newElement, void 0, newChildren) : null });\n  }\n  return /* @__PURE__ */ jsx(SlotClone, { ...slotProps, ref: forwardedRef, children });\n});\nSlot.displayName = \"Slot\";\nvar SlotClone = React.forwardRef((props, forwardedRef) => {\n  const { children, ...slotProps } = props;\n  if (React.isValidElement(children)) {\n    const childrenRef = getElementRef(children);\n    return React.cloneElement(children, {\n      ...mergeProps(slotProps, children.props),\n      // @ts-ignore\n      ref: forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef\n    });\n  }\n  return React.Children.count(children) > 1 ? React.Children.only(null) : null;\n});\nSlotClone.displayName = \"SlotClone\";\nvar Slottable = ({ children }) => {\n  return /* @__PURE__ */ jsx(Fragment, { children });\n};\nfunction isSlottable(child) {\n  return React.isValidElement(child) && child.type === Slottable;\n}\nfunction mergeProps(slotProps, childProps) {\n  const overrideProps = { ...childProps };\n  for (const propName in childProps) {\n    const slotPropValue = slotProps[propName];\n    const childPropValue = childProps[propName];\n    const isHandler = /^on[A-Z]/.test(propName);\n    if (isHandler) {\n      if (slotPropValue && childPropValue) {\n        overrideProps[propName] = (...args) => {\n          childPropValue(...args);\n          slotPropValue(...args);\n        };\n      } else if (slotPropValue) {\n        overrideProps[propName] = slotPropValue;\n      }\n    } else if (propName === \"style\") {\n      overrideProps[propName] = { ...slotPropValue, ...childPropValue };\n    } else if (propName === \"className\") {\n      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(\" \");\n    }\n  }\n  return { ...slotProps, ...overrideProps };\n}\nfunction getElementRef(element) {\n  let getter = Object.getOwnPropertyDescriptor(element.props, \"ref\")?.get;\n  let mayWarn = getter && \"isReactWarning\" in getter && getter.isReactWarning;\n  if (mayWarn) {\n    return element.ref;\n  }\n  getter = Object.getOwnPropertyDescriptor(element, \"ref\")?.get;\n  mayWarn = getter && \"isReactWarning\" in getter && getter.isReactWarning;\n  if (mayWarn) {\n    return element.props.ref;\n  }\n  return element.props.ref || element.ref;\n}\n\nexport { Slot, Slottable };\n//# sourceMappingURL=index.js.map\n","import * as React from 'react';\n\n// packages/react/use-callback-ref/src/useCallbackRef.tsx\nfunction useCallbackRef(callback) {\n  const callbackRef = React.useRef(callback);\n  React.useEffect(() => {\n    callbackRef.current = callback;\n  });\n  return React.useMemo(() => (...args) => callbackRef.current?.(...args), []);\n}\n\nexport { useCallbackRef };\n//# sourceMappingURL=index.js.map\n","import * as React from 'react';\nimport { useCallbackRef } from '../../../../../@radix-ui_react-use-callback-ref@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-use-callback-ref/dist/index.js';\n\n// packages/react/use-controllable-state/src/useControllableState.tsx\nfunction useControllableState({\n  prop,\n  defaultProp,\n  onChange = () => {\n  }\n}) {\n  const [uncontrolledProp, setUncontrolledProp] = useUncontrolledState({ defaultProp, onChange });\n  const isControlled = prop !== void 0;\n  const value = isControlled ? prop : uncontrolledProp;\n  const handleChange = useCallbackRef(onChange);\n  const setValue = React.useCallback(\n    (nextValue) => {\n      if (isControlled) {\n        const setter = nextValue;\n        const value2 = typeof nextValue === \"function\" ? setter(prop) : nextValue;\n        if (value2 !== prop) handleChange(value2);\n      } else {\n        setUncontrolledProp(nextValue);\n      }\n    },\n    [isControlled, prop, setUncontrolledProp, handleChange]\n  );\n  return [value, setValue];\n}\nfunction useUncontrolledState({\n  defaultProp,\n  onChange\n}) {\n  const uncontrolledState = React.useState(defaultProp);\n  const [value] = uncontrolledState;\n  const prevValueRef = React.useRef(value);\n  const handleChange = useCallbackRef(onChange);\n  React.useEffect(() => {\n    if (prevValueRef.current !== value) {\n      handleChange(value);\n      prevValueRef.current = value;\n    }\n  }, [value, prevValueRef, handleChange]);\n  return uncontrolledState;\n}\n\nexport { useControllableState };\n//# sourceMappingURL=index.js.map\n","import * as React from 'react';\n\n// packages/react/use-layout-effect/src/useLayoutEffect.tsx\nvar useLayoutEffect2 = Boolean(globalThis?.document) ? React.useLayoutEffect : () => {\n};\n\nexport { useLayoutEffect2 as useLayoutEffect };\n//# sourceMappingURL=index.js.map\n","import * as React from 'react';\nimport { useLayoutEffect as useLayoutEffect2 } from '../../../../../@radix-ui_react-use-layout-effect@1.1.0_@types_react@18.3.5_react@18.3.1/node_modules/@radix-ui/react-use-layout-effect/dist/index.js';\n\n// packages/react/use-size/src/useSize.tsx\nfunction useSize(element) {\n  const [size, setSize] = React.useState(void 0);\n  useLayoutEffect2(() => {\n    if (element) {\n      setSize({ width: element.offsetWidth, height: element.offsetHeight });\n      const resizeObserver = new ResizeObserver((entries) => {\n        if (!Array.isArray(entries)) {\n          return;\n        }\n        if (!entries.length) {\n          return;\n        }\n        const entry = entries[0];\n        let width;\n        let height;\n        if (\"borderBoxSize\" in entry) {\n          const borderSizeEntry = entry[\"borderBoxSize\"];\n          const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;\n          width = borderSize[\"inlineSize\"];\n          height = borderSize[\"blockSize\"];\n        } else {\n          width = element.offsetWidth;\n          height = element.offsetHeight;\n        }\n        setSize({ width, height });\n      });\n      resizeObserver.observe(element, { box: \"border-box\" });\n      return () => resizeObserver.unobserve(element);\n    } else {\n      setSize(void 0);\n    }\n  }, [element]);\n  return size;\n}\n\nexport { useSize };\n//# sourceMappingURL=index.js.map\n","/**\n * @license React\n * react-jsx-runtime.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var f=require(\"react\"),k=Symbol.for(\"react.element\"),l=Symbol.for(\"react.fragment\"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};\nfunction q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=\"\"+g);void 0!==a.key&&(e=\"\"+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-jsx-runtime.production.min.js');\n} else {\n  module.exports = require('./cjs/react-jsx-runtime.development.js');\n}\n"],"names":["composeEventHandlers","originalEventHandler","ourEventHandler","checkForDefaultPrevented","event","defaultPrevented","composeRefs","refs","node","forEach","ref","value","current","setRef","useComposedRefs","createContext2","rootComponentName","defaultContext","Context","Provider","props","children","context","Object","values","jsx","displayName","consumerName","Error","createContextScope","scopeName","createContextScopeDeps","defaultContexts","createScope","scopeContexts","map","scope","contexts","BaseContext","index","length","composeContextScopes","scopes","baseScope","scopeHooks","createScope2","useScope","overrideScopes","nextScopes","reduce","nextScopes2","originalBodyPointerEvents","CONTEXT_UPDATE","POINTER_DOWN_OUTSIDE","FOCUS_OUTSIDE","DismissableLayerContext","layers","Set","layersWithOutsidePointerEventsDisabled","branches","DismissableLayer","forwardedRef","disableOutsidePointerEvents","onEscapeKeyDown","onPointerDownOutside","onFocusOutside","onInteractOutside","onDismiss","layerProps","setNode","ownerDocument","globalThis","document","force","composedRefs","node2","Array","from","highestLayerWithOutsidePointerEventsDisabled","slice","highestLayerWithOutsidePointerEventsDisabledIndex","indexOf","isBodyPointerEventsDisabled","size","isPointerEventsEnabled","pointerDownOutside","handlePointerDownOutside","isPointerInsideReactTreeRef","handleClickRef","handlePointerDown","target","handleAndDispatchPointerDownOutsideEvent2","handleAndDispatchCustomEvent","eventDetail","discrete","originalEvent","pointerType","removeEventListener","addEventListener","once","timerId","window","setTimeout","clearTimeout","onPointerDownCapture","usePointerDownOutside","isPointerDownOnBranch","some","branch","contains","focusOutside","handleFocusOutside","isFocusInsideReactTreeRef","handleFocus","onFocusCapture","onBlurCapture","useFocusOutside","onEscapeKeyDownProp","handleKeyDown","key","capture","useEscapeKeydown","preventDefault","body","style","pointerEvents","add","dispatchUpdate","delete","handleUpdate","div","DismissableLayerBranch","CustomEvent","dispatchEvent","name","handler","detail","bubbles","cancelable","useReactId","toString","count","useId","deterministicId","id","setId","reactId","String","sides","min","Math","max","round","floor","createCoords","v","x","y","oppositeSideMap","left","right","bottom","top","oppositeAlignmentMap","start","end","clamp","evaluate","param","getSide","placement","split","getAlignment","getOppositeAxis","axis","getAxisLength","getSideAxis","includes","getAlignmentAxis","getOppositeAlignmentPlacement","replace","alignment","getOppositePlacement","side","getPaddingObject","padding","expandPaddingObject","rectToClientRect","rect","width","height","computeCoordsFromPlacement","_ref","rtl","reference","floating","sideAxis","alignmentAxis","alignLength","isVertical","commonX","commonY","commonAlign","coords","async","detectOverflow","state","options","_await$platform$isEle","platform","rects","elements","strategy","boundary","rootBoundary","elementContext","altBoundary","paddingObject","element","clippingClientRect","getClippingRect","isElement","contextElement","getDocumentElement","offsetParent","getOffsetParent","offsetScale","getScale","elementClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","getSideOffsets","overflow","isAnySideFullyClipped","getNodeName","isNode","nodeName","toLowerCase","getWindow","_node$ownerDocument","defaultView","documentElement","Node","Element","isHTMLElement","HTMLElement","isShadowRoot","ShadowRoot","isOverflowElement","overflowX","overflowY","display","getComputedStyle","test","isTableElement","isTopLayer","selector","matches","e","isContainingBlock","elementOrCss","webkit","isWebKit","css","transform","perspective","containerType","backdropFilter","filter","willChange","contain","CSS","supports","isLastTraversableNode","getNodeScroll","scrollLeft","scrollTop","scrollX","scrollY","getParentNode","result","assignedSlot","parentNode","host","getNearestOverflowAncestor","getOverflowAncestors","list","traverseIframes","_node$ownerDocument2","scrollableAncestor","isBody","win","frameElement","getFrameElement","concat","visualViewport","parent","getPrototypeOf","getCssDimensions","parseFloat","hasOffset","offsetWidth","offsetHeight","shouldFallback","$","unwrapElement","domElement","getBoundingClientRect","Number","isFinite","noOffsets","getVisualOffsets","offsetLeft","offsetTop","includeScale","isFixedStrategy","clientRect","scale","visualOffsets","isFixed","floatingOffsetParent","shouldAddVisualOffsets","offsetWin","currentWin","currentIFrame","iframeScale","iframeRect","clientLeft","paddingLeft","clientTop","paddingTop","getWindowScrollBarX","getClientRectFromClippingAncestor","clippingAncestor","html","clientWidth","clientHeight","visualViewportBased","getViewportRect","scroll","scrollWidth","scrollHeight","direction","getDocumentRect","getInnerBoundingClientRect","hasFixedPositionAncestor","stopNode","position","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsets","offsetRect","isStaticPositioned","getTrueOffsetParent","polyfill","svgOffsetParent","currentNode","getContainingBlock","topLayer","clippingAncestors","cache","cachedResult","get","el","currentContainingBlockComputedStyle","elementIsFixed","computedStyle","currentNodeIsContaining","ancestor","set","getClippingElementAncestors","this","_c","firstClippingAncestor","clippingRect","accRect","getElementRects","data","getOffsetParentFn","getDimensionsFn","getDimensions","floatingDimensions","getClientRects","isRTL","autoUpdate","update","ancestorScroll","ancestorResize","elementResize","ResizeObserver","layoutShift","IntersectionObserver","animationFrame","referenceEl","ancestors","passive","cleanupIo","onMove","timeoutId","io","root","cleanup","_io","disconnect","refresh","skip","threshold","rootMargin","isFirstUpdate","handleObserve","entries","ratio","intersectionRatio","observe","observeMove","frameId","reobserveFrame","resizeObserver","firstEntry","unobserve","cancelAnimationFrame","requestAnimationFrame","_resizeObserver","prevRefRect","frameLoop","nextRefRect","_resizeObserver2","fn","_middlewareData$offse","_middlewareData$arrow","middlewareData","diffCoords","mainAxisMulti","crossAxisMulti","rawValue","mainAxis","crossAxis","convertValueToCoords","offset","arrow","alignmentOffset","checkMainAxis","checkCrossAxis","limiter","detectOverflowOptions","mainAxisCoord","crossAxisCoord","maxSide","limitedCoords","_middlewareData$flip","initialPlacement","fallbackPlacements","specifiedFallbackPlacements","fallbackStrategy","fallbackAxisSideDirection","flipAlignment","initialSideAxis","isBasePlacement","oppositePlacement","getExpandedPlacements","hasFallbackAxisSideDirection","push","isStart","lr","rl","tb","bt","getSideList","getOppositeAxisPlacements","placements","overflows","overflowsData","flip","mainAlignmentSide","getAlignmentSides","every","_middlewareData$flip2","_overflowsData$filter","nextIndex","nextPlacement","reset","resetPlacement","d","sort","a","b","_overflowsData$filter2","currentSideAxis","acc","apply","isYAxis","heightSide","widthSide","maximumClippingHeight","maximumClippingWidth","overflowAvailableHeight","overflowAvailableWidth","noShift","shift","availableHeight","availableWidth","xMin","xMax","yMin","yMax","nextDimensions","referenceHiddenOffsets","referenceHidden","escapedOffsets","escaped","arrowDimensions","minProp","maxProp","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","centerToReference","largestPossiblePadding","minPadding","maxPadding","min$1","center","shouldAddOffset","centerOffset","rawOffset","computedOffset","len","limitMin","limitMax","_middlewareData$offse2","isOriginSide","Map","mergedOptions","platformWithCache","config","middleware","validMiddleware","Boolean","statefulPlacement","resetCount","i","nextX","nextY","computePosition","useLayoutEffect","useEffect","deepEqual","keys","isArray","hasOwnProperty","call","$$typeof","getDPR","devicePixelRatio","roundByDPR","dpr","useLatestRef","arrow$1","deps","Arrow","arrowProps","svg","viewBox","preserveAspectRatio","asChild","points","Root","POPPER_NAME","createPopperContext","createPopperScope","PopperProvider","usePopperContext","Popper","__scopePopper","anchor","setAnchor","onAnchorChange","ANCHOR_NAME","PopperAnchor","virtualRef","anchorProps","CONTENT_NAME","PopperContentProvider","useContentContext","PopperContent","sideOffset","align","alignOffset","arrowPadding","avoidCollisions","collisionBoundary","collisionPadding","collisionPaddingProp","sticky","hideWhenDetached","updatePositionStrategy","onPlaced","contentProps","content","setContent","setArrow","arrowSize","arrowWidth","arrowHeight","desiredPlacement","hasExplicitBoundaries","isNotNull","floatingStyles","isPositioned","externalReference","externalFloating","whileElementsMounted","open","setData","latestMiddleware","setLatestMiddleware","_reference","_setReference","_floating","_setFloating","setReference","referenceRef","setFloating","floatingRef","floatingEl","dataRef","hasWhileElementsMounted","whileElementsMountedRef","platformRef","then","fullData","isMountedRef","initialStyles","useFloating","args","anchorWidth","anchorHeight","contentStyle","setProperty","transformOrigin","placedSide","placedAlign","getSideAndAlignFromPlacement","handlePlaced","arrowX","arrowY","cannotCenterArrow","contentZIndex","setContentZIndex","zIndex","minWidth","join","hide","visibility","dir","onArrowChange","shouldHideArrow","animation","ARROW_NAME","OPPOSITE_SIDE","PopperArrow","contentContext","baseSide","isArrowHidden","noArrowAlign","arrowXCenter","arrowYCenter","Root2","Anchor","Content","Portal","container","containerProp","portalProps","mounted","setMounted","Presence","present","presence","stylesRef","prevPresentRef","prevAnimationNameRef","initialState","send","machine","useStateMachine","UNMOUNT","ANIMATION_OUT","unmountSuspended","MOUNT","ANIMATION_END","unmounted","currentAnimationName","getAnimationName","styles","wasPresent","prevAnimationName","handleAnimationEnd","isCurrentAnimation","animationName","handleAnimationStart","isPresent","usePresence","child","only","getter","getOwnPropertyDescriptor","mayWarn","isReactWarning","getElementRef","Primitive","primitive","primitiveProps","Comp","Symbol","for","dispatchDiscreteCustomEvent","Slot","slotProps","childrenArray","toArray","slottable","find","isSlottable","newElement","newChildren","SlotClone","childrenRef","mergeProps","Slottable","Fragment","type","childProps","overrideProps","propName","slotPropValue","childPropValue","useCallbackRef","callback","callbackRef","useControllableState","prop","defaultProp","onChange","uncontrolledProp","setUncontrolledProp","uncontrolledState","prevValueRef","handleChange","useUncontrolledState","isControlled","nextValue","value2","useLayoutEffect2","useSize","setSize","entry","borderSizeEntry","borderSize","box","f","k","l","m","prototype","n","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","ReactCurrentOwner","p","__self","__source","q","c","g","h","defaultProps","_owner","exports","jsxs","module"],"sourceRoot":""}