@eightshift/ui-components 0.0.1

package/dist/tooltip-CkCndvTI.js

@@ -0,0 +1,1094 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { g as $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c, o as $b5e257d569688ac6$export$535bd6ca7f90a273, d as $3ef42575df84b30b$export$9d1611c77c2fe928, e as $bdb11010cef70236$export$f680877a34711e37, a as $64fa3d84918910a7$export$29f1550f4b0d4415, c as $64fa3d84918910a7$export$4d86445c2cf5e3, j as $64fa3d84918910a7$export$2881499e37b75b9a, q as $64fa3d84918910a7$export$45fda7c47f93fd48, r as $64fa3d84918910a7$export$6d3443f2c48bfc20 } from "./utils-BsiH7-5Y.js";
+import React__default, { useEffect, useState, useRef, useCallback, useContext, useMemo, forwardRef, createContext } from "react";
+import { $ as $e6afbd83fe6ebbd2$export$4c014de7c8940b4c, b as $e6afbd83fe6ebbd2$export$13f3202a3e5ddd5 } from "./useFocusable-5q1Gek1J.js";
+import { p as $c87311424ea30a05$export$78551043582a6a98, $ as $6179b936705e76d3$export$ae780daf29e6d456, t as $507fabe10e71c6fb$export$630ff653c5ada6a9, a as $507fabe10e71c6fb$export$b9b3dfddab17db27, e as $458b0a5536c1a7cf$export$40bfa8c7b0832715, d as $9ab94262bd0047c7$export$420e68273165f4ec } from "./focusSafely-C3K8zAKj.js";
+import { $ as $65484d02dcb7eb3e$export$457c3d6518dd4c6f } from "./filterDOMProps-DG2RfOUr.js";
+import { $ as $dbSRa$reactdom } from "./index-Bfb9bWcb.js";
+import { $ as $9446cca9a3875146$export$7d15b64cf5a3a4c4 } from "./number-rWqELA8W.js";
+import { $ as $18f2051aff69b9bf$export$43bb16f9c6d9e3f7 } from "./context-jMy6xdVq.js";
+import { classnames } from "./utilities/classnames.js";
+function $9daab02d461809db$var$hasResizeObserver() {
+  return typeof window.ResizeObserver !== "undefined";
+}
+function $9daab02d461809db$export$683480f191c0e3ea(options) {
+  const { ref, onResize } = options;
+  useEffect(() => {
+    let element = ref === null || ref === void 0 ? void 0 : ref.current;
+    if (!element)
+      return;
+    if (!$9daab02d461809db$var$hasResizeObserver()) {
+      window.addEventListener("resize", onResize, false);
+      return () => {
+        window.removeEventListener("resize", onResize, false);
+      };
+    } else {
+      const resizeObserverInstance = new window.ResizeObserver((entries) => {
+        if (!entries.length)
+          return;
+        onResize();
+      });
+      resizeObserverInstance.observe(element);
+      return () => {
+        if (element)
+          resizeObserverInstance.unobserve(element);
+      };
+    }
+  }, [
+    onResize,
+    ref
+  ]);
+}
+const $edcf132a9284368a$var$AXIS = {
+  top: "top",
+  bottom: "top",
+  left: "left",
+  right: "left"
+};
+const $edcf132a9284368a$var$FLIPPED_DIRECTION = {
+  top: "bottom",
+  bottom: "top",
+  left: "right",
+  right: "left"
+};
+const $edcf132a9284368a$var$CROSS_AXIS = {
+  top: "left",
+  left: "top"
+};
+const $edcf132a9284368a$var$AXIS_SIZE = {
+  top: "height",
+  left: "width"
+};
+const $edcf132a9284368a$var$TOTAL_SIZE = {
+  width: "totalWidth",
+  height: "totalHeight"
+};
+const $edcf132a9284368a$var$PARSED_PLACEMENT_CACHE = {};
+let $edcf132a9284368a$var$visualViewport = typeof document !== "undefined" && window.visualViewport;
+function $edcf132a9284368a$var$getContainerDimensions(containerNode) {
+  let width = 0, height = 0, totalWidth = 0, totalHeight = 0, top = 0, left = 0;
+  let scroll = {};
+  let isPinchZoomedIn = ($edcf132a9284368a$var$visualViewport === null || $edcf132a9284368a$var$visualViewport === void 0 ? void 0 : $edcf132a9284368a$var$visualViewport.scale) > 1;
+  if (containerNode.tagName === "BODY") {
+    let documentElement = document.documentElement;
+    totalWidth = documentElement.clientWidth;
+    totalHeight = documentElement.clientHeight;
+    var _visualViewport_width;
+    width = (_visualViewport_width = $edcf132a9284368a$var$visualViewport === null || $edcf132a9284368a$var$visualViewport === void 0 ? void 0 : $edcf132a9284368a$var$visualViewport.width) !== null && _visualViewport_width !== void 0 ? _visualViewport_width : totalWidth;
+    var _visualViewport_height;
+    height = (_visualViewport_height = $edcf132a9284368a$var$visualViewport === null || $edcf132a9284368a$var$visualViewport === void 0 ? void 0 : $edcf132a9284368a$var$visualViewport.height) !== null && _visualViewport_height !== void 0 ? _visualViewport_height : totalHeight;
+    scroll.top = documentElement.scrollTop || containerNode.scrollTop;
+    scroll.left = documentElement.scrollLeft || containerNode.scrollLeft;
+    if ($edcf132a9284368a$var$visualViewport) {
+      top = $edcf132a9284368a$var$visualViewport.offsetTop;
+      left = $edcf132a9284368a$var$visualViewport.offsetLeft;
+    }
+  } else {
+    ({ width, height, top, left } = $edcf132a9284368a$var$getOffset(containerNode));
+    scroll.top = containerNode.scrollTop;
+    scroll.left = containerNode.scrollLeft;
+    totalWidth = width;
+    totalHeight = height;
+  }
+  if ($c87311424ea30a05$export$78551043582a6a98() && (containerNode.tagName === "BODY" || containerNode.tagName === "HTML") && isPinchZoomedIn) {
+    scroll.top = 0;
+    scroll.left = 0;
+    top = $edcf132a9284368a$var$visualViewport.pageTop;
+    left = $edcf132a9284368a$var$visualViewport.pageLeft;
+  }
+  return {
+    width,
+    height,
+    totalWidth,
+    totalHeight,
+    scroll,
+    top,
+    left
+  };
+}
+function $edcf132a9284368a$var$getScroll(node) {
+  return {
+    top: node.scrollTop,
+    left: node.scrollLeft,
+    width: node.scrollWidth,
+    height: node.scrollHeight
+  };
+}
+function $edcf132a9284368a$var$getDelta(axis, offset, size, boundaryDimensions, containerDimensions, padding, containerOffsetWithBoundary) {
+  let containerScroll = containerDimensions.scroll[axis];
+  let boundarySize = boundaryDimensions[$edcf132a9284368a$var$AXIS_SIZE[axis]];
+  let boundaryStartEdge = boundaryDimensions.scroll[$edcf132a9284368a$var$AXIS[axis]] + padding;
+  let boundaryEndEdge = boundarySize + boundaryDimensions.scroll[$edcf132a9284368a$var$AXIS[axis]] - padding;
+  let startEdgeOffset = offset - containerScroll + containerOffsetWithBoundary[axis] - boundaryDimensions[$edcf132a9284368a$var$AXIS[axis]];
+  let endEdgeOffset = offset - containerScroll + size + containerOffsetWithBoundary[axis] - boundaryDimensions[$edcf132a9284368a$var$AXIS[axis]];
+  if (startEdgeOffset < boundaryStartEdge)
+    return boundaryStartEdge - startEdgeOffset;
+  else if (endEdgeOffset > boundaryEndEdge)
+    return Math.max(boundaryEndEdge - endEdgeOffset, boundaryStartEdge - startEdgeOffset);
+  else
+    return 0;
+}
+function $edcf132a9284368a$var$getMargins(node) {
+  let style = window.getComputedStyle(node);
+  return {
+    top: parseInt(style.marginTop, 10) || 0,
+    bottom: parseInt(style.marginBottom, 10) || 0,
+    left: parseInt(style.marginLeft, 10) || 0,
+    right: parseInt(style.marginRight, 10) || 0
+  };
+}
+function $edcf132a9284368a$var$parsePlacement(input) {
+  if ($edcf132a9284368a$var$PARSED_PLACEMENT_CACHE[input])
+    return $edcf132a9284368a$var$PARSED_PLACEMENT_CACHE[input];
+  let [placement, crossPlacement] = input.split(" ");
+  let axis = $edcf132a9284368a$var$AXIS[placement] || "right";
+  let crossAxis = $edcf132a9284368a$var$CROSS_AXIS[axis];
+  if (!$edcf132a9284368a$var$AXIS[crossPlacement])
+    crossPlacement = "center";
+  let size = $edcf132a9284368a$var$AXIS_SIZE[axis];
+  let crossSize = $edcf132a9284368a$var$AXIS_SIZE[crossAxis];
+  $edcf132a9284368a$var$PARSED_PLACEMENT_CACHE[input] = {
+    placement,
+    crossPlacement,
+    axis,
+    crossAxis,
+    size,
+    crossSize
+  };
+  return $edcf132a9284368a$var$PARSED_PLACEMENT_CACHE[input];
+}
+function $edcf132a9284368a$var$computePosition(childOffset, boundaryDimensions, overlaySize, placementInfo, offset, crossOffset, containerOffsetWithBoundary, isContainerPositioned, arrowSize, arrowBoundaryOffset) {
+  let { placement, crossPlacement, axis, crossAxis, size, crossSize } = placementInfo;
+  let position = {};
+  position[crossAxis] = childOffset[crossAxis];
+  if (crossPlacement === "center")
+    position[crossAxis] += (childOffset[crossSize] - overlaySize[crossSize]) / 2;
+  else if (crossPlacement !== crossAxis)
+    position[crossAxis] += childOffset[crossSize] - overlaySize[crossSize];
+  position[crossAxis] += crossOffset;
+  const minPosition = childOffset[crossAxis] - overlaySize[crossSize] + arrowSize + arrowBoundaryOffset;
+  const maxPosition = childOffset[crossAxis] + childOffset[crossSize] - arrowSize - arrowBoundaryOffset;
+  position[crossAxis] = $9446cca9a3875146$export$7d15b64cf5a3a4c4(position[crossAxis], minPosition, maxPosition);
+  if (placement === axis) {
+    const containerHeight = isContainerPositioned ? containerOffsetWithBoundary[size] : boundaryDimensions[$edcf132a9284368a$var$TOTAL_SIZE[size]];
+    position[$edcf132a9284368a$var$FLIPPED_DIRECTION[axis]] = Math.floor(containerHeight - childOffset[axis] + offset);
+  } else
+    position[axis] = Math.floor(childOffset[axis] + childOffset[size] + offset);
+  return position;
+}
+function $edcf132a9284368a$var$getMaxHeight(position, boundaryDimensions, containerOffsetWithBoundary, isContainerPositioned, margins, padding, overlayHeight, heightGrowthDirection) {
+  const containerHeight = isContainerPositioned ? containerOffsetWithBoundary.height : boundaryDimensions[$edcf132a9284368a$var$TOTAL_SIZE.height];
+  let overlayTop = position.top != null ? containerOffsetWithBoundary.top + position.top : containerOffsetWithBoundary.top + (containerHeight - position.bottom - overlayHeight);
+  let maxHeight = heightGrowthDirection !== "top" ? (
+    // We want the distance between the top of the overlay to the bottom of the boundary
+    Math.max(0, boundaryDimensions.height + boundaryDimensions.top + boundaryDimensions.scroll.top - overlayTop - (margins.top + margins.bottom + padding))
+  ) : Math.max(0, overlayTop + overlayHeight - (boundaryDimensions.top + boundaryDimensions.scroll.top) - (margins.top + margins.bottom + padding));
+  return Math.min(boundaryDimensions.height - padding * 2, maxHeight);
+}
+function $edcf132a9284368a$var$getAvailableSpace(boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding, placementInfo) {
+  let { placement, axis, size } = placementInfo;
+  if (placement === axis)
+    return Math.max(0, childOffset[axis] - boundaryDimensions[axis] - boundaryDimensions.scroll[axis] + containerOffsetWithBoundary[axis] - margins[axis] - margins[$edcf132a9284368a$var$FLIPPED_DIRECTION[axis]] - padding);
+  return Math.max(0, boundaryDimensions[size] + boundaryDimensions[axis] + boundaryDimensions.scroll[axis] - containerOffsetWithBoundary[axis] - childOffset[axis] - childOffset[size] - margins[axis] - margins[$edcf132a9284368a$var$FLIPPED_DIRECTION[axis]] - padding);
+}
+function $edcf132a9284368a$export$6839422d1f33cee9(placementInput, childOffset, overlaySize, scrollSize, margins, padding, flip, boundaryDimensions, containerDimensions, containerOffsetWithBoundary, offset, crossOffset, isContainerPositioned, userSetMaxHeight, arrowSize, arrowBoundaryOffset) {
+  let placementInfo = $edcf132a9284368a$var$parsePlacement(placementInput);
+  let { size, crossAxis, crossSize, placement, crossPlacement } = placementInfo;
+  let position = $edcf132a9284368a$var$computePosition(childOffset, boundaryDimensions, overlaySize, placementInfo, offset, crossOffset, containerOffsetWithBoundary, isContainerPositioned, arrowSize, arrowBoundaryOffset);
+  let normalizedOffset = offset;
+  let space = $edcf132a9284368a$var$getAvailableSpace(boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding + offset, placementInfo);
+  if (flip && scrollSize[size] > space) {
+    let flippedPlacementInfo = $edcf132a9284368a$var$parsePlacement(`${$edcf132a9284368a$var$FLIPPED_DIRECTION[placement]} ${crossPlacement}`);
+    let flippedPosition = $edcf132a9284368a$var$computePosition(childOffset, boundaryDimensions, overlaySize, flippedPlacementInfo, offset, crossOffset, containerOffsetWithBoundary, isContainerPositioned, arrowSize, arrowBoundaryOffset);
+    let flippedSpace = $edcf132a9284368a$var$getAvailableSpace(boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding + offset, flippedPlacementInfo);
+    if (flippedSpace > space) {
+      placementInfo = flippedPlacementInfo;
+      position = flippedPosition;
+      normalizedOffset = offset;
+    }
+  }
+  let heightGrowthDirection = "bottom";
+  if (placementInfo.axis === "top") {
+    if (placementInfo.placement === "top")
+      heightGrowthDirection = "top";
+    else if (placementInfo.placement === "bottom")
+      heightGrowthDirection = "bottom";
+  } else if (placementInfo.crossAxis === "top") {
+    if (placementInfo.crossPlacement === "top")
+      heightGrowthDirection = "bottom";
+    else if (placementInfo.crossPlacement === "bottom")
+      heightGrowthDirection = "top";
+  }
+  let delta = $edcf132a9284368a$var$getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, containerDimensions, padding, containerOffsetWithBoundary);
+  position[crossAxis] += delta;
+  let maxHeight = $edcf132a9284368a$var$getMaxHeight(position, boundaryDimensions, containerOffsetWithBoundary, isContainerPositioned, margins, padding, overlaySize.height, heightGrowthDirection);
+  if (userSetMaxHeight && userSetMaxHeight < maxHeight)
+    maxHeight = userSetMaxHeight;
+  overlaySize.height = Math.min(overlaySize.height, maxHeight);
+  position = $edcf132a9284368a$var$computePosition(childOffset, boundaryDimensions, overlaySize, placementInfo, normalizedOffset, crossOffset, containerOffsetWithBoundary, isContainerPositioned, arrowSize, arrowBoundaryOffset);
+  delta = $edcf132a9284368a$var$getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, containerDimensions, padding, containerOffsetWithBoundary);
+  position[crossAxis] += delta;
+  let arrowPosition = {};
+  let preferredArrowPosition = childOffset[crossAxis] + 0.5 * childOffset[crossSize] - position[crossAxis];
+  const arrowMinPosition = arrowSize / 2 + arrowBoundaryOffset;
+  const arrowMaxPosition = overlaySize[crossSize] - arrowSize / 2 - arrowBoundaryOffset;
+  const arrowOverlappingChildMinEdge = childOffset[crossAxis] - position[crossAxis] + arrowSize / 2;
+  const arrowOverlappingChildMaxEdge = childOffset[crossAxis] + childOffset[crossSize] - position[crossAxis] - arrowSize / 2;
+  const arrowPositionOverlappingChild = $9446cca9a3875146$export$7d15b64cf5a3a4c4(preferredArrowPosition, arrowOverlappingChildMinEdge, arrowOverlappingChildMaxEdge);
+  arrowPosition[crossAxis] = $9446cca9a3875146$export$7d15b64cf5a3a4c4(arrowPositionOverlappingChild, arrowMinPosition, arrowMaxPosition);
+  return {
+    position,
+    maxHeight,
+    arrowOffsetLeft: arrowPosition.left,
+    arrowOffsetTop: arrowPosition.top,
+    placement: placementInfo.placement
+  };
+}
+function $edcf132a9284368a$export$b3ceb0cbf1056d98(opts) {
+  let { placement, targetNode, overlayNode, scrollNode, padding, shouldFlip, boundaryElement, offset, crossOffset, maxHeight, arrowSize = 0, arrowBoundaryOffset = 0 } = opts;
+  let container = overlayNode instanceof HTMLElement ? $edcf132a9284368a$var$getContainingBlock(overlayNode) : document.documentElement;
+  let isViewportContainer = container === document.documentElement;
+  const containerPositionStyle = window.getComputedStyle(container).position;
+  let isContainerPositioned = !!containerPositionStyle && containerPositionStyle !== "static";
+  let childOffset = isViewportContainer ? $edcf132a9284368a$var$getOffset(targetNode) : $edcf132a9284368a$var$getPosition(targetNode, container);
+  if (!isViewportContainer) {
+    let { marginTop, marginLeft } = window.getComputedStyle(targetNode);
+    childOffset.top += parseInt(marginTop, 10) || 0;
+    childOffset.left += parseInt(marginLeft, 10) || 0;
+  }
+  let overlaySize = $edcf132a9284368a$var$getOffset(overlayNode);
+  let margins = $edcf132a9284368a$var$getMargins(overlayNode);
+  overlaySize.width += margins.left + margins.right;
+  overlaySize.height += margins.top + margins.bottom;
+  let scrollSize = $edcf132a9284368a$var$getScroll(scrollNode);
+  let boundaryDimensions = $edcf132a9284368a$var$getContainerDimensions(boundaryElement);
+  let containerDimensions = $edcf132a9284368a$var$getContainerDimensions(container);
+  let containerOffsetWithBoundary = boundaryElement.tagName === "BODY" ? $edcf132a9284368a$var$getOffset(container) : $edcf132a9284368a$var$getPosition(container, boundaryElement);
+  if (container.tagName === "HTML" && boundaryElement.tagName === "BODY") {
+    containerDimensions.scroll.top = 0;
+    containerDimensions.scroll.left = 0;
+  }
+  return $edcf132a9284368a$export$6839422d1f33cee9(placement, childOffset, overlaySize, scrollSize, margins, padding, shouldFlip, boundaryDimensions, containerDimensions, containerOffsetWithBoundary, offset, crossOffset, isContainerPositioned, maxHeight, arrowSize, arrowBoundaryOffset);
+}
+function $edcf132a9284368a$var$getOffset(node) {
+  let { top, left, width, height } = node.getBoundingClientRect();
+  let { scrollTop, scrollLeft, clientTop, clientLeft } = document.documentElement;
+  return {
+    top: top + scrollTop - clientTop,
+    left: left + scrollLeft - clientLeft,
+    width,
+    height
+  };
+}
+function $edcf132a9284368a$var$getPosition(node, parent) {
+  let style = window.getComputedStyle(node);
+  let offset;
+  if (style.position === "fixed") {
+    let { top, left, width, height } = node.getBoundingClientRect();
+    offset = {
+      top,
+      left,
+      width,
+      height
+    };
+  } else {
+    offset = $edcf132a9284368a$var$getOffset(node);
+    let parentOffset = $edcf132a9284368a$var$getOffset(parent);
+    let parentStyle = window.getComputedStyle(parent);
+    parentOffset.top += (parseInt(parentStyle.borderTopWidth, 10) || 0) - parent.scrollTop;
+    parentOffset.left += (parseInt(parentStyle.borderLeftWidth, 10) || 0) - parent.scrollLeft;
+    offset.top -= parentOffset.top;
+    offset.left -= parentOffset.left;
+  }
+  offset.top -= parseInt(style.marginTop, 10) || 0;
+  offset.left -= parseInt(style.marginLeft, 10) || 0;
+  return offset;
+}
+function $edcf132a9284368a$var$getContainingBlock(node) {
+  let offsetParent = node.offsetParent;
+  if (offsetParent && offsetParent === document.body && window.getComputedStyle(offsetParent).position === "static" && !$edcf132a9284368a$var$isContainingBlock(offsetParent))
+    offsetParent = document.documentElement;
+  if (offsetParent == null) {
+    offsetParent = node.parentElement;
+    while (offsetParent && !$edcf132a9284368a$var$isContainingBlock(offsetParent))
+      offsetParent = offsetParent.parentElement;
+  }
+  return offsetParent || document.documentElement;
+}
+function $edcf132a9284368a$var$isContainingBlock(node) {
+  let style = window.getComputedStyle(node);
+  return style.transform !== "none" || /transform|perspective/.test(style.willChange) || style.filter !== "none" || style.contain === "paint" || // @ts-ignore
+  "backdropFilter" in style && style.backdropFilter !== "none" || // @ts-ignore
+  "WebkitBackdropFilter" in style && style.WebkitBackdropFilter !== "none";
+}
+const $dd149f63282afbbf$export$f6211563215e3b37 = /* @__PURE__ */ new WeakMap();
+function $dd149f63282afbbf$export$18fc8428861184da(opts) {
+  let { triggerRef, isOpen, onClose } = opts;
+  useEffect(() => {
+    if (!isOpen || onClose === null)
+      return;
+    let onScroll = (e) => {
+      let target = e.target;
+      if (!triggerRef.current || target instanceof Node && !target.contains(triggerRef.current))
+        return;
+      let onCloseHandler = onClose || $dd149f63282afbbf$export$f6211563215e3b37.get(triggerRef.current);
+      if (onCloseHandler)
+        onCloseHandler();
+    };
+    window.addEventListener("scroll", onScroll, true);
+    return () => {
+      window.removeEventListener("scroll", onScroll, true);
+    };
+  }, [
+    isOpen,
+    onClose,
+    triggerRef
+  ]);
+}
+let $2a41e45df1593e64$var$visualViewport = typeof document !== "undefined" && window.visualViewport;
+function $2a41e45df1593e64$export$d39e1813b3bdd0e1(props) {
+  let { direction } = $18f2051aff69b9bf$export$43bb16f9c6d9e3f7();
+  let { arrowSize = 0, targetRef, overlayRef, scrollRef = overlayRef, placement = "bottom", containerPadding = 12, shouldFlip = true, boundaryElement = typeof document !== "undefined" ? document.body : null, offset = 0, crossOffset = 0, shouldUpdatePosition = true, isOpen = true, onClose, maxHeight, arrowBoundaryOffset = 0 } = props;
+  let [position, setPosition] = useState({
+    position: {},
+    arrowOffsetLeft: void 0,
+    arrowOffsetTop: void 0,
+    maxHeight: void 0,
+    placement: void 0
+  });
+  let deps = [
+    shouldUpdatePosition,
+    placement,
+    overlayRef.current,
+    targetRef.current,
+    scrollRef.current,
+    containerPadding,
+    shouldFlip,
+    boundaryElement,
+    offset,
+    crossOffset,
+    isOpen,
+    direction,
+    maxHeight,
+    arrowBoundaryOffset,
+    arrowSize
+  ];
+  let lastScale = useRef($2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.scale);
+  useEffect(() => {
+    if (isOpen)
+      lastScale.current = $2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.scale;
+  }, [
+    isOpen
+  ]);
+  let updatePosition = useCallback(() => {
+    if (shouldUpdatePosition === false || !isOpen || !overlayRef.current || !targetRef.current || !scrollRef.current || !boundaryElement)
+      return;
+    if (($2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.scale) !== lastScale.current)
+      return;
+    let overlay = overlayRef.current;
+    if (!maxHeight && overlayRef.current) {
+      var _window_visualViewport;
+      overlay.style.top = "0px";
+      overlay.style.bottom = "";
+      var _window_visualViewport_height;
+      overlay.style.maxHeight = ((_window_visualViewport_height = (_window_visualViewport = window.visualViewport) === null || _window_visualViewport === void 0 ? void 0 : _window_visualViewport.height) !== null && _window_visualViewport_height !== void 0 ? _window_visualViewport_height : window.innerHeight) + "px";
+    }
+    let position2 = $edcf132a9284368a$export$b3ceb0cbf1056d98({
+      placement: $2a41e45df1593e64$var$translateRTL(placement, direction),
+      overlayNode: overlayRef.current,
+      targetNode: targetRef.current,
+      scrollNode: scrollRef.current,
+      padding: containerPadding,
+      shouldFlip,
+      boundaryElement,
+      offset,
+      crossOffset,
+      maxHeight,
+      arrowSize,
+      arrowBoundaryOffset
+    });
+    overlay.style.top = "";
+    overlay.style.bottom = "";
+    Object.keys(position2.position).forEach((key) => overlay.style[key] = position2.position[key] + "px");
+    overlay.style.maxHeight = position2.maxHeight != null ? position2.maxHeight + "px" : void 0;
+    setPosition(position2);
+  }, deps);
+  $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(updatePosition, deps);
+  $2a41e45df1593e64$var$useResize(updatePosition);
+  $9daab02d461809db$export$683480f191c0e3ea({
+    ref: overlayRef,
+    onResize: updatePosition
+  });
+  let isResizing = useRef(false);
+  $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(() => {
+    let timeout;
+    let onResize = () => {
+      isResizing.current = true;
+      clearTimeout(timeout);
+      timeout = setTimeout(() => {
+        isResizing.current = false;
+      }, 500);
+      updatePosition();
+    };
+    let onScroll = () => {
+      if (isResizing.current)
+        onResize();
+    };
+    $2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.addEventListener("resize", onResize);
+    $2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.addEventListener("scroll", onScroll);
+    return () => {
+      $2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.removeEventListener("resize", onResize);
+      $2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.removeEventListener("scroll", onScroll);
+    };
+  }, [
+    updatePosition
+  ]);
+  let close = useCallback(() => {
+    if (!isResizing.current)
+      onClose();
+  }, [
+    onClose,
+    isResizing
+  ]);
+  $dd149f63282afbbf$export$18fc8428861184da({
+    triggerRef: targetRef,
+    isOpen,
+    onClose: onClose && close
+  });
+  return {
+    overlayProps: {
+      style: {
+        position: "absolute",
+        zIndex: 1e5,
+        ...position.position,
+        maxHeight: position.maxHeight
+      }
+    },
+    placement: position.placement,
+    arrowProps: {
+      "aria-hidden": "true",
+      role: "presentation",
+      style: {
+        left: position.arrowOffsetLeft,
+        top: position.arrowOffsetTop
+      }
+    },
+    updatePosition
+  };
+}
+function $2a41e45df1593e64$var$useResize(onResize) {
+  $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(() => {
+    window.addEventListener("resize", onResize, false);
+    return () => {
+      window.removeEventListener("resize", onResize, false);
+    };
+  }, [
+    onResize
+  ]);
+}
+function $2a41e45df1593e64$var$translateRTL(position, direction) {
+  if (direction === "rtl")
+    return position.replace("start", "right").replace("end", "left");
+  return position.replace("start", "left").replace("end", "right");
+}
+const $f57aed4a881a3485$var$Context = /* @__PURE__ */ React__default.createContext(null);
+function $f57aed4a881a3485$export$178405afcd8c5eb(props) {
+  let { children } = props;
+  let parent = useContext($f57aed4a881a3485$var$Context);
+  let [modalCount, setModalCount] = useState(0);
+  let context = useMemo(() => ({
+    parent,
+    modalCount,
+    addModal() {
+      setModalCount((count) => count + 1);
+      if (parent)
+        parent.addModal();
+    },
+    removeModal() {
+      setModalCount((count) => count - 1);
+      if (parent)
+        parent.removeModal();
+    }
+  }), [
+    parent,
+    modalCount
+  ]);
+  return /* @__PURE__ */ React__default.createElement($f57aed4a881a3485$var$Context.Provider, {
+    value: context
+  }, children);
+}
+function $f57aed4a881a3485$export$d9aaed4c3ece1bc0() {
+  let context = useContext($f57aed4a881a3485$var$Context);
+  return {
+    modalProviderProps: {
+      "aria-hidden": context && context.modalCount > 0 ? true : null
+    }
+  };
+}
+function $f57aed4a881a3485$var$OverlayContainerDOM(props) {
+  let { modalProviderProps } = $f57aed4a881a3485$export$d9aaed4c3ece1bc0();
+  return /* @__PURE__ */ React__default.createElement("div", {
+    "data-overlay-container": true,
+    ...props,
+    ...modalProviderProps
+  });
+}
+function $f57aed4a881a3485$export$bf688221f59024e5(props) {
+  return /* @__PURE__ */ React__default.createElement($f57aed4a881a3485$export$178405afcd8c5eb, null, /* @__PURE__ */ React__default.createElement($f57aed4a881a3485$var$OverlayContainerDOM, props));
+}
+function $f57aed4a881a3485$export$b47c3594eab58386(props) {
+  let isSSR = $b5e257d569688ac6$export$535bd6ca7f90a273();
+  let { portalContainer = isSSR ? null : document.body, ...rest } = props;
+  React__default.useEffect(() => {
+    if (portalContainer === null || portalContainer === void 0 ? void 0 : portalContainer.closest("[data-overlay-container]"))
+      throw new Error("An OverlayContainer must not be inside another container. Please change the portalContainer prop.");
+  }, [
+    portalContainer
+  ]);
+  if (!portalContainer)
+    return null;
+  let contents = /* @__PURE__ */ React__default.createElement($f57aed4a881a3485$export$bf688221f59024e5, rest);
+  return /* @__PURE__ */ $dbSRa$reactdom.createPortal(contents, portalContainer);
+}
+function $326e436e94273fe1$export$1c4b08e0eca38426(props, state) {
+  let domProps = $65484d02dcb7eb3e$export$457c3d6518dd4c6f(props, {
+    labelable: true
+  });
+  let { hoverProps } = $6179b936705e76d3$export$ae780daf29e6d456({
+    onHoverStart: () => state === null || state === void 0 ? void 0 : state.open(true),
+    onHoverEnd: () => state === null || state === void 0 ? void 0 : state.close()
+  });
+  return {
+    tooltipProps: $3ef42575df84b30b$export$9d1611c77c2fe928(domProps, hoverProps, {
+      role: "tooltip"
+    })
+  };
+}
+function $4e1b34546679e357$export$a6da6c504e4bba8b(props, state, ref) {
+  let { isDisabled, trigger } = props;
+  let tooltipId = $bdb11010cef70236$export$f680877a34711e37();
+  let isHovered = useRef(false);
+  let isFocused = useRef(false);
+  let handleShow = () => {
+    if (isHovered.current || isFocused.current)
+      state.open(isFocused.current);
+  };
+  let handleHide = (immediate) => {
+    if (!isHovered.current && !isFocused.current)
+      state.close(immediate);
+  };
+  useEffect(() => {
+    let onKeyDown = (e) => {
+      if (ref && ref.current) {
+        if (e.key === "Escape") {
+          e.stopPropagation();
+          state.close(true);
+        }
+      }
+    };
+    if (state.isOpen) {
+      document.addEventListener("keydown", onKeyDown, true);
+      return () => {
+        document.removeEventListener("keydown", onKeyDown, true);
+      };
+    }
+  }, [
+    ref,
+    state
+  ]);
+  let onHoverStart = () => {
+    if (trigger === "focus")
+      return;
+    if ($507fabe10e71c6fb$export$630ff653c5ada6a9() === "pointer")
+      isHovered.current = true;
+    else
+      isHovered.current = false;
+    handleShow();
+  };
+  let onHoverEnd = () => {
+    if (trigger === "focus")
+      return;
+    isFocused.current = false;
+    isHovered.current = false;
+    handleHide();
+  };
+  let onPressStart = () => {
+    isFocused.current = false;
+    isHovered.current = false;
+    handleHide(true);
+  };
+  let onFocus = () => {
+    let isVisible = $507fabe10e71c6fb$export$b9b3dfddab17db27();
+    if (isVisible) {
+      isFocused.current = true;
+      handleShow();
+    }
+  };
+  let onBlur = () => {
+    isFocused.current = false;
+    isHovered.current = false;
+    handleHide(true);
+  };
+  let { hoverProps } = $6179b936705e76d3$export$ae780daf29e6d456({
+    isDisabled,
+    onHoverStart,
+    onHoverEnd
+  });
+  let { focusableProps } = $e6afbd83fe6ebbd2$export$4c014de7c8940b4c({
+    isDisabled,
+    onFocus,
+    onBlur
+  }, ref);
+  return {
+    triggerProps: {
+      "aria-describedby": state.isOpen ? tooltipId : void 0,
+      ...$3ef42575df84b30b$export$9d1611c77c2fe928(focusableProps, hoverProps, {
+        onPointerDown: onPressStart,
+        onKeyDown: onPressStart
+      })
+    },
+    tooltipProps: {
+      id: tooltipId
+    }
+  };
+}
+function $fc909762b330b746$export$61c6a8c84e605fb6(props) {
+  let [isOpen, setOpen] = $458b0a5536c1a7cf$export$40bfa8c7b0832715(props.isOpen, props.defaultOpen || false, props.onOpenChange);
+  const open = useCallback(() => {
+    setOpen(true);
+  }, [
+    setOpen
+  ]);
+  const close = useCallback(() => {
+    setOpen(false);
+  }, [
+    setOpen
+  ]);
+  const toggle = useCallback(() => {
+    setOpen(!isOpen);
+  }, [
+    setOpen,
+    isOpen
+  ]);
+  return {
+    isOpen,
+    setOpen,
+    open,
+    close,
+    toggle
+  };
+}
+const $8796f90736e175cb$var$TOOLTIP_DELAY = 1500;
+const $8796f90736e175cb$var$TOOLTIP_COOLDOWN = 500;
+let $8796f90736e175cb$var$tooltips = {};
+let $8796f90736e175cb$var$tooltipId = 0;
+let $8796f90736e175cb$var$globalWarmedUp = false;
+let $8796f90736e175cb$var$globalWarmUpTimeout = null;
+let $8796f90736e175cb$var$globalCooldownTimeout = null;
+function $8796f90736e175cb$export$4d40659c25ecb50b(props = {}) {
+  let { delay = $8796f90736e175cb$var$TOOLTIP_DELAY, closeDelay = $8796f90736e175cb$var$TOOLTIP_COOLDOWN } = props;
+  let { isOpen, open, close } = $fc909762b330b746$export$61c6a8c84e605fb6(props);
+  let id = useMemo(() => `${++$8796f90736e175cb$var$tooltipId}`, []);
+  let closeTimeout = useRef();
+  let ensureTooltipEntry = () => {
+    $8796f90736e175cb$var$tooltips[id] = hideTooltip;
+  };
+  let closeOpenTooltips = () => {
+    for (let hideTooltipId in $8796f90736e175cb$var$tooltips)
+      if (hideTooltipId !== id) {
+        $8796f90736e175cb$var$tooltips[hideTooltipId](true);
+        delete $8796f90736e175cb$var$tooltips[hideTooltipId];
+      }
+  };
+  let showTooltip = () => {
+    clearTimeout(closeTimeout.current);
+    closeTimeout.current = null;
+    closeOpenTooltips();
+    ensureTooltipEntry();
+    $8796f90736e175cb$var$globalWarmedUp = true;
+    open();
+    if ($8796f90736e175cb$var$globalWarmUpTimeout) {
+      clearTimeout($8796f90736e175cb$var$globalWarmUpTimeout);
+      $8796f90736e175cb$var$globalWarmUpTimeout = null;
+    }
+    if ($8796f90736e175cb$var$globalCooldownTimeout) {
+      clearTimeout($8796f90736e175cb$var$globalCooldownTimeout);
+      $8796f90736e175cb$var$globalCooldownTimeout = null;
+    }
+  };
+  let hideTooltip = (immediate) => {
+    if (immediate || closeDelay <= 0) {
+      clearTimeout(closeTimeout.current);
+      closeTimeout.current = null;
+      close();
+    } else if (!closeTimeout.current)
+      closeTimeout.current = setTimeout(() => {
+        closeTimeout.current = null;
+        close();
+      }, closeDelay);
+    if ($8796f90736e175cb$var$globalWarmUpTimeout) {
+      clearTimeout($8796f90736e175cb$var$globalWarmUpTimeout);
+      $8796f90736e175cb$var$globalWarmUpTimeout = null;
+    }
+    if ($8796f90736e175cb$var$globalWarmedUp) {
+      if ($8796f90736e175cb$var$globalCooldownTimeout)
+        clearTimeout($8796f90736e175cb$var$globalCooldownTimeout);
+      $8796f90736e175cb$var$globalCooldownTimeout = setTimeout(() => {
+        delete $8796f90736e175cb$var$tooltips[id];
+        $8796f90736e175cb$var$globalCooldownTimeout = null;
+        $8796f90736e175cb$var$globalWarmedUp = false;
+      }, Math.max($8796f90736e175cb$var$TOOLTIP_COOLDOWN, closeDelay));
+    }
+  };
+  let warmupTooltip = () => {
+    closeOpenTooltips();
+    ensureTooltipEntry();
+    if (!isOpen && !$8796f90736e175cb$var$globalWarmUpTimeout && !$8796f90736e175cb$var$globalWarmedUp)
+      $8796f90736e175cb$var$globalWarmUpTimeout = setTimeout(() => {
+        $8796f90736e175cb$var$globalWarmUpTimeout = null;
+        $8796f90736e175cb$var$globalWarmedUp = true;
+        showTooltip();
+      }, delay);
+    else if (!isOpen)
+      showTooltip();
+  };
+  useEffect(() => {
+    return () => {
+      clearTimeout(closeTimeout.current);
+      let tooltip = $8796f90736e175cb$var$tooltips[id];
+      if (tooltip)
+        delete $8796f90736e175cb$var$tooltips[id];
+    };
+  }, [
+    id
+  ]);
+  return {
+    isOpen,
+    open: (immediate) => {
+      if (!immediate && delay > 0 && !closeTimeout.current)
+        warmupTooltip();
+      else
+        showTooltip();
+    },
+    close: hideTooltip
+  };
+}
+const $44f671af83e7d9e0$export$2de4954e8ae13b9f = /* @__PURE__ */ createContext({
+  placement: "bottom"
+});
+function $44f671af83e7d9e0$var$OverlayArrow(props, ref) {
+  [props, ref] = $64fa3d84918910a7$export$29f1550f4b0d4415(props, ref, $44f671af83e7d9e0$export$2de4954e8ae13b9f);
+  let placement = props.placement;
+  let style = {
+    position: "absolute",
+    [placement]: "100%",
+    transform: placement === "top" || placement === "bottom" ? "translateX(-50%)" : "translateY(-50%)"
+  };
+  let renderProps = $64fa3d84918910a7$export$4d86445c2cf5e3({
+    ...props,
+    defaultClassName: "react-aria-OverlayArrow",
+    values: {
+      placement
+    }
+  });
+  if (renderProps.style)
+    Object.keys(renderProps.style).forEach((key) => renderProps.style[key] === void 0 && delete renderProps.style[key]);
+  return /* @__PURE__ */ React__default.createElement("div", {
+    ...props,
+    ...renderProps,
+    style: {
+      ...style,
+      ...renderProps.style
+    },
+    ref,
+    "data-placement": placement
+  });
+}
+const $44f671af83e7d9e0$export$746d02f47f4d381 = /* @__PURE__ */ forwardRef($44f671af83e7d9e0$var$OverlayArrow);
+const $4e3b923658d69c60$export$7a7623236eec67fa = /* @__PURE__ */ createContext(null);
+const $4e3b923658d69c60$export$39ae08fa83328b12 = /* @__PURE__ */ createContext(null);
+function $4e3b923658d69c60$export$8c610744efcf8a1d(props) {
+  let state = $8796f90736e175cb$export$4d40659c25ecb50b(props);
+  let ref = useRef(null);
+  let { triggerProps, tooltipProps } = $4e1b34546679e357$export$a6da6c504e4bba8b(props, state, ref);
+  return /* @__PURE__ */ React__default.createElement($64fa3d84918910a7$export$2881499e37b75b9a, {
+    values: [
+      [
+        $4e3b923658d69c60$export$7a7623236eec67fa,
+        state
+      ],
+      [
+        $4e3b923658d69c60$export$39ae08fa83328b12,
+        {
+          ...tooltipProps,
+          triggerRef: ref
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ React__default.createElement($e6afbd83fe6ebbd2$export$13f3202a3e5ddd5, {
+    ...triggerProps,
+    ref
+  }, props.children));
+}
+function $4e3b923658d69c60$var$Tooltip({ UNSTABLE_portalContainer, ...props }, ref) {
+  [props, ref] = $64fa3d84918910a7$export$29f1550f4b0d4415(props, ref, $4e3b923658d69c60$export$39ae08fa83328b12);
+  let contextState = useContext($4e3b923658d69c60$export$7a7623236eec67fa);
+  let localState = $8796f90736e175cb$export$4d40659c25ecb50b(props);
+  let state = props.isOpen != null || props.defaultOpen != null || !contextState ? localState : contextState;
+  let isExiting = $64fa3d84918910a7$export$45fda7c47f93fd48(ref, state.isOpen) || props.isExiting || false;
+  if (!state.isOpen && !isExiting)
+    return null;
+  return /* @__PURE__ */ React__default.createElement($f57aed4a881a3485$export$b47c3594eab58386, {
+    portalContainer: UNSTABLE_portalContainer
+  }, /* @__PURE__ */ React__default.createElement($4e3b923658d69c60$var$TooltipInner, {
+    ...props,
+    tooltipRef: ref,
+    isExiting
+  }));
+}
+const $4e3b923658d69c60$export$28c660c63b792dea = /* @__PURE__ */ forwardRef($4e3b923658d69c60$var$Tooltip);
+function $4e3b923658d69c60$var$TooltipInner(props) {
+  let state = useContext($4e3b923658d69c60$export$7a7623236eec67fa);
+  let arrowRef = useRef(null);
+  let [arrowWidth, setArrowWidth] = useState(0);
+  $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(() => {
+    if (arrowRef.current && state.isOpen)
+      setArrowWidth(arrowRef.current.getBoundingClientRect().width);
+  }, [
+    state.isOpen,
+    arrowRef
+  ]);
+  let { overlayProps, arrowProps, placement } = $2a41e45df1593e64$export$d39e1813b3bdd0e1({
+    placement: props.placement || "top",
+    targetRef: props.triggerRef,
+    overlayRef: props.tooltipRef,
+    offset: props.offset,
+    crossOffset: props.crossOffset,
+    isOpen: state.isOpen,
+    arrowSize: arrowWidth,
+    arrowBoundaryOffset: props.arrowBoundaryOffset,
+    shouldFlip: props.shouldFlip
+  });
+  let isEntering = $64fa3d84918910a7$export$6d3443f2c48bfc20(props.tooltipRef, !!placement) || props.isEntering || false;
+  let renderProps = $64fa3d84918910a7$export$4d86445c2cf5e3({
+    ...props,
+    defaultClassName: "react-aria-Tooltip",
+    values: {
+      placement,
+      isEntering,
+      isExiting: props.isExiting,
+      state
+    }
+  });
+  props = $3ef42575df84b30b$export$9d1611c77c2fe928(props, overlayProps);
+  let { tooltipProps } = $326e436e94273fe1$export$1c4b08e0eca38426(props, state);
+  return /* @__PURE__ */ React__default.createElement("div", {
+    ...tooltipProps,
+    ref: props.tooltipRef,
+    ...renderProps,
+    style: {
+      ...overlayProps.style,
+      ...renderProps.style
+    },
+    "data-placement": placement,
+    "data-entering": isEntering || void 0,
+    "data-exiting": props.isExiting || void 0
+  }, /* @__PURE__ */ React__default.createElement($44f671af83e7d9e0$export$2de4954e8ae13b9f.Provider, {
+    value: {
+      ...arrowProps,
+      placement,
+      ref: arrowRef
+    }
+  }, renderProps.children));
+}
+/**
+ * A simple tooltip component.
+ *
+ * It can be used in two modes:
+ * - **Controlled mode**: You can control the tooltip with the `open` prop.
+ * - **Uncontrolled mode**: The tooltip will be open by default with the `defaultOpen` prop.
+ *
+ * @component
+ * @param {Object} props - Component props.
+ * @param {string|JSX.Element} props.text - The text to display in the tooltip.
+ * @param {TooltipTheme} [props.theme='dark'] - The theme of the tooltip.
+ * @param {number} [props.offset=0] - Additional offset between the tooltip and the element on the main axis (same axis as element).
+ * @param {number} [props.crossOffset=0] - Additional offset between the tooltip and the element on the cross axis (opposite axis as element).
+ * @param {number} [props.containerPadding=12] - Space that should be left between the tooltip and the main containing element (usually browser window).
+ * @param {number} [props.openDelay=1500] - Duration before the tooltip is shown, in milliseconds.
+ * @param {number} [props.closeDelay=500] - Duration before the tooltip is hidden, in milliseconds.
+ * @param {boolean} [props.shouldFlip=true] - If `false`, the tooltip will not flip to the opposite side if there is not enough space.
+ * @param {boolean} [props.defaultOpen] - (**Uncontrolled mode**) Whether the tooltip is initially open.
+ * @param {boolean} [props.open] - (**Controlled mode**) Whether the tooltip is open.
+ * @param {Function} [props.onOpenChange] - (**Controlled mode**) Function to run when the tooltip is opened or closed.
+ * @param {TooltipPlacement} [props.placement] - The side of the trigger element where the tooltip will be displayed.
+ * @param {string} [props.className] - Classes to pass to the tooltip.
+ * @param {RefObject<Element>} [props.triggerRef] - Ref to anchor the tooltip to. If not provided, the tooltip will be anchored to the trigger element.
+ * @param {boolean} [props.arrow] - If `true`, an arrow is shown on the tooltip.
+ *
+ * @returns {JSX.Element} The Tooltip component.
+ *
+ * @typedef {'light' | 'dark'} TooltipTheme
+ * @typedef {'bottom' | 'bottom left' | 'bottom right' | 'bottom start' | 'bottom end' | 'top' | 'top left' | 'top right' | 'top start' | 'top end' | 'left' | 'left top' | 'left bottom' | 'start' | 'start top' | 'start bottom' | 'right' | 'right top' | 'right bottom' | 'end' | 'end top' | 'end bottom'} TooltipPlacement
+ *
+ * @example
+ * <Tooltip text='My tooltip'>
+ * 	<Button>Hover me</Button>
+ * </Tooltip>
+ *
+ * @preserve
+ */
+const Tooltip = (props) => {
+  const {
+    children,
+    text,
+    theme = "dark",
+    offset = 0,
+    crossOffset = 0,
+    containerPadding = 12,
+    openDelay = 1500,
+    closeDelay = 500,
+    shouldFlip = true,
+    arrow,
+    open,
+    defaultOpen,
+    onOpenChange,
+    placement,
+    className,
+    triggerRef,
+    disabled
+  } = props;
+  return /* @__PURE__ */ jsxs(
+    $4e3b923658d69c60$export$8c610744efcf8a1d,
+    {
+      delay: openDelay,
+      closeDelay,
+      isDisabled: disabled,
+      isOpen: open,
+      onOpenChange,
+      defaultOpen,
+      children: [
+        children,
+        /* @__PURE__ */ jsxs(
+          $4e3b923658d69c60$export$28c660c63b792dea,
+          {
+            containerPadding,
+            placement,
+            shouldFlip,
+            triggerRef,
+            offset,
+            crossOffset,
+            className: ({ isEntering, isExiting }) => classnames(
+              "es-uic-group",
+              "es-uic-z-20 es-uic-select-none es-uic-rounded-md es-uic-border es-uic-px-1.5 es-uic-py-0.5 es-uic-text-sm es-uic-shadow es-uic-backdrop-blur-xl es-uic-will-change-[transform,opacity]",
+              theme === "light" && "es-uic-border-gray-200 es-uic-bg-white/60 es-uic-text-gray-700",
+              theme === "dark" && "es-uic-border-gray-600 es-uic-bg-black/60 es-uic-text-gray-100",
+              isEntering && "es-uic-duration-300 es-uic-ease-out es-uic-animate-in es-uic-fade-in",
+              isEntering && "placement-left:es-uic-slide-in-from-right-0.5 placement-right:es-uic-slide-in-from-left-0.5 placement-top:es-uic-slide-in-from-bottom-0.5 placement-bottom:es-uic-slide-in-from-top-0.5",
+              isExiting && "es-uic-duration-150 es-uic-ease-in es-uic-animate-out es-uic-fade-out",
+              isExiting && "placement-left:es-uic-slide-out-to-right-0.5 placement-right:es-uic-slide-out-to-left-0.5 placement-top:es-uic-slide-out-to-bottom-0.5 placement-bottom:es-uic-slide-out-to-top-0.5",
+              className
+            ),
+            children: [
+              arrow && /* @__PURE__ */ jsx($44f671af83e7d9e0$export$746d02f47f4d381, { children: /* @__PURE__ */ jsx(
+                "svg",
+                {
+                  width: 8,
+                  height: 8,
+                  viewBox: "0 0 8 8",
+                  className: classnames(
+                    "es-uic-m-px es-uic-stroke-none es-uic-drop-shadow-sm",
+                    theme === "light" && "es-uic-fill-gray-200",
+                    theme === "dark" && "es-uic-fill-gray-600",
+                    "group-placement-left:-es-uic-rotate-90 group-placement-right:es-uic-rotate-90 group-placement-bottom:es-uic-rotate-180",
+                    "forced-colors:es-uic-fill-[Canvas] forced-colors:es-uic-stroke-[ButtonBorder]"
+                  ),
+                  children: /* @__PURE__ */ jsx("path", { d: "M0 0 L4 4 L8 0" })
+                }
+              ) }),
+              text
+            ]
+          }
+        )
+      ]
+    }
+  );
+};
+/**
+ * A "decorative" tooltip than can be used with element that usually don't support tooltips.
+ * Usually the only elements that support tooltips are interactive elements like buttons or links.
+ *
+ * This component will wrap the element and add the tooltip functionality to it.
+ * The tooltip will be shown when the element is hovered or anything within is focused.
+ *
+ * **Note**: This is not officially supported by the ARIA spec, so use with caution.
+ *
+ * @see {@link Tooltip} before using this component.
+ *
+ * @component
+ * @param {Object} props - Component props.
+ * @param {string|JSX.Element} props.text - The text to display in the tooltip.
+ * @param {TooltipTheme} [props.theme='dark'] - The theme of the tooltip.
+ * @param {number} [props.offset=0] - Additional offset between the tooltip and the element on the main axis (same axis as element).
+ * @param {number} [props.crossOffset=0] - Additional offset between the tooltip and the element on the cross axis (opposite axis as element).
+ * @param {number} [props.containerPadding=12] - Space that should be left between the tooltip and the main containing element (usually browser window).
+ * @param {number} [props.openDelay=1500] - Duration before the tooltip is shown, in milliseconds.
+ * @param {number} [props.closeDelay=500] - Duration before the tooltip is hidden, in milliseconds.
+ * @param {boolean} [props.shouldFlip=true] - If `false`, the tooltip will not flip to the opposite side if there is not enough space.
+ * @param {TooltipPlacement} [props.placement] - The side of the trigger element where the tooltip will be displayed.
+ * @param {string} [props.className] - Classes to pass to the tooltip.
+ * @param {string} [props.wrapperClassName] - Classes to pass to the tooltip wrapper (if `doNotReplaceChild` is `false`).
+ * @param {boolean} [props.arrow] - If `true`, an arrow is shown on the tooltip.
+ *
+ * @returns {JSX.Element} The DecorativeTooltip component.
+ *
+ * @typedef {'light' | 'dark'} TooltipTheme
+ * @typedef {'bottom' | 'bottom left' | 'bottom right' | 'bottom start' | 'bottom end' | 'top' | 'top left' | 'top right' | 'top start' | 'top end' | 'left' | 'left top' | 'left bottom' | 'start' | 'start top' | 'start bottom' | 'right' | 'right top' | 'right bottom' | 'end' | 'end top' | 'end bottom'} TooltipPlacement
+ *
+ * @example
+ * <DecorativeTooltip text='My tooltip'>
+ * 	<span>Hover me</span>
+ * </DecorativeTooltip>
+ *
+ * @preserve
+ */
+const DecorativeTooltip = (props) => {
+  const { openDelay, closeDelay, children, text, wrapperClassName, ...rest } = props;
+  const [open, setOpen] = useState(false);
+  let { hoverProps } = $6179b936705e76d3$export$ae780daf29e6d456({
+    onHoverStart: () => setTimeout(() => setOpen(true), openDelay),
+    onHoverEnd: () => setTimeout(() => setOpen(false), closeDelay)
+  });
+  let { focusWithinProps } = $9ab94262bd0047c7$export$420e68273165f4ec({
+    onFocusWithinChange: (isFocusWithin) => setOpen(isFocusWithin)
+  });
+  const ref = useRef(null);
+  return /* @__PURE__ */ jsx(
+    Tooltip,
+    {
+      triggerRef: ref,
+      text,
+      open,
+      className: "es-uic-pointer-events-none",
+      ...rest,
+      children: /* @__PURE__ */ jsx(
+        "div",
+        {
+          ref,
+          className: classnames("es-uic-inline", wrapperClassName),
+          ...$3ef42575df84b30b$export$9d1611c77c2fe928(hoverProps, focusWithinProps),
+          children
+        }
+      )
+    }
+  );
+};
+export {
+  $9daab02d461809db$export$683480f191c0e3ea as $,
+  DecorativeTooltip as D,
+  Tooltip as T,
+  $fc909762b330b746$export$61c6a8c84e605fb6 as a,
+  $dd149f63282afbbf$export$f6211563215e3b37 as b,
+  $2a41e45df1593e64$export$d39e1813b3bdd0e1 as c,
+  $44f671af83e7d9e0$export$2de4954e8ae13b9f as d
+};