@burtson-labs/ui 0.13.1 → 0.14.1

package/dist/primitives/vendor/radix/react-tooltip/tooltip.js

@@ -0,0 +1,503 @@
+"use client";
+import { createContextScope } from "../react-context/create-context.js";
+import { useComposedRefs } from "../react-compose-refs/compose-refs.js";
+import { createSlottable } from "../react-slot/slot.js";
+import { composeEventHandlers } from "../primitive/primitive.js";
+import { useLayoutEffect } from "../react-use-layout-effect/use-layout-effect.js";
+import { useControllableState } from "../react-use-controllable-state/use-controllable-state.js";
+import { Primitive } from "../react-primitive/primitive.js";
+import { Presence } from "../react-presence/presence.js";
+import { useId } from "../react-id/id.js";
+import { DismissableLayer } from "../react-dismissable-layer/dismissable-layer.js";
+import { Portal as Portal$1 } from "../react-portal/portal.js";
+import { Anchor, Arrow as Arrow$1, Content as Content$1, Root as Root$1, createPopperScope } from "../react-popper/popper.js";
+import { Root as Root$2 } from "../react-visually-hidden/visually-hidden.js";
+import * as React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/primitives/vendor/radix/react-tooltip/tooltip.tsx
+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, delayDuration = DEFAULT_DELAY_DURATION, skipDelayDuration = 300, disableHoverableContent = false, children } = props;
+	const isOpenDelayedRef = React.useRef(true);
+	const isPointerInTransitRef = React.useRef(false);
+	const skipDelayTimerRef = React.useRef(0);
+	React.useEffect(() => {
+		const skipDelayTimer = skipDelayTimerRef.current;
+		return () => window.clearTimeout(skipDelayTimer);
+	}, []);
+	return /* @__PURE__ */ jsx(TooltipProviderContextProvider, {
+		scope: __scopeTooltip,
+		isOpenDelayedRef,
+		delayDuration,
+		onOpen: React.useCallback(() => {
+			if (skipDelayDuration <= 0) return;
+			window.clearTimeout(skipDelayTimerRef.current);
+			isOpenDelayedRef.current = false;
+		}, [skipDelayDuration]),
+		onClose: React.useCallback(() => {
+			if (skipDelayDuration <= 0) return;
+			window.clearTimeout(skipDelayTimerRef.current);
+			skipDelayTimerRef.current = window.setTimeout(() => isOpenDelayedRef.current = true, skipDelayDuration);
+		}, [skipDelayDuration]),
+		isPointerInTransitRef,
+		onPointerInTransitChange: React.useCallback((inTransit) => {
+			isPointerInTransitRef.current = inTransit;
+		}, []),
+		disableHoverableContent,
+		children
+	});
+};
+var TOOLTIP_NAME = "Tooltip";
+var [TooltipContextProvider, useTooltipContext] = createTooltipContext(TOOLTIP_NAME);
+var Tooltip = (props) => {
+	const { __scopeTooltip, children, open: openProp, defaultOpen, onOpenChange, disableHoverableContent: disableHoverableContentProp, delayDuration: delayDurationProp } = props;
+	const providerContext = useTooltipProviderContext(TOOLTIP_NAME, props.__scopeTooltip);
+	const popperScope = usePopperScope(__scopeTooltip);
+	const [trigger, setTrigger] = React.useState(null);
+	const [contentIdState, setContentId] = React.useState(void 0);
+	const generatedContentId = useId();
+	const openTimerRef = React.useRef(0);
+	const disableHoverableContent = disableHoverableContentProp ?? providerContext.disableHoverableContent;
+	const delayDuration = delayDurationProp ?? providerContext.delayDuration;
+	const wasOpenDelayedRef = React.useRef(false);
+	const [open, setOpen] = useControllableState({
+		prop: openProp,
+		defaultProp: defaultOpen ?? false,
+		onChange: (open) => {
+			if (open) {
+				providerContext.onOpen();
+				document.dispatchEvent(new CustomEvent(TOOLTIP_OPEN));
+			} else providerContext.onClose();
+			onOpenChange?.(open);
+		},
+		caller: TOOLTIP_NAME
+	});
+	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 = React.useCallback(() => {
+		window.clearTimeout(openTimerRef.current);
+		openTimerRef.current = 0;
+		setOpen(false);
+	}, [setOpen]);
+	const handleDelayedOpen = React.useCallback(() => {
+		window.clearTimeout(openTimerRef.current);
+		openTimerRef.current = window.setTimeout(() => {
+			wasOpenDelayedRef.current = true;
+			setOpen(true);
+			openTimerRef.current = 0;
+		}, delayDuration);
+	}, [delayDuration, setOpen]);
+	React.useEffect(() => {
+		return () => {
+			if (openTimerRef.current) {
+				window.clearTimeout(openTimerRef.current);
+				openTimerRef.current = 0;
+			}
+		};
+	}, []);
+	const contentId = contentIdState ?? generatedContentId;
+	return /* @__PURE__ */ jsx(Root$1, {
+		...popperScope,
+		children: /* @__PURE__ */ jsx(TooltipContextProvider, {
+			scope: __scopeTooltip,
+			contentId,
+			setContentId,
+			open,
+			stateAttribute,
+			trigger,
+			onTriggerChange: setTrigger,
+			onTriggerEnter: React.useCallback(() => {
+				if (providerContext.isOpenDelayedRef.current) handleDelayedOpen();
+				else handleOpen();
+			}, [
+				providerContext.isOpenDelayedRef,
+				handleDelayedOpen,
+				handleOpen
+			]),
+			onTriggerLeave: React.useCallback(() => {
+				if (disableHoverableContent) handleClose();
+				else {
+					window.clearTimeout(openTimerRef.current);
+					openTimerRef.current = 0;
+				}
+			}, [handleClose, disableHoverableContent]),
+			onOpen: handleOpen,
+			onClose: handleClose,
+			disableHoverableContent,
+			children
+		})
+	});
+};
+var TRIGGER_NAME = "TooltipTrigger";
+var TooltipTrigger = /* @__PURE__ */ React.forwardRef(function TooltipTrigger(props, forwardedRef) {
+	const { __scopeTooltip, ...triggerProps } = props;
+	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__ */ 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, () => {
+				if (context.open) context.onClose();
+				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)
+		})
+	});
+});
+var PORTAL_NAME = "TooltipPortal";
+var [PortalProvider, usePortalContext] = createTooltipContext(PORTAL_NAME, { forceMount: void 0 });
+var TooltipPortal = (props) => {
+	const { __scopeTooltip, forceMount, children, container } = props;
+	const context = useTooltipContext(PORTAL_NAME, __scopeTooltip);
+	return /* @__PURE__ */ jsx(PortalProvider, {
+		scope: __scopeTooltip,
+		forceMount,
+		children: /* @__PURE__ */ jsx(Presence, {
+			present: forceMount || context.open,
+			children: /* @__PURE__ */ jsx(Portal$1, {
+				asChild: true,
+				container,
+				children
+			})
+		})
+	});
+};
+var CONTENT_NAME = "TooltipContent";
+var TooltipContent = /* @__PURE__ */ React.forwardRef(function TooltipContent(props, forwardedRef) {
+	const portalContext = usePortalContext(CONTENT_NAME, props.__scopeTooltip);
+	const { forceMount = portalContext.forceMount, side = "top", ...contentProps } = props;
+	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
+		})
+	});
+});
+var TooltipContentHoverable = /* @__PURE__ */ React.forwardRef(function TooltipContentHoverable(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, onClose } = context;
+	const content = ref.current;
+	const { onPointerInTransitChange } = providerContext;
+	const handleRemoveGraceArea = React.useCallback(() => {
+		setPointerGraceArea(null);
+		onPointerInTransitChange(false);
+	}, [onPointerInTransitChange]);
+	const handleCreateGraceArea = React.useCallback((event, hoverTarget) => {
+		const currentTarget = event.currentTarget;
+		const exitPoint = {
+			x: event.clientX,
+			y: event.clientY
+		};
+		const paddedExitPoints = getPaddedExitPoints(exitPoint, getExitSideFromRect(exitPoint, currentTarget.getBoundingClientRect()));
+		const hoverTargetPoints = getPointsFromRect(hoverTarget.getBoundingClientRect());
+		const graceArea = getHull([...paddedExitPoints, ...hoverTargetPoints]);
+		setPointerGraceArea(graceArea);
+		onPointerInTransitChange(true);
+	}, [onPointerInTransitChange]);
+	React.useEffect(() => {
+		return () => handleRemoveGraceArea();
+	}, [handleRemoveGraceArea]);
+	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);
+			return () => {
+				trigger.removeEventListener("pointerleave", handleTriggerLeave);
+				content.removeEventListener("pointerleave", handleContentLeave);
+			};
+		}
+	}, [
+		trigger,
+		content,
+		handleCreateGraceArea,
+		handleRemoveGraceArea
+	]);
+	React.useEffect(() => {
+		if (pointerGraceArea) {
+			const handleTrackPointerGrace = (event) => {
+				const target = event.target;
+				const pointerPosition = {
+					x: event.clientX,
+					y: event.clientY
+				};
+				const hasEnteredTarget = trigger?.contains(target) || content?.contains(target);
+				const isPointerOutsideGraceArea = !isPointInPolygon(pointerPosition, pointerGraceArea);
+				if (hasEnteredTarget) handleRemoveGraceArea();
+				else if (isPointerOutsideGraceArea) {
+					handleRemoveGraceArea();
+					onClose();
+				}
+			};
+			document.addEventListener("pointermove", handleTrackPointerGrace);
+			return () => document.removeEventListener("pointermove", handleTrackPointerGrace);
+		}
+	}, [
+		trigger,
+		content,
+		pointerGraceArea,
+		onClose,
+		handleRemoveGraceArea
+	]);
+	return /* @__PURE__ */ jsx(TooltipContentImpl, {
+		...props,
+		ref: composedRefs
+	});
+});
+var Slottable = /* @__PURE__ */ createSlottable("TooltipContent");
+var TooltipContentImpl = /* @__PURE__ */ React.forwardRef(function TooltipContentImpl(props, forwardedRef) {
+	const { __scopeTooltip, children, "aria-label": ariaLabel, id: idProp, onEscapeKeyDown, onPointerDownOutside, ...contentProps } = props;
+	const context = useTooltipContext(CONTENT_NAME, __scopeTooltip);
+	const popperScope = usePopperScope(__scopeTooltip);
+	const { onClose } = context;
+	React.useEffect(() => {
+		document.addEventListener(TOOLTIP_OPEN, onClose);
+		return () => document.removeEventListener(TOOLTIP_OPEN, onClose);
+	}, [onClose]);
+	React.useEffect(() => {
+		if (context.trigger) {
+			const handleScroll = (event) => {
+				if (event.target instanceof Node && event.target.contains(context.trigger)) onClose();
+			};
+			window.addEventListener("scroll", handleScroll, { capture: true });
+			return () => window.removeEventListener("scroll", handleScroll, { capture: true });
+		}
+	}, [context.trigger, onClose]);
+	const { setContentId } = context;
+	useLayoutEffect(() => {
+		setContentId(idProp);
+		return () => {
+			setContentId(void 0);
+		};
+	}, [idProp, setContentId]);
+	return /* @__PURE__ */ jsx(DismissableLayer, {
+		asChild: true,
+		disableOutsidePointerEvents: false,
+		onEscapeKeyDown,
+		onPointerDownOutside,
+		onFocusOutside: (event) => event.preventDefault(),
+		onDismiss: onClose,
+		children: /* @__PURE__ */ jsxs(Content$1, {
+			"data-state": context.stateAttribute,
+			role: ariaLabel ? void 0 : "tooltip",
+			id: ariaLabel ? void 0 : context.contentId,
+			...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)"
+			},
+			children: [/* @__PURE__ */ jsx(Slottable, { children }), ariaLabel ? /* @__PURE__ */ jsx(Root$2, {
+				id: context.contentId,
+				role: "tooltip",
+				children: ariaLabel
+			}) : null]
+		})
+	});
+});
+var TooltipArrow = /* @__PURE__ */ React.forwardRef(function TooltipArrow(props, forwardedRef) {
+	const { __scopeTooltip, ...arrowProps } = props;
+	const popperScope = usePopperScope(__scopeTooltip);
+	return /* @__PURE__ */ jsx(Arrow$1, {
+		...popperScope,
+		...arrowProps,
+		ref: forwardedRef
+	});
+});
+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";
+		case right: return "right";
+		case top: return "top";
+		case bottom: return "bottom";
+		default: throw new Error("unreachable");
+	}
+}
+function getPaddedExitPoints(exitPoint, exitSide, padding = 5) {
+	const paddedExitPoints = [];
+	switch (exitSide) {
+		case "top":
+			paddedExitPoints.push({
+				x: exitPoint.x - padding,
+				y: exitPoint.y + padding
+			}, {
+				x: exitPoint.x + padding,
+				y: exitPoint.y + padding
+			});
+			break;
+		case "bottom":
+			paddedExitPoints.push({
+				x: exitPoint.x - padding,
+				y: exitPoint.y - padding
+			}, {
+				x: exitPoint.x + padding,
+				y: exitPoint.y - padding
+			});
+			break;
+		case "left":
+			paddedExitPoints.push({
+				x: exitPoint.x + padding,
+				y: exitPoint.y - padding
+			}, {
+				x: exitPoint.x + padding,
+				y: exitPoint.y + padding
+			});
+			break;
+		case "right": paddedExitPoints.push({
+			x: exitPoint.x - padding,
+			y: exitPoint.y - padding
+		}, {
+			x: exitPoint.x - padding,
+			y: exitPoint.y + padding
+		});
+	}
+	return paddedExitPoints;
+}
+function getPointsFromRect(rect) {
+	const { top, right, bottom, left } = rect;
+	return [
+		{
+			x: left,
+			y: top
+		},
+		{
+			x: right,
+			y: top
+		},
+		{
+			x: right,
+			y: bottom
+		},
+		{
+			x: left,
+			y: bottom
+		}
+	];
+}
+function isPointInPolygon(point, polygon) {
+	const { x, y } = point;
+	let inside = false;
+	for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+		const ii = polygon[i];
+		const jj = polygon[j];
+		const xi = ii.x;
+		const yi = ii.y;
+		const xj = jj.x;
+		const yj = jj.y;
+		if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) inside = !inside;
+	}
+	return inside;
+}
+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 getHullPresorted(newPoints);
+}
+function getHullPresorted(points) {
+	if (points.length <= 1) return points.slice();
+	const upperHull = [];
+	for (let i = 0; i < points.length; i++) {
+		const p = points[i];
+		while (upperHull.length >= 2) {
+			const q = upperHull[upperHull.length - 1];
+			const r = upperHull[upperHull.length - 2];
+			if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x)) upperHull.pop();
+			else break;
+		}
+		upperHull.push(p);
+	}
+	upperHull.pop();
+	const lowerHull = [];
+	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];
+			if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x)) lowerHull.pop();
+			else break;
+		}
+		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);
+}
+var Provider = TooltipProvider;
+var Root = Tooltip;
+var Trigger = TooltipTrigger;
+var Portal = TooltipPortal;
+var Content = TooltipContent;
+var Arrow = TooltipArrow;
+//#endregion
+export { Arrow, Content, Portal, Provider, Root, Tooltip, TooltipArrow, TooltipContent, TooltipPortal, TooltipProvider, TooltipTrigger, Trigger };
+
+//# sourceMappingURL=tooltip.js.map

