{"version":3,"file":"static/chunks/5791-b2937b51d645db51.js","mappings":"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","sources":["webpack://_N_E/./node_modules/next/dist/api/navigation.js","webpack://_N_E/./node_modules/@floating-ui/core/dist/floating-ui.core.mjs","webpack://_N_E/./node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs","webpack://_N_E/./node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs","webpack://_N_E/./node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs","webpack://_N_E/./node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs","webpack://_N_E/./node_modules/@radix-ui/react-arrow/dist/index.mjs","webpack://_N_E/./node_modules/@radix-ui/react-popper/dist/index.mjs","webpack://_N_E/./node_modules/@radix-ui/react-use-size/dist/index.mjs","webpack://_N_E/<anon>"],"sourcesContent":["export * from \"../client/components/navigation\";\n\n//# sourceMappingURL=navigation.js.map","import { getSideAxis, getAlignmentAxis, getAxisLength, getSide, getAlignment, evaluate, getPaddingObject, rectToClientRect, min, clamp, placements, getAlignmentSides, getOppositeAlignmentPlacement, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, sides, max, getOppositeAxis } from '@floating-ui/utils';\nexport { rectToClientRect } from '@floating-ui/utils';\n\nfunction computeCoordsFromPlacement(_ref, placement, rtl) {\n  let {\n    reference,\n    floating\n  } = _ref;\n  const sideAxis = getSideAxis(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const alignLength = getAxisLength(alignmentAxis);\n  const side = getSide(placement);\n  const isVertical = sideAxis === 'y';\n  const commonX = reference.x + reference.width / 2 - floating.width / 2;\n  const commonY = reference.y + reference.height / 2 - floating.height / 2;\n  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;\n  let coords;\n  switch (side) {\n    case 'top':\n      coords = {\n        x: commonX,\n        y: reference.y - floating.height\n      };\n      break;\n    case 'bottom':\n      coords = {\n        x: commonX,\n        y: reference.y + reference.height\n      };\n      break;\n    case 'right':\n      coords = {\n        x: reference.x + reference.width,\n        y: commonY\n      };\n      break;\n    case 'left':\n      coords = {\n        x: reference.x - floating.width,\n        y: commonY\n      };\n      break;\n    default:\n      coords = {\n        x: reference.x,\n        y: reference.y\n      };\n  }\n  switch (getAlignment(placement)) {\n    case 'start':\n      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n    case 'end':\n      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n  }\n  return coords;\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n *\n * This export does not have any `platform` interface logic. You will need to\n * write one for the platform you are using Floating UI with.\n */\nconst computePosition = async (reference, floating, config) => {\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform\n  } = config;\n  const validMiddleware = middleware.filter(Boolean);\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));\n  let rects = await platform.getElementRects({\n    reference,\n    floating,\n    strategy\n  });\n  let {\n    x,\n    y\n  } = computeCoordsFromPlacement(rects, placement, rtl);\n  let statefulPlacement = placement;\n  let middlewareData = {};\n  let resetCount = 0;\n  for (let i = 0; i < validMiddleware.length; i++) {\n    const {\n      name,\n      fn\n    } = validMiddleware[i];\n    const {\n      x: nextX,\n      y: nextY,\n      data,\n      reset\n    } = await fn({\n      x,\n      y,\n      initialPlacement: placement,\n      placement: statefulPlacement,\n      strategy,\n      middlewareData,\n      rects,\n      platform,\n      elements: {\n        reference,\n        floating\n      }\n    });\n    x = nextX != null ? nextX : x;\n    y = nextY != null ? nextY : y;\n    middlewareData = {\n      ...middlewareData,\n      [name]: {\n        ...middlewareData[name],\n        ...data\n      }\n    };\n    if (reset && resetCount <= 50) {\n      resetCount++;\n      if (typeof reset === 'object') {\n        if (reset.placement) {\n          statefulPlacement = reset.placement;\n        }\n        if (reset.rects) {\n          rects = reset.rects === true ? await platform.getElementRects({\n            reference,\n            floating,\n            strategy\n          }) : reset.rects;\n        }\n        ({\n          x,\n          y\n        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));\n      }\n      i = -1;\n    }\n  }\n  return {\n    x,\n    y,\n    placement: statefulPlacement,\n    strategy,\n    middlewareData\n  };\n};\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nasync function detectOverflow(state, options) {\n  var _await$platform$isEle;\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    x,\n    y,\n    platform,\n    rects,\n    elements,\n    strategy\n  } = state;\n  const {\n    boundary = 'clippingAncestors',\n    rootBoundary = 'viewport',\n    elementContext = 'floating',\n    altBoundary = false,\n    padding = 0\n  } = evaluate(options, state);\n  const paddingObject = getPaddingObject(padding);\n  const altContext = elementContext === 'floating' ? 'reference' : 'floating';\n  const element = elements[altBoundary ? altContext : elementContext];\n  const clippingClientRect = rectToClientRect(await platform.getClippingRect({\n    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),\n    boundary,\n    rootBoundary,\n    strategy\n  }));\n  const rect = elementContext === 'floating' ? {\n    ...rects.floating,\n    x,\n    y\n  } : rects.reference;\n  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));\n  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {\n    x: 1,\n    y: 1\n  } : {\n    x: 1,\n    y: 1\n  };\n  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  }) : rect);\n  return {\n    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,\n    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,\n    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,\n    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x\n  };\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => ({\n  name: 'arrow',\n  options,\n  async fn(state) {\n    const {\n      x,\n      y,\n      placement,\n      rects,\n      platform,\n      elements,\n      middlewareData\n    } = state;\n    // Since `element` is required, we don't Partial<> the type.\n    const {\n      element,\n      padding = 0\n    } = evaluate(options, state) || {};\n    if (element == null) {\n      return {};\n    }\n    const paddingObject = getPaddingObject(padding);\n    const coords = {\n      x,\n      y\n    };\n    const axis = getAlignmentAxis(placement);\n    const length = getAxisLength(axis);\n    const arrowDimensions = await platform.getDimensions(element);\n    const isYAxis = axis === 'y';\n    const minProp = isYAxis ? 'top' : 'left';\n    const maxProp = isYAxis ? 'bottom' : 'right';\n    const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';\n    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];\n    const startDiff = coords[axis] - rects.reference[axis];\n    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));\n    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;\n\n    // DOM platform can return `window` as the `offsetParent`.\n    if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {\n      clientSize = elements.floating[clientProp] || rects.floating[length];\n    }\n    const centerToReference = endDiff / 2 - startDiff / 2;\n\n    // If the padding is large enough that it causes the arrow to no longer be\n    // centered, modify the padding so that it is centered.\n    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;\n    const minPadding = min(paddingObject[minProp], largestPossiblePadding);\n    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);\n\n    // Make sure the arrow doesn't overflow the floating element if the center\n    // point is outside the floating element's bounds.\n    const min$1 = minPadding;\n    const max = clientSize - arrowDimensions[length] - maxPadding;\n    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;\n    const offset = clamp(min$1, center, max);\n\n    // If the reference is small enough that the arrow's padding causes it to\n    // to point to nothing for an aligned placement, adjust the offset of the\n    // floating element itself. To ensure `shift()` continues to take action,\n    // a single reset is performed when this is true.\n    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;\n    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;\n    return {\n      [axis]: coords[axis] + alignmentOffset,\n      data: {\n        [axis]: offset,\n        centerOffset: center - offset - alignmentOffset,\n        ...(shouldAddOffset && {\n          alignmentOffset\n        })\n      },\n      reset: shouldAddOffset\n    };\n  }\n});\n\nfunction getPlacementList(alignment, autoAlignment, allowedPlacements) {\n  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);\n  return allowedPlacementsSortedByAlignment.filter(placement => {\n    if (alignment) {\n      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);\n    }\n    return true;\n  });\n}\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'autoPlacement',\n    options,\n    async fn(state) {\n      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;\n      const {\n        rects,\n        middlewareData,\n        placement,\n        platform,\n        elements\n      } = state;\n      const {\n        crossAxis = false,\n        alignment,\n        allowedPlacements = placements,\n        autoAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;\n      const currentPlacement = placements$1[currentIndex];\n      if (currentPlacement == null) {\n        return {};\n      }\n      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));\n\n      // Make `computeCoords` start from the right place.\n      if (placement !== currentPlacement) {\n        return {\n          reset: {\n            placement: placements$1[0]\n          }\n        };\n      }\n      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];\n      const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {\n        placement: currentPlacement,\n        overflows: currentOverflows\n      }];\n      const nextPlacement = placements$1[currentIndex + 1];\n\n      // There are more placements to check.\n      if (nextPlacement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: nextPlacement\n          }\n        };\n      }\n      const placementsSortedByMostSpace = allOverflows.map(d => {\n        const alignment = getAlignment(d.placement);\n        return [d.placement, alignment && crossAxis ?\n        // Check along the mainAxis and main crossAxis side.\n        d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :\n        // Check only the mainAxis.\n        d.overflows[0], d.overflows];\n      }).sort((a, b) => a[1] - b[1]);\n      const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,\n      // Aligned placements should not check their opposite crossAxis\n      // side.\n      getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));\n      const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];\n      if (resetPlacement !== placement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: resetPlacement\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'flip',\n    options,\n    async fn(state) {\n      var _middlewareData$arrow, _middlewareData$flip;\n      const {\n        placement,\n        middlewareData,\n        rects,\n        initialPlacement,\n        platform,\n        elements\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true,\n        fallbackPlacements: specifiedFallbackPlacements,\n        fallbackStrategy = 'bestFit',\n        fallbackAxisSideDirection = 'none',\n        flipAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n\n      // If a reset by the arrow was caused due to an alignment offset being\n      // added, we should skip any logic now since `flip()` has already done its\n      // work.\n      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643\n      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      const side = getSide(placement);\n      const isBasePlacement = getSide(initialPlacement) === initialPlacement;\n      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));\n      if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== 'none') {\n        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));\n      }\n      const placements = [initialPlacement, ...fallbackPlacements];\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const overflows = [];\n      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];\n      if (checkMainAxis) {\n        overflows.push(overflow[side]);\n      }\n      if (checkCrossAxis) {\n        const sides = getAlignmentSides(placement, rects, rtl);\n        overflows.push(overflow[sides[0]], overflow[sides[1]]);\n      }\n      overflowsData = [...overflowsData, {\n        placement,\n        overflows\n      }];\n\n      // One or more sides is overflowing.\n      if (!overflows.every(side => side <= 0)) {\n        var _middlewareData$flip2, _overflowsData$filter;\n        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;\n        const nextPlacement = placements[nextIndex];\n        if (nextPlacement) {\n          // Try next placement and re-run the lifecycle.\n          return {\n            data: {\n              index: nextIndex,\n              overflows: overflowsData\n            },\n            reset: {\n              placement: nextPlacement\n            }\n          };\n        }\n\n        // First, find the candidates that fit on the mainAxis side of overflow,\n        // then find the placement that fits the best on the main crossAxis side.\n        let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;\n\n        // Otherwise fallback.\n        if (!resetPlacement) {\n          switch (fallbackStrategy) {\n            case 'bestFit':\n              {\n                var _overflowsData$map$so;\n                const placement = (_overflowsData$map$so = overflowsData.map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0];\n                if (placement) {\n                  resetPlacement = placement;\n                }\n                break;\n              }\n            case 'initialPlacement':\n              resetPlacement = initialPlacement;\n              break;\n          }\n        }\n        if (placement !== resetPlacement) {\n          return {\n            reset: {\n              placement: resetPlacement\n            }\n          };\n        }\n      }\n      return {};\n    }\n  };\n};\n\nfunction getSideOffsets(overflow, rect) {\n  return {\n    top: overflow.top - rect.height,\n    right: overflow.right - rect.width,\n    bottom: overflow.bottom - rect.height,\n    left: overflow.left - rect.width\n  };\n}\nfunction isAnySideFullyClipped(overflow) {\n  return sides.some(side => overflow[side] >= 0);\n}\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'hide',\n    options,\n    async fn(state) {\n      const {\n        rects\n      } = state;\n      const {\n        strategy = 'referenceHidden',\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      switch (strategy) {\n        case 'referenceHidden':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              elementContext: 'reference'\n            });\n            const offsets = getSideOffsets(overflow, rects.reference);\n            return {\n              data: {\n                referenceHiddenOffsets: offsets,\n                referenceHidden: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        case 'escaped':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              altBoundary: true\n            });\n            const offsets = getSideOffsets(overflow, rects.floating);\n            return {\n              data: {\n                escapedOffsets: offsets,\n                escaped: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        default:\n          {\n            return {};\n          }\n      }\n    }\n  };\n};\n\nfunction getBoundingRect(rects) {\n  const minX = min(...rects.map(rect => rect.left));\n  const minY = min(...rects.map(rect => rect.top));\n  const maxX = max(...rects.map(rect => rect.right));\n  const maxY = max(...rects.map(rect => rect.bottom));\n  return {\n    x: minX,\n    y: minY,\n    width: maxX - minX,\n    height: maxY - minY\n  };\n}\nfunction getRectsByLine(rects) {\n  const sortedRects = rects.slice().sort((a, b) => a.y - b.y);\n  const groups = [];\n  let prevRect = null;\n  for (let i = 0; i < sortedRects.length; i++) {\n    const rect = sortedRects[i];\n    if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {\n      groups.push([rect]);\n    } else {\n      groups[groups.length - 1].push(rect);\n    }\n    prevRect = rect;\n  }\n  return groups.map(rect => rectToClientRect(getBoundingRect(rect)));\n}\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'inline',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        elements,\n        rects,\n        platform,\n        strategy\n      } = state;\n      // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a\n      // ClientRect's bounds, despite the event listener being triggered. A\n      // padding of 2 seems to handle this issue.\n      const {\n        padding = 2,\n        x,\n        y\n      } = evaluate(options, state);\n      const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);\n      const clientRects = getRectsByLine(nativeClientRects);\n      const fallback = rectToClientRect(getBoundingRect(nativeClientRects));\n      const paddingObject = getPaddingObject(padding);\n      function getBoundingClientRect() {\n        // There are two rects and they are disjoined.\n        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {\n          // Find the first rect in which the point is fully inside.\n          return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;\n        }\n\n        // There are 2 or more connected rects.\n        if (clientRects.length >= 2) {\n          if (getSideAxis(placement) === 'y') {\n            const firstRect = clientRects[0];\n            const lastRect = clientRects[clientRects.length - 1];\n            const isTop = getSide(placement) === 'top';\n            const top = firstRect.top;\n            const bottom = lastRect.bottom;\n            const left = isTop ? firstRect.left : lastRect.left;\n            const right = isTop ? firstRect.right : lastRect.right;\n            const width = right - left;\n            const height = bottom - top;\n            return {\n              top,\n              bottom,\n              left,\n              right,\n              width,\n              height,\n              x: left,\n              y: top\n            };\n          }\n          const isLeftSide = getSide(placement) === 'left';\n          const maxRight = max(...clientRects.map(rect => rect.right));\n          const minLeft = min(...clientRects.map(rect => rect.left));\n          const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);\n          const top = measureRects[0].top;\n          const bottom = measureRects[measureRects.length - 1].bottom;\n          const left = minLeft;\n          const right = maxRight;\n          const width = right - left;\n          const height = bottom - top;\n          return {\n            top,\n            bottom,\n            left,\n            right,\n            width,\n            height,\n            x: left,\n            y: top\n          };\n        }\n        return fallback;\n      }\n      const resetRects = await platform.getElementRects({\n        reference: {\n          getBoundingClientRect\n        },\n        floating: elements.floating,\n        strategy\n      });\n      if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {\n        return {\n          reset: {\n            rects: resetRects\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n// For type backwards-compatibility, the `OffsetOptions` type was also\n// Derivable.\n\nasync function convertValueToCoords(state, options) {\n  const {\n    placement,\n    platform,\n    elements\n  } = state;\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n  const side = getSide(placement);\n  const alignment = getAlignment(placement);\n  const isVertical = getSideAxis(placement) === 'y';\n  const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;\n  const crossAxisMulti = rtl && isVertical ? -1 : 1;\n  const rawValue = evaluate(options, state);\n  let {\n    mainAxis,\n    crossAxis,\n    alignmentAxis\n  } = typeof rawValue === 'number' ? {\n    mainAxis: rawValue,\n    crossAxis: 0,\n    alignmentAxis: null\n  } : {\n    mainAxis: 0,\n    crossAxis: 0,\n    alignmentAxis: null,\n    ...rawValue\n  };\n  if (alignment && typeof alignmentAxis === 'number') {\n    crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;\n  }\n  return isVertical ? {\n    x: crossAxis * crossAxisMulti,\n    y: mainAxis * mainAxisMulti\n  } : {\n    x: mainAxis * mainAxisMulti,\n    y: crossAxis * crossAxisMulti\n  };\n}\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = function (options) {\n  if (options === void 0) {\n    options = 0;\n  }\n  return {\n    name: 'offset',\n    options,\n    async fn(state) {\n      var _middlewareData$offse, _middlewareData$arrow;\n      const {\n        x,\n        y,\n        placement,\n        middlewareData\n      } = state;\n      const diffCoords = await convertValueToCoords(state, options);\n\n      // If the placement is the same and the arrow caused an alignment offset\n      // then we don't need to change the positioning coordinates.\n      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      return {\n        x: x + diffCoords.x,\n        y: y + diffCoords.y,\n        data: {\n          ...diffCoords,\n          placement\n        }\n      };\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'shift',\n    options,\n    async fn(state) {\n      const {\n        x,\n        y,\n        placement\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = false,\n        limiter = {\n          fn: _ref => {\n            let {\n              x,\n              y\n            } = _ref;\n            return {\n              x,\n              y\n            };\n          }\n        },\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const crossAxis = getSideAxis(getSide(placement));\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      if (checkMainAxis) {\n        const minSide = mainAxis === 'y' ? 'top' : 'left';\n        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';\n        const min = mainAxisCoord + overflow[minSide];\n        const max = mainAxisCoord - overflow[maxSide];\n        mainAxisCoord = clamp(min, mainAxisCoord, max);\n      }\n      if (checkCrossAxis) {\n        const minSide = crossAxis === 'y' ? 'top' : 'left';\n        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';\n        const min = crossAxisCoord + overflow[minSide];\n        const max = crossAxisCoord - overflow[maxSide];\n        crossAxisCoord = clamp(min, crossAxisCoord, max);\n      }\n      const limitedCoords = limiter.fn({\n        ...state,\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      });\n      return {\n        ...limitedCoords,\n        data: {\n          x: limitedCoords.x - x,\n          y: limitedCoords.y - y\n        }\n      };\n    }\n  };\n};\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    options,\n    fn(state) {\n      const {\n        x,\n        y,\n        placement,\n        rects,\n        middlewareData\n      } = state;\n      const {\n        offset = 0,\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const crossAxis = getSideAxis(placement);\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      const rawOffset = evaluate(offset, state);\n      const computedOffset = typeof rawOffset === 'number' ? {\n        mainAxis: rawOffset,\n        crossAxis: 0\n      } : {\n        mainAxis: 0,\n        crossAxis: 0,\n        ...rawOffset\n      };\n      if (checkMainAxis) {\n        const len = mainAxis === 'y' ? 'height' : 'width';\n        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;\n        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;\n        if (mainAxisCoord < limitMin) {\n          mainAxisCoord = limitMin;\n        } else if (mainAxisCoord > limitMax) {\n          mainAxisCoord = limitMax;\n        }\n      }\n      if (checkCrossAxis) {\n        var _middlewareData$offse, _middlewareData$offse2;\n        const len = mainAxis === 'y' ? 'width' : 'height';\n        const isOriginSide = ['top', 'left'].includes(getSide(placement));\n        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);\n        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);\n        if (crossAxisCoord < limitMin) {\n          crossAxisCoord = limitMin;\n        } else if (crossAxisCoord > limitMax) {\n          crossAxisCoord = limitMax;\n        }\n      }\n      return {\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      };\n    }\n  };\n};\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'size',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        rects,\n        platform,\n        elements\n      } = state;\n      const {\n        apply = () => {},\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const side = getSide(placement);\n      const alignment = getAlignment(placement);\n      const isYAxis = getSideAxis(placement) === 'y';\n      const {\n        width,\n        height\n      } = rects.floating;\n      let heightSide;\n      let widthSide;\n      if (side === 'top' || side === 'bottom') {\n        heightSide = side;\n        widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';\n      } else {\n        widthSide = side;\n        heightSide = alignment === 'end' ? 'top' : 'bottom';\n      }\n      const overflowAvailableHeight = height - overflow[heightSide];\n      const overflowAvailableWidth = width - overflow[widthSide];\n      const noShift = !state.middlewareData.shift;\n      let availableHeight = overflowAvailableHeight;\n      let availableWidth = overflowAvailableWidth;\n      if (isYAxis) {\n        const maximumClippingWidth = width - overflow.left - overflow.right;\n        availableWidth = alignment || noShift ? min(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;\n      } else {\n        const maximumClippingHeight = height - overflow.top - overflow.bottom;\n        availableHeight = alignment || noShift ? min(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;\n      }\n      if (noShift && !alignment) {\n        const xMin = max(overflow.left, 0);\n        const xMax = max(overflow.right, 0);\n        const yMin = max(overflow.top, 0);\n        const yMax = max(overflow.bottom, 0);\n        if (isYAxis) {\n          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));\n        } else {\n          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));\n        }\n      }\n      await apply({\n        ...state,\n        availableWidth,\n        availableHeight\n      });\n      const nextDimensions = await platform.getDimensions(elements.floating);\n      if (width !== nextDimensions.width || height !== nextDimensions.height) {\n        return {\n          reset: {\n            rects: true\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\nexport { arrow, autoPlacement, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, shift, size };\n","function getNodeName(node) {\n  if (isNode(node)) {\n    return (node.nodeName || '').toLowerCase();\n  }\n  // Mocked nodes in testing environments may not be instances of Node. By\n  // returning `#document` an infinite loop won't occur.\n  // https://github.com/floating-ui/floating-ui/issues/2317\n  return '#document';\n}\nfunction getWindow(node) {\n  var _node$ownerDocument;\n  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;\n}\nfunction getDocumentElement(node) {\n  var _ref;\n  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;\n}\nfunction isNode(value) {\n  return value instanceof Node || value instanceof getWindow(value).Node;\n}\nfunction isElement(value) {\n  return value instanceof Element || value instanceof getWindow(value).Element;\n}\nfunction isHTMLElement(value) {\n  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;\n}\nfunction isShadowRoot(value) {\n  // Browsers without `ShadowRoot` support.\n  if (typeof ShadowRoot === 'undefined') {\n    return false;\n  }\n  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;\n}\nfunction isOverflowElement(element) {\n  const {\n    overflow,\n    overflowX,\n    overflowY,\n    display\n  } = getComputedStyle(element);\n  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);\n}\nfunction isTableElement(element) {\n  return ['table', 'td', 'th'].includes(getNodeName(element));\n}\nfunction isContainingBlock(element) {\n  const webkit = isWebKit();\n  const css = getComputedStyle(element);\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));\n}\nfunction getContainingBlock(element) {\n  let currentNode = getParentNode(element);\n  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    if (isContainingBlock(currentNode)) {\n      return currentNode;\n    } else {\n      currentNode = getParentNode(currentNode);\n    }\n  }\n  return null;\n}\nfunction isWebKit() {\n  if (typeof CSS === 'undefined' || !CSS.supports) return false;\n  return CSS.supports('-webkit-backdrop-filter', 'none');\n}\nfunction isLastTraversableNode(node) {\n  return ['html', 'body', '#document'].includes(getNodeName(node));\n}\nfunction getComputedStyle(element) {\n  return getWindow(element).getComputedStyle(element);\n}\nfunction getNodeScroll(element) {\n  if (isElement(element)) {\n    return {\n      scrollLeft: element.scrollLeft,\n      scrollTop: element.scrollTop\n    };\n  }\n  return {\n    scrollLeft: element.pageXOffset,\n    scrollTop: element.pageYOffset\n  };\n}\nfunction getParentNode(node) {\n  if (getNodeName(node) === 'html') {\n    return node;\n  }\n  const result =\n  // Step into the shadow DOM of the parent of a slotted node.\n  node.assignedSlot ||\n  // DOM Element detected.\n  node.parentNode ||\n  // ShadowRoot detected.\n  isShadowRoot(node) && node.host ||\n  // Fallback.\n  getDocumentElement(node);\n  return isShadowRoot(result) ? result.host : result;\n}\nfunction getNearestOverflowAncestor(node) {\n  const parentNode = getParentNode(node);\n  if (isLastTraversableNode(parentNode)) {\n    return node.ownerDocument ? node.ownerDocument.body : node.body;\n  }\n  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {\n    return parentNode;\n  }\n  return getNearestOverflowAncestor(parentNode);\n}\nfunction getOverflowAncestors(node, list, traverseIframes) {\n  var _node$ownerDocument2;\n  if (list === void 0) {\n    list = [];\n  }\n  if (traverseIframes === void 0) {\n    traverseIframes = true;\n  }\n  const scrollableAncestor = getNearestOverflowAncestor(node);\n  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);\n  const win = getWindow(scrollableAncestor);\n  if (isBody) {\n    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);\n  }\n  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));\n}\n\nexport { getComputedStyle, getContainingBlock, getDocumentElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isWebKit };\n","import { rectToClientRect, autoPlacement as autoPlacement$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, arrow as arrow$1, inline as inline$1, limitShift as limitShift$1, computePosition as computePosition$1 } from '@floating-ui/core';\nexport { detectOverflow, offset } from '@floating-ui/core';\nimport { round, createCoords, max, min, floor } from '@floating-ui/utils';\nimport { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getDocumentElement, getNodeName, isOverflowElement, getNodeScroll, getOverflowAncestors, getParentNode, isLastTraversableNode, isContainingBlock, isTableElement, getContainingBlock } from '@floating-ui/utils/dom';\nexport { getOverflowAncestors } from '@floating-ui/utils/dom';\n\nfunction getCssDimensions(element) {\n  const css = getComputedStyle(element);\n  // In testing environments, the `width` and `height` properties are empty\n  // strings for SVG elements, returning NaN. Fallback to `0` in this case.\n  let width = parseFloat(css.width) || 0;\n  let height = parseFloat(css.height) || 0;\n  const hasOffset = isHTMLElement(element);\n  const offsetWidth = hasOffset ? element.offsetWidth : width;\n  const offsetHeight = hasOffset ? element.offsetHeight : height;\n  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;\n  if (shouldFallback) {\n    width = offsetWidth;\n    height = offsetHeight;\n  }\n  return {\n    width,\n    height,\n    $: shouldFallback\n  };\n}\n\nfunction unwrapElement(element) {\n  return !isElement(element) ? element.contextElement : element;\n}\n\nfunction getScale(element) {\n  const domElement = unwrapElement(element);\n  if (!isHTMLElement(domElement)) {\n    return createCoords(1);\n  }\n  const rect = domElement.getBoundingClientRect();\n  const {\n    width,\n    height,\n    $\n  } = getCssDimensions(domElement);\n  let x = ($ ? round(rect.width) : rect.width) / width;\n  let y = ($ ? round(rect.height) : rect.height) / height;\n\n  // 0, NaN, or Infinity should always fallback to 1.\n\n  if (!x || !Number.isFinite(x)) {\n    x = 1;\n  }\n  if (!y || !Number.isFinite(y)) {\n    y = 1;\n  }\n  return {\n    x,\n    y\n  };\n}\n\nconst noOffsets = /*#__PURE__*/createCoords(0);\nfunction getVisualOffsets(element) {\n  const win = getWindow(element);\n  if (!isWebKit() || !win.visualViewport) {\n    return noOffsets;\n  }\n  return {\n    x: win.visualViewport.offsetLeft,\n    y: win.visualViewport.offsetTop\n  };\n}\nfunction shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {\n  if (isFixed === void 0) {\n    isFixed = false;\n  }\n  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {\n    return false;\n  }\n  return isFixed;\n}\n\nfunction getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {\n  if (includeScale === void 0) {\n    includeScale = false;\n  }\n  if (isFixedStrategy === void 0) {\n    isFixedStrategy = false;\n  }\n  const clientRect = element.getBoundingClientRect();\n  const domElement = unwrapElement(element);\n  let scale = createCoords(1);\n  if (includeScale) {\n    if (offsetParent) {\n      if (isElement(offsetParent)) {\n        scale = getScale(offsetParent);\n      }\n    } else {\n      scale = getScale(element);\n    }\n  }\n  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);\n  let x = (clientRect.left + visualOffsets.x) / scale.x;\n  let y = (clientRect.top + visualOffsets.y) / scale.y;\n  let width = clientRect.width / scale.x;\n  let height = clientRect.height / scale.y;\n  if (domElement) {\n    const win = getWindow(domElement);\n    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;\n    let currentWin = win;\n    let currentIFrame = currentWin.frameElement;\n    while (currentIFrame && offsetParent && offsetWin !== currentWin) {\n      const iframeScale = getScale(currentIFrame);\n      const iframeRect = currentIFrame.getBoundingClientRect();\n      const css = getComputedStyle(currentIFrame);\n      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;\n      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;\n      x *= iframeScale.x;\n      y *= iframeScale.y;\n      width *= iframeScale.x;\n      height *= iframeScale.y;\n      x += left;\n      y += top;\n      currentWin = getWindow(currentIFrame);\n      currentIFrame = currentWin.frameElement;\n    }\n  }\n  return rectToClientRect({\n    width,\n    height,\n    x,\n    y\n  });\n}\n\nconst topLayerSelectors = [':popover-open', ':modal'];\nfunction isTopLayer(floating) {\n  return topLayerSelectors.some(selector => {\n    try {\n      return floating.matches(selector);\n    } catch (e) {\n      return false;\n    }\n  });\n}\n\nfunction convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {\n  let {\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  } = _ref;\n  const isFixed = strategy === 'fixed';\n  const documentElement = getDocumentElement(offsetParent);\n  const topLayer = elements ? isTopLayer(elements.floating) : false;\n  if (offsetParent === documentElement || topLayer && isFixed) {\n    return rect;\n  }\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  let scale = createCoords(1);\n  const offsets = createCoords(0);\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isHTMLElement(offsetParent)) {\n      const offsetRect = getBoundingClientRect(offsetParent);\n      scale = getScale(offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    }\n  }\n  return {\n    width: rect.width * scale.x,\n    height: rect.height * scale.y,\n    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,\n    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y\n  };\n}\n\nfunction getClientRects(element) {\n  return Array.from(element.getClientRects());\n}\n\nfunction getWindowScrollBarX(element) {\n  // If <html> has a CSS width greater than the viewport, then this will be\n  // incorrect for RTL.\n  return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;\n}\n\n// Gets the entire size of the scrollable document area, even extending outside\n// of the `<html>` and `<body>` rect bounds if horizontally scrollable.\nfunction getDocumentRect(element) {\n  const html = getDocumentElement(element);\n  const scroll = getNodeScroll(element);\n  const body = element.ownerDocument.body;\n  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);\n  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);\n  let x = -scroll.scrollLeft + getWindowScrollBarX(element);\n  const y = -scroll.scrollTop;\n  if (getComputedStyle(body).direction === 'rtl') {\n    x += max(html.clientWidth, body.clientWidth) - width;\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\nfunction getViewportRect(element, strategy) {\n  const win = getWindow(element);\n  const html = getDocumentElement(element);\n  const visualViewport = win.visualViewport;\n  let width = html.clientWidth;\n  let height = html.clientHeight;\n  let x = 0;\n  let y = 0;\n  if (visualViewport) {\n    width = visualViewport.width;\n    height = visualViewport.height;\n    const visualViewportBased = isWebKit();\n    if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {\n      x = visualViewport.offsetLeft;\n      y = visualViewport.offsetTop;\n    }\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\n// Returns the inner client rect, subtracting scrollbars if present.\nfunction getInnerBoundingClientRect(element, strategy) {\n  const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');\n  const top = clientRect.top + element.clientTop;\n  const left = clientRect.left + element.clientLeft;\n  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);\n  const width = element.clientWidth * scale.x;\n  const height = element.clientHeight * scale.y;\n  const x = left * scale.x;\n  const y = top * scale.y;\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\nfunction getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {\n  let rect;\n  if (clippingAncestor === 'viewport') {\n    rect = getViewportRect(element, strategy);\n  } else if (clippingAncestor === 'document') {\n    rect = getDocumentRect(getDocumentElement(element));\n  } else if (isElement(clippingAncestor)) {\n    rect = getInnerBoundingClientRect(clippingAncestor, strategy);\n  } else {\n    const visualOffsets = getVisualOffsets(element);\n    rect = {\n      ...clippingAncestor,\n      x: clippingAncestor.x - visualOffsets.x,\n      y: clippingAncestor.y - visualOffsets.y\n    };\n  }\n  return rectToClientRect(rect);\n}\nfunction hasFixedPositionAncestor(element, stopNode) {\n  const parentNode = getParentNode(element);\n  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {\n    return false;\n  }\n  return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);\n}\n\n// A \"clipping ancestor\" is an `overflow` element with the characteristic of\n// clipping (or hiding) child elements. This returns all clipping ancestors\n// of the given element up the tree.\nfunction getClippingElementAncestors(element, cache) {\n  const cachedResult = cache.get(element);\n  if (cachedResult) {\n    return cachedResult;\n  }\n  let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');\n  let currentContainingBlockComputedStyle = null;\n  const elementIsFixed = getComputedStyle(element).position === 'fixed';\n  let currentNode = elementIsFixed ? getParentNode(element) : element;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    const computedStyle = getComputedStyle(currentNode);\n    const currentNodeIsContaining = isContainingBlock(currentNode);\n    if (!currentNodeIsContaining && computedStyle.position === 'fixed') {\n      currentContainingBlockComputedStyle = null;\n    }\n    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);\n    if (shouldDropCurrentNode) {\n      // Drop non-containing blocks.\n      result = result.filter(ancestor => ancestor !== currentNode);\n    } else {\n      // Record last containing block for next iteration.\n      currentContainingBlockComputedStyle = computedStyle;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  cache.set(element, result);\n  return result;\n}\n\n// Gets the maximum area that the element is visible in due to any number of\n// clipping ancestors.\nfunction getClippingRect(_ref) {\n  let {\n    element,\n    boundary,\n    rootBoundary,\n    strategy\n  } = _ref;\n  const elementClippingAncestors = boundary === 'clippingAncestors' ? getClippingElementAncestors(element, this._c) : [].concat(boundary);\n  const clippingAncestors = [...elementClippingAncestors, rootBoundary];\n  const firstClippingAncestor = clippingAncestors[0];\n  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {\n    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);\n    accRect.top = max(rect.top, accRect.top);\n    accRect.right = min(rect.right, accRect.right);\n    accRect.bottom = min(rect.bottom, accRect.bottom);\n    accRect.left = max(rect.left, accRect.left);\n    return accRect;\n  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));\n  return {\n    width: clippingRect.right - clippingRect.left,\n    height: clippingRect.bottom - clippingRect.top,\n    x: clippingRect.left,\n    y: clippingRect.top\n  };\n}\n\nfunction getDimensions(element) {\n  const {\n    width,\n    height\n  } = getCssDimensions(element);\n  return {\n    width,\n    height\n  };\n}\n\nfunction getRectRelativeToOffsetParent(element, offsetParent, strategy) {\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n  const isFixed = strategy === 'fixed';\n  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  const offsets = createCoords(0);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isOffsetParentAnElement) {\n      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    } else if (documentElement) {\n      offsets.x = getWindowScrollBarX(documentElement);\n    }\n  }\n  const x = rect.left + scroll.scrollLeft - offsets.x;\n  const y = rect.top + scroll.scrollTop - offsets.y;\n  return {\n    x,\n    y,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\nfunction getTrueOffsetParent(element, polyfill) {\n  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {\n    return null;\n  }\n  if (polyfill) {\n    return polyfill(element);\n  }\n  return element.offsetParent;\n}\n\n// Gets the closest ancestor positioned element. Handles some edge cases,\n// such as table ancestors and cross browser bugs.\nfunction getOffsetParent(element, polyfill) {\n  const window = getWindow(element);\n  if (!isHTMLElement(element) || isTopLayer(element)) {\n    return window;\n  }\n  let offsetParent = getTrueOffsetParent(element, polyfill);\n  while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === 'static') {\n    offsetParent = getTrueOffsetParent(offsetParent, polyfill);\n  }\n  if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) {\n    return window;\n  }\n  return offsetParent || getContainingBlock(element) || window;\n}\n\nconst getElementRects = async function (data) {\n  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;\n  const getDimensionsFn = this.getDimensions;\n  return {\n    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),\n    floating: {\n      x: 0,\n      y: 0,\n      ...(await getDimensionsFn(data.floating))\n    }\n  };\n};\n\nfunction isRTL(element) {\n  return getComputedStyle(element).direction === 'rtl';\n}\n\nconst platform = {\n  convertOffsetParentRelativeRectToViewportRelativeRect,\n  getDocumentElement,\n  getClippingRect,\n  getOffsetParent,\n  getElementRects,\n  getClientRects,\n  getDimensions,\n  getScale,\n  isElement,\n  isRTL\n};\n\n// https://samthor.au/2021/observing-dom/\nfunction observeMove(element, onMove) {\n  let io = null;\n  let timeoutId;\n  const root = getDocumentElement(element);\n  function cleanup() {\n    var _io;\n    clearTimeout(timeoutId);\n    (_io = io) == null || _io.disconnect();\n    io = null;\n  }\n  function refresh(skip, threshold) {\n    if (skip === void 0) {\n      skip = false;\n    }\n    if (threshold === void 0) {\n      threshold = 1;\n    }\n    cleanup();\n    const {\n      left,\n      top,\n      width,\n      height\n    } = element.getBoundingClientRect();\n    if (!skip) {\n      onMove();\n    }\n    if (!width || !height) {\n      return;\n    }\n    const insetTop = floor(top);\n    const insetRight = floor(root.clientWidth - (left + width));\n    const insetBottom = floor(root.clientHeight - (top + height));\n    const insetLeft = floor(left);\n    const rootMargin = -insetTop + \"px \" + -insetRight + \"px \" + -insetBottom + \"px \" + -insetLeft + \"px\";\n    const options = {\n      rootMargin,\n      threshold: max(0, min(1, threshold)) || 1\n    };\n    let isFirstUpdate = true;\n    function handleObserve(entries) {\n      const ratio = entries[0].intersectionRatio;\n      if (ratio !== threshold) {\n        if (!isFirstUpdate) {\n          return refresh();\n        }\n        if (!ratio) {\n          timeoutId = setTimeout(() => {\n            refresh(false, 1e-7);\n          }, 100);\n        } else {\n          refresh(false, ratio);\n        }\n      }\n      isFirstUpdate = false;\n    }\n\n    // Older browsers don't support a `document` as the root and will throw an\n    // error.\n    try {\n      io = new IntersectionObserver(handleObserve, {\n        ...options,\n        // Handle <iframe>s\n        root: root.ownerDocument\n      });\n    } catch (e) {\n      io = new IntersectionObserver(handleObserve, options);\n    }\n    io.observe(element);\n  }\n  refresh(true);\n  return cleanup;\n}\n\n/**\n * Automatically updates the position of the floating element when necessary.\n * Should only be called when the floating element is mounted on the DOM or\n * visible on the screen.\n * @returns cleanup function that should be invoked when the floating element is\n * removed from the DOM or hidden from the screen.\n * @see https://floating-ui.com/docs/autoUpdate\n */\nfunction autoUpdate(reference, floating, update, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    ancestorScroll = true,\n    ancestorResize = true,\n    elementResize = typeof ResizeObserver === 'function',\n    layoutShift = typeof IntersectionObserver === 'function',\n    animationFrame = false\n  } = options;\n  const referenceEl = unwrapElement(reference);\n  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];\n  ancestors.forEach(ancestor => {\n    ancestorScroll && ancestor.addEventListener('scroll', update, {\n      passive: true\n    });\n    ancestorResize && ancestor.addEventListener('resize', update);\n  });\n  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;\n  let reobserveFrame = -1;\n  let resizeObserver = null;\n  if (elementResize) {\n    resizeObserver = new ResizeObserver(_ref => {\n      let [firstEntry] = _ref;\n      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {\n        // Prevent update loops when using the `size` middleware.\n        // https://github.com/floating-ui/floating-ui/issues/1740\n        resizeObserver.unobserve(floating);\n        cancelAnimationFrame(reobserveFrame);\n        reobserveFrame = requestAnimationFrame(() => {\n          var _resizeObserver;\n          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);\n        });\n      }\n      update();\n    });\n    if (referenceEl && !animationFrame) {\n      resizeObserver.observe(referenceEl);\n    }\n    resizeObserver.observe(floating);\n  }\n  let frameId;\n  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;\n  if (animationFrame) {\n    frameLoop();\n  }\n  function frameLoop() {\n    const nextRefRect = getBoundingClientRect(reference);\n    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {\n      update();\n    }\n    prevRefRect = nextRefRect;\n    frameId = requestAnimationFrame(frameLoop);\n  }\n  update();\n  return () => {\n    var _resizeObserver2;\n    ancestors.forEach(ancestor => {\n      ancestorScroll && ancestor.removeEventListener('scroll', update);\n      ancestorResize && ancestor.removeEventListener('resize', update);\n    });\n    cleanupIo == null || cleanupIo();\n    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();\n    resizeObserver = null;\n    if (animationFrame) {\n      cancelAnimationFrame(frameId);\n    }\n  };\n}\n\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = autoPlacement$1;\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = shift$1;\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = flip$1;\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = size$1;\n\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = hide$1;\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = arrow$1;\n\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = inline$1;\n\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = limitShift$1;\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n */\nconst computePosition = (reference, floating, options) => {\n  // This caches the expensive `getClippingElementAncestors` function so that\n  // multiple lifecycle resets re-use the same result. It only lives for a\n  // single call. If other functions become expensive, we can add them as well.\n  const cache = new Map();\n  const mergedOptions = {\n    platform,\n    ...options\n  };\n  const platformWithCache = {\n    ...mergedOptions.platform,\n    _c: cache\n  };\n  return computePosition$1(reference, floating, {\n    ...mergedOptions,\n    platform: platformWithCache\n  });\n};\n\nexport { arrow, autoPlacement, autoUpdate, computePosition, flip, hide, inline, limitShift, platform, shift, size };\n","import { arrow as arrow$1, computePosition } from '@floating-ui/dom';\nexport { autoPlacement, autoUpdate, computePosition, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size } from '@floating-ui/dom';\nimport * as React from 'react';\nimport { useLayoutEffect, useEffect } from 'react';\nimport * as ReactDOM from 'react-dom';\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * This wraps the core `arrow` middleware to allow React refs as the element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => {\n  function isRef(value) {\n    return {}.hasOwnProperty.call(value, 'current');\n  }\n  return {\n    name: 'arrow',\n    options,\n    fn(state) {\n      const {\n        element,\n        padding\n      } = typeof options === 'function' ? options(state) : options;\n      if (element && isRef(element)) {\n        if (element.current != null) {\n          return arrow$1({\n            element: element.current,\n            padding\n          }).fn(state);\n        }\n        return {};\n      }\n      if (element) {\n        return arrow$1({\n          element,\n          padding\n        }).fn(state);\n      }\n      return {};\n    }\n  };\n};\n\nvar index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\n\n// Fork of `fast-deep-equal` that only does the comparisons we need and compares\n// functions\nfunction deepEqual(a, b) {\n  if (a === b) {\n    return true;\n  }\n  if (typeof a !== typeof b) {\n    return false;\n  }\n  if (typeof a === 'function' && a.toString() === b.toString()) {\n    return true;\n  }\n  let length;\n  let i;\n  let keys;\n  if (a && b && typeof a === 'object') {\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length !== b.length) return false;\n      for (i = length; i-- !== 0;) {\n        if (!deepEqual(a[i], b[i])) {\n          return false;\n        }\n      }\n      return true;\n    }\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) {\n      return false;\n    }\n    for (i = length; i-- !== 0;) {\n      if (!{}.hasOwnProperty.call(b, keys[i])) {\n        return false;\n      }\n    }\n    for (i = length; i-- !== 0;) {\n      const key = keys[i];\n      if (key === '_owner' && a.$$typeof) {\n        continue;\n      }\n      if (!deepEqual(a[key], b[key])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  // biome-ignore lint/suspicious/noSelfCompare: in source\n  return a !== a && b !== b;\n}\n\nfunction getDPR(element) {\n  if (typeof window === 'undefined') {\n    return 1;\n  }\n  const win = element.ownerDocument.defaultView || window;\n  return win.devicePixelRatio || 1;\n}\n\nfunction roundByDPR(element, value) {\n  const dpr = getDPR(element);\n  return Math.round(value * dpr) / dpr;\n}\n\nfunction useLatestRef(value) {\n  const ref = React.useRef(value);\n  index(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n\n/**\n * Provides data to position a floating element.\n * @see https://floating-ui.com/docs/useFloating\n */\nfunction useFloating(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform,\n    elements: {\n      reference: externalReference,\n      floating: externalFloating\n    } = {},\n    transform = true,\n    whileElementsMounted,\n    open\n  } = options;\n  const [data, setData] = React.useState({\n    x: 0,\n    y: 0,\n    strategy,\n    placement,\n    middlewareData: {},\n    isPositioned: false\n  });\n  const [latestMiddleware, setLatestMiddleware] = React.useState(middleware);\n  if (!deepEqual(latestMiddleware, middleware)) {\n    setLatestMiddleware(middleware);\n  }\n  const [_reference, _setReference] = React.useState(null);\n  const [_floating, _setFloating] = React.useState(null);\n  const setReference = React.useCallback(node => {\n    if (node !== referenceRef.current) {\n      referenceRef.current = node;\n      _setReference(node);\n    }\n  }, []);\n  const setFloating = React.useCallback(node => {\n    if (node !== floatingRef.current) {\n      floatingRef.current = node;\n      _setFloating(node);\n    }\n  }, []);\n  const referenceEl = externalReference || _reference;\n  const floatingEl = externalFloating || _floating;\n  const referenceRef = React.useRef(null);\n  const floatingRef = React.useRef(null);\n  const dataRef = React.useRef(data);\n  const hasWhileElementsMounted = whileElementsMounted != null;\n  const whileElementsMountedRef = useLatestRef(whileElementsMounted);\n  const platformRef = useLatestRef(platform);\n  const update = React.useCallback(() => {\n    if (!referenceRef.current || !floatingRef.current) {\n      return;\n    }\n    const config = {\n      placement,\n      strategy,\n      middleware: latestMiddleware\n    };\n    if (platformRef.current) {\n      config.platform = platformRef.current;\n    }\n    computePosition(referenceRef.current, floatingRef.current, config).then(data => {\n      const fullData = {\n        ...data,\n        isPositioned: true\n      };\n      if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {\n        dataRef.current = fullData;\n        ReactDOM.flushSync(() => {\n          setData(fullData);\n        });\n      }\n    });\n  }, [latestMiddleware, placement, strategy, platformRef]);\n  index(() => {\n    if (open === false && dataRef.current.isPositioned) {\n      dataRef.current.isPositioned = false;\n      setData(data => ({\n        ...data,\n        isPositioned: false\n      }));\n    }\n  }, [open]);\n  const isMountedRef = React.useRef(false);\n  index(() => {\n    isMountedRef.current = true;\n    return () => {\n      isMountedRef.current = false;\n    };\n  }, []);\n\n  // biome-ignore lint/correctness/useExhaustiveDependencies: `hasWhileElementsMounted` is intentionally included.\n  index(() => {\n    if (referenceEl) referenceRef.current = referenceEl;\n    if (floatingEl) floatingRef.current = floatingEl;\n    if (referenceEl && floatingEl) {\n      if (whileElementsMountedRef.current) {\n        return whileElementsMountedRef.current(referenceEl, floatingEl, update);\n      }\n      update();\n    }\n  }, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);\n  const refs = React.useMemo(() => ({\n    reference: referenceRef,\n    floating: floatingRef,\n    setReference,\n    setFloating\n  }), [setReference, setFloating]);\n  const elements = React.useMemo(() => ({\n    reference: referenceEl,\n    floating: floatingEl\n  }), [referenceEl, floatingEl]);\n  const floatingStyles = React.useMemo(() => {\n    const initialStyles = {\n      position: strategy,\n      left: 0,\n      top: 0\n    };\n    if (!elements.floating) {\n      return initialStyles;\n    }\n    const x = roundByDPR(elements.floating, data.x);\n    const y = roundByDPR(elements.floating, data.y);\n    if (transform) {\n      return {\n        ...initialStyles,\n        transform: \"translate(\" + x + \"px, \" + y + \"px)\",\n        ...(getDPR(elements.floating) >= 1.5 && {\n          willChange: 'transform'\n        })\n      };\n    }\n    return {\n      position: strategy,\n      left: x,\n      top: y\n    };\n  }, [strategy, transform, elements.floating, data.x, data.y]);\n  return React.useMemo(() => ({\n    ...data,\n    update,\n    refs,\n    elements,\n    floatingStyles\n  }), [data, update, refs, elements, floatingStyles]);\n}\n\nexport { arrow, useFloating };\n","/**\n * Custom positioning reference element.\n * @see https://floating-ui.com/docs/virtual-elements\n */\n\nconst sides = ['top', 'right', 'bottom', 'left'];\nconst alignments = ['start', 'end'];\nconst placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + \"-\" + alignments[0], side + \"-\" + alignments[1]), []);\nconst min = Math.min;\nconst max = Math.max;\nconst round = Math.round;\nconst floor = Math.floor;\nconst createCoords = v => ({\n  x: v,\n  y: v\n});\nconst oppositeSideMap = {\n  left: 'right',\n  right: 'left',\n  bottom: 'top',\n  top: 'bottom'\n};\nconst oppositeAlignmentMap = {\n  start: 'end',\n  end: 'start'\n};\nfunction clamp(start, value, end) {\n  return max(start, min(value, end));\n}\nfunction evaluate(value, param) {\n  return typeof value === 'function' ? value(param) : value;\n}\nfunction getSide(placement) {\n  return placement.split('-')[0];\n}\nfunction getAlignment(placement) {\n  return placement.split('-')[1];\n}\nfunction getOppositeAxis(axis) {\n  return axis === 'x' ? 'y' : 'x';\n}\nfunction getAxisLength(axis) {\n  return axis === 'y' ? 'height' : 'width';\n}\nfunction getSideAxis(placement) {\n  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';\n}\nfunction getAlignmentAxis(placement) {\n  return getOppositeAxis(getSideAxis(placement));\n}\nfunction getAlignmentSides(placement, rects, rtl) {\n  if (rtl === void 0) {\n    rtl = false;\n  }\n  const alignment = getAlignment(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const length = getAxisLength(alignmentAxis);\n  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';\n  if (rects.reference[length] > rects.floating[length]) {\n    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);\n  }\n  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];\n}\nfunction getExpandedPlacements(placement) {\n  const oppositePlacement = getOppositePlacement(placement);\n  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];\n}\nfunction getOppositeAlignmentPlacement(placement) {\n  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);\n}\nfunction getSideList(side, isStart, rtl) {\n  const lr = ['left', 'right'];\n  const rl = ['right', 'left'];\n  const tb = ['top', 'bottom'];\n  const bt = ['bottom', 'top'];\n  switch (side) {\n    case 'top':\n    case 'bottom':\n      if (rtl) return isStart ? rl : lr;\n      return isStart ? lr : rl;\n    case 'left':\n    case 'right':\n      return isStart ? tb : bt;\n    default:\n      return [];\n  }\n}\nfunction getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {\n  const alignment = getAlignment(placement);\n  let list = getSideList(getSide(placement), direction === 'start', rtl);\n  if (alignment) {\n    list = list.map(side => side + \"-\" + alignment);\n    if (flipAlignment) {\n      list = list.concat(list.map(getOppositeAlignmentPlacement));\n    }\n  }\n  return list;\n}\nfunction getOppositePlacement(placement) {\n  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);\n}\nfunction expandPaddingObject(padding) {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0,\n    ...padding\n  };\n}\nfunction getPaddingObject(padding) {\n  return typeof padding !== 'number' ? expandPaddingObject(padding) : {\n    top: padding,\n    right: padding,\n    bottom: padding,\n    left: padding\n  };\n}\nfunction rectToClientRect(rect) {\n  return {\n    ...rect,\n    top: rect.y,\n    left: rect.x,\n    right: rect.x + rect.width,\n    bottom: rect.y + rect.height\n  };\n}\n\nexport { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };\n","import $jbnEx$babelruntimehelpersesmextends from \"@babel/runtime/helpers/esm/extends\";\nimport {forwardRef as $jbnEx$forwardRef, createElement as $jbnEx$createElement} from \"react\";\nimport {Primitive as $jbnEx$Primitive} from \"@radix-ui/react-primitive\";\n\n\n\n\n/* -------------------------------------------------------------------------------------------------\n * Arrow\n * -----------------------------------------------------------------------------------------------*/ const $7e8f5cd07187803e$var$NAME = 'Arrow';\nconst $7e8f5cd07187803e$export$21b07c8f274aebd5 = /*#__PURE__*/ $jbnEx$forwardRef((props, forwardedRef)=>{\n    const { children: children , width: width = 10 , height: height = 5 , ...arrowProps } = props;\n    return /*#__PURE__*/ $jbnEx$createElement($jbnEx$Primitive.svg, $jbnEx$babelruntimehelpersesmextends({}, arrowProps, {\n        ref: forwardedRef,\n        width: width,\n        height: height,\n        viewBox: \"0 0 30 10\",\n        preserveAspectRatio: \"none\"\n    }), props.asChild ? children : /*#__PURE__*/ $jbnEx$createElement(\"polygon\", {\n        points: \"0,0 30,0 15,10\"\n    }));\n});\n/*#__PURE__*/ Object.assign($7e8f5cd07187803e$export$21b07c8f274aebd5, {\n    displayName: $7e8f5cd07187803e$var$NAME\n});\n/* -----------------------------------------------------------------------------------------------*/ const $7e8f5cd07187803e$export$be92b6f5f03c0fe9 = $7e8f5cd07187803e$export$21b07c8f274aebd5;\n\n\n\n\nexport {$7e8f5cd07187803e$export$21b07c8f274aebd5 as Arrow, $7e8f5cd07187803e$export$be92b6f5f03c0fe9 as Root};\n//# sourceMappingURL=index.mjs.map\n","import $kY93V$babelruntimehelpersesmextends from \"@babel/runtime/helpers/esm/extends\";\nimport {useState as $kY93V$useState, createElement as $kY93V$createElement, forwardRef as $kY93V$forwardRef, useRef as $kY93V$useRef, useEffect as $kY93V$useEffect} from \"react\";\nimport {useFloating as $kY93V$useFloating, autoUpdate as $kY93V$autoUpdate, offset as $kY93V$offset, shift as $kY93V$shift, limitShift as $kY93V$limitShift, flip as $kY93V$flip, size as $kY93V$size, arrow as $kY93V$arrow, hide as $kY93V$hide} from \"@floating-ui/react-dom\";\nimport {Root as $kY93V$Root} from \"@radix-ui/react-arrow\";\nimport {useComposedRefs as $kY93V$useComposedRefs} from \"@radix-ui/react-compose-refs\";\nimport {createContextScope as $kY93V$createContextScope} from \"@radix-ui/react-context\";\nimport {Primitive as $kY93V$Primitive} from \"@radix-ui/react-primitive\";\nimport {useCallbackRef as $kY93V$useCallbackRef} from \"@radix-ui/react-use-callback-ref\";\nimport {useLayoutEffect as $kY93V$useLayoutEffect} from \"@radix-ui/react-use-layout-effect\";\nimport {useSize as $kY93V$useSize} from \"@radix-ui/react-use-size\";\n\n\n\n\n\n\n\n\n\n\n\nconst $cf1ac5d9fe0e8206$export$36f0086da09c4b9f = [\n    'top',\n    'right',\n    'bottom',\n    'left'\n];\nconst $cf1ac5d9fe0e8206$export$3671ffab7b302fc9 = [\n    'start',\n    'center',\n    'end'\n];\n/* -------------------------------------------------------------------------------------------------\n * Popper\n * -----------------------------------------------------------------------------------------------*/ const $cf1ac5d9fe0e8206$var$POPPER_NAME = 'Popper';\nconst [$cf1ac5d9fe0e8206$var$createPopperContext, $cf1ac5d9fe0e8206$export$722aac194ae923] = $kY93V$createContextScope($cf1ac5d9fe0e8206$var$POPPER_NAME);\nconst [$cf1ac5d9fe0e8206$var$PopperProvider, $cf1ac5d9fe0e8206$var$usePopperContext] = $cf1ac5d9fe0e8206$var$createPopperContext($cf1ac5d9fe0e8206$var$POPPER_NAME);\nconst $cf1ac5d9fe0e8206$export$badac9ada3a0bdf9 = (props)=>{\n    const { __scopePopper: __scopePopper , children: children  } = props;\n    const [anchor, setAnchor] = $kY93V$useState(null);\n    return /*#__PURE__*/ $kY93V$createElement($cf1ac5d9fe0e8206$var$PopperProvider, {\n        scope: __scopePopper,\n        anchor: anchor,\n        onAnchorChange: setAnchor\n    }, children);\n};\n/*#__PURE__*/ Object.assign($cf1ac5d9fe0e8206$export$badac9ada3a0bdf9, {\n    displayName: $cf1ac5d9fe0e8206$var$POPPER_NAME\n});\n/* -------------------------------------------------------------------------------------------------\n * PopperAnchor\n * -----------------------------------------------------------------------------------------------*/ const $cf1ac5d9fe0e8206$var$ANCHOR_NAME = 'PopperAnchor';\nconst $cf1ac5d9fe0e8206$export$ecd4e1ccab6ed6d = /*#__PURE__*/ $kY93V$forwardRef((props, forwardedRef)=>{\n    const { __scopePopper: __scopePopper , virtualRef: virtualRef , ...anchorProps } = props;\n    const context = $cf1ac5d9fe0e8206$var$usePopperContext($cf1ac5d9fe0e8206$var$ANCHOR_NAME, __scopePopper);\n    const ref = $kY93V$useRef(null);\n    const composedRefs = $kY93V$useComposedRefs(forwardedRef, ref);\n    $kY93V$useEffect(()=>{\n        // Consumer can anchor the popper to something that isn't\n        // a DOM node e.g. pointer position, so we override the\n        // `anchorRef` with their virtual ref in this case.\n        context.onAnchorChange((virtualRef === null || virtualRef === void 0 ? void 0 : virtualRef.current) || ref.current);\n    });\n    return virtualRef ? null : /*#__PURE__*/ $kY93V$createElement($kY93V$Primitive.div, $kY93V$babelruntimehelpersesmextends({}, anchorProps, {\n        ref: composedRefs\n    }));\n});\n/*#__PURE__*/ Object.assign($cf1ac5d9fe0e8206$export$ecd4e1ccab6ed6d, {\n    displayName: $cf1ac5d9fe0e8206$var$ANCHOR_NAME\n});\n/* -------------------------------------------------------------------------------------------------\n * PopperContent\n * -----------------------------------------------------------------------------------------------*/ const $cf1ac5d9fe0e8206$var$CONTENT_NAME = 'PopperContent';\nconst [$cf1ac5d9fe0e8206$var$PopperContentProvider, $cf1ac5d9fe0e8206$var$useContentContext] = $cf1ac5d9fe0e8206$var$createPopperContext($cf1ac5d9fe0e8206$var$CONTENT_NAME);\nconst $cf1ac5d9fe0e8206$export$bc4ae5855d3c4fc = /*#__PURE__*/ $kY93V$forwardRef((props, forwardedRef)=>{\n    var _arrowSize$width, _arrowSize$height, _middlewareData$arrow, _middlewareData$arrow2, _middlewareData$arrow3, _middlewareData$trans, _middlewareData$trans2, _middlewareData$hide;\n    const { __scopePopper: __scopePopper , side: side = 'bottom' , sideOffset: sideOffset = 0 , align: align = 'center' , alignOffset: alignOffset = 0 , arrowPadding: arrowPadding = 0 , avoidCollisions: avoidCollisions = true , collisionBoundary: collisionBoundary = [] , collisionPadding: collisionPaddingProp = 0 , sticky: sticky = 'partial' , hideWhenDetached: hideWhenDetached = false , updatePositionStrategy: updatePositionStrategy = 'optimized' , onPlaced: onPlaced , ...contentProps } = props;\n    const context = $cf1ac5d9fe0e8206$var$usePopperContext($cf1ac5d9fe0e8206$var$CONTENT_NAME, __scopePopper);\n    const [content, setContent] = $kY93V$useState(null);\n    const composedRefs = $kY93V$useComposedRefs(forwardedRef, (node)=>setContent(node)\n    );\n    const [arrow, setArrow] = $kY93V$useState(null);\n    const arrowSize = $kY93V$useSize(arrow);\n    const arrowWidth = (_arrowSize$width = arrowSize === null || arrowSize === void 0 ? void 0 : arrowSize.width) !== null && _arrowSize$width !== void 0 ? _arrowSize$width : 0;\n    const arrowHeight = (_arrowSize$height = arrowSize === null || arrowSize === void 0 ? void 0 : arrowSize.height) !== null && _arrowSize$height !== void 0 ? _arrowSize$height : 0;\n    const desiredPlacement = side + (align !== 'center' ? '-' + align : '');\n    const collisionPadding = typeof collisionPaddingProp === 'number' ? collisionPaddingProp : {\n        top: 0,\n        right: 0,\n        bottom: 0,\n        left: 0,\n        ...collisionPaddingProp\n    };\n    const boundary = Array.isArray(collisionBoundary) ? collisionBoundary : [\n        collisionBoundary\n    ];\n    const hasExplicitBoundaries = boundary.length > 0;\n    const detectOverflowOptions = {\n        padding: collisionPadding,\n        boundary: boundary.filter($cf1ac5d9fe0e8206$var$isNotNull),\n        // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries\n        altBoundary: hasExplicitBoundaries\n    };\n    const { refs: refs , floatingStyles: floatingStyles , placement: placement , isPositioned: isPositioned , middlewareData: middlewareData  } = $kY93V$useFloating({\n        // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues\n        strategy: 'fixed',\n        placement: desiredPlacement,\n        whileElementsMounted: (...args)=>{\n            const cleanup = $kY93V$autoUpdate(...args, {\n                animationFrame: updatePositionStrategy === 'always'\n            });\n            return cleanup;\n        },\n        elements: {\n            reference: context.anchor\n        },\n        middleware: [\n            $kY93V$offset({\n                mainAxis: sideOffset + arrowHeight,\n                alignmentAxis: alignOffset\n            }),\n            avoidCollisions && $kY93V$shift({\n                mainAxis: true,\n                crossAxis: false,\n                limiter: sticky === 'partial' ? $kY93V$limitShift() : undefined,\n                ...detectOverflowOptions\n            }),\n            avoidCollisions && $kY93V$flip({\n                ...detectOverflowOptions\n            }),\n            $kY93V$size({\n                ...detectOverflowOptions,\n                apply: ({ elements: elements , rects: rects , availableWidth: availableWidth , availableHeight: availableHeight  })=>{\n                    const { width: anchorWidth , height: anchorHeight  } = rects.reference;\n                    const contentStyle = elements.floating.style;\n                    contentStyle.setProperty('--radix-popper-available-width', `${availableWidth}px`);\n                    contentStyle.setProperty('--radix-popper-available-height', `${availableHeight}px`);\n                    contentStyle.setProperty('--radix-popper-anchor-width', `${anchorWidth}px`);\n                    contentStyle.setProperty('--radix-popper-anchor-height', `${anchorHeight}px`);\n                }\n            }),\n            arrow && $kY93V$arrow({\n                element: arrow,\n                padding: arrowPadding\n            }),\n            $cf1ac5d9fe0e8206$var$transformOrigin({\n                arrowWidth: arrowWidth,\n                arrowHeight: arrowHeight\n            }),\n            hideWhenDetached && $kY93V$hide({\n                strategy: 'referenceHidden',\n                ...detectOverflowOptions\n            })\n        ]\n    });\n    const [placedSide, placedAlign] = $cf1ac5d9fe0e8206$var$getSideAndAlignFromPlacement(placement);\n    const handlePlaced = $kY93V$useCallbackRef(onPlaced);\n    $kY93V$useLayoutEffect(()=>{\n        if (isPositioned) handlePlaced === null || handlePlaced === void 0 || handlePlaced();\n    }, [\n        isPositioned,\n        handlePlaced\n    ]);\n    const arrowX = (_middlewareData$arrow = middlewareData.arrow) === null || _middlewareData$arrow === void 0 ? void 0 : _middlewareData$arrow.x;\n    const arrowY = (_middlewareData$arrow2 = middlewareData.arrow) === null || _middlewareData$arrow2 === void 0 ? void 0 : _middlewareData$arrow2.y;\n    const cannotCenterArrow = ((_middlewareData$arrow3 = middlewareData.arrow) === null || _middlewareData$arrow3 === void 0 ? void 0 : _middlewareData$arrow3.centerOffset) !== 0;\n    const [contentZIndex, setContentZIndex] = $kY93V$useState();\n    $kY93V$useLayoutEffect(()=>{\n        if (content) setContentZIndex(window.getComputedStyle(content).zIndex);\n    }, [\n        content\n    ]);\n    return /*#__PURE__*/ $kY93V$createElement(\"div\", {\n        ref: refs.setFloating,\n        \"data-radix-popper-content-wrapper\": \"\",\n        style: {\n            ...floatingStyles,\n            transform: isPositioned ? floatingStyles.transform : 'translate(0, -200%)',\n            // keep off the page when measuring\n            minWidth: 'max-content',\n            zIndex: contentZIndex,\n            ['--radix-popper-transform-origin']: [\n                (_middlewareData$trans = middlewareData.transformOrigin) === null || _middlewareData$trans === void 0 ? void 0 : _middlewareData$trans.x,\n                (_middlewareData$trans2 = middlewareData.transformOrigin) === null || _middlewareData$trans2 === void 0 ? void 0 : _middlewareData$trans2.y\n            ].join(' ')\n        } // Floating UI interally calculates logical alignment based the `dir` attribute on\n        ,\n        dir: props.dir\n    }, /*#__PURE__*/ $kY93V$createElement($cf1ac5d9fe0e8206$var$PopperContentProvider, {\n        scope: __scopePopper,\n        placedSide: placedSide,\n        onArrowChange: setArrow,\n        arrowX: arrowX,\n        arrowY: arrowY,\n        shouldHideArrow: cannotCenterArrow\n    }, /*#__PURE__*/ $kY93V$createElement($kY93V$Primitive.div, $kY93V$babelruntimehelpersesmextends({\n        \"data-side\": placedSide,\n        \"data-align\": placedAlign\n    }, contentProps, {\n        ref: composedRefs,\n        style: {\n            ...contentProps.style,\n            // if the PopperContent hasn't been placed yet (not all measurements done)\n            // we prevent animations so that users's animation don't kick in too early referring wrong sides\n            animation: !isPositioned ? 'none' : undefined,\n            // hide the content if using the hide middleware and should be hidden\n            opacity: (_middlewareData$hide = middlewareData.hide) !== null && _middlewareData$hide !== void 0 && _middlewareData$hide.referenceHidden ? 0 : undefined\n        }\n    }))));\n});\n/*#__PURE__*/ Object.assign($cf1ac5d9fe0e8206$export$bc4ae5855d3c4fc, {\n    displayName: $cf1ac5d9fe0e8206$var$CONTENT_NAME\n});\n/* -------------------------------------------------------------------------------------------------\n * PopperArrow\n * -----------------------------------------------------------------------------------------------*/ const $cf1ac5d9fe0e8206$var$ARROW_NAME = 'PopperArrow';\nconst $cf1ac5d9fe0e8206$var$OPPOSITE_SIDE = {\n    top: 'bottom',\n    right: 'left',\n    bottom: 'top',\n    left: 'right'\n};\nconst $cf1ac5d9fe0e8206$export$79d62cd4e10a3fd0 = /*#__PURE__*/ $kY93V$forwardRef(function $cf1ac5d9fe0e8206$export$79d62cd4e10a3fd0(props, forwardedRef) {\n    const { __scopePopper: __scopePopper , ...arrowProps } = props;\n    const contentContext = $cf1ac5d9fe0e8206$var$useContentContext($cf1ac5d9fe0e8206$var$ARROW_NAME, __scopePopper);\n    const baseSide = $cf1ac5d9fe0e8206$var$OPPOSITE_SIDE[contentContext.placedSide];\n    return(/*#__PURE__*/ // we have to use an extra wrapper because `ResizeObserver` (used by `useSize`)\n    // doesn't report size as we'd expect on SVG elements.\n    // it reports their bounding box which is effectively the largest path inside the SVG.\n    $kY93V$createElement(\"span\", {\n        ref: contentContext.onArrowChange,\n        style: {\n            position: 'absolute',\n            left: contentContext.arrowX,\n            top: contentContext.arrowY,\n            [baseSide]: 0,\n            transformOrigin: {\n                top: '',\n                right: '0 0',\n                bottom: 'center 0',\n                left: '100% 0'\n            }[contentContext.placedSide],\n            transform: {\n                top: 'translateY(100%)',\n                right: 'translateY(50%) rotate(90deg) translateX(-50%)',\n                bottom: `rotate(180deg)`,\n                left: 'translateY(50%) rotate(-90deg) translateX(50%)'\n            }[contentContext.placedSide],\n            visibility: contentContext.shouldHideArrow ? 'hidden' : undefined\n        }\n    }, /*#__PURE__*/ $kY93V$createElement($kY93V$Root, $kY93V$babelruntimehelpersesmextends({}, arrowProps, {\n        ref: forwardedRef,\n        style: {\n            ...arrowProps.style,\n            // ensures the element can be measured correctly (mostly for if SVG)\n            display: 'block'\n        }\n    }))));\n});\n/*#__PURE__*/ Object.assign($cf1ac5d9fe0e8206$export$79d62cd4e10a3fd0, {\n    displayName: $cf1ac5d9fe0e8206$var$ARROW_NAME\n});\n/* -----------------------------------------------------------------------------------------------*/ function $cf1ac5d9fe0e8206$var$isNotNull(value) {\n    return value !== null;\n}\nconst $cf1ac5d9fe0e8206$var$transformOrigin = (options)=>({\n        name: 'transformOrigin',\n        options: options,\n        fn (data) {\n            var _middlewareData$arrow4, _middlewareData$arrow5, _middlewareData$arrow6, _middlewareData$arrow7, _middlewareData$arrow8;\n            const { placement: placement , rects: rects , middlewareData: middlewareData  } = data;\n            const cannotCenterArrow = ((_middlewareData$arrow4 = middlewareData.arrow) === null || _middlewareData$arrow4 === void 0 ? void 0 : _middlewareData$arrow4.centerOffset) !== 0;\n            const isArrowHidden = cannotCenterArrow;\n            const arrowWidth = isArrowHidden ? 0 : options.arrowWidth;\n            const arrowHeight = isArrowHidden ? 0 : options.arrowHeight;\n            const [placedSide, placedAlign] = $cf1ac5d9fe0e8206$var$getSideAndAlignFromPlacement(placement);\n            const noArrowAlign = {\n                start: '0%',\n                center: '50%',\n                end: '100%'\n            }[placedAlign];\n            const arrowXCenter = ((_middlewareData$arrow5 = (_middlewareData$arrow6 = middlewareData.arrow) === null || _middlewareData$arrow6 === void 0 ? void 0 : _middlewareData$arrow6.x) !== null && _middlewareData$arrow5 !== void 0 ? _middlewareData$arrow5 : 0) + arrowWidth / 2;\n            const arrowYCenter = ((_middlewareData$arrow7 = (_middlewareData$arrow8 = middlewareData.arrow) === null || _middlewareData$arrow8 === void 0 ? void 0 : _middlewareData$arrow8.y) !== null && _middlewareData$arrow7 !== void 0 ? _middlewareData$arrow7 : 0) + arrowHeight / 2;\n            let x = '';\n            let y = '';\n            if (placedSide === 'bottom') {\n                x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;\n                y = `${-arrowHeight}px`;\n            } else if (placedSide === 'top') {\n                x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;\n                y = `${rects.floating.height + arrowHeight}px`;\n            } else if (placedSide === 'right') {\n                x = `${-arrowHeight}px`;\n                y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;\n            } else if (placedSide === 'left') {\n                x = `${rects.floating.width + arrowHeight}px`;\n                y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;\n            }\n            return {\n                data: {\n                    x: x,\n                    y: y\n                }\n            };\n        }\n    })\n;\nfunction $cf1ac5d9fe0e8206$var$getSideAndAlignFromPlacement(placement) {\n    const [side, align = 'center'] = placement.split('-');\n    return [\n        side,\n        align\n    ];\n}\nconst $cf1ac5d9fe0e8206$export$be92b6f5f03c0fe9 = $cf1ac5d9fe0e8206$export$badac9ada3a0bdf9;\nconst $cf1ac5d9fe0e8206$export$b688253958b8dfe7 = $cf1ac5d9fe0e8206$export$ecd4e1ccab6ed6d;\nconst $cf1ac5d9fe0e8206$export$7c6e2c02157bb7d2 = $cf1ac5d9fe0e8206$export$bc4ae5855d3c4fc;\nconst $cf1ac5d9fe0e8206$export$21b07c8f274aebd5 = $cf1ac5d9fe0e8206$export$79d62cd4e10a3fd0;\n\n\n\n\nexport {$cf1ac5d9fe0e8206$export$722aac194ae923 as createPopperScope, $cf1ac5d9fe0e8206$export$badac9ada3a0bdf9 as Popper, $cf1ac5d9fe0e8206$export$ecd4e1ccab6ed6d as PopperAnchor, $cf1ac5d9fe0e8206$export$bc4ae5855d3c4fc as PopperContent, $cf1ac5d9fe0e8206$export$79d62cd4e10a3fd0 as PopperArrow, $cf1ac5d9fe0e8206$export$be92b6f5f03c0fe9 as Root, $cf1ac5d9fe0e8206$export$b688253958b8dfe7 as Anchor, $cf1ac5d9fe0e8206$export$7c6e2c02157bb7d2 as Content, $cf1ac5d9fe0e8206$export$21b07c8f274aebd5 as Arrow, $cf1ac5d9fe0e8206$export$36f0086da09c4b9f as SIDE_OPTIONS, $cf1ac5d9fe0e8206$export$3671ffab7b302fc9 as ALIGN_OPTIONS};\n//# sourceMappingURL=index.mjs.map\n","import {useState as $9gyGR$useState} from \"react\";\nimport {useLayoutEffect as $9gyGR$useLayoutEffect} from \"@radix-ui/react-use-layout-effect\";\n\n\n\nfunction $db6c3485150b8e66$export$1ab7ae714698c4b8(element) {\n    const [size, setSize] = $9gyGR$useState(undefined);\n    $9gyGR$useLayoutEffect(()=>{\n        if (element) {\n            // provide size as early as possible\n            setSize({\n                width: element.offsetWidth,\n                height: element.offsetHeight\n            });\n            const resizeObserver = new ResizeObserver((entries)=>{\n                if (!Array.isArray(entries)) return;\n                 // Since we only observe the one element, we don't need to loop over the\n                // array\n                if (!entries.length) return;\n                const entry = entries[0];\n                let width;\n                let height;\n                if ('borderBoxSize' in entry) {\n                    const borderSizeEntry = entry['borderBoxSize']; // iron out differences between browsers\n                    const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;\n                    width = borderSize['inlineSize'];\n                    height = borderSize['blockSize'];\n                } else {\n                    // for browsers that don't support `borderBoxSize`\n                    // we calculate it ourselves to get the correct border box.\n                    width = element.offsetWidth;\n                    height = element.offsetHeight;\n                }\n                setSize({\n                    width: width,\n                    height: height\n                });\n            });\n            resizeObserver.observe(element, {\n                box: 'border-box'\n            });\n            return ()=>resizeObserver.unobserve(element)\n            ;\n        } else // We only want to reset to `undefined` when the element becomes `null`,\n        // not if it changes to another element.\n        setSize(undefined);\n    }, [\n        element\n    ]);\n    return size;\n}\n\n\n\n\nexport {$db6c3485150b8e66$export$1ab7ae714698c4b8 as useSize};\n//# sourceMappingURL=index.mjs.map\n"],"names":["computeCoordsFromPlacement","_ref","placement","rtl","coords","reference","floating","sideAxis","getSideAxis","alignmentAxis","getAlignmentAxis","alignLength","getAxisLength","side","getSide","isVertical","commonX","x","width","commonY","y","height","commonAlign","getAlignment","computePosition","config","strategy","middleware","platform","validMiddleware","filter","Boolean","isRTL","rects","getElementRects","statefulPlacement","middlewareData","resetCount","i","length","name","fn","nextX","nextY","data","reset","initialPlacement","elements","detectOverflow","state","options","_await$platform$isEle","boundary","rootBoundary","elementContext","altBoundary","padding","evaluate","paddingObject","getPaddingObject","element","clippingClientRect","rectToClientRect","getClippingRect","isElement","contextElement","getDocumentElement","rect","offsetParent","getOffsetParent","offsetScale","getScale","elementClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","top","bottom","left","right","arrow","axis","arrowDimensions","getDimensions","isYAxis","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","largestPossiblePadding","minPadding","min","maxPadding","max","center","offset","clamp","shouldAddOffset","alignmentOffset","centerOffset","flip","_middlewareData$arrow","_middlewareData$flip","_middlewareData$flip2","_overflowsData$filter","_overflowsData$map$so","mainAxis","checkMainAxis","crossAxis","checkCrossAxis","fallbackPlacements","specifiedFallbackPlacements","fallbackStrategy","fallbackAxisSideDirection","flipAlignment","detectOverflowOptions","isBasePlacement","getOppositePlacement","getExpandedPlacements","push","getOppositeAxisPlacements","placements","overflow","overflows","overflowsData","sides","getAlignmentSides","every","nextIndex","index","nextPlacement","resetPlacement","d","sort","a","b","map","reduce","acc","getSideOffsets","isAnySideFullyClipped","some","hide","offsets","referenceHiddenOffsets","referenceHidden","escapedOffsets","escaped","convertValueToCoords","alignment","mainAxisMulti","includes","crossAxisMulti","rawValue","_middlewareData$offse","diffCoords","shift","limiter","getOppositeAxis","mainAxisCoord","crossAxisCoord","minSide","maxSide","limitedCoords","limitShift","rawOffset","computedOffset","len","limitMin","limitMax","_middlewareData$offse2","isOriginSide","size","heightSide","widthSide","apply","overflowAvailableHeight","overflowAvailableWidth","noShift","availableHeight","availableWidth","maximumClippingWidth","maximumClippingHeight","xMin","xMax","yMin","yMax","nextDimensions","getNodeName","node","nodeName","toLowerCase","getWindow","_node$ownerDocument","ownerDocument","defaultView","window","isNode","document","documentElement","value","Node","Element","isHTMLElement","HTMLElement","isShadowRoot","ShadowRoot","isOverflowElement","overflowX","overflowY","display","getComputedStyle","test","isContainingBlock","webkit","isWebKit","css","transform","perspective","containerType","backdropFilter","willChange","contain","CSS","supports","isLastTraversableNode","getNodeScroll","scrollLeft","scrollTop","pageXOffset","pageYOffset","getParentNode","result","assignedSlot","parentNode","host","getOverflowAncestors","list","traverseIframes","_node$ownerDocument2","scrollableAncestor","getNearestOverflowAncestor","body","isBody","win","concat","visualViewport","frameElement","getCssDimensions","parseFloat","hasOffset","offsetWidth","offsetHeight","shouldFallback","round","$","unwrapElement","domElement","createCoords","getBoundingClientRect","Number","isFinite","noOffsets","getVisualOffsets","offsetLeft","offsetTop","includeScale","isFixedStrategy","isFixed","clientRect","scale","visualOffsets","shouldAddVisualOffsets","floatingOffsetParent","offsetWin","currentWin","currentIFrame","iframeScale","iframeRect","clientLeft","paddingLeft","clientTop","paddingTop","topLayerSelectors","isTopLayer","selector","matches","e","getWindowScrollBarX","getClientRectFromClippingAncestor","clippingAncestor","getViewportRect","html","clientWidth","clientHeight","visualViewportBased","getDocumentRect","scroll","scrollWidth","scrollHeight","direction","getInnerBoundingClientRect","getTrueOffsetParent","polyfill","position","getContainingBlock","currentNode","getOffsetParentFn","getDimensionsFn","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsetRect","topLayer","clippingAncestors","getClippingElementAncestors","cache","cachedResult","get","el","currentContainingBlockComputedStyle","elementIsFixed","computedStyle","currentNodeIsContaining","hasFixedPositionAncestor","stopNode","ancestor","set","_c","firstClippingAncestor","clippingRect","accRect","getClientRects","Array","from","autoUpdate","update","frameId","ancestorScroll","ancestorResize","elementResize","ResizeObserver","layoutShift","IntersectionObserver","animationFrame","referenceEl","ancestors","forEach","addEventListener","passive","cleanupIo","observeMove","onMove","timeoutId","io","root","cleanup","_io","clearTimeout","disconnect","refresh","skip","threshold","insetTop","floor","insetRight","rootMargin","isFirstUpdate","handleObserve","entries","ratio","intersectionRatio","setTimeout","observe","reobserveFrame","resizeObserver","firstEntry","target","unobserve","cancelAnimationFrame","requestAnimationFrame","_resizeObserver","prevRefRect","frameLoop","nextRefRect","_resizeObserver2","removeEventListener","shift$1","flip$1","size$1","hide$1","arrow$1","limitShift$1","Map","mergedOptions","platformWithCache","computePosition$1","hasOwnProperty","call","current","useLayoutEffect","useEffect","deepEqual","keys","toString","isArray","Object","key","$$typeof","getDPR","devicePixelRatio","roundByDPR","dpr","Math","useLatestRef","ref","React","useFloating","externalReference","externalFloating","whileElementsMounted","open","setData","isPositioned","latestMiddleware","setLatestMiddleware","_reference","_setReference","_floating","_setFloating","setReference","referenceRef","setFloating","floatingRef","floatingEl","dataRef","hasWhileElementsMounted","whileElementsMountedRef","platformRef","then","fullData","isMountedRef","ReactDOM","refs","floatingStyles","initialStyles","v","oppositeSideMap","oppositeAlignmentMap","start","end","param","split","mainAlignmentSide","oppositePlacement","getOppositeAlignmentPlacement","replace","getSideList","isStart","lr","rl","$7e8f5cd07187803e$export$21b07c8f274aebd5","$jbnEx$forwardRef","props","forwardedRef","children","arrowProps","$jbnEx$createElement","$jbnEx$Primitive","svg","$jbnEx$babelruntimehelpersesmextends","viewBox","preserveAspectRatio","asChild","points","$cf1ac5d9fe0e8206$var$POPPER_NAME","$cf1ac5d9fe0e8206$var$createPopperContext","$cf1ac5d9fe0e8206$export$722aac194ae923","$kY93V$createContextScope","$cf1ac5d9fe0e8206$var$PopperProvider","$cf1ac5d9fe0e8206$var$usePopperContext","$cf1ac5d9fe0e8206$export$ecd4e1ccab6ed6d","$kY93V$forwardRef","__scopePopper","virtualRef","anchorProps","context","$kY93V$useRef","composedRefs","$kY93V$useComposedRefs","$kY93V$useEffect","onAnchorChange","$kY93V$createElement","$kY93V$Primitive","div","$kY93V$babelruntimehelpersesmextends","$cf1ac5d9fe0e8206$var$CONTENT_NAME","$cf1ac5d9fe0e8206$var$PopperContentProvider","$cf1ac5d9fe0e8206$var$useContentContext","$cf1ac5d9fe0e8206$export$bc4ae5855d3c4fc","_arrowSize$width","_arrowSize$height","_middlewareData$arrow2","_middlewareData$arrow3","_middlewareData$trans","_middlewareData$trans2","_middlewareData$hide","sideOffset","align","alignOffset","arrowPadding","avoidCollisions","collisionBoundary","collisionPadding","collisionPaddingProp","sticky","hideWhenDetached","updatePositionStrategy","onPlaced","contentProps","content","setContent","$kY93V$useState","setArrow","arrowSize","$kY93V$useSize","arrowWidth","arrowHeight","hasExplicitBoundaries","$cf1ac5d9fe0e8206$var$isNotNull","$kY93V$useFloating","args","$kY93V$autoUpdate","anchor","$kY93V$offset","$kY93V$shift","$kY93V$limitShift","undefined","$kY93V$flip","$kY93V$size","anchorWidth","anchorHeight","contentStyle","style","setProperty","$kY93V$arrow","$cf1ac5d9fe0e8206$var$transformOrigin","$kY93V$hide","placedSide","placedAlign","$cf1ac5d9fe0e8206$var$getSideAndAlignFromPlacement","handlePlaced","$kY93V$useCallbackRef","$kY93V$useLayoutEffect","arrowX","arrowY","cannotCenterArrow","contentZIndex","setContentZIndex","zIndex","minWidth","transformOrigin","join","dir","scope","onArrowChange","shouldHideArrow","animation","opacity","$cf1ac5d9fe0e8206$var$OPPOSITE_SIDE","$cf1ac5d9fe0e8206$export$79d62cd4e10a3fd0","contentContext","baseSide","visibility","_middlewareData$arrow4","_middlewareData$arrow5","_middlewareData$arrow6","_middlewareData$arrow7","_middlewareData$arrow8","isArrowHidden","noArrowAlign","arrowXCenter","arrowYCenter","$cf1ac5d9fe0e8206$export$be92b6f5f03c0fe9","setAnchor","$cf1ac5d9fe0e8206$export$b688253958b8dfe7","$cf1ac5d9fe0e8206$export$7c6e2c02157bb7d2","$cf1ac5d9fe0e8206$export$21b07c8f274aebd5","$db6c3485150b8e66$export$1ab7ae714698c4b8","setSize","$9gyGR$useState","$9gyGR$useLayoutEffect","entry","borderSizeEntry","borderSize","box"],"sourceRoot":""}