@youcan/celeste 0.6.102 → 0.7.1

package/dist/cjs/chunks/tooltip-content.cjs

@@ -1,9 +1,589 @@
-const require_dist = require("./dist.cjs");
+require("./chunk.cjs");
 const require_clsx = require("./clsx.cjs");
 const require__plugin_vue_export_helper = require("./_plugin-vue_export-helper.cjs");
+const require_dist = require("./dist.cjs");
+const require_DismissableLayer = require("./DismissableLayer.cjs");
+const require_useForwardExpose = require("./useForwardExpose.cjs");
+const require_useForwardProps = require("./useForwardProps.cjs");
+const require_useForwardPropsEmits = require("./useForwardPropsEmits.cjs");
+const require_Presence = require("./Presence.cjs");
+const require_Teleport = require("./Teleport.cjs");
+const require_VisuallyHidden = require("./VisuallyHidden.cjs");
+const require_PopperArrow = require("./PopperArrow.cjs");
+const require_PopperContent = require("./PopperContent.cjs");
+const require_TooltipProvider = require("./TooltipProvider.cjs");
+const require_TooltipRoot = require("./TooltipRoot.cjs");
 const require_compact_button = require("./compact-button.cjs");
 const require_use_delegated_props = require("../use-delegated-props.cjs");
 let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/shared/useGraceArea.js