package/dist/primitives/vendor/radix/react-tooltip/tooltip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip.js","names":["PopperPrimitive.Root","PopperPrimitive.Anchor","PortalPrimitive","PopperPrimitive.Content","VisuallyHiddenPrimitive.Root","PopperPrimitive.Arrow"],"sources":["../../../../../src/primitives/vendor/radix/react-tooltip/tooltip.tsx"],"sourcesContent":["// Vendored from Radix Primitives (c) 2022 WorkOS, MIT. See vendor/LICENSE.radix.\n// Local modification: package imports resolve to the pinned local source.\nimport * as React from 'react';\nimport { composeEventHandlers } from '../primitive';\nimport { useComposedRefs } from '../react-compose-refs';\nimport { createContextScope } from '../react-context';\nimport { DismissableLayer } from '../react-dismissable-layer';\nimport { useId } from '../react-id';\nimport * as PopperPrimitive from '../react-popper';\nimport { createPopperScope } from '../react-popper';\nimport { Portal as PortalPrimitive } from '../react-portal';\nimport { Presence } from '../react-presence';\nimport { Primitive } from '../react-primitive';\nimport { createSlottable } from '../react-slot';\nimport { useControllableState } from '../react-use-controllable-state';\nimport { useLayoutEffect } from '../react-use-layout-effect';\nimport * as VisuallyHiddenPrimitive from '../react-visually-hidden';\n\nimport type { Scope } from '../react-context';\n\ntype ScopedProps<P = {}> = P & { __scopeTooltip?: Scope };\nconst [createTooltipContext, createTooltipScope] = createContextScope('Tooltip', [\n  createPopperScope,\n]);\nconst usePopperScope = createPopperScope();\n\n/* -------------------------------------------------------------------------------------------------\n * TooltipProvider\n * -----------------------------------------------------------------------------------------------*/\n\nconst PROVIDER_NAME = 'TooltipProvider';\nconst DEFAULT_DELAY_DURATION = 700;\nconst TOOLTIP_OPEN = 'tooltip.open';\n\ninterface TooltipProviderContextValue {\n  isOpenDelayedRef: React.RefObject<boolean>;\n  delayDuration: number;\n  onOpen(): void;\n  onClose(): void;\n  onPointerInTransitChange(inTransit: boolean): void;\n  isPointerInTransitRef: React.RefObject<boolean>;\n  disableHoverableContent: boolean;\n}\n\nconst [TooltipProviderContextProvider, useTooltipProviderContext] =\n  createTooltipContext<TooltipProviderContextValue>(PROVIDER_NAME);\n\ninterface TooltipProviderProps {\n  children: React.ReactNode;\n  /**\n   * The duration from when the pointer enters the trigger until the tooltip gets opened.\n   * @defaultValue 700\n   */\n  delayDuration?: number;\n  /**\n   * How much time a user has to enter another trigger without incurring a delay again.\n   * @defaultValue 300\n   */\n  skipDelayDuration?: number;\n  /**\n   * When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.\n   * @defaultValue false\n   */\n  disableHoverableContent?: boolean;\n}\n\nconst TooltipProvider: React.FC<TooltipProviderProps> = (\n  props: ScopedProps<TooltipProviderProps>,\n) => {\n  const {\n    __scopeTooltip,\n    delayDuration = DEFAULT_DELAY_DURATION,\n    skipDelayDuration = 300,\n    disableHoverableContent = false,\n    children,\n  } = props;\n  const isOpenDelayedRef = React.useRef(true);\n  const isPointerInTransitRef = React.useRef(false);\n  const skipDelayTimerRef = React.useRef(0);\n\n  React.useEffect(() => {\n    const skipDelayTimer = skipDelayTimerRef.current;\n    return () => window.clearTimeout(skipDelayTimer);\n  }, []);\n\n  return (\n    <TooltipProviderContextProvider\n      scope={__scopeTooltip}\n      isOpenDelayedRef={isOpenDelayedRef}\n      delayDuration={delayDuration}\n      onOpen={React.useCallback(() => {\n        if (skipDelayDuration <= 0) return;\n        window.clearTimeout(skipDelayTimerRef.current);\n        isOpenDelayedRef.current = false;\n      }, [skipDelayDuration])}\n      onClose={React.useCallback(() => {\n        if (skipDelayDuration <= 0) return;\n        window.clearTimeout(skipDelayTimerRef.current);\n        skipDelayTimerRef.current = window.setTimeout(\n          () => (isOpenDelayedRef.current = true),\n          skipDelayDuration,\n        );\n      }, [skipDelayDuration])}\n      isPointerInTransitRef={isPointerInTransitRef}\n      onPointerInTransitChange={React.useCallback((inTransit: boolean) => {\n        isPointerInTransitRef.current = inTransit;\n      }, [])}\n      disableHoverableContent={disableHoverableContent}\n    >\n      {children}\n    </TooltipProviderContextProvider>\n  );\n};\n\n/* -------------------------------------------------------------------------------------------------\n * Tooltip\n * -----------------------------------------------------------------------------------------------*/\n\nconst TOOLTIP_NAME = 'Tooltip';\n\ninterface TooltipContextValue {\n  contentId: string;\n  open: boolean;\n  stateAttribute: 'closed' | 'delayed-open' | 'instant-open';\n  trigger: TooltipTriggerElement | null;\n  onTriggerChange(trigger: TooltipTriggerElement | null): void;\n  onTriggerEnter(): void;\n  onTriggerLeave(): void;\n  onOpen(): void;\n  onClose(): void;\n  disableHoverableContent: boolean;\n  setContentId: React.Dispatch<React.SetStateAction<string | undefined>>;\n}\n\nconst [TooltipContextProvider, useTooltipContext] =\n  createTooltipContext<TooltipContextValue>(TOOLTIP_NAME);\n\ninterface TooltipProps {\n  children?: React.ReactNode;\n  open?: boolean;\n  defaultOpen?: boolean;\n  onOpenChange?: (open: boolean) => void;\n  /**\n   * The duration from when the pointer enters the trigger until the tooltip gets opened. This will\n   * override the prop with the same name passed to Provider.\n   * @defaultValue 700\n   */\n  delayDuration?: number;\n  /**\n   * When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.\n   * @defaultValue false\n   */\n  disableHoverableContent?: boolean;\n}\n\nconst Tooltip: React.FC<TooltipProps> = (props: ScopedProps<TooltipProps>) => {\n  const {\n    __scopeTooltip,\n    children,\n    open: openProp,\n    defaultOpen,\n    onOpenChange,\n    disableHoverableContent: disableHoverableContentProp,\n    delayDuration: delayDurationProp,\n  } = props;\n  const providerContext = useTooltipProviderContext(TOOLTIP_NAME, props.__scopeTooltip);\n  const popperScope = usePopperScope(__scopeTooltip);\n  const [trigger, setTrigger] = React.useState<HTMLButtonElement | null>(null);\n  const [contentIdState, setContentId] = React.useState<string | undefined>(undefined);\n  const generatedContentId = useId();\n  const openTimerRef = React.useRef(0);\n  const disableHoverableContent =\n    disableHoverableContentProp ?? providerContext.disableHoverableContent;\n  const delayDuration = delayDurationProp ?? providerContext.delayDuration;\n  const wasOpenDelayedRef = React.useRef(false);\n  const [open, setOpen] = useControllableState({\n    prop: openProp,\n    defaultProp: defaultOpen ?? false,\n    onChange: (open) => {\n      if (open) {\n        providerContext.onOpen();\n\n        // as `onChange` is called within a lifecycle method we\n        // avoid dispatching via `dispatchDiscreteCustomEvent`.\n        document.dispatchEvent(new CustomEvent(TOOLTIP_OPEN));\n      } else {\n        providerContext.onClose();\n      }\n      onOpenChange?.(open);\n    },\n    caller: TOOLTIP_NAME,\n  });\n  const stateAttribute = React.useMemo(() => {\n    return open ? (wasOpenDelayedRef.current ? 'delayed-open' : 'instant-open') : 'closed';\n  }, [open]);\n\n  const handleOpen = React.useCallback(() => {\n    window.clearTimeout(openTimerRef.current);\n    openTimerRef.current = 0;\n    wasOpenDelayedRef.current = false;\n    setOpen(true);\n  }, [setOpen]);\n\n  const handleClose = React.useCallback(() => {\n    window.clearTimeout(openTimerRef.current);\n    openTimerRef.current = 0;\n    setOpen(false);\n  }, [setOpen]);\n\n  const handleDelayedOpen = React.useCallback(() => {\n    window.clearTimeout(openTimerRef.current);\n    openTimerRef.current = window.setTimeout(() => {\n      wasOpenDelayedRef.current = true;\n      setOpen(true);\n      openTimerRef.current = 0;\n    }, delayDuration);\n  }, [delayDuration, setOpen]);\n\n  React.useEffect(() => {\n    return () => {\n      if (openTimerRef.current) {\n        window.clearTimeout(openTimerRef.current);\n        openTimerRef.current = 0;\n      }\n    };\n  }, []);\n\n  const contentId = contentIdState ?? generatedContentId;\n\n  return (\n    <PopperPrimitive.Root {...popperScope}>\n      <TooltipContextProvider\n        scope={__scopeTooltip}\n        contentId={contentId}\n        setContentId={setContentId}\n        open={open}\n        stateAttribute={stateAttribute}\n        trigger={trigger}\n        onTriggerChange={setTrigger}\n        onTriggerEnter={React.useCallback(() => {\n          if (providerContext.isOpenDelayedRef.current) handleDelayedOpen();\n          else handleOpen();\n        }, [providerContext.isOpenDelayedRef, handleDelayedOpen, handleOpen])}\n        onTriggerLeave={React.useCallback(() => {\n          if (disableHoverableContent) {\n            handleClose();\n          } else {\n            // Clear the timer in case the pointer leaves the trigger before the tooltip is opened.\n            window.clearTimeout(openTimerRef.current);\n            openTimerRef.current = 0;\n          }\n        }, [handleClose, disableHoverableContent])}\n        onOpen={handleOpen}\n        onClose={handleClose}\n        disableHoverableContent={disableHoverableContent}\n      >\n        {children}\n      </TooltipContextProvider>\n    </PopperPrimitive.Root>\n  );\n};\n\n/* -------------------------------------------------------------------------------------------------\n * TooltipTrigger\n * -----------------------------------------------------------------------------------------------*/\n\nconst TRIGGER_NAME = 'TooltipTrigger';\n\ntype TooltipTriggerElement = React.ComponentRef<typeof Primitive.button>;\ntype PrimitiveButtonProps = React.ComponentPropsWithoutRef<typeof Primitive.button>;\ninterface TooltipTriggerProps extends PrimitiveButtonProps {}\n\nconst TooltipTrigger = /* @__PURE__ */ React.forwardRef<TooltipTriggerElement, TooltipTriggerProps>(\n  function TooltipTrigger(props: ScopedProps<TooltipTriggerProps>, forwardedRef) {\n    const { __scopeTooltip, ...triggerProps } = props;\n    const context = useTooltipContext(TRIGGER_NAME, __scopeTooltip);\n    const providerContext = useTooltipProviderContext(TRIGGER_NAME, __scopeTooltip);\n    const popperScope = usePopperScope(__scopeTooltip);\n    const ref = React.useRef<TooltipTriggerElement>(null);\n    const composedRefs = useComposedRefs(forwardedRef, ref, context.onTriggerChange);\n    const isPointerDownRef = React.useRef(false);\n    const hasPointerMoveOpenedRef = React.useRef(false);\n    const handlePointerUp = React.useCallback(() => (isPointerDownRef.current = false), []);\n\n    React.useEffect(() => {\n      return () => document.removeEventListener('pointerup', handlePointerUp);\n    }, [handlePointerUp]);\n\n    return (\n      <PopperPrimitive.Anchor asChild {...popperScope}>\n        <Primitive.button\n          // We purposefully avoid adding `type=button` here because tooltip triggers are also\n          // commonly anchors and the anchor `type` attribute signifies MIME type.\n          aria-describedby={context.open ? context.contentId : undefined}\n          data-state={context.stateAttribute}\n          {...triggerProps}\n          ref={composedRefs}\n          onPointerMove={composeEventHandlers(props.onPointerMove, (event) => {\n            if (event.pointerType === 'touch') return;\n            if (\n              !hasPointerMoveOpenedRef.current &&\n              !providerContext.isPointerInTransitRef.current\n            ) {\n              context.onTriggerEnter();\n              hasPointerMoveOpenedRef.current = true;\n            }\n          })}\n          onPointerLeave={composeEventHandlers(props.onPointerLeave, () => {\n            context.onTriggerLeave();\n            hasPointerMoveOpenedRef.current = false;\n          })}\n          onPointerDown={composeEventHandlers(props.onPointerDown, () => {\n            if (context.open) {\n              context.onClose();\n            }\n            isPointerDownRef.current = true;\n            document.addEventListener('pointerup', handlePointerUp, { once: true });\n          })}\n          onFocus={composeEventHandlers(props.onFocus, () => {\n            if (!isPointerDownRef.current) context.onOpen();\n          })}\n          onBlur={composeEventHandlers(props.onBlur, context.onClose)}\n          onClick={composeEventHandlers(props.onClick, context.onClose)}\n        />\n      </PopperPrimitive.Anchor>\n    );\n  },\n);\n\n/* -------------------------------------------------------------------------------------------------\n * TooltipPortal\n * -----------------------------------------------------------------------------------------------*/\n\nconst PORTAL_NAME = 'TooltipPortal';\n\ntype PortalContextValue = { forceMount?: true };\nconst [PortalProvider, usePortalContext] = createTooltipContext<PortalContextValue>(PORTAL_NAME, {\n  forceMount: undefined,\n});\n\ntype PortalProps = React.ComponentPropsWithoutRef<typeof PortalPrimitive>;\ninterface TooltipPortalProps {\n  children?: React.ReactNode;\n  /**\n   * Specify a container element to portal the content into.\n   */\n  container?: PortalProps['container'];\n  /**\n   * Used to force mounting when more control is needed. Useful when\n   * controlling animation with React animation libraries.\n   */\n  forceMount?: true;\n}\n\nconst TooltipPortal: React.FC<TooltipPortalProps> = (props: ScopedProps<TooltipPortalProps>) => {\n  const { __scopeTooltip, forceMount, children, container } = props;\n  const context = useTooltipContext(PORTAL_NAME, __scopeTooltip);\n  return (\n    <PortalProvider scope={__scopeTooltip} forceMount={forceMount}>\n      <Presence present={forceMount || context.open}>\n        <PortalPrimitive asChild container={container}>\n          {children}\n        </PortalPrimitive>\n      </Presence>\n    </PortalProvider>\n  );\n};\n\n/* -------------------------------------------------------------------------------------------------\n * TooltipContent\n * -----------------------------------------------------------------------------------------------*/\n\nconst CONTENT_NAME = 'TooltipContent';\n\ntype TooltipContentElement = TooltipContentImplElement;\ninterface TooltipContentProps extends TooltipContentImplProps {\n  /**\n   * Used to force mounting when more control is needed. Useful when\n   * controlling animation with React animation libraries.\n   */\n  forceMount?: true;\n}\n\nconst TooltipContent = /* @__PURE__ */ React.forwardRef<TooltipContentElement, TooltipContentProps>(\n  function TooltipContent(props: ScopedProps<TooltipContentProps>, forwardedRef) {\n    const portalContext = usePortalContext(CONTENT_NAME, props.__scopeTooltip);\n    const { forceMount = portalContext.forceMount, side = 'top', ...contentProps } = props;\n    const context = useTooltipContext(CONTENT_NAME, props.__scopeTooltip);\n\n    return (\n      <Presence present={forceMount || context.open}>\n        {context.disableHoverableContent ? (\n          <TooltipContentImpl side={side} {...contentProps} ref={forwardedRef} />\n        ) : (\n          <TooltipContentHoverable side={side} {...contentProps} ref={forwardedRef} />\n        )}\n      </Presence>\n    );\n  },\n);\n\ntype Point = { x: number; y: number };\ntype Polygon = Point[];\n\ntype TooltipContentHoverableElement = TooltipContentImplElement;\ninterface TooltipContentHoverableProps extends TooltipContentImplProps {}\n\nconst TooltipContentHoverable = /* @__PURE__ */ React.forwardRef<\n  TooltipContentHoverableElement,\n  TooltipContentHoverableProps\n>(function TooltipContentHoverable(props: ScopedProps<TooltipContentHoverableProps>, forwardedRef) {\n  const context = useTooltipContext(CONTENT_NAME, props.__scopeTooltip);\n  const providerContext = useTooltipProviderContext(CONTENT_NAME, props.__scopeTooltip);\n  const ref = React.useRef<TooltipContentHoverableElement>(null);\n  const composedRefs = useComposedRefs(forwardedRef, ref);\n  const [pointerGraceArea, setPointerGraceArea] = React.useState<Polygon | null>(null);\n\n  const { trigger, onClose } = context;\n  const content = ref.current;\n\n  const { onPointerInTransitChange } = providerContext;\n\n  const handleRemoveGraceArea = React.useCallback(() => {\n    setPointerGraceArea(null);\n    onPointerInTransitChange(false);\n  }, [onPointerInTransitChange]);\n\n  const handleCreateGraceArea = React.useCallback(\n    (event: PointerEvent, hoverTarget: HTMLElement) => {\n      const currentTarget = event.currentTarget as HTMLElement;\n      const exitPoint = { x: event.clientX, y: event.clientY };\n      const exitSide = getExitSideFromRect(exitPoint, currentTarget.getBoundingClientRect());\n      const paddedExitPoints = getPaddedExitPoints(exitPoint, exitSide);\n      const hoverTargetPoints = getPointsFromRect(hoverTarget.getBoundingClientRect());\n      const graceArea = getHull([...paddedExitPoints, ...hoverTargetPoints]);\n      setPointerGraceArea(graceArea);\n      onPointerInTransitChange(true);\n    },\n    [onPointerInTransitChange],\n  );\n\n  React.useEffect(() => {\n    return () => handleRemoveGraceArea();\n  }, [handleRemoveGraceArea]);\n\n  React.useEffect(() => {\n    if (trigger && content) {\n      const handleTriggerLeave = (event: PointerEvent) => handleCreateGraceArea(event, content);\n      const handleContentLeave = (event: PointerEvent) => handleCreateGraceArea(event, trigger);\n\n      trigger.addEventListener('pointerleave', handleTriggerLeave);\n      content.addEventListener('pointerleave', handleContentLeave);\n      return () => {\n        trigger.removeEventListener('pointerleave', handleTriggerLeave);\n        content.removeEventListener('pointerleave', handleContentLeave);\n      };\n    }\n  }, [trigger, content, handleCreateGraceArea, handleRemoveGraceArea]);\n\n  React.useEffect(() => {\n    if (pointerGraceArea) {\n      const handleTrackPointerGrace = (event: PointerEvent) => {\n        const target = event.target as HTMLElement;\n        const pointerPosition = { x: event.clientX, y: event.clientY };\n        const hasEnteredTarget = trigger?.contains(target) || content?.contains(target);\n        const isPointerOutsideGraceArea = !isPointInPolygon(pointerPosition, pointerGraceArea);\n\n        if (hasEnteredTarget) {\n          handleRemoveGraceArea();\n        } else if (isPointerOutsideGraceArea) {\n          handleRemoveGraceArea();\n          onClose();\n        }\n      };\n      document.addEventListener('pointermove', handleTrackPointerGrace);\n      return () => document.removeEventListener('pointermove', handleTrackPointerGrace);\n    }\n  }, [trigger, content, pointerGraceArea, onClose, handleRemoveGraceArea]);\n\n  return <TooltipContentImpl {...props} ref={composedRefs} />;\n});\n\ntype TooltipContentImplElement = React.ComponentRef<typeof PopperPrimitive.Content>;\ntype DismissableLayerProps = React.ComponentPropsWithoutRef<typeof DismissableLayer>;\ntype PopperContentProps = React.ComponentPropsWithoutRef<typeof PopperPrimitive.Content>;\ninterface TooltipContentImplProps extends Omit<PopperContentProps, 'onPlaced'> {\n  /**\n   * A more descriptive label for accessibility purpose\n   */\n  'aria-label'?: string;\n\n  /**\n   * Event handler called when the escape key is down.\n   * Can be prevented.\n   */\n  onEscapeKeyDown?: DismissableLayerProps['onEscapeKeyDown'];\n  /**\n   * Event handler called when the a `pointerdown` event happens outside of the `Tooltip`.\n   * Can be prevented.\n   */\n  onPointerDownOutside?: DismissableLayerProps['onPointerDownOutside'];\n}\n\nconst Slottable = createSlottable('TooltipContent');\n\nconst TooltipContentImpl = /* @__PURE__ */ React.forwardRef<\n  TooltipContentImplElement,\n  TooltipContentImplProps\n>(\n  // blank line to reduce diff noise\n  function TooltipContentImpl(props: ScopedProps<TooltipContentImplProps>, forwardedRef) {\n    const {\n      __scopeTooltip,\n      children,\n      'aria-label': ariaLabel,\n      id: idProp,\n      onEscapeKeyDown,\n      onPointerDownOutside,\n      ...contentProps\n    } = props;\n    const context = useTooltipContext(CONTENT_NAME, __scopeTooltip);\n    const popperScope = usePopperScope(__scopeTooltip);\n    const { onClose } = context;\n\n    // Close this tooltip if another one opens\n    React.useEffect(() => {\n      document.addEventListener(TOOLTIP_OPEN, onClose);\n      return () => document.removeEventListener(TOOLTIP_OPEN, onClose);\n    }, [onClose]);\n\n    // Close the tooltip if the trigger is scrolled\n    React.useEffect(() => {\n      if (context.trigger) {\n        const handleScroll = (event: Event) => {\n          if (event.target instanceof Node && event.target.contains(context.trigger)) {\n            onClose();\n          }\n        };\n        window.addEventListener('scroll', handleScroll, { capture: true });\n        return () => window.removeEventListener('scroll', handleScroll, { capture: true });\n      }\n    }, [context.trigger, onClose]);\n\n    const { setContentId } = context;\n    useLayoutEffect(() => {\n      setContentId(idProp);\n      return () => {\n        setContentId(undefined);\n      };\n    }, [idProp, setContentId]);\n\n    return (\n      <DismissableLayer\n        asChild\n        disableOutsidePointerEvents={false}\n        onEscapeKeyDown={onEscapeKeyDown}\n        onPointerDownOutside={onPointerDownOutside}\n        onFocusOutside={(event) => event.preventDefault()}\n        onDismiss={onClose}\n      >\n        <PopperPrimitive.Content\n          data-state={context.stateAttribute}\n          // Following the ARIA tooltip pattern, the visible content acts as the\n          // accessible description (referenced by the trigger's\n          // `aria-describedby`) when no `aria-label` override is provided. This\n          // lets `children` render a single time instead of being duplicated\n          // into a visually hidden copy.\n          role={ariaLabel ? undefined : 'tooltip'}\n          id={ariaLabel ? undefined : context.contentId}\n          {...popperScope}\n          {...contentProps}\n          ref={forwardedRef}\n          style={{\n            ...contentProps.style,\n            // re-namespace exposed content custom properties\n            ...{\n              '--radix-tooltip-content-transform-origin': 'var(--radix-popper-transform-origin)',\n              '--radix-tooltip-content-available-width': 'var(--radix-popper-available-width)',\n              '--radix-tooltip-content-available-height': 'var(--radix-popper-available-height)',\n              '--radix-tooltip-trigger-width': 'var(--radix-popper-anchor-width)',\n              '--radix-tooltip-trigger-height': 'var(--radix-popper-anchor-height)',\n            },\n          }}\n        >\n          <Slottable>{children}</Slottable>\n          {ariaLabel ? (\n            <VisuallyHiddenPrimitive.Root id={context.contentId} role=\"tooltip\">\n              {ariaLabel}\n            </VisuallyHiddenPrimitive.Root>\n          ) : null}\n        </PopperPrimitive.Content>\n      </DismissableLayer>\n    );\n  },\n);\n\n/* -------------------------------------------------------------------------------------------------\n * TooltipArrow\n * -----------------------------------------------------------------------------------------------*/\n\ntype TooltipArrowElement = React.ComponentRef<typeof PopperPrimitive.Arrow>;\ntype PopperArrowProps = React.ComponentPropsWithoutRef<typeof PopperPrimitive.Arrow>;\ninterface TooltipArrowProps extends PopperArrowProps {}\n\nconst TooltipArrow = /* @__PURE__ */ React.forwardRef<TooltipArrowElement, TooltipArrowProps>(\n  function TooltipArrow(props: ScopedProps<TooltipArrowProps>, forwardedRef) {\n    const { __scopeTooltip, ...arrowProps } = props;\n    const popperScope = usePopperScope(__scopeTooltip);\n    return <PopperPrimitive.Arrow {...popperScope} {...arrowProps} ref={forwardedRef} />;\n  },\n);\n\n/* -----------------------------------------------------------------------------------------------*/\n\ntype Side = NonNullable<TooltipContentProps['side']>;\n\nfunction getExitSideFromRect(point: Point, rect: DOMRect): Side {\n  const top = Math.abs(rect.top - point.y);\n  const bottom = Math.abs(rect.bottom - point.y);\n  const right = Math.abs(rect.right - point.x);\n  const left = Math.abs(rect.left - point.x);\n\n  switch (Math.min(top, bottom, right, left)) {\n    case left:\n      return 'left';\n    case right:\n      return 'right';\n    case top:\n      return 'top';\n    case bottom:\n      return 'bottom';\n    default:\n      throw new Error('unreachable');\n  }\n}\n\nfunction getPaddedExitPoints(exitPoint: Point, exitSide: Side, padding = 5) {\n  const paddedExitPoints: Point[] = [];\n  switch (exitSide) {\n    case 'top':\n      paddedExitPoints.push(\n        { x: exitPoint.x - padding, y: exitPoint.y + padding },\n        { x: exitPoint.x + padding, y: exitPoint.y + padding },\n      );\n      break;\n    case 'bottom':\n      paddedExitPoints.push(\n        { x: exitPoint.x - padding, y: exitPoint.y - padding },\n        { x: exitPoint.x + padding, y: exitPoint.y - padding },\n      );\n      break;\n    case 'left':\n      paddedExitPoints.push(\n        { x: exitPoint.x + padding, y: exitPoint.y - padding },\n        { x: exitPoint.x + padding, y: exitPoint.y + padding },\n      );\n      break;\n    case 'right':\n      paddedExitPoints.push(\n        { x: exitPoint.x - padding, y: exitPoint.y - padding },\n        { x: exitPoint.x - padding, y: exitPoint.y + padding },\n      );\n      break;\n  }\n  return paddedExitPoints;\n}\n\nfunction getPointsFromRect(rect: DOMRect) {\n  const { top, right, bottom, left } = rect;\n  return [\n    { x: left, y: top },\n    { x: right, y: top },\n    { x: right, y: bottom },\n    { x: left, y: bottom },\n  ];\n}\n\n// Determine if a point is inside of a polygon.\n// Based on https://github.com/substack/point-in-polygon\nfunction isPointInPolygon(point: Point, polygon: Polygon) {\n  const { x, y } = point;\n  let inside = false;\n  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {\n    const ii = polygon[i]!;\n    const jj = polygon[j]!;\n    const xi = ii.x;\n    const yi = ii.y;\n    const xj = jj.x;\n    const yj = jj.y;\n\n    // oxfmt-ignore\n    const intersect = ((yi > y) !== (yj > y)) && (x < (xj - xi) * (y - yi) / (yj - yi) + xi);\n    if (intersect) inside = !inside;\n  }\n\n  return inside;\n}\n\n// Returns a new array of points representing the convex hull of the given set of points.\n// https://www.nayuki.io/page/convex-hull-algorithm\nfunction getHull<P extends Point>(points: Readonly<Array<P>>): Array<P> {\n  const newPoints: Array<P> = points.slice();\n  newPoints.sort((a: Point, b: Point) => {\n    if (a.x < b.x) return -1;\n    else if (a.x > b.x) return +1;\n    else if (a.y < b.y) return -1;\n    else if (a.y > b.y) return +1;\n    else return 0;\n  });\n  return getHullPresorted(newPoints);\n}\n\n// Returns the convex hull, assuming that each points[i] <= points[i + 1]. Runs in O(n) time.\nfunction getHullPresorted<P extends Point>(points: Readonly<Array<P>>): Array<P> {\n  if (points.length <= 1) return points.slice();\n\n  const upperHull: Array<P> = [];\n  for (let i = 0; i < points.length; i++) {\n    const p = points[i]!;\n    while (upperHull.length >= 2) {\n      const q = upperHull[upperHull.length - 1]!;\n      const r = upperHull[upperHull.length - 2]!;\n      if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x)) upperHull.pop();\n      else break;\n    }\n    upperHull.push(p);\n  }\n  upperHull.pop();\n\n  const lowerHull: Array<P> = [];\n  for (let i = points.length - 1; i >= 0; i--) {\n    const p = points[i]!;\n    while (lowerHull.length >= 2) {\n      const q = lowerHull[lowerHull.length - 1]!;\n      const r = lowerHull[lowerHull.length - 2]!;\n      if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x)) lowerHull.pop();\n      else break;\n    }\n    lowerHull.push(p);\n  }\n  lowerHull.pop();\n\n  if (\n    upperHull.length === 1 &&\n    lowerHull.length === 1 &&\n    upperHull[0]!.x === lowerHull[0]!.x &&\n    upperHull[0]!.y === lowerHull[0]!.y\n  ) {\n    return upperHull;\n  } else {\n    return upperHull.concat(lowerHull);\n  }\n}\n\nconst Provider = TooltipProvider;\nconst Root = Tooltip;\nconst Trigger = TooltipTrigger;\nconst Portal = TooltipPortal;\nconst Content = TooltipContent;\nconst Arrow = TooltipArrow;\n\nexport {\n  createTooltipScope,\n  //\n  TooltipProvider,\n  Tooltip,\n  TooltipTrigger,\n  TooltipPortal,\n  TooltipContent,\n  TooltipArrow,\n  //\n  Provider,\n  Root,\n  Trigger,\n  Portal,\n  Content,\n  Arrow,\n};\nexport type {\n  TooltipProviderProps,\n  TooltipProps,\n  TooltipTriggerProps,\n  TooltipPortalProps,\n  TooltipContentProps,\n  TooltipArrowProps,\n};\n"],"mappings":"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"}

