@channel.io/bezier-react 2.6.1 → 3.0.0

package/dist/esm/node_modules/@radix-ui/react-tooltip/dist/index.mjs

@@ -1,287 +1,297 @@
-import _extends from '../../../@babel/runtime/helpers/esm/extends.mjs';
-import { useState, useRef, useEffect, createElement, useCallback, useMemo, forwardRef } from 'react';
-import { composeEventHandlers as $e42e1063c40fb3ef$export$b9ecd428b558ff10 } from '../../primitive/dist/index.mjs';
-import { useComposedRefs as $6ed0406888f73fc4$export$c7b2cbe3552a0d05 } from '../../react-compose-refs/dist/index.mjs';
-import { createContextScope as $c512c27ab02ef895$export$50c7b4e9d9f19c1 } from '../../react-context/dist/index.mjs';
-import { DismissableLayer as $5cb92bef7577960e$export$177fb62ff3ec1f22 } from '../../react-dismissable-layer/dist/index.mjs';
-import { useId as $1746a345f3d73bb7$export$f680877a34711e37 } from '../../react-id/dist/index.mjs';
-import { createPopperScope as $cf1ac5d9fe0e8206$export$722aac194ae923, Root as $cf1ac5d9fe0e8206$export$be92b6f5f03c0fe9, Anchor as $cf1ac5d9fe0e8206$export$b688253958b8dfe7, Content as $cf1ac5d9fe0e8206$export$7c6e2c02157bb7d2, Arrow as $cf1ac5d9fe0e8206$export$21b07c8f274aebd5 } from '../../react-popper/dist/index.mjs';
-import { Portal as $f1701beae083dbae$export$602eac185826482c } from '../../react-portal/dist/index.mjs';
-import { Presence as $921a889cee6df7e8$export$99c2b779aa4e8b8b } from '../../react-presence/dist/index.mjs';
-import { Primitive as $8927f6f2acc4f386$export$250ffa63cdc0d034 } from '../../react-primitive/dist/index.mjs';
-import { Slottable as $5e63c961fc1ce211$export$d9f1ccf0bdb05d45 } from '../../react-slot/dist/index.mjs';
-import { useControllableState as $71cd76cc60e0454e$export$6f32135080cb4c3 } from '../../react-use-controllable-state/dist/index.mjs';
-import { Root as $ea1ef594cf570d83$export$be92b6f5f03c0fe9 } from '../../react-visually-hidden/dist/index.mjs';
+import * as React from 'react';
+import { composeEventHandlers } from '../../primitive/dist/index.mjs';
+import { useComposedRefs } from '../../react-compose-refs/dist/index.mjs';
+import { createContextScope } from '../../react-context/dist/index.mjs';
+import { DismissableLayer } from '../../react-dismissable-layer/dist/index.mjs';
+import { useId } from '../../react-id/dist/index.mjs';
+import { createPopperScope, Root as Root2, Anchor, Content, Arrow } from '../../react-popper/dist/index.mjs';
+import { Portal } from '../../react-portal/dist/index.mjs';
+import { Presence } from '../../react-presence/dist/index.mjs';
+import { Primitive } from '../../react-primitive/dist/index.mjs';
+import { Slottable } from '../../react-slot/dist/index.mjs';
+import { useControllableState } from '../../react-use-controllable-state/dist/index.mjs';
+import { Root } from '../../react-visually-hidden/dist/index.mjs';
+import { jsx, jsxs } from 'react/jsx-runtime';
 