+function useGraceArea(triggerElement, containerElement) {
+	const isPointerInTransit = require_dist.refAutoReset(false, 300);
+	require_dist.tryOnScopeDispose(() => {
+		isPointerInTransit.value = false;
+	});
+	const pointerGraceArea = (0, vue.ref)(null);
+	const pointerExit = require_dist.createEventHook();
+	function handleRemoveGraceArea() {
+		pointerGraceArea.value = null;
+		isPointerInTransit.value = false;
+	}
+	function handleCreateGraceArea(event, hoverTarget) {
+		if (!hoverTarget) return;
+		const currentTarget = event.currentTarget;
+		const exitPoint = {
+			x: event.clientX,
+			y: event.clientY
+		};
+		const paddedExitPoints = getPaddedExitPoints(exitPoint, getExitSideFromRect(exitPoint, currentTarget.getBoundingClientRect()), 1);
+		const hoverTargetPoints = getPointsFromRect(hoverTarget.getBoundingClientRect());
+		pointerGraceArea.value = getHull([...paddedExitPoints, ...hoverTargetPoints]);
+		isPointerInTransit.value = true;
+	}
+	(0, vue.watchEffect)((cleanupFn) => {
+		if (triggerElement.value && containerElement.value) {
+			const handleTriggerLeave = (event) => handleCreateGraceArea(event, containerElement.value);
+			const handleContentLeave = (event) => handleCreateGraceArea(event, triggerElement.value);
+			triggerElement.value.addEventListener("pointerleave", handleTriggerLeave);
+			containerElement.value.addEventListener("pointerleave", handleContentLeave);
+			cleanupFn(() => {
+				triggerElement.value?.removeEventListener("pointerleave", handleTriggerLeave);
+				containerElement.value?.removeEventListener("pointerleave", handleContentLeave);
+			});
+		}
+	});
+	(0, vue.watchEffect)((cleanupFn) => {
+		if (pointerGraceArea.value) {
+			const handleTrackPointerGrace = (event) => {
+				if (!pointerGraceArea.value || !(event.target instanceof Element)) return;
+				const target = event.target;
+				const pointerPosition = {
+					x: event.clientX,
+					y: event.clientY
+				};
+				const hasEnteredTarget = triggerElement.value?.contains(target) || containerElement.value?.contains(target);
+				const isPointerOutsideGraceArea = !isPointInPolygon(pointerPosition, pointerGraceArea.value);
+				const isAnotherGraceAreaTrigger = !!target.closest("[data-grace-area-trigger]");
+				if (hasEnteredTarget) handleRemoveGraceArea();
+				else if (isPointerOutsideGraceArea || isAnotherGraceAreaTrigger) {
+					handleRemoveGraceArea();
+					pointerExit.trigger();
+				}
+			};
+			triggerElement.value?.ownerDocument.addEventListener("pointermove", handleTrackPointerGrace);
+			cleanupFn(() => triggerElement.value?.ownerDocument.removeEventListener("pointermove", handleTrackPointerGrace));
+		}
+	});
+	return {
+		isPointerInTransit,
+		onPointerExit: pointerExit.on
+	};
+}
+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
+			});
+			break;
+	}
+	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 xi = polygon[i].x;
+		const yi = polygon[i].y;
+		const xj = polygon[j].x;
+		const yj = polygon[j].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.at(-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.at(-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);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Tooltip/TooltipArrow.js
+var TooltipArrow_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "TooltipArrow",
+	props: {
+		width: {
+			type: Number,
+			required: false,
+			default: 10
+		},
+		height: {
+			type: Number,
+			required: false,
+			default: 5
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "svg"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		require_useForwardExpose.useForwardExpose();
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_PopperArrow.PopperArrow_default), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Tooltip/TooltipContentImpl.js
+var TooltipContentImpl_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "TooltipContentImpl",
+	props: {
+		ariaLabel: {
+			type: String,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		as: {
+			type: null,
+			required: false
+		},
+		side: {
+			type: null,
+			required: false
+		},
+		sideOffset: {
+			type: Number,
+			required: false
+		},
+		align: {
+			type: null,
+			required: false
+		},
+		alignOffset: {
+			type: Number,
+			required: false
+		},
+		avoidCollisions: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		collisionBoundary: {
+			type: null,
+			required: false
+		},
+		collisionPadding: {
+			type: [Number, Object],
+			required: false
+		},
+		arrowPadding: {
+			type: Number,
+			required: false
+		},
+		sticky: {
+			type: String,
+			required: false
+		},
+		hideWhenDetached: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		positionStrategy: {
+			type: String,
+			required: false
+		},
+		updatePositionStrategy: {
+			type: String,
+			required: false
+		}
+	},
+	emits: ["escapeKeyDown", "pointerDownOutside"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const rootContext = require_TooltipRoot.injectTooltipRootContext();
+		const providerContext = require_TooltipProvider.injectTooltipProviderContext();
+		const { forwardRef, currentElement } = require_useForwardExpose.useForwardExpose();
+		const ariaLabel = (0, vue.computed)(() => props.ariaLabel || currentElement.value?.textContent);
+		const popperContentProps = (0, vue.computed)(() => {
+			const { ariaLabel: _, ...restProps } = props;
+			return require_DismissableLayer.defu(restProps, providerContext.content.value ?? {}, {
+				side: "top",
+				sideOffset: 0,
+				align: "center",
+				avoidCollisions: true,
+				collisionBoundary: [],
+				collisionPadding: 0,
+				arrowPadding: 0,
+				sticky: "partial",
+				hideWhenDetached: false
+			});
+		});
+		(0, vue.onMounted)(() => {
+			require_dist.useEventListener(window, "scroll", (event) => {
+				if (event.target?.contains(rootContext.trigger.value)) rootContext.onClose();
+			}, { capture: true });
+			require_dist.useEventListener(window, require_TooltipRoot.TOOLTIP_OPEN, rootContext.onClose);
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_DismissableLayer.DismissableLayer_default), {
+				"as-child": "",
+				"disable-outside-pointer-events": false,
+				onEscapeKeyDown: _cache[0] || (_cache[0] = ($event) => emits("escapeKeyDown", $event)),
+				onPointerDownOutside: _cache[1] || (_cache[1] = (event) => {
+					if ((0, vue.unref)(rootContext).disableClosingTrigger.value && (0, vue.unref)(rootContext).trigger.value?.contains(event.target)) event.preventDefault();
+					emits("pointerDownOutside", event);
+				}),
+				onFocusOutside: _cache[2] || (_cache[2] = (0, vue.withModifiers)(() => {}, ["prevent"])),
+				onDismiss: _cache[3] || (_cache[3] = ($event) => (0, vue.unref)(rootContext).onClose())
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(require_PopperContent.PopperContent_default), (0, vue.mergeProps)({
+					ref: (0, vue.unref)(forwardRef),
+					"data-state": (0, vue.unref)(rootContext).stateAttribute.value
+				}, {
+					..._ctx.$attrs,
+					...popperContentProps.value
+				}, { style: {
+					"--reka-tooltip-content-transform-origin": "var(--reka-popper-transform-origin)",
+					"--reka-tooltip-content-available-width": "var(--reka-popper-available-width)",
+					"--reka-tooltip-content-available-height": "var(--reka-popper-available-height)",
+					"--reka-tooltip-trigger-width": "var(--reka-popper-anchor-width)",
+					"--reka-tooltip-trigger-height": "var(--reka-popper-anchor-height)"
+				} }), {
+					default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default"), (0, vue.createVNode)((0, vue.unref)(require_VisuallyHidden.VisuallyHidden_default), {
+						id: (0, vue.unref)(rootContext).contentId,
+						role: "tooltip"
+					}, {
+						default: (0, vue.withCtx)(() => [(0, vue.createTextVNode)((0, vue.toDisplayString)(ariaLabel.value), 1)]),
+						_: 1
+					}, 8, ["id"])]),
+					_: 3
+				}, 16, ["data-state"])]),
+				_: 3
+			});
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Tooltip/TooltipContentHoverable.js
+var TooltipContentHoverable_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "TooltipContentHoverable",
+	props: {
+		ariaLabel: {
+			type: String,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		},
+		side: {
+			type: null,
+			required: false
+		},
+		sideOffset: {
+			type: Number,
+			required: false
+		},
+		align: {
+			type: null,
+			required: false
+		},
+		alignOffset: {
+			type: Number,
+			required: false
+		},
+		avoidCollisions: {
+			type: Boolean,
+			required: false
+		},
+		collisionBoundary: {
+			type: null,
+			required: false
+		},
+		collisionPadding: {
+			type: [Number, Object],
+			required: false
+		},
+		arrowPadding: {
+			type: Number,
+			required: false
+		},
+		sticky: {
+			type: String,
+			required: false
+		},
+		hideWhenDetached: {
+			type: Boolean,
+			required: false
+		},
+		positionStrategy: {
+			type: String,
+			required: false
+		},
+		updatePositionStrategy: {
+			type: String,
+			required: false
+		}
+	},
+	setup(__props) {
+		const forwardedProps = require_useForwardProps.useForwardProps(__props);
+		const { forwardRef, currentElement } = require_useForwardExpose.useForwardExpose();
+		const { trigger, onClose } = require_TooltipRoot.injectTooltipRootContext();
+		const providerContext = require_TooltipProvider.injectTooltipProviderContext();
+		const { isPointerInTransit, onPointerExit } = useGraceArea(trigger, currentElement);
+		providerContext.isPointerInTransitRef = isPointerInTransit;
+		onPointerExit(() => {
+			onClose();
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)(TooltipContentImpl_default, (0, vue.mergeProps)({ ref: (0, vue.unref)(forwardRef) }, (0, vue.unref)(forwardedProps)), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Tooltip/TooltipContent.js
+var TooltipContent_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "TooltipContent",
+	props: {
+		forceMount: {
+			type: Boolean,
+			required: false
+		},
+		ariaLabel: {
+			type: String,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		},
+		side: {
+			type: null,
+			required: false
+		},
+		sideOffset: {
+			type: Number,
+			required: false
+		},
+		align: {
+			type: null,
+			required: false
+		},
+		alignOffset: {
+			type: Number,
+			required: false
+		},
+		avoidCollisions: {
+			type: Boolean,
+			required: false
+		},
+		collisionBoundary: {
+			type: null,
+			required: false
+		},
+		collisionPadding: {
+			type: [Number, Object],
+			required: false
+		},
+		arrowPadding: {
+			type: Number,
+			required: false
+		},
+		sticky: {
+			type: String,
+			required: false
+		},
+		hideWhenDetached: {
+			type: Boolean,
+			required: false
+		},
+		positionStrategy: {
+			type: String,
+			required: false
+		},
+		updatePositionStrategy: {
+			type: String,
+			required: false
+		}
+	},
+	emits: ["escapeKeyDown", "pointerDownOutside"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const rootContext = require_TooltipRoot.injectTooltipRootContext();
+		const forwarded = require_useForwardPropsEmits.useForwardPropsEmits(props, emits);
+		const { forwardRef } = require_useForwardExpose.useForwardExpose();
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Presence.Presence_default), { present: _ctx.forceMount || (0, vue.unref)(rootContext).open.value }, {
+				default: (0, vue.withCtx)(() => [((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)((0, vue.unref)(rootContext).disableHoverableContent.value ? TooltipContentImpl_default : TooltipContentHoverable_default), (0, vue.mergeProps)({ ref: (0, vue.unref)(forwardRef) }, (0, vue.unref)(forwarded)), {
+					default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+					_: 3
+				}, 16))]),
+				_: 3
+			}, 8, ["present"]);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Tooltip/TooltipPortal.js
+var TooltipPortal_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "TooltipPortal",
+	props: {
+		to: {
+			type: null,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		defer: {
+			type: Boolean,
+			required: false
+		},
+		forceMount: {
+			type: Boolean,
+			required: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Teleport.Teleport_default), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16);
+		};
+	}
+});
+//#endregion
 //#region src/components/tooltip/tooltip-content.vue?vue&type=script&setup=true&lang.ts
 var _hoisted_1 = { class: "celeste-tooltip-content-box" };
 var _hoisted_2 = {
@@ -38,13 +618,15 @@ var tooltip_content_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ *
 		collisionPadding: {},
 		arrowPadding: {},
 		sticky: {},
-		hideWhenDetached: { type: Boolean }
+		hideWhenDetached: { type: Boolean },
+		positionStrategy: {},
+		updatePositionStrategy: {}
 	},
 	emits: ["escapeKeyDown", "pointerDownOutside"],
 	setup(__props, { emit: __emit }) {
 		const props = __props;
 		const emits = __emit;
-		const forwarded = require_dist.Se(require_use_delegated_props.useDelegatedProps(props, [
+		const forwarded = require_useForwardPropsEmits.useForwardPropsEmits(require_use_delegated_props.useDelegatedProps(props, [
 			"class",
 			"size",
 			"variant",
@@ -58,8 +640,8 @@ var tooltip_content_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ *
 			props.onDismiss?.();
 		}
 		return (_ctx, _cache) => {
-			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_dist.qg), { class: "celeste-tooltip-portal" }, {
-				default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(require_dist.Ug), (0, vue.mergeProps)((0, vue.unref)(forwarded), {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(TooltipPortal_default), { class: "celeste-tooltip-portal" }, {
+				default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(TooltipContent_default), (0, vue.mergeProps)((0, vue.unref)(forwarded), {
 					size: _ctx.size,
 					variant: _ctx.variant,
 					class: (0, vue.unref)(require_clsx.clsx)("celeste-tooltip-content", props.class)
@@ -80,7 +662,7 @@ var tooltip_content_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ *
 							icon: "i-celeste-close-line",
 							onClick: handleDismiss
 						})) : (0, vue.createCommentVNode)("", true),
-						(0, vue.createVNode)((0, vue.unref)(require_dist.Gg), { "as-child": "" }, {
+						(0, vue.createVNode)((0, vue.unref)(TooltipArrow_default), { "as-child": "" }, {
 							default: (0, vue.withCtx)(() => _cache[0] || (_cache[0] = [(0, vue.createElementVNode)("span", { class: "celeste-tooltip-content-arrow" }, null, -1)])),
 							_: 1
 						})
@@ -98,7 +680,7 @@ var tooltip_content_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ *
 });
 //#endregion
 //#region src/components/tooltip/tooltip-content.vue
-var tooltip_content_default = /* @__PURE__ */ require__plugin_vue_export_helper._plugin_vue_export_helper_default(tooltip_content_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-aa109675"]]);
+var tooltip_content_default = /* @__PURE__ */ require__plugin_vue_export_helper._plugin_vue_export_helper_default(tooltip_content_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-04ee6e0c"]]);
 //#endregion
 Object.defineProperty(exports, "tooltip_content_default", {
 	enumerable: true,

package/dist/cjs/chunks/tooltip-provider.cjs

@@ -1,4 +1,5 @@
-const require_dist = require("./dist.cjs");
+require("./chunk.cjs");
+const require_TooltipProvider = require("./TooltipProvider.cjs");
 let vue = require("vue");
 //#endregion
 //#region src/components/tooltip/tooltip-provider.vue
@@ -10,12 +11,13 @@ var tooltip_provider_default = /* @__PURE__ */ (0, vue.defineComponent)({
 		disableHoverableContent: { type: Boolean },
 		disableClosingTrigger: { type: Boolean },
 		disabled: { type: Boolean },
-		ignoreNonKeyboardFocus: { type: Boolean }
+		ignoreNonKeyboardFocus: { type: Boolean },
+		content: {}
 	},
 	setup(__props) {
 		const props = __props;
 		return (_ctx, _cache) => {
-			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_dist.Hg), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_TooltipProvider.TooltipProvider_default), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
 				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
 				_: 3
 			}, 16);

package/dist/cjs/chunks/tooltip-root.cjs

@@ -1,4 +1,6 @@
-const require_dist = require("./dist.cjs");
+require("./chunk.cjs");
+const require_useForwardPropsEmits = require("./useForwardPropsEmits.cjs");
+const require_TooltipRoot = require("./TooltipRoot.cjs");
 const require_use_delegated_props = require("../use-delegated-props.cjs");
 let vue = require("vue");
 //#endregion
@@ -18,10 +20,10 @@ var tooltip_root_default = /* @__PURE__ */ (0, vue.defineComponent)({
 	setup(__props, { emit: __emit }) {
 		const props = __props;
 		const emits = __emit;
-		const forwarded = require_dist.Se(require_use_delegated_props.useDelegatedProps(props, "open"), emits);
+		const forwarded = require_useForwardPropsEmits.useForwardPropsEmits(require_use_delegated_props.useDelegatedProps(props, "open"), emits);
 		const open = (0, vue.ref)(false);
 		return (_ctx, _cache) => {
-			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_dist.Wg), (0, vue.mergeProps)((0, vue.unref)(forwarded), {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_TooltipRoot.TooltipRoot_default), (0, vue.mergeProps)((0, vue.unref)(forwarded), {
 				open: open.value,
 				"onUpdate:open": _cache[0] || (_cache[0] = ($event) => open.value = $event)
 			}), {