dap-design-system 0.60.2 → 0.61.0

package/dist/node_modules/@floating-ui/core/dist/floating-ui.core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"floating-ui.core.js","sources":["../../../../../node_modules/@floating-ui/core/dist/floating-ui.core.mjs"],"sourcesContent":["import { getSideAxis, getAlignmentAxis, getAxisLength, getSide, getAlignment, evaluate, getPaddingObject, rectToClientRect, min, clamp, placements, getAlignmentSides, getOppositeAlignmentPlacement, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, sides, max, getOppositeAxis } from '@floating-ui/utils';\nexport { rectToClientRect } from '@floating-ui/utils';\n\nfunction computeCoordsFromPlacement(_ref, placement, rtl) {\n  let {\n    reference,\n    floating\n  } = _ref;\n  const sideAxis = getSideAxis(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const alignLength = getAxisLength(alignmentAxis);\n  const side = getSide(placement);\n  const isVertical = sideAxis === 'y';\n  const commonX = reference.x + reference.width / 2 - floating.width / 2;\n  const commonY = reference.y + reference.height / 2 - floating.height / 2;\n  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;\n  let coords;\n  switch (side) {\n    case 'top':\n      coords = {\n        x: commonX,\n        y: reference.y - floating.height\n      };\n      break;\n    case 'bottom':\n      coords = {\n        x: commonX,\n        y: reference.y + reference.height\n      };\n      break;\n    case 'right':\n      coords = {\n        x: reference.x + reference.width,\n        y: commonY\n      };\n      break;\n    case 'left':\n      coords = {\n        x: reference.x - floating.width,\n        y: commonY\n      };\n      break;\n    default:\n      coords = {\n        x: reference.x,\n        y: reference.y\n      };\n  }\n  switch (getAlignment(placement)) {\n    case 'start':\n      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n    case 'end':\n      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n  }\n  return coords;\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n *\n * This export does not have any `platform` interface logic. You will need to\n * write one for the platform you are using Floating UI with.\n */\nconst computePosition = async (reference, floating, config) => {\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform\n  } = config;\n  const validMiddleware = middleware.filter(Boolean);\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));\n  let rects = await platform.getElementRects({\n    reference,\n    floating,\n    strategy\n  });\n  let {\n    x,\n    y\n  } = computeCoordsFromPlacement(rects, placement, rtl);\n  let statefulPlacement = placement;\n  let middlewareData = {};\n  let resetCount = 0;\n  for (let i = 0; i < validMiddleware.length; i++) {\n    const {\n      name,\n      fn\n    } = validMiddleware[i];\n    const {\n      x: nextX,\n      y: nextY,\n      data,\n      reset\n    } = await fn({\n      x,\n      y,\n      initialPlacement: placement,\n      placement: statefulPlacement,\n      strategy,\n      middlewareData,\n      rects,\n      platform,\n      elements: {\n        reference,\n        floating\n      }\n    });\n    x = nextX != null ? nextX : x;\n    y = nextY != null ? nextY : y;\n    middlewareData = {\n      ...middlewareData,\n      [name]: {\n        ...middlewareData[name],\n        ...data\n      }\n    };\n    if (reset && resetCount <= 50) {\n      resetCount++;\n      if (typeof reset === 'object') {\n        if (reset.placement) {\n          statefulPlacement = reset.placement;\n        }\n        if (reset.rects) {\n          rects = reset.rects === true ? await platform.getElementRects({\n            reference,\n            floating,\n            strategy\n          }) : reset.rects;\n        }\n        ({\n          x,\n          y\n        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));\n      }\n      i = -1;\n    }\n  }\n  return {\n    x,\n    y,\n    placement: statefulPlacement,\n    strategy,\n    middlewareData\n  };\n};\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nasync function detectOverflow(state, options) {\n  var _await$platform$isEle;\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    x,\n    y,\n    platform,\n    rects,\n    elements,\n    strategy\n  } = state;\n  const {\n    boundary = 'clippingAncestors',\n    rootBoundary = 'viewport',\n    elementContext = 'floating',\n    altBoundary = false,\n    padding = 0\n  } = evaluate(options, state);\n  const paddingObject = getPaddingObject(padding);\n  const altContext = elementContext === 'floating' ? 'reference' : 'floating';\n  const element = elements[altBoundary ? altContext : elementContext];\n  const clippingClientRect = rectToClientRect(await platform.getClippingRect({\n    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),\n    boundary,\n    rootBoundary,\n    strategy\n  }));\n  const rect = elementContext === 'floating' ? {\n    x,\n    y,\n    width: rects.floating.width,\n    height: rects.floating.height\n  } : rects.reference;\n  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));\n  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {\n    x: 1,\n    y: 1\n  } : {\n    x: 1,\n    y: 1\n  };\n  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  }) : rect);\n  return {\n    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,\n    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,\n    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,\n    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x\n  };\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => ({\n  name: 'arrow',\n  options,\n  async fn(state) {\n    const {\n      x,\n      y,\n      placement,\n      rects,\n      platform,\n      elements,\n      middlewareData\n    } = state;\n    // Since `element` is required, we don't Partial<> the type.\n    const {\n      element,\n      padding = 0\n    } = evaluate(options, state) || {};\n    if (element == null) {\n      return {};\n    }\n    const paddingObject = getPaddingObject(padding);\n    const coords = {\n      x,\n      y\n    };\n    const axis = getAlignmentAxis(placement);\n    const length = getAxisLength(axis);\n    const arrowDimensions = await platform.getDimensions(element);\n    const isYAxis = axis === 'y';\n    const minProp = isYAxis ? 'top' : 'left';\n    const maxProp = isYAxis ? 'bottom' : 'right';\n    const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';\n    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];\n    const startDiff = coords[axis] - rects.reference[axis];\n    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));\n    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;\n\n    // DOM platform can return `window` as the `offsetParent`.\n    if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {\n      clientSize = elements.floating[clientProp] || rects.floating[length];\n    }\n    const centerToReference = endDiff / 2 - startDiff / 2;\n\n    // If the padding is large enough that it causes the arrow to no longer be\n    // centered, modify the padding so that it is centered.\n    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;\n    const minPadding = min(paddingObject[minProp], largestPossiblePadding);\n    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);\n\n    // Make sure the arrow doesn't overflow the floating element if the center\n    // point is outside the floating element's bounds.\n    const min$1 = minPadding;\n    const max = clientSize - arrowDimensions[length] - maxPadding;\n    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;\n    const offset = clamp(min$1, center, max);\n\n    // If the reference is small enough that the arrow's padding causes it to\n    // to point to nothing for an aligned placement, adjust the offset of the\n    // floating element itself. To ensure `shift()` continues to take action,\n    // a single reset is performed when this is true.\n    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;\n    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;\n    return {\n      [axis]: coords[axis] + alignmentOffset,\n      data: {\n        [axis]: offset,\n        centerOffset: center - offset - alignmentOffset,\n        ...(shouldAddOffset && {\n          alignmentOffset\n        })\n      },\n      reset: shouldAddOffset\n    };\n  }\n});\n\nfunction getPlacementList(alignment, autoAlignment, allowedPlacements) {\n  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);\n  return allowedPlacementsSortedByAlignment.filter(placement => {\n    if (alignment) {\n      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);\n    }\n    return true;\n  });\n}\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'autoPlacement',\n    options,\n    async fn(state) {\n      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;\n      const {\n        rects,\n        middlewareData,\n        placement,\n        platform,\n        elements\n      } = state;\n      const {\n        crossAxis = false,\n        alignment,\n        allowedPlacements = placements,\n        autoAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;\n      const currentPlacement = placements$1[currentIndex];\n      if (currentPlacement == null) {\n        return {};\n      }\n      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));\n\n      // Make `computeCoords` start from the right place.\n      if (placement !== currentPlacement) {\n        return {\n          reset: {\n            placement: placements$1[0]\n          }\n        };\n      }\n      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];\n      const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {\n        placement: currentPlacement,\n        overflows: currentOverflows\n      }];\n      const nextPlacement = placements$1[currentIndex + 1];\n\n      // There are more placements to check.\n      if (nextPlacement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: nextPlacement\n          }\n        };\n      }\n      const placementsSortedByMostSpace = allOverflows.map(d => {\n        const alignment = getAlignment(d.placement);\n        return [d.placement, alignment && crossAxis ?\n        // Check along the mainAxis and main crossAxis side.\n        d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :\n        // Check only the mainAxis.\n        d.overflows[0], d.overflows];\n      }).sort((a, b) => a[1] - b[1]);\n      const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,\n      // Aligned placements should not check their opposite crossAxis\n      // side.\n      getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));\n      const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];\n      if (resetPlacement !== placement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: resetPlacement\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'flip',\n    options,\n    async fn(state) {\n      var _middlewareData$arrow, _middlewareData$flip;\n      const {\n        placement,\n        middlewareData,\n        rects,\n        initialPlacement,\n        platform,\n        elements\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true,\n        fallbackPlacements: specifiedFallbackPlacements,\n        fallbackStrategy = 'bestFit',\n        fallbackAxisSideDirection = 'none',\n        flipAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n\n      // If a reset by the arrow was caused due to an alignment offset being\n      // added, we should skip any logic now since `flip()` has already done its\n      // work.\n      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643\n      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      const side = getSide(placement);\n      const initialSideAxis = getSideAxis(initialPlacement);\n      const isBasePlacement = getSide(initialPlacement) === initialPlacement;\n      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));\n      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';\n      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {\n        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));\n      }\n      const placements = [initialPlacement, ...fallbackPlacements];\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const overflows = [];\n      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];\n      if (checkMainAxis) {\n        overflows.push(overflow[side]);\n      }\n      if (checkCrossAxis) {\n        const sides = getAlignmentSides(placement, rects, rtl);\n        overflows.push(overflow[sides[0]], overflow[sides[1]]);\n      }\n      overflowsData = [...overflowsData, {\n        placement,\n        overflows\n      }];\n\n      // One or more sides is overflowing.\n      if (!overflows.every(side => side <= 0)) {\n        var _middlewareData$flip2, _overflowsData$filter;\n        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;\n        const nextPlacement = placements[nextIndex];\n        if (nextPlacement) {\n          const ignoreCrossAxisOverflow = checkCrossAxis === 'alignment' ? initialSideAxis !== getSideAxis(nextPlacement) : false;\n          if (!ignoreCrossAxisOverflow ||\n          // We leave the current main axis only if every placement on that axis\n          // overflows the main axis.\n          overflowsData.every(d => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {\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\n        // First, find the candidates that fit on the mainAxis side of overflow,\n        // then find the placement that fits the best on the main crossAxis side.\n        let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;\n\n        // Otherwise fallback.\n        if (!resetPlacement) {\n          switch (fallbackStrategy) {\n            case 'bestFit':\n              {\n                var _overflowsData$filter2;\n                const placement = (_overflowsData$filter2 = overflowsData.filter(d => {\n                  if (hasFallbackAxisSideDirection) {\n                    const currentSideAxis = getSideAxis(d.placement);\n                    return currentSideAxis === initialSideAxis ||\n                    // Create a bias to the `y` side axis due to horizontal\n                    // reading directions favoring greater width.\n                    currentSideAxis === 'y';\n                  }\n                  return true;\n                }).map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];\n                if (placement) {\n                  resetPlacement = placement;\n                }\n                break;\n              }\n            case 'initialPlacement':\n              resetPlacement = initialPlacement;\n              break;\n          }\n        }\n        if (placement !== resetPlacement) {\n          return {\n            reset: {\n              placement: resetPlacement\n            }\n          };\n        }\n      }\n      return {};\n    }\n  };\n};\n\nfunction getSideOffsets(overflow, rect) {\n  return {\n    top: overflow.top - rect.height,\n    right: overflow.right - rect.width,\n    bottom: overflow.bottom - rect.height,\n    left: overflow.left - rect.width\n  };\n}\nfunction isAnySideFullyClipped(overflow) {\n  return sides.some(side => overflow[side] >= 0);\n}\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'hide',\n    options,\n    async fn(state) {\n      const {\n        rects\n      } = state;\n      const {\n        strategy = 'referenceHidden',\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      switch (strategy) {\n        case 'referenceHidden':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              elementContext: 'reference'\n            });\n            const offsets = getSideOffsets(overflow, rects.reference);\n            return {\n              data: {\n                referenceHiddenOffsets: offsets,\n                referenceHidden: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        case 'escaped':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              altBoundary: true\n            });\n            const offsets = getSideOffsets(overflow, rects.floating);\n            return {\n              data: {\n                escapedOffsets: offsets,\n                escaped: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        default:\n          {\n            return {};\n          }\n      }\n    }\n  };\n};\n\nfunction getBoundingRect(rects) {\n  const minX = min(...rects.map(rect => rect.left));\n  const minY = min(...rects.map(rect => rect.top));\n  const maxX = max(...rects.map(rect => rect.right));\n  const maxY = max(...rects.map(rect => rect.bottom));\n  return {\n    x: minX,\n    y: minY,\n    width: maxX - minX,\n    height: maxY - minY\n  };\n}\nfunction getRectsByLine(rects) {\n  const sortedRects = rects.slice().sort((a, b) => a.y - b.y);\n  const groups = [];\n  let prevRect = null;\n  for (let i = 0; i < sortedRects.length; i++) {\n    const rect = sortedRects[i];\n    if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {\n      groups.push([rect]);\n    } else {\n      groups[groups.length - 1].push(rect);\n    }\n    prevRect = rect;\n  }\n  return groups.map(rect => rectToClientRect(getBoundingRect(rect)));\n}\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'inline',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        elements,\n        rects,\n        platform,\n        strategy\n      } = state;\n      // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a\n      // ClientRect's bounds, despite the event listener being triggered. A\n      // padding of 2 seems to handle this issue.\n      const {\n        padding = 2,\n        x,\n        y\n      } = evaluate(options, state);\n      const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);\n      const clientRects = getRectsByLine(nativeClientRects);\n      const fallback = rectToClientRect(getBoundingRect(nativeClientRects));\n      const paddingObject = getPaddingObject(padding);\n      function getBoundingClientRect() {\n        // There are two rects and they are disjoined.\n        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {\n          // Find the first rect in which the point is fully inside.\n          return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;\n        }\n\n        // There are 2 or more connected rects.\n        if (clientRects.length >= 2) {\n          if (getSideAxis(placement) === 'y') {\n            const firstRect = clientRects[0];\n            const lastRect = clientRects[clientRects.length - 1];\n            const isTop = getSide(placement) === 'top';\n            const top = firstRect.top;\n            const bottom = lastRect.bottom;\n            const left = isTop ? firstRect.left : lastRect.left;\n            const right = isTop ? firstRect.right : lastRect.right;\n            const width = right - left;\n            const height = bottom - top;\n            return {\n              top,\n              bottom,\n              left,\n              right,\n              width,\n              height,\n              x: left,\n              y: top\n            };\n          }\n          const isLeftSide = getSide(placement) === 'left';\n          const maxRight = max(...clientRects.map(rect => rect.right));\n          const minLeft = min(...clientRects.map(rect => rect.left));\n          const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);\n          const top = measureRects[0].top;\n          const bottom = measureRects[measureRects.length - 1].bottom;\n          const left = minLeft;\n          const right = maxRight;\n          const width = right - left;\n          const height = bottom - top;\n          return {\n            top,\n            bottom,\n            left,\n            right,\n            width,\n            height,\n            x: left,\n            y: top\n          };\n        }\n        return fallback;\n      }\n      const resetRects = await platform.getElementRects({\n        reference: {\n          getBoundingClientRect\n        },\n        floating: elements.floating,\n        strategy\n      });\n      if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {\n        return {\n          reset: {\n            rects: resetRects\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\nconst originSides = /*#__PURE__*/new Set(['left', 'top']);\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 = originSides.has(side) ? -1 : 1;\n  const crossAxisMulti = rtl && isVertical ? -1 : 1;\n  const rawValue = evaluate(options, state);\n\n  // eslint-disable-next-line prefer-const\n  let {\n    mainAxis,\n    crossAxis,\n    alignmentAxis\n  } = typeof rawValue === 'number' ? {\n    mainAxis: rawValue,\n    crossAxis: 0,\n    alignmentAxis: null\n  } : {\n    mainAxis: rawValue.mainAxis || 0,\n    crossAxis: rawValue.crossAxis || 0,\n    alignmentAxis: rawValue.alignmentAxis\n  };\n  if (alignment && typeof alignmentAxis === 'number') {\n    crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;\n  }\n  return isVertical ? {\n    x: crossAxis * crossAxisMulti,\n    y: mainAxis * mainAxisMulti\n  } : {\n    x: mainAxis * mainAxisMulti,\n    y: crossAxis * crossAxisMulti\n  };\n}\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = function (options) {\n  if (options === void 0) {\n    options = 0;\n  }\n  return {\n    name: 'offset',\n    options,\n    async fn(state) {\n      var _middlewareData$offse, _middlewareData$arrow;\n      const {\n        x,\n        y,\n        placement,\n        middlewareData\n      } = state;\n      const diffCoords = await convertValueToCoords(state, options);\n\n      // If the placement is the same and the arrow caused an alignment offset\n      // then we don't need to change the positioning coordinates.\n      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      return {\n        x: x + diffCoords.x,\n        y: y + diffCoords.y,\n        data: {\n          ...diffCoords,\n          placement\n        }\n      };\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'shift',\n    options,\n    async fn(state) {\n      const {\n        x,\n        y,\n        placement\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = false,\n        limiter = {\n          fn: _ref => {\n            let {\n              x,\n              y\n            } = _ref;\n            return {\n              x,\n              y\n            };\n          }\n        },\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const crossAxis = getSideAxis(getSide(placement));\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      if (checkMainAxis) {\n        const minSide = mainAxis === 'y' ? 'top' : 'left';\n        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';\n        const min = mainAxisCoord + overflow[minSide];\n        const max = mainAxisCoord - overflow[maxSide];\n        mainAxisCoord = clamp(min, mainAxisCoord, max);\n      }\n      if (checkCrossAxis) {\n        const minSide = crossAxis === 'y' ? 'top' : 'left';\n        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';\n        const min = crossAxisCoord + overflow[minSide];\n        const max = crossAxisCoord - overflow[maxSide];\n        crossAxisCoord = clamp(min, crossAxisCoord, max);\n      }\n      const limitedCoords = limiter.fn({\n        ...state,\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      });\n      return {\n        ...limitedCoords,\n        data: {\n          x: limitedCoords.x - x,\n          y: limitedCoords.y - y,\n          enabled: {\n            [mainAxis]: checkMainAxis,\n            [crossAxis]: checkCrossAxis\n          }\n        }\n      };\n    }\n  };\n};\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    options,\n    fn(state) {\n      const {\n        x,\n        y,\n        placement,\n        rects,\n        middlewareData\n      } = state;\n      const {\n        offset = 0,\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const crossAxis = getSideAxis(placement);\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      const rawOffset = evaluate(offset, state);\n      const computedOffset = typeof rawOffset === 'number' ? {\n        mainAxis: rawOffset,\n        crossAxis: 0\n      } : {\n        mainAxis: 0,\n        crossAxis: 0,\n        ...rawOffset\n      };\n      if (checkMainAxis) {\n        const len = mainAxis === 'y' ? 'height' : 'width';\n        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;\n        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;\n        if (mainAxisCoord < limitMin) {\n          mainAxisCoord = limitMin;\n        } else if (mainAxisCoord > limitMax) {\n          mainAxisCoord = limitMax;\n        }\n      }\n      if (checkCrossAxis) {\n        var _middlewareData$offse, _middlewareData$offse2;\n        const len = mainAxis === 'y' ? 'width' : 'height';\n        const isOriginSide = originSides.has(getSide(placement));\n        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);\n        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);\n        if (crossAxisCoord < limitMin) {\n          crossAxisCoord = limitMin;\n        } else if (crossAxisCoord > limitMax) {\n          crossAxisCoord = limitMax;\n        }\n      }\n      return {\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      };\n    }\n  };\n};\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'size',\n    options,\n    async fn(state) {\n      var _state$middlewareData, _state$middlewareData2;\n      const {\n        placement,\n        rects,\n        platform,\n        elements\n      } = state;\n      const {\n        apply = () => {},\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const side = getSide(placement);\n      const alignment = getAlignment(placement);\n      const isYAxis = getSideAxis(placement) === 'y';\n      const {\n        width,\n        height\n      } = rects.floating;\n      let heightSide;\n      let widthSide;\n      if (side === 'top' || side === 'bottom') {\n        heightSide = side;\n        widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';\n      } else {\n        widthSide = side;\n        heightSide = alignment === 'end' ? 'top' : 'bottom';\n      }\n      const maximumClippingHeight = height - overflow.top - overflow.bottom;\n      const maximumClippingWidth = width - overflow.left - overflow.right;\n      const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);\n      const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);\n      const noShift = !state.middlewareData.shift;\n      let availableHeight = overflowAvailableHeight;\n      let availableWidth = overflowAvailableWidth;\n      if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) {\n        availableWidth = maximumClippingWidth;\n      }\n      if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) {\n        availableHeight = maximumClippingHeight;\n      }\n      if (noShift && !alignment) {\n        const xMin = max(overflow.left, 0);\n        const xMax = max(overflow.right, 0);\n        const yMin = max(overflow.top, 0);\n        const yMax = max(overflow.bottom, 0);\n        if (isYAxis) {\n          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));\n        } else {\n          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));\n        }\n      }\n      await apply({\n        ...state,\n        availableWidth,\n        availableHeight\n      });\n      const nextDimensions = await platform.getDimensions(elements.floating);\n      if (width !== nextDimensions.width || height !== nextDimensions.height) {\n        return {\n          reset: {\n            rects: true\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\nexport { arrow, autoPlacement, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, shift, size };\n"],"names":["computeCoordsFromPlacement","_ref","placement","rtl","reference","floating","sideAxis","getSideAxis","alignmentAxis","getAlignmentAxis","alignLength","getAxisLength","side","getSide","isVertical","commonX","commonY","commonAlign","coords","getAlignment","computePosition","config","__async","strategy","middleware","platform","validMiddleware","rects","x","y","statefulPlacement","middlewareData","resetCount","i","name","fn","nextX","nextY","data","reset","__spreadProps","__spreadValues","detectOverflow","state","options","_await$platform$isEle","elements","boundary","rootBoundary","elementContext","altBoundary","padding","evaluate","paddingObject","getPaddingObject","element","clippingClientRect","rectToClientRect","rect","offsetParent","offsetScale","elementClientRect","arrow","axis","length","arrowDimensions","isYAxis","minProp","maxProp","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","centerToReference","largestPossiblePadding","minPadding","min","maxPadding","min$1","max","center","offset","clamp","shouldAddOffset","alignmentOffset","flip","_middlewareData$arrow","_middlewareData$flip","initialPlacement","_a","checkMainAxis","checkCrossAxis","specifiedFallbackPlacements","fallbackStrategy","fallbackAxisSideDirection","flipAlignment","detectOverflowOptions","__objRest","initialSideAxis","isBasePlacement","fallbackPlacements","getOppositePlacement","getExpandedPlacements","hasFallbackAxisSideDirection","getOppositeAxisPlacements","placements","overflow","overflows","overflowsData","sides","getAlignmentSides","_middlewareData$flip2","_overflowsData$filter","nextIndex","nextPlacement","d","resetPlacement","a","b","_overflowsData$filter2","currentSideAxis","acc","originSides","convertValueToCoords","alignment","mainAxisMulti","crossAxisMulti","rawValue","mainAxis","crossAxis","_middlewareData$offse","diffCoords","shift","limiter","getOppositeAxis","mainAxisCoord","crossAxisCoord","minSide","maxSide","limitedCoords","size","_state$middlewareData","_state$middlewareData2","apply","width","height","heightSide","widthSide","maximumClippingHeight","maximumClippingWidth","overflowAvailableHeight","overflowAvailableWidth","noShift","availableHeight","availableWidth","xMin","xMax","yMin","yMax","nextDimensions"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@floating-ui/dom/dist/floating-ui.dom.js

@@ -0,0 +1,427 @@
+var ut = Object.defineProperty, ht = Object.defineProperties;
+var at = Object.getOwnPropertyDescriptors;
+var j = Object.getOwnPropertySymbols;
+var dt = Object.prototype.hasOwnProperty, gt = Object.prototype.propertyIsEnumerable;
+var G = (t, e, o) => e in t ? ut(t, e, { enumerable: !0, configurable: !0, writable: !0, value: o }) : t[e] = o, W = (t, e) => {
+  for (var o in e || (e = {}))
+    dt.call(e, o) && G(t, o, e[o]);
+  if (j)
+    for (var o of j(e))
+      gt.call(e, o) && G(t, o, e[o]);
+  return t;
+}, D = (t, e) => ht(t, at(e));
+var J = (t, e, o) => new Promise((n, i) => {
+  var c = (r) => {
+    try {
+      l(o.next(r));
+    } catch (f) {
+      i(f);
+    }
+  }, s = (r) => {
+    try {
+      l(o.throw(r));
+    } catch (f) {
+      i(f);
+    }
+  }, l = (r) => r.done ? n(r.value) : Promise.resolve(r.value).then(c, s);
+  l((o = o.apply(t, e)).next());
+});
+import { offset as pt, flip as wt, shift as mt, size as yt, arrow as xt, computePosition as vt } from "../../core/dist/floating-ui.core.js";
+import { createCoords as y, rectToClientRect as et, round as H, max as E, min as $, floor as z } from "../../utils/dist/floating-ui.utils.js";
+import { getOverflowAncestors as _, isElement as v, getDocumentElement as R, getWindow as L, getFrameElement as Q, getComputedStyle as b, isHTMLElement as C, isTopLayer as q, getParentNode as S, isLastTraversableNode as I, isTableElement as bt, isContainingBlock as ot, getContainingBlock as Rt, getNodeName as X, isOverflowElement as k, getNodeScroll as M, isWebKit as nt } from "../../utils/dist/floating-ui.utils.dom.js";
+function it(t) {
+  const e = b(t);
+  let o = parseFloat(e.width) || 0, n = parseFloat(e.height) || 0;
+  const i = C(t), c = i ? t.offsetWidth : o, s = i ? t.offsetHeight : n, l = H(o) !== c || H(n) !== s;
+  return l && (o = c, n = s), {
+    width: o,
+    height: n,
+    $: l
+  };
+}
+function P(t) {
+  return v(t) ? t : t.contextElement;
+}
+function F(t) {
+  const e = P(t);
+  if (!C(e))
+    return y(1);
+  const o = e.getBoundingClientRect(), {
+    width: n,
+    height: i,
+    $: c
+  } = it(e);
+  let s = (c ? H(o.width) : o.width) / n, l = (c ? H(o.height) : o.height) / i;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!l || !Number.isFinite(l)) && (l = 1), {
+    x: s,
+    y: l
+  };
+}
+const Ct = /* @__PURE__ */ y(0);
+function st(t) {
+  const e = L(t);
+  return !nt() || !e.visualViewport ? Ct : {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+function Ot(t, e, o) {
+  return e === void 0 && (e = !1), !o || e && o !== L(t) ? !1 : e;
+}
+function T(t, e, o, n) {
+  e === void 0 && (e = !1), o === void 0 && (o = !1);
+  const i = t.getBoundingClientRect(), c = P(t);
+  let s = y(1);
+  e && (n ? v(n) && (s = F(n)) : s = F(t));
+  const l = Ot(c, o, n) ? st(c) : y(0);
+  let r = (i.left + l.x) / s.x, f = (i.top + l.y) / s.y, u = i.width / s.x, h = i.height / s.y;
+  if (c) {
+    const d = L(c), a = n && v(n) ? L(n) : n;
+    let w = d, p = Q(w);
+    for (; p && n && a !== w; ) {
+      const m = F(p), g = p.getBoundingClientRect(), x = b(p), O = g.left + (p.clientLeft + parseFloat(x.paddingLeft)) * m.x, B = g.top + (p.clientTop + parseFloat(x.paddingTop)) * m.y;
+      r *= m.x, f *= m.y, u *= m.x, h *= m.y, r += O, f += B, w = L(p), p = Q(w);
+    }
+  }
+  return et({
+    width: u,
+    height: h,
+    x: r,
+    y: f
+  });
+}
+function N(t, e) {
+  const o = M(t).scrollLeft;
+  return e ? e.left + o : T(R(t)).left + o;
+}
+function rt(t, e) {
+  const o = t.getBoundingClientRect(), n = o.left + e.scrollLeft - N(t, o), i = o.top + e.scrollTop;
+  return {
+    x: n,
+    y: i
+  };
+}
+function Lt(t) {
+  let {
+    elements: e,
+    rect: o,
+    offsetParent: n,
+    strategy: i
+  } = t;
+  const c = i === "fixed", s = R(n), l = e ? q(e.floating) : !1;
+  if (n === s || l && c)
+    return o;
+  let r = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, f = y(1);
+  const u = y(0), h = C(n);
+  if ((h || !h && !c) && ((X(n) !== "body" || k(s)) && (r = M(n)), C(n))) {
+    const a = T(n);
+    f = F(n), u.x = a.x + n.clientLeft, u.y = a.y + n.clientTop;
+  }
+  const d = s && !h && !c ? rt(s, r) : y(0);
+  return {
+    width: o.width * f.x,
+    height: o.height * f.y,
+    x: o.x * f.x - r.scrollLeft * f.x + u.x + d.x,
+    y: o.y * f.y - r.scrollTop * f.y + u.y + d.y
+  };
+}
+function Tt(t) {
+  return Array.from(t.getClientRects());
+}
+function Et(t) {
+  const e = R(t), o = M(t), n = t.ownerDocument.body, i = E(e.scrollWidth, e.clientWidth, n.scrollWidth, n.clientWidth), c = E(e.scrollHeight, e.clientHeight, n.scrollHeight, n.clientHeight);
+  let s = -o.scrollLeft + N(t);
+  const l = -o.scrollTop;
+  return b(n).direction === "rtl" && (s += E(e.clientWidth, n.clientWidth) - i), {
+    width: i,
+    height: c,
+    x: s,
+    y: l
+  };
+}
+const Y = 25;
+function Ft(t, e) {
+  const o = L(t), n = R(t), i = o.visualViewport;
+  let c = n.clientWidth, s = n.clientHeight, l = 0, r = 0;
+  if (i) {
+    c = i.width, s = i.height;
+    const u = nt();
+    (!u || u && e === "fixed") && (l = i.offsetLeft, r = i.offsetTop);
+  }
+  const f = N(n);
+  if (f <= 0) {
+    const u = n.ownerDocument, h = u.body, d = getComputedStyle(h), a = u.compatMode === "CSS1Compat" && parseFloat(d.marginLeft) + parseFloat(d.marginRight) || 0, w = Math.abs(n.clientWidth - h.clientWidth - a);
+    w <= Y && (c -= w);
+  } else f <= Y && (c += f);
+  return {
+    width: c,
+    height: s,
+    x: l,
+    y: r
+  };
+}
+const Wt = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function St(t, e) {
+  const o = T(t, !0, e === "fixed"), n = o.top + t.clientTop, i = o.left + t.clientLeft, c = C(t) ? F(t) : y(1), s = t.clientWidth * c.x, l = t.clientHeight * c.y, r = i * c.x, f = n * c.y;
+  return {
+    width: s,
+    height: l,
+    x: r,
+    y: f
+  };
+}
+function Z(t, e, o) {
+  let n;
+  if (e === "viewport")
+    n = Ft(t, o);
+  else if (e === "document")
+    n = Et(R(t));
+  else if (v(e))
+    n = St(e, o);
+  else {
+    const i = st(t);
+    n = {
+      x: e.x - i.x,
+      y: e.y - i.y,
+      width: e.width,
+      height: e.height
+    };
+  }
+  return et(n);
+}
+function ct(t, e) {
+  const o = S(t);
+  return o === e || !v(o) || I(o) ? !1 : b(o).position === "fixed" || ct(o, e);
+}
+function Bt(t, e) {
+  const o = e.get(t);
+  if (o)
+    return o;
+  let n = _(t, [], !1).filter((l) => v(l) && X(l) !== "body"), i = null;
+  const c = b(t).position === "fixed";
+  let s = c ? S(t) : t;
+  for (; v(s) && !I(s); ) {
+    const l = b(s), r = ot(s);
+    !r && l.position === "fixed" && (i = null), (c ? !r && !i : !r && l.position === "static" && !!i && Wt.has(i.position) || k(s) && !r && ct(t, s)) ? n = n.filter((u) => u !== s) : i = l, s = S(s);
+  }
+  return e.set(t, n), n;
+}
+function At(t) {
+  let {
+    element: e,
+    boundary: o,
+    rootBoundary: n,
+    strategy: i
+  } = t;
+  const s = [...o === "clippingAncestors" ? q(e) ? [] : Bt(e, this._c) : [].concat(o), n], l = s[0], r = s.reduce((f, u) => {
+    const h = Z(e, u, i);
+    return f.top = E(h.top, f.top), f.right = $(h.right, f.right), f.bottom = $(h.bottom, f.bottom), f.left = E(h.left, f.left), f;
+  }, Z(e, l, i));
+  return {
+    width: r.right - r.left,
+    height: r.bottom - r.top,
+    x: r.left,
+    y: r.top
+  };
+}
+function Dt(t) {
+  const {
+    width: e,
+    height: o
+  } = it(t);
+  return {
+    width: e,
+    height: o
+  };
+}
+function zt(t, e, o) {
+  const n = C(e), i = R(e), c = o === "fixed", s = T(t, !0, c, e);
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const r = y(0);
+  function f() {
+    r.x = N(i);
+  }
+  if (n || !n && !c)
+    if ((X(e) !== "body" || k(i)) && (l = M(e)), n) {
+      const a = T(e, !0, c, e);
+      r.x = a.x + e.clientLeft, r.y = a.y + e.clientTop;
+    } else i && f();
+  c && !n && i && f();
+  const u = i && !n && !c ? rt(i, l) : y(0), h = s.left + l.scrollLeft - r.x - u.x, d = s.top + l.scrollTop - r.y - u.y;
+  return {
+    x: h,
+    y: d,
+    width: s.width,
+    height: s.height
+  };
+}
+function V(t) {
+  return b(t).position === "static";
+}
+function tt(t, e) {
+  if (!C(t) || b(t).position === "fixed")
+    return null;
+  if (e)
+    return e(t);
+  let o = t.offsetParent;
+  return R(t) === o && (o = o.ownerDocument.body), o;
+}
+function lt(t, e) {
+  const o = L(t);
+  if (q(t))
+    return o;
+  if (!C(t)) {
+    let i = S(t);
+    for (; i && !I(i); ) {
+      if (v(i) && !V(i))
+        return i;
+      i = S(i);
+    }
+    return o;
+  }
+  let n = tt(t, e);
+  for (; n && bt(n) && V(n); )
+    n = tt(n, e);
+  return n && I(n) && V(n) && !ot(n) ? o : n || Rt(t) || o;
+}
+const Ht = function(t) {
+  return J(this, null, function* () {
+    const e = this.getOffsetParent || lt, o = this.getDimensions, n = yield o(t.floating);
+    return {
+      reference: zt(t.reference, yield e(t.floating), t.strategy),
+      floating: {
+        x: 0,
+        y: 0,
+        width: n.width,
+        height: n.height
+      }
+    };
+  });
+};
+function It(t) {
+  return b(t).direction === "rtl";
+}
+const Mt = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Lt,
+  getDocumentElement: R,
+  getClippingRect: At,
+  getOffsetParent: lt,
+  getElementRects: Ht,
+  getClientRects: Tt,
+  getDimensions: Dt,
+  getScale: F,
+  isElement: v,
+  isRTL: It
+};
+function ft(t, e) {
+  return t.x === e.x && t.y === e.y && t.width === e.width && t.height === e.height;
+}
+function Nt(t, e) {
+  let o = null, n;
+  const i = R(t);
+  function c() {
+    var l;
+    clearTimeout(n), (l = o) == null || l.disconnect(), o = null;
+  }
+  function s(l, r) {
+    l === void 0 && (l = !1), r === void 0 && (r = 1), c();
+    const f = t.getBoundingClientRect(), {
+      left: u,
+      top: h,
+      width: d,
+      height: a
+    } = f;
+    if (l || e(), !d || !a)
+      return;
+    const w = z(h), p = z(i.clientWidth - (u + d)), m = z(i.clientHeight - (h + a)), g = z(u), O = {
+      rootMargin: -w + "px " + -p + "px " + -m + "px " + -g + "px",
+      threshold: E(0, $(1, r)) || 1
+    };
+    let B = !0;
+    function U(K) {
+      const A = K[0].intersectionRatio;
+      if (A !== r) {
+        if (!B)
+          return s();
+        A ? s(!1, A) : n = setTimeout(() => {
+          s(!1, 1e-7);
+        }, 1e3);
+      }
+      A === 1 && !ft(f, t.getBoundingClientRect()) && s(), B = !1;
+    }
+    try {
+      o = new IntersectionObserver(U, D(W({}, O), {
+        // Handle <iframe>s
+        root: i.ownerDocument
+      }));
+    } catch (K) {
+      o = new IntersectionObserver(U, O);
+    }
+    o.observe(t);
+  }
+  return s(!0), c;
+}
+function Xt(t, e, o, n) {
+  n === void 0 && (n = {});
+  const {
+    ancestorScroll: i = !0,
+    ancestorResize: c = !0,
+    elementResize: s = typeof ResizeObserver == "function",
+    layoutShift: l = typeof IntersectionObserver == "function",
+    animationFrame: r = !1
+  } = n, f = P(t), u = i || c ? [...f ? _(f) : [], ..._(e)] : [];
+  u.forEach((g) => {
+    i && g.addEventListener("scroll", o, {
+      passive: !0
+    }), c && g.addEventListener("resize", o);
+  });
+  const h = f && l ? Nt(f, o) : null;
+  let d = -1, a = null;
+  s && (a = new ResizeObserver((g) => {
+    let [x] = g;
+    x && x.target === f && a && (a.unobserve(e), cancelAnimationFrame(d), d = requestAnimationFrame(() => {
+      var O;
+      (O = a) == null || O.observe(e);
+    })), o();
+  }), f && !r && a.observe(f), a.observe(e));
+  let w, p = r ? T(t) : null;
+  r && m();
+  function m() {
+    const g = T(t);
+    p && !ft(p, g) && o(), p = g, w = requestAnimationFrame(m);
+  }
+  return o(), () => {
+    var g;
+    u.forEach((x) => {
+      i && x.removeEventListener("scroll", o), c && x.removeEventListener("resize", o);
+    }), h == null || h(), (g = a) == null || g.disconnect(), a = null, r && cancelAnimationFrame(w);
+  };
+}
+const kt = pt, Pt = mt, Ut = wt, Kt = yt, jt = xt, Gt = (t, e, o) => {
+  const n = /* @__PURE__ */ new Map(), i = W({
+    platform: Mt
+  }, o), c = D(W({}, i.platform), {
+    _c: n
+  });
+  return vt(t, e, D(W({}, i), {
+    platform: c
+  }));
+};
+export {
+  jt as arrow,
+  Xt as autoUpdate,
+  Gt as computePosition,
+  Ut as flip,
+  _ as getOverflowAncestors,
+  kt as offset,
+  Mt as platform,
+  Pt as shift,
+  Kt as size
+};
+//# sourceMappingURL=floating-ui.dom.js.map