-const [$a093c7e1ec25a057$var$createTooltipContext, $a093c7e1ec25a057$export$1c540a2224f0d865] = $c512c27ab02ef895$export$50c7b4e9d9f19c1('Tooltip', [$cf1ac5d9fe0e8206$export$722aac194ae923]);
-const $a093c7e1ec25a057$var$usePopperScope = $cf1ac5d9fe0e8206$export$722aac194ae923();
-/* -------------------------------------------------------------------------------------------------
- * TooltipProvider
- * -----------------------------------------------------------------------------------------------*/
-const $a093c7e1ec25a057$var$PROVIDER_NAME = 'TooltipProvider';
-const $a093c7e1ec25a057$var$DEFAULT_DELAY_DURATION = 700;
-const $a093c7e1ec25a057$var$TOOLTIP_OPEN = 'tooltip.open';
-const [$a093c7e1ec25a057$var$TooltipProviderContextProvider, $a093c7e1ec25a057$var$useTooltipProviderContext] = $a093c7e1ec25a057$var$createTooltipContext($a093c7e1ec25a057$var$PROVIDER_NAME);
-const $a093c7e1ec25a057$export$f78649fb9ca566b8 = props => {
+var [createTooltipContext, createTooltipScope] = createContextScope("Tooltip", [createPopperScope]);
+var usePopperScope = createPopperScope();
+var PROVIDER_NAME = "TooltipProvider";
+var DEFAULT_DELAY_DURATION = 700;
+var TOOLTIP_OPEN = "tooltip.open";
+var [TooltipProviderContextProvider, useTooltipProviderContext] = createTooltipContext(PROVIDER_NAME);
+var TooltipProvider = props => {
   const {
-    __scopeTooltip: __scopeTooltip,
-    delayDuration = $a093c7e1ec25a057$var$DEFAULT_DELAY_DURATION,
+    __scopeTooltip,
+    delayDuration = DEFAULT_DELAY_DURATION,
     skipDelayDuration = 300,
     disableHoverableContent = false,
-    children: children
+    children
   } = props;
-  const [isOpenDelayed, setIsOpenDelayed] = useState(true);
-  const isPointerInTransitRef = useRef(false);
-  const skipDelayTimerRef = useRef(0);
-  useEffect(() => {
+  const [isOpenDelayed, setIsOpenDelayed] = React.useState(true);
+  const isPointerInTransitRef = React.useRef(false);
+  const skipDelayTimerRef = React.useRef(0);
+  React.useEffect(() => {
     const skipDelayTimer = skipDelayTimerRef.current;
     return () => window.clearTimeout(skipDelayTimer);
   }, []);
-  return /*#__PURE__*/createElement($a093c7e1ec25a057$var$TooltipProviderContextProvider, {
+  return /* @__PURE__ */jsx(TooltipProviderContextProvider, {
     scope: __scopeTooltip,
-    isOpenDelayed: isOpenDelayed,
-    delayDuration: delayDuration,
-    onOpen: useCallback(() => {
+    isOpenDelayed,
+    delayDuration,
+    onOpen: React.useCallback(() => {
       window.clearTimeout(skipDelayTimerRef.current);
       setIsOpenDelayed(false);
     }, []),
-    onClose: useCallback(() => {
+    onClose: React.useCallback(() => {
       window.clearTimeout(skipDelayTimerRef.current);
       skipDelayTimerRef.current = window.setTimeout(() => setIsOpenDelayed(true), skipDelayDuration);
     }, [skipDelayDuration]),
-    isPointerInTransitRef: isPointerInTransitRef,
-    onPointerInTransitChange: useCallback(inTransit => {
+    isPointerInTransitRef,
+    onPointerInTransitChange: React.useCallback(inTransit => {
       isPointerInTransitRef.current = inTransit;
     }, []),
-    disableHoverableContent: disableHoverableContent
-  }, children);
+    disableHoverableContent,
+    children
+  });
 };
-/* -------------------------------------------------------------------------------------------------
- * Tooltip
- * -----------------------------------------------------------------------------------------------*/
-const $a093c7e1ec25a057$var$TOOLTIP_NAME = 'Tooltip';
-const [$a093c7e1ec25a057$var$TooltipContextProvider, $a093c7e1ec25a057$var$useTooltipContext] = $a093c7e1ec25a057$var$createTooltipContext($a093c7e1ec25a057$var$TOOLTIP_NAME);
-const $a093c7e1ec25a057$export$28c660c63b792dea = props => {
+TooltipProvider.displayName = PROVIDER_NAME;
+var TOOLTIP_NAME = "Tooltip";
+var [TooltipContextProvider, useTooltipContext] = createTooltipContext(TOOLTIP_NAME);
+var Tooltip = props => {
   const {
-    __scopeTooltip: __scopeTooltip,
-    children: children,
+    __scopeTooltip,
+    children,
     open: openProp,
     defaultOpen = false,
-    onOpenChange: onOpenChange,
+    onOpenChange,
     disableHoverableContent: disableHoverableContentProp,
     delayDuration: delayDurationProp
   } = props;
-  const providerContext = $a093c7e1ec25a057$var$useTooltipProviderContext($a093c7e1ec25a057$var$TOOLTIP_NAME, props.__scopeTooltip);
-  const popperScope = $a093c7e1ec25a057$var$usePopperScope(__scopeTooltip);
-  const [trigger, setTrigger] = useState(null);
-  const contentId = $1746a345f3d73bb7$export$f680877a34711e37();
-  const openTimerRef = useRef(0);
+  const providerContext = useTooltipProviderContext(TOOLTIP_NAME, props.__scopeTooltip);
+  const popperScope = usePopperScope(__scopeTooltip);
+  const [trigger, setTrigger] = React.useState(null);
+  const contentId = useId();
+  const openTimerRef = React.useRef(0);
   const disableHoverableContent = disableHoverableContentProp !== null && disableHoverableContentProp !== void 0 ? disableHoverableContentProp : providerContext.disableHoverableContent;
   const delayDuration = delayDurationProp !== null && delayDurationProp !== void 0 ? delayDurationProp : providerContext.delayDuration;
-  const wasOpenDelayedRef = useRef(false);
-  const [open1 = false, setOpen] = $71cd76cc60e0454e$export$6f32135080cb4c3({
+  const wasOpenDelayedRef = React.useRef(false);
+  const [open = false, setOpen] = useControllableState({
     prop: openProp,
     defaultProp: defaultOpen,
-    onChange: open => {
-      if (open) {
-        providerContext.onOpen(); // as `onChange` is called within a lifecycle method we
-        // avoid dispatching via `dispatchDiscreteCustomEvent`.
-        document.dispatchEvent(new CustomEvent($a093c7e1ec25a057$var$TOOLTIP_OPEN));
-      } else providerContext.onClose();
-      onOpenChange === null || onOpenChange === void 0 || onOpenChange(open);
+    onChange: open2 => {
+      if (open2) {
+        providerContext.onOpen();
+        document.dispatchEvent(new CustomEvent(TOOLTIP_OPEN));
+      } else {
+        providerContext.onClose();
+      }
+      onOpenChange === null || onOpenChange === void 0 || onOpenChange(open2);
     }
   });
-  const stateAttribute = useMemo(() => {
-    return open1 ? wasOpenDelayedRef.current ? 'delayed-open' : 'instant-open' : 'closed';
-  }, [open1]);
-  const handleOpen = useCallback(() => {
+  const stateAttribute = React.useMemo(() => {
+    return open ? wasOpenDelayedRef.current ? "delayed-open" : "instant-open" : "closed";
+  }, [open]);
+  const handleOpen = React.useCallback(() => {
     window.clearTimeout(openTimerRef.current);
+    openTimerRef.current = 0;
     wasOpenDelayedRef.current = false;
     setOpen(true);
   }, [setOpen]);
-  const handleClose = useCallback(() => {
+  const handleClose = React.useCallback(() => {
     window.clearTimeout(openTimerRef.current);
+    openTimerRef.current = 0;
     setOpen(false);
   }, [setOpen]);
-  const handleDelayedOpen = useCallback(() => {
+  const handleDelayedOpen = React.useCallback(() => {
     window.clearTimeout(openTimerRef.current);
     openTimerRef.current = window.setTimeout(() => {
       wasOpenDelayedRef.current = true;
       setOpen(true);
+      openTimerRef.current = 0;
     }, delayDuration);
   }, [delayDuration, setOpen]);
-  useEffect(() => {
-    return () => window.clearTimeout(openTimerRef.current);
-  }, []);
-  return /*#__PURE__*/createElement($cf1ac5d9fe0e8206$export$be92b6f5f03c0fe9, popperScope, /*#__PURE__*/createElement($a093c7e1ec25a057$var$TooltipContextProvider, {
-    scope: __scopeTooltip,
-    contentId: contentId,
-    open: open1,
-    stateAttribute: stateAttribute,
-    trigger: trigger,
-    onTriggerChange: setTrigger,
-    onTriggerEnter: useCallback(() => {
-      if (providerContext.isOpenDelayed) handleDelayedOpen();else handleOpen();
-    }, [providerContext.isOpenDelayed, handleDelayedOpen, handleOpen]),
-    onTriggerLeave: useCallback(() => {
-      if (disableHoverableContent) handleClose();else
-        // Clear the timer in case the pointer leaves the trigger before the tooltip is opened.
+  React.useEffect(() => {
+    return () => {
+      if (openTimerRef.current) {
         window.clearTimeout(openTimerRef.current);
-    }, [handleClose, disableHoverableContent]),
-    onOpen: handleOpen,
-    onClose: handleClose,
-    disableHoverableContent: disableHoverableContent
-  }, children));
+        openTimerRef.current = 0;
+      }
+    };
+  }, []);
+  return /* @__PURE__ */jsx(Root2, {
+    ...popperScope,
+    children: /* @__PURE__ */jsx(TooltipContextProvider, {
+      scope: __scopeTooltip,
+      contentId,
+      open,
+      stateAttribute,
+      trigger,
+      onTriggerChange: setTrigger,
+      onTriggerEnter: React.useCallback(() => {
+        if (providerContext.isOpenDelayed) handleDelayedOpen();else handleOpen();
+      }, [providerContext.isOpenDelayed, handleDelayedOpen, handleOpen]),
+      onTriggerLeave: React.useCallback(() => {
+        if (disableHoverableContent) {
+          handleClose();
+        } else {
+          window.clearTimeout(openTimerRef.current);
+          openTimerRef.current = 0;
+        }
+      }, [handleClose, disableHoverableContent]),
+      onOpen: handleOpen,
+      onClose: handleClose,
+      disableHoverableContent,
+      children
+    })
+  });
 };
-/* -------------------------------------------------------------------------------------------------
- * TooltipTrigger
- * -----------------------------------------------------------------------------------------------*/
-const $a093c7e1ec25a057$var$TRIGGER_NAME = 'TooltipTrigger';
-const $a093c7e1ec25a057$export$8c610744efcf8a1d = /*#__PURE__*/forwardRef((props, forwardedRef) => {
+Tooltip.displayName = TOOLTIP_NAME;
+var TRIGGER_NAME = "TooltipTrigger";
+var TooltipTrigger = /*#__PURE__*/React.forwardRef((props, forwardedRef) => {
   const {
-    __scopeTooltip: __scopeTooltip,
+    __scopeTooltip,
     ...triggerProps
   } = props;
-  const context = $a093c7e1ec25a057$var$useTooltipContext($a093c7e1ec25a057$var$TRIGGER_NAME, __scopeTooltip);
-  const providerContext = $a093c7e1ec25a057$var$useTooltipProviderContext($a093c7e1ec25a057$var$TRIGGER_NAME, __scopeTooltip);
-  const popperScope = $a093c7e1ec25a057$var$usePopperScope(__scopeTooltip);
-  const ref = useRef(null);
-  const composedRefs = $6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, ref, context.onTriggerChange);
-  const isPointerDownRef = useRef(false);
-  const hasPointerMoveOpenedRef = useRef(false);
-  const handlePointerUp = useCallback(() => isPointerDownRef.current = false, []);
-  useEffect(() => {
-    return () => document.removeEventListener('pointerup', handlePointerUp);
+  const context = useTooltipContext(TRIGGER_NAME, __scopeTooltip);
+  const providerContext = useTooltipProviderContext(TRIGGER_NAME, __scopeTooltip);
+  const popperScope = usePopperScope(__scopeTooltip);
+  const ref = React.useRef(null);
+  const composedRefs = useComposedRefs(forwardedRef, ref, context.onTriggerChange);
+  const isPointerDownRef = React.useRef(false);
+  const hasPointerMoveOpenedRef = React.useRef(false);
+  const handlePointerUp = React.useCallback(() => isPointerDownRef.current = false, []);
+  React.useEffect(() => {
+    return () => document.removeEventListener("pointerup", handlePointerUp);
   }, [handlePointerUp]);
-  return /*#__PURE__*/createElement($cf1ac5d9fe0e8206$export$b688253958b8dfe7, _extends({
-    asChild: true
-  }, popperScope), /*#__PURE__*/createElement($8927f6f2acc4f386$export$250ffa63cdc0d034.button, _extends({
-    // We purposefully avoid adding `type=button` here because tooltip triggers are also
-    // commonly anchors and the anchor `type` attribute signifies MIME type.
-    "aria-describedby": context.open ? context.contentId : undefined,
-    "data-state": context.stateAttribute
-  }, triggerProps, {
-    ref: composedRefs,
-    onPointerMove: $e42e1063c40fb3ef$export$b9ecd428b558ff10(props.onPointerMove, event => {
-      if (event.pointerType === 'touch') return;
-      if (!hasPointerMoveOpenedRef.current && !providerContext.isPointerInTransitRef.current) {
-        context.onTriggerEnter();
-        hasPointerMoveOpenedRef.current = true;
-      }
-    }),
-    onPointerLeave: $e42e1063c40fb3ef$export$b9ecd428b558ff10(props.onPointerLeave, () => {
-      context.onTriggerLeave();
-      hasPointerMoveOpenedRef.current = false;
-    }),
-    onPointerDown: $e42e1063c40fb3ef$export$b9ecd428b558ff10(props.onPointerDown, () => {
-      isPointerDownRef.current = true;
-      document.addEventListener('pointerup', handlePointerUp, {
-        once: true
-      });
-    }),
-    onFocus: $e42e1063c40fb3ef$export$b9ecd428b558ff10(props.onFocus, () => {
-      if (!isPointerDownRef.current) context.onOpen();
-    }),
-    onBlur: $e42e1063c40fb3ef$export$b9ecd428b558ff10(props.onBlur, context.onClose),
-    onClick: $e42e1063c40fb3ef$export$b9ecd428b558ff10(props.onClick, context.onClose)
-  })));
+  return /* @__PURE__ */jsx(Anchor, {
+    asChild: true,
+    ...popperScope,
+    children: /* @__PURE__ */jsx(Primitive.button, {
+      "aria-describedby": context.open ? context.contentId : void 0,
+      "data-state": context.stateAttribute,
+      ...triggerProps,
+      ref: composedRefs,
+      onPointerMove: composeEventHandlers(props.onPointerMove, event => {
+        if (event.pointerType === "touch") return;
+        if (!hasPointerMoveOpenedRef.current && !providerContext.isPointerInTransitRef.current) {
+          context.onTriggerEnter();
+          hasPointerMoveOpenedRef.current = true;
+        }
+      }),
+      onPointerLeave: composeEventHandlers(props.onPointerLeave, () => {
+        context.onTriggerLeave();
+        hasPointerMoveOpenedRef.current = false;
+      }),
+      onPointerDown: composeEventHandlers(props.onPointerDown, () => {
+        isPointerDownRef.current = true;
+        document.addEventListener("pointerup", handlePointerUp, {
+          once: true
+        });
+      }),
+      onFocus: composeEventHandlers(props.onFocus, () => {
+        if (!isPointerDownRef.current) context.onOpen();
+      }),
+      onBlur: composeEventHandlers(props.onBlur, context.onClose),
+      onClick: composeEventHandlers(props.onClick, context.onClose)
+    })
+  });
 });
-/* -------------------------------------------------------------------------------------------------
- * TooltipPortal
- * -----------------------------------------------------------------------------------------------*/
-const $a093c7e1ec25a057$var$PORTAL_NAME = 'TooltipPortal';
-const [$a093c7e1ec25a057$var$PortalProvider, $a093c7e1ec25a057$var$usePortalContext] = $a093c7e1ec25a057$var$createTooltipContext($a093c7e1ec25a057$var$PORTAL_NAME, {
-  forceMount: undefined
+TooltipTrigger.displayName = TRIGGER_NAME;
+var PORTAL_NAME = "TooltipPortal";
+var [PortalProvider, usePortalContext] = createTooltipContext(PORTAL_NAME, {
+  forceMount: void 0
 });
-const $a093c7e1ec25a057$export$7b36b8f925ab7497 = props => {
+var TooltipPortal = props => {
   const {
-    __scopeTooltip: __scopeTooltip,
-    forceMount: forceMount,
-    children: children,
-    container: container
+    __scopeTooltip,
+    forceMount,
+    children,
+    container
   } = props;
-  const context = $a093c7e1ec25a057$var$useTooltipContext($a093c7e1ec25a057$var$PORTAL_NAME, __scopeTooltip);
-  return /*#__PURE__*/createElement($a093c7e1ec25a057$var$PortalProvider, {
+  const context = useTooltipContext(PORTAL_NAME, __scopeTooltip);
+  return /* @__PURE__ */jsx(PortalProvider, {
     scope: __scopeTooltip,
-    forceMount: forceMount
-  }, /*#__PURE__*/createElement($921a889cee6df7e8$export$99c2b779aa4e8b8b, {
-    present: forceMount || context.open
-  }, /*#__PURE__*/createElement($f1701beae083dbae$export$602eac185826482c, {
-    asChild: true,
-    container: container
-  }, children)));
+    forceMount,
+    children: /* @__PURE__ */jsx(Presence, {
+      present: forceMount || context.open,
+      children: /* @__PURE__ */jsx(Portal, {
+        asChild: true,
+        container,
+        children
+      })
+    })
+  });
 };
-/* -------------------------------------------------------------------------------------------------
- * TooltipContent
- * -----------------------------------------------------------------------------------------------*/
-const $a093c7e1ec25a057$var$CONTENT_NAME = 'TooltipContent';
-const $a093c7e1ec25a057$export$e9003e2be37ec060 = /*#__PURE__*/forwardRef((props, forwardedRef) => {
-  const portalContext = $a093c7e1ec25a057$var$usePortalContext($a093c7e1ec25a057$var$CONTENT_NAME, props.__scopeTooltip);
+TooltipPortal.displayName = PORTAL_NAME;
+var CONTENT_NAME = "TooltipContent";
+var TooltipContent = /*#__PURE__*/React.forwardRef((props, forwardedRef) => {
+  const portalContext = usePortalContext(CONTENT_NAME, props.__scopeTooltip);
   const {
     forceMount = portalContext.forceMount,
-    side = 'top',
+    side = "top",
     ...contentProps
   } = props;
-  const context = $a093c7e1ec25a057$var$useTooltipContext($a093c7e1ec25a057$var$CONTENT_NAME, props.__scopeTooltip);
-  return /*#__PURE__*/createElement($921a889cee6df7e8$export$99c2b779aa4e8b8b, {
-    present: forceMount || context.open
-  }, context.disableHoverableContent ? /*#__PURE__*/createElement($a093c7e1ec25a057$var$TooltipContentImpl, _extends({
-    side: side
-  }, contentProps, {
-    ref: forwardedRef
-  })) : /*#__PURE__*/createElement($a093c7e1ec25a057$var$TooltipContentHoverable, _extends({
-    side: side
-  }, contentProps, {
-    ref: forwardedRef
-  })));
+  const context = useTooltipContext(CONTENT_NAME, props.__scopeTooltip);
+  return /* @__PURE__ */jsx(Presence, {
+    present: forceMount || context.open,
+    children: context.disableHoverableContent ? /* @__PURE__ */jsx(TooltipContentImpl, {
+      side,
+      ...contentProps,
+      ref: forwardedRef
+    }) : /* @__PURE__ */jsx(TooltipContentHoverable, {
+      side,
+      ...contentProps,
+      ref: forwardedRef
+    })
+  });
 });
-const $a093c7e1ec25a057$var$TooltipContentHoverable = /*#__PURE__*/forwardRef((props, forwardedRef) => {
-  const context = $a093c7e1ec25a057$var$useTooltipContext($a093c7e1ec25a057$var$CONTENT_NAME, props.__scopeTooltip);
-  const providerContext = $a093c7e1ec25a057$var$useTooltipProviderContext($a093c7e1ec25a057$var$CONTENT_NAME, props.__scopeTooltip);
-  const ref = useRef(null);
-  const composedRefs = $6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, ref);
-  const [pointerGraceArea, setPointerGraceArea] = useState(null);
+var TooltipContentHoverable = /*#__PURE__*/React.forwardRef((props, forwardedRef) => {
+  const context = useTooltipContext(CONTENT_NAME, props.__scopeTooltip);
+  const providerContext = useTooltipProviderContext(CONTENT_NAME, props.__scopeTooltip);
+  const ref = React.useRef(null);
+  const composedRefs = useComposedRefs(forwardedRef, ref);
+  const [pointerGraceArea, setPointerGraceArea] = React.useState(null);
   const {
-    trigger: trigger,
-    onClose: onClose
+    trigger,
+    onClose
   } = context;
   const content = ref.current;
   const {
-    onPointerInTransitChange: onPointerInTransitChange
+    onPointerInTransitChange
   } = providerContext;
-  const handleRemoveGraceArea = useCallback(() => {
+  const handleRemoveGraceArea = React.useCallback(() => {
     setPointerGraceArea(null);
     onPointerInTransitChange(false);
   }, [onPointerInTransitChange]);
-  const handleCreateGraceArea = useCallback((event, hoverTarget) => {
+  const handleCreateGraceArea = React.useCallback((event, hoverTarget) => {
     const currentTarget = event.currentTarget;
     const exitPoint = {
       x: event.clientX,
       y: event.clientY
     };
-    const exitSide = $a093c7e1ec25a057$var$getExitSideFromRect(exitPoint, currentTarget.getBoundingClientRect());
-    const paddedExitPoints = $a093c7e1ec25a057$var$getPaddedExitPoints(exitPoint, exitSide);
-    const hoverTargetPoints = $a093c7e1ec25a057$var$getPointsFromRect(hoverTarget.getBoundingClientRect());
-    const graceArea = $a093c7e1ec25a057$var$getHull([...paddedExitPoints, ...hoverTargetPoints]);
+    const exitSide = getExitSideFromRect(exitPoint, currentTarget.getBoundingClientRect());
+    const paddedExitPoints = getPaddedExitPoints(exitPoint, exitSide);
+    const hoverTargetPoints = getPointsFromRect(hoverTarget.getBoundingClientRect());
+    const graceArea = getHull([...paddedExitPoints, ...hoverTargetPoints]);
     setPointerGraceArea(graceArea);
     onPointerInTransitChange(true);
   }, [onPointerInTransitChange]);
-  useEffect(() => {
+  React.useEffect(() => {
     return () => handleRemoveGraceArea();
   }, [handleRemoveGraceArea]);
-  useEffect(() => {
+  React.useEffect(() => {
     if (trigger && content) {
       const handleTriggerLeave = event => handleCreateGraceArea(event, content);
       const handleContentLeave = event => handleCreateGraceArea(event, trigger);
-      trigger.addEventListener('pointerleave', handleTriggerLeave);
-      content.addEventListener('pointerleave', handleContentLeave);
+      trigger.addEventListener("pointerleave", handleTriggerLeave);
+      content.addEventListener("pointerleave", handleContentLeave);
       return () => {
-        trigger.removeEventListener('pointerleave', handleTriggerLeave);
-        content.removeEventListener('pointerleave', handleContentLeave);
+        trigger.removeEventListener("pointerleave", handleTriggerLeave);
+        content.removeEventListener("pointerleave", handleContentLeave);
       };
     }
   }, [trigger, content, handleCreateGraceArea, handleRemoveGraceArea]);
-  useEffect(() => {
+  React.useEffect(() => {
     if (pointerGraceArea) {
       const handleTrackPointerGrace = event => {
         const target = event.target;
@@ -290,121 +300,133 @@ const $a093c7e1ec25a057$var$TooltipContentHoverable = /*#__PURE__*/forwardRef((p
           y: event.clientY
         };
         const hasEnteredTarget = (trigger === null || trigger === void 0 ? void 0 : trigger.contains(target)) || (content === null || content === void 0 ? void 0 : content.contains(target));
-        const isPointerOutsideGraceArea = !$a093c7e1ec25a057$var$isPointInPolygon(pointerPosition, pointerGraceArea);
-        if (hasEnteredTarget) handleRemoveGraceArea();else if (isPointerOutsideGraceArea) {
+        const isPointerOutsideGraceArea = !isPointInPolygon(pointerPosition, pointerGraceArea);
+        if (hasEnteredTarget) {
+          handleRemoveGraceArea();
+        } else if (isPointerOutsideGraceArea) {
           handleRemoveGraceArea();
           onClose();
         }
       };
-      document.addEventListener('pointermove', handleTrackPointerGrace);
-      return () => document.removeEventListener('pointermove', handleTrackPointerGrace);
+      document.addEventListener("pointermove", handleTrackPointerGrace);
+      return () => document.removeEventListener("pointermove", handleTrackPointerGrace);
     }
   }, [trigger, content, pointerGraceArea, onClose, handleRemoveGraceArea]);
-  return /*#__PURE__*/createElement($a093c7e1ec25a057$var$TooltipContentImpl, _extends({}, props, {
+  return /* @__PURE__ */jsx(TooltipContentImpl, {
+    ...props,
     ref: composedRefs
-  }));
+  });
 });
-const [$a093c7e1ec25a057$var$VisuallyHiddenContentContextProvider, $a093c7e1ec25a057$var$useVisuallyHiddenContentContext] = $a093c7e1ec25a057$var$createTooltipContext($a093c7e1ec25a057$var$TOOLTIP_NAME, {
+var [VisuallyHiddenContentContextProvider, useVisuallyHiddenContentContext] = createTooltipContext(TOOLTIP_NAME, {
   isInside: false
 });
-const $a093c7e1ec25a057$var$TooltipContentImpl = /*#__PURE__*/forwardRef((props, forwardedRef) => {
+var TooltipContentImpl = /*#__PURE__*/React.forwardRef((props, forwardedRef) => {
   const {
-    __scopeTooltip: __scopeTooltip,
-    children: children,
-    'aria-label': ariaLabel,
-    onEscapeKeyDown: onEscapeKeyDown,
-    onPointerDownOutside: onPointerDownOutside,
+    __scopeTooltip,
+    children,
+    "aria-label": ariaLabel,
+    onEscapeKeyDown,
+    onPointerDownOutside,
     ...contentProps
   } = props;
-  const context = $a093c7e1ec25a057$var$useTooltipContext($a093c7e1ec25a057$var$CONTENT_NAME, __scopeTooltip);
-  const popperScope = $a093c7e1ec25a057$var$usePopperScope(__scopeTooltip);
+  const context = useTooltipContext(CONTENT_NAME, __scopeTooltip);
+  const popperScope = usePopperScope(__scopeTooltip);
   const {
-    onClose: onClose
-  } = context; // Close this tooltip if another one opens
-  useEffect(() => {
-    document.addEventListener($a093c7e1ec25a057$var$TOOLTIP_OPEN, onClose);
-    return () => document.removeEventListener($a093c7e1ec25a057$var$TOOLTIP_OPEN, onClose);
-  }, [onClose]); // Close the tooltip if the trigger is scrolled
-  useEffect(() => {
+    onClose
+  } = context;
+  React.useEffect(() => {
+    document.addEventListener(TOOLTIP_OPEN, onClose);
+    return () => document.removeEventListener(TOOLTIP_OPEN, onClose);
+  }, [onClose]);
+  React.useEffect(() => {
     if (context.trigger) {
       const handleScroll = event => {
         const target = event.target;
         if (target !== null && target !== void 0 && target.contains(context.trigger)) onClose();
       };
-      window.addEventListener('scroll', handleScroll, {
+      window.addEventListener("scroll", handleScroll, {
         capture: true
       });
-      return () => window.removeEventListener('scroll', handleScroll, {
+      return () => window.removeEventListener("scroll", handleScroll, {
         capture: true
       });
     }
   }, [context.trigger, onClose]);
-  return /*#__PURE__*/createElement($5cb92bef7577960e$export$177fb62ff3ec1f22, {
+  return /* @__PURE__ */jsx(DismissableLayer, {
     asChild: true,
     disableOutsidePointerEvents: false,
-    onEscapeKeyDown: onEscapeKeyDown,
-    onPointerDownOutside: onPointerDownOutside,
+    onEscapeKeyDown,
+    onPointerDownOutside,
     onFocusOutside: event => event.preventDefault(),
-    onDismiss: onClose
-  }, /*#__PURE__*/createElement($cf1ac5d9fe0e8206$export$7c6e2c02157bb7d2, _extends({
-    "data-state": context.stateAttribute
-  }, popperScope, contentProps, {
-    ref: forwardedRef,
-    style: {
-      ...contentProps.style,
-      '--radix-tooltip-content-transform-origin': 'var(--radix-popper-transform-origin)',
-      '--radix-tooltip-content-available-width': 'var(--radix-popper-available-width)',
-      '--radix-tooltip-content-available-height': 'var(--radix-popper-available-height)',
-      '--radix-tooltip-trigger-width': 'var(--radix-popper-anchor-width)',
-      '--radix-tooltip-trigger-height': 'var(--radix-popper-anchor-height)'
-    }
-  }), /*#__PURE__*/createElement($5e63c961fc1ce211$export$d9f1ccf0bdb05d45, null, children), /*#__PURE__*/createElement($a093c7e1ec25a057$var$VisuallyHiddenContentContextProvider, {
-    scope: __scopeTooltip,
-    isInside: true
-  }, /*#__PURE__*/createElement($ea1ef594cf570d83$export$be92b6f5f03c0fe9, {
-    id: context.contentId,
-    role: "tooltip"
-  }, ariaLabel || children))));
+    onDismiss: onClose,
+    children: /* @__PURE__ */jsxs(Content, {
+      "data-state": context.stateAttribute,
+      ...popperScope,
+      ...contentProps,
+      ref: forwardedRef,
+      style: {
+        ...contentProps.style,
+        // re-namespace exposed content custom properties
+        ...{
+          "--radix-tooltip-content-transform-origin": "var(--radix-popper-transform-origin)",
+          "--radix-tooltip-content-available-width": "var(--radix-popper-available-width)",
+          "--radix-tooltip-content-available-height": "var(--radix-popper-available-height)",
+          "--radix-tooltip-trigger-width": "var(--radix-popper-anchor-width)",
+          "--radix-tooltip-trigger-height": "var(--radix-popper-anchor-height)"
+        }
+      },
+      children: [/* @__PURE__ */jsx(Slottable, {
+        children
+      }), /* @__PURE__ */jsx(VisuallyHiddenContentContextProvider, {
+        scope: __scopeTooltip,
+        isInside: true,
+        children: /* @__PURE__ */jsx(Root, {
+          id: context.contentId,
+          role: "tooltip",
+          children: ariaLabel || children
+        })
+      })]
+    })
+  });
 });
-/* -------------------------------------------------------------------------------------------------
- * TooltipArrow
- * -----------------------------------------------------------------------------------------------*/
-const $a093c7e1ec25a057$var$ARROW_NAME = 'TooltipArrow';
-const $a093c7e1ec25a057$export$c27ee0ad710f7559 = /*#__PURE__*/forwardRef((props, forwardedRef) => {
+TooltipContent.displayName = CONTENT_NAME;
+var ARROW_NAME = "TooltipArrow";
+var TooltipArrow = /*#__PURE__*/React.forwardRef((props, forwardedRef) => {
   const {
-    __scopeTooltip: __scopeTooltip,
+    __scopeTooltip,
     ...arrowProps
   } = props;
-  const popperScope = $a093c7e1ec25a057$var$usePopperScope(__scopeTooltip);
-  const visuallyHiddenContentContext = $a093c7e1ec25a057$var$useVisuallyHiddenContentContext($a093c7e1ec25a057$var$ARROW_NAME, __scopeTooltip); // if the arrow is inside the `VisuallyHidden`, we don't want to render it all to
-  // prevent issues in positioning the arrow due to the duplicate
-  return visuallyHiddenContentContext.isInside ? null : /*#__PURE__*/createElement($cf1ac5d9fe0e8206$export$21b07c8f274aebd5, _extends({}, popperScope, arrowProps, {
+  const popperScope = usePopperScope(__scopeTooltip);
+  const visuallyHiddenContentContext = useVisuallyHiddenContentContext(ARROW_NAME, __scopeTooltip);
+  return visuallyHiddenContentContext.isInside ? null : /* @__PURE__ */jsx(Arrow, {
+    ...popperScope,
+    ...arrowProps,
     ref: forwardedRef
-  }));
+  });
 });
-/* -----------------------------------------------------------------------------------------------*/
-function $a093c7e1ec25a057$var$getExitSideFromRect(point, rect) {
+TooltipArrow.displayName = ARROW_NAME;
+function getExitSideFromRect(point, rect) {
   const top = Math.abs(rect.top - point.y);
   const bottom = Math.abs(rect.bottom - point.y);
   const right = Math.abs(rect.right - point.x);
   const left = Math.abs(rect.left - point.x);
   switch (Math.min(top, bottom, right, left)) {
     case left:
-      return 'left';
+      return "left";
     case right:
-      return 'right';
+      return "right";
     case top:
-      return 'top';
+      return "top";
     case bottom:
-      return 'bottom';
+      return "bottom";
     default:
-      throw new Error('unreachable');
+      throw new Error("unreachable");
   }
 }
-function $a093c7e1ec25a057$var$getPaddedExitPoints(exitPoint, exitSide, padding = 5) {
+function getPaddedExitPoints(exitPoint, exitSide, padding = 5) {
   const paddedExitPoints = [];
   switch (exitSide) {
-    case 'top':
+    case "top":
       paddedExitPoints.push({
         x: exitPoint.x - padding,
         y: exitPoint.y + padding
@@ -413,7 +435,7 @@ function $a093c7e1ec25a057$var$getPaddedExitPoints(exitPoint, exitSide, padding
         y: exitPoint.y + padding
       });
       break;
-    case 'bottom':
+    case "bottom":
       paddedExitPoints.push({
         x: exitPoint.x - padding,
         y: exitPoint.y - padding
@@ -422,7 +444,7 @@ function $a093c7e1ec25a057$var$getPaddedExitPoints(exitPoint, exitSide, padding
         y: exitPoint.y - padding
       });
       break;
-    case 'left':
+    case "left":
       paddedExitPoints.push({
         x: exitPoint.x + padding,
         y: exitPoint.y - padding
@@ -431,7 +453,7 @@ function $a093c7e1ec25a057$var$getPaddedExitPoints(exitPoint, exitSide, padding
         y: exitPoint.y + padding
       });
       break;
-    case 'right':
+    case "right":
       paddedExitPoints.push({
         x: exitPoint.x - padding,
         y: exitPoint.y - padding
@@ -443,12 +465,12 @@ function $a093c7e1ec25a057$var$getPaddedExitPoints(exitPoint, exitSide, padding
   }
   return paddedExitPoints;
 }
-function $a093c7e1ec25a057$var$getPointsFromRect(rect) {
+function getPointsFromRect(rect) {
   const {
-    top: top,
-    right: right,
-    bottom: bottom,
-    left: left
+    top,
+    right,
+    bottom,
+    left
   } = rect;
   return [{
     x: left,
@@ -463,33 +485,31 @@ function $a093c7e1ec25a057$var$getPointsFromRect(rect) {
     x: left,
     y: bottom
   }];
-} // Determine if a point is inside of a polygon.
-// Based on https://github.com/substack/point-in-polygon
-function $a093c7e1ec25a057$var$isPointInPolygon(point, polygon) {
+}
+function isPointInPolygon(point, polygon) {
   const {
-    x: x,
-    y: y
+    x,
+    y
   } = point;
   let inside = false;
   for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
     const xi = polygon[i].x;
     const yi = polygon[i].y;
     const xj = polygon[j].x;
-    const yj = polygon[j].y; // prettier-ignore
+    const yj = polygon[j].y;
     const intersect = yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi;
     if (intersect) inside = !inside;
   }
   return inside;
-} // Returns a new array of points representing the convex hull of the given set of points.
-// https://www.nayuki.io/page/convex-hull-algorithm
-function $a093c7e1ec25a057$var$getHull(points) {
+}
+function getHull(points) {
   const newPoints = points.slice();
   newPoints.sort((a, b) => {
     if (a.x < b.x) return -1;else if (a.x > b.x) return 1;else if (a.y < b.y) return -1;else if (a.y > b.y) return 1;else return 0;
   });
-  return $a093c7e1ec25a057$var$getHullPresorted(newPoints);
-} // Returns the convex hull, assuming that each points[i] <= points[i + 1]. Runs in O(n) time.
-function $a093c7e1ec25a057$var$getHullPresorted(points) {
+  return getHullPresorted(newPoints);
+}
+function getHullPresorted(points) {
   if (points.length <= 1) return points.slice();
   const upperHull = [];
   for (let i = 0; i < points.length; i++) {
@@ -503,8 +523,8 @@ function $a093c7e1ec25a057$var$getHullPresorted(points) {
   }
   upperHull.pop();
   const lowerHull = [];
-  for (let i1 = points.length - 1; i1 >= 0; i1--) {
-    const p = points[i1];
+  for (let i = points.length - 1; i >= 0; i--) {
+    const p = points[i];
     while (lowerHull.length >= 2) {
       const q = lowerHull[lowerHull.length - 1];
       const r = lowerHull[lowerHull.length - 2];
@@ -513,8 +533,12 @@ function $a093c7e1ec25a057$var$getHullPresorted(points) {
     lowerHull.push(p);
   }
   lowerHull.pop();
-  if (upperHull.length === 1 && lowerHull.length === 1 && upperHull[0].x === lowerHull[0].x && upperHull[0].y === lowerHull[0].y) return upperHull;else return upperHull.concat(lowerHull);
+  if (upperHull.length === 1 && lowerHull.length === 1 && upperHull[0].x === lowerHull[0].x && upperHull[0].y === lowerHull[0].y) {
+    return upperHull;
+  } else {
+    return upperHull.concat(lowerHull);
+  }
 }
 
-export { $a093c7e1ec25a057$export$28c660c63b792dea as Tooltip, $a093c7e1ec25a057$export$c27ee0ad710f7559 as TooltipArrow, $a093c7e1ec25a057$export$e9003e2be37ec060 as TooltipContent, $a093c7e1ec25a057$export$7b36b8f925ab7497 as TooltipPortal, $a093c7e1ec25a057$export$f78649fb9ca566b8 as TooltipProvider, $a093c7e1ec25a057$export$8c610744efcf8a1d as TooltipTrigger, $a093c7e1ec25a057$export$1c540a2224f0d865 as createTooltipScope };
+export { Tooltip, TooltipArrow, TooltipContent, TooltipPortal, TooltipProvider, TooltipTrigger, createTooltipScope };
 //# sourceMappingURL=index.mjs.map