package/dist/primitives/vendor/radix/react-use-callback-ref/index.d.ts

@@ -0,0 +1 @@
+export { useCallbackRef } from './use-callback-ref';

package/dist/primitives/vendor/radix/react-use-callback-ref/use-callback-ref.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A custom hook that converts a callback to a ref to avoid triggering re-renders when passed as a
+ * prop or avoid re-executing effects when passed as a dependency
+ */
+declare function useCallbackRef<T extends (...args: any[]) => any>(callback: T | undefined): T;
+export { useCallbackRef };

package/dist/primitives/vendor/radix/react-use-callback-ref/use-callback-ref.js

@@ -0,0 +1,18 @@
+"use client";
+import * as React from "react";
+//#region src/primitives/vendor/radix/react-use-callback-ref/use-callback-ref.tsx
+/**
+* A custom hook that converts a callback to a ref to avoid triggering re-renders when passed as a
+* prop or avoid re-executing effects when passed as a dependency
+*/
+function useCallbackRef(callback) {
+	const callbackRef = React.useRef(callback);
+	React.useEffect(() => {
+		callbackRef.current = callback;
+	});
+	return React.useMemo(() => ((...args) => callbackRef.current?.(...args)), []);
+}
+//#endregion
+export { useCallbackRef };
+
+//# sourceMappingURL=use-callback-ref.js.map

package/dist/primitives/vendor/radix/react-use-callback-ref/use-callback-ref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-callback-ref.js","names":[],"sources":["../../../../../src/primitives/vendor/radix/react-use-callback-ref/use-callback-ref.tsx"],"sourcesContent":["// Vendored from Radix Primitives (c) 2022 WorkOS, MIT. See vendor/LICENSE.radix.\n// Local modification: package imports resolve to the pinned local source.\nimport * as React from 'react';\n\n/**\n * A custom hook that converts a callback to a ref to avoid triggering re-renders when passed as a\n * prop or avoid re-executing effects when passed as a dependency\n */\nfunction useCallbackRef<T extends (...args: any[]) => any>(callback: T | undefined): T {\n  const callbackRef = React.useRef(callback);\n\n  React.useEffect(() => {\n    callbackRef.current = callback;\n  });\n\n  // https://github.com/facebook/react/issues/19240\n  return React.useMemo(() => ((...args) => callbackRef.current?.(...args)) as T, []);\n}\n\nexport { useCallbackRef };\n"],"mappings":";;;;;;;AAQA,SAAS,eAAkD,UAA4B;CACrF,MAAM,cAAc,MAAM,OAAO,QAAQ;CAEzC,MAAM,gBAAgB;EACpB,YAAY,UAAU;CACxB,CAAC;CAGD,OAAO,MAAM,gBAAgB,GAAG,SAAS,YAAY,UAAU,GAAG,IAAI,IAAS,CAAC,CAAC;AACnF"}

package/dist/primitives/vendor/radix/react-use-controllable-state/index.d.ts

@@ -0,0 +1,2 @@
+export { useControllableState } from './use-controllable-state';
+export { useControllableStateReducer } from './use-controllable-state-reducer';

package/dist/primitives/vendor/radix/react-use-controllable-state/use-controllable-state-reducer.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+type ChangeHandler<T> = (state: T) => void;
+interface UseControllableStateParams<T> {
+    prop: T | undefined;
+    defaultProp: T;
+    onChange: ChangeHandler<T> | undefined;
+    caller: string;
+}
+interface AnyAction {
+    type: string;
+}
+export declare function useControllableStateReducer<T, S extends {}, A extends AnyAction>(reducer: (prevState: S & {
+    state: T;
+}, action: A) => S & {
+    state: T;
+}, userArgs: UseControllableStateParams<T>, initialState: S): [S & {
+    state: T;
+}, React.Dispatch<A>];
+export declare function useControllableStateReducer<T, S extends {}, I, A extends AnyAction>(reducer: (prevState: S & {
+    state: T;
+}, action: A) => S & {
+    state: T;
+}, userArgs: UseControllableStateParams<T>, initialArg: I, init: (i: I & {
+    state: T;
+}) => S): [S & {
+    state: T;
+}, React.Dispatch<A>];
+export {};