@vizejs/ui 0.426.2 → 0.427.0

package/dist/hover-card-Cexm4O5X.mjs

@@ -0,0 +1,651 @@
+import { a as useDeterministicId, n as deriveDeterministicId } from "./deterministic-id-bMmJU5xD.mjs";
+import { createContext } from "./context.mjs";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { useControllableState } from "./controllable-state.mjs";
+import { t as createDismissableLayer } from "./dismissable-layer-B9LIsTUt.mjs";
+import { t as portal_default } from "./portal-DeHaLxGL.mjs";
+import { t as positioner_default } from "./positioner--uuI0oZY.mjs";
+import { t as presence_default } from "./presence-CTG1EV3w.mjs";
+import { t as createPointerGrace } from "./pointer-grace-DI0G3oRJ.mjs";
+import { useHover } from "./hover.mjs";
+import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, guardReactiveProps, mergeProps, normalizeProps, onMounted, onScopeDispose, onUnmounted, openBlock, renderSlot, resolveDynamicComponent, shallowRef, unref, useTemplateRef, watch, withCtx } from "vue";
+//#region src/families/overlays/hover-card/hover-card-context.ts
+const hoverCardContext = createContext("HoverCard");
+//#endregion
+//#region src/families/overlays/hover-card/hover-card-root.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1$1 = [
+	"id",
+	"data-state",
+	"data-disabled"
+];
+//#endregion
+//#region src/families/overlays/hover-card/hover-card-root.vue
+var hover_card_root_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "hover-card-root",
+	props: {
+		id: {
+			type: [String, null],
+			required: false,
+			default: () => void 0
+		},
+		open: {
+			type: Boolean,
+			required: false,
+			default: () => void 0
+		},
+		defaultOpen: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		openDelay: {
+			type: Number,
+			required: false,
+			default: 700
+		},
+		closeDelay: {
+			type: Number,
+			required: false,
+			default: 300
+		},
+		touchBehavior: {
+			type: String,
+			required: false,
+			default: "ignore"
+		},
+		longPressDelay: {
+			type: Number,
+			required: false,
+			default: 500
+		}
+	},
+	emits: ["update:open", "open-change"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const emit = __emit;
+		const openState = useControllableState({
+			value: () => __props.open,
+			defaultValue: () => __props.defaultOpen
+		});
+		const disabledState = computed(() => __props.disabled);
+		const isOpen = computed(() => openState.value.value && !disabledState.value);
+		const state = computed(() => isOpen.value ? "open" : "closed");
+		const baseId = useDeterministicId({
+			id: () => __props.id,
+			hint: "hover-card"
+		});
+		const triggerId = computed(() => deriveDeterministicId(baseId.value, "trigger"));
+		const contentId = computed(() => deriveDeterministicId(baseId.value, "content"));
+		const openDelayState = computed(() => normalizeDelay(__props.openDelay));
+		const closeDelayState = computed(() => normalizeDelay(__props.closeDelay));
+		const touchBehaviorState = computed(() => __props.touchBehavior);
+		const longPressDelayState = computed(() => normalizeDelay(__props.longPressDelay));
+		const openReason = shallowRef(null);
+		const reason = computed(() => isOpen.value ? openReason.value : null);
+		const triggerElement = shallowRef(null);
+		const contentElement = shallowRef(null);
+		const slotState = computed(() => ({
+			disabled: disabledState.value,
+			open: isOpen.value,
+			reason: reason.value,
+			state: state.value
+		}));
+		let openTimer = null;
+		let closeTimer = null;
+		function readOpen() {
+			return isOpen.value;
+		}
+		function normalizeDelay(value) {
+			return Number.isFinite(value) && value > 0 ? value : 0;
+		}
+		function cancelOpenTimer() {
+			if (openTimer === null) return false;
+			clearTimeout(openTimer);
+			openTimer = null;
+			return true;
+		}
+		function cancelCloseTimer() {
+			if (closeTimer === null) return false;
+			clearTimeout(closeTimer);
+			closeTimer = null;
+			return true;
+		}
+		function cancelPending() {
+			const cancelledOpen = cancelOpenTimer();
+			return cancelCloseTimer() || cancelledOpen;
+		}
+		function commitOpen(value, nativeEvent, nextReason) {
+			const next = value && !disabledState.value;
+			const previous = readOpen();
+			if (next) openReason.value = nextReason;
+			const changed = openState.set(next);
+			if (changed) {
+				emit("update:open", next);
+				emit("open-change", next, previous, nativeEvent);
+			}
+			return changed;
+		}
+		function setOpen(value, nativeEvent = null, nextReason = "programmatic") {
+			cancelPending();
+			return commitOpen(value, nativeEvent, nextReason);
+		}
+		function scheduleOpen(nativeEvent = null, nextReason = "hover") {
+			cancelCloseTimer();
+			if (disabledState.value || isOpen.value) return false;
+			if (openDelayState.value === 0) return commitOpen(true, nativeEvent, nextReason);
+			if (openTimer !== null) return false;
+			openTimer = setTimeout(() => {
+				openTimer = null;
+				commitOpen(true, nativeEvent, nextReason);
+			}, openDelayState.value);
+			return true;
+		}
+		function scheduleClose(nativeEvent = null) {
+			const cancelledOpen = cancelOpenTimer();
+			if (!isOpen.value) return cancelledOpen;
+			if (closeDelayState.value === 0) return commitOpen(false, nativeEvent, "programmatic");
+			if (closeTimer !== null) return false;
+			closeTimer = setTimeout(() => {
+				closeTimer = null;
+				commitOpen(false, nativeEvent, "programmatic");
+			}, closeDelayState.value);
+			return true;
+		}
+		watch(disabledState, (next) => {
+			if (!next) return;
+			cancelPending();
+			if (openState.value.value) {
+				if (openState.set(false)) {
+					emit("update:open", false);
+					emit("open-change", false, true, null);
+				}
+			}
+		});
+		onScopeDispose(cancelPending);
+		hoverCardContext.provide({
+			cancelPending,
+			contentElement,
+			contentId,
+			disabled: disabledState,
+			id: baseId,
+			longPressDelay: longPressDelayState,
+			open: isOpen,
+			reason,
+			scheduleClose,
+			scheduleOpen,
+			setOpen,
+			state,
+			touchBehavior: touchBehaviorState,
+			triggerElement,
+			triggerId
+		});
+		__expose({
+			cancelPending,
+			closeDelay: closeDelayState,
+			contentId,
+			disabled: disabledState,
+			id: baseId,
+			open: isOpen,
+			openDelay: openDelayState,
+			reason,
+			scheduleClose: (nativeEvent = null) => scheduleClose(nativeEvent),
+			scheduleOpen: (nativeEvent = null) => scheduleOpen(nativeEvent, "programmatic"),
+			setOpen: (value, nativeEvent = null) => setOpen(value, nativeEvent),
+			state,
+			triggerId
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("span", {
+				id: unref(baseId),
+				"data-vize-ui": "hover-card-root",
+				part: "root",
+				"data-state": state.value,
+				"data-disabled": __props.disabled ? "true" : void 0
+			}, [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotState.value)), void 0, true)], 8, _hoisted_1$1);
+		};
+	}
+}), [["__scopeId", "data-v-7a8da278"]]);
+//#endregion
+//#region src/families/overlays/hover-card/hover-card-content.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = ["hidden", "data-state"];
+const _hoisted_2 = [
+	"id",
+	"aria-label",
+	"hidden",
+	"data-state",
+	"data-placement",
+	"data-reason",
+	"data-top-layer"
+];
+//#endregion
+//#region src/families/overlays/hover-card/hover-card-content.vue
+var hover_card_content_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "hover-card-content",
+	props: {
+		forceMount: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		to: {
+			type: null,
+			required: false,
+			default: "body"
+		},
+		portalDisabled: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		defer: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		placement: {
+			type: String,
+			required: false,
+			default: "bottom"
+		},
+		strategy: {
+			type: String,
+			required: false,
+			default: "fixed"
+		},
+		offset: {
+			type: Number,
+			required: false,
+			default: 8
+		},
+		collisionPadding: {
+			type: Number,
+			required: false,
+			default: 8
+		},
+		flip: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		shift: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		hide: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		updateOnScroll: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		updateOnResize: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		viewport: {
+			type: Object,
+			required: false,
+			default: () => void 0
+		},
+		closeOnEscape: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		closeOnPointerDownOutside: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		ariaLabel: {
+			type: String,
+			required: false,
+			default: () => void 0
+		}
+	},
+	emits: [
+		"escape-key-down",
+		"pointer-down-outside",
+		"dismiss"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const emit = __emit;
+		const context = hoverCardContext.use();
+		const element = useTemplateRef("element");
+		const present = computed(() => context.open.value || __props.forceMount);
+		const slotState = computed(() => ({
+			disabled: context.disabled.value,
+			open: context.open.value,
+			placement: __props.placement,
+			reason: context.reason.value,
+			state: context.state.value
+		}));
+		const positionerProps = computed(() => {
+			const base = {
+				collisionPadding: __props.collisionPadding,
+				flip: __props.flip,
+				hide: __props.hide,
+				offset: __props.offset,
+				placement: __props.placement,
+				reference: context.triggerElement.value,
+				shift: __props.shift,
+				strategy: __props.strategy,
+				updateOnResize: __props.updateOnResize,
+				updateOnScroll: __props.updateOnScroll
+			};
+			return __props.viewport === void 0 ? base : {
+				...base,
+				viewport: __props.viewport
+			};
+		});
+		const dismissableLayer = createDismissableLayer({
+			root: element,
+			branches: () => [context.triggerElement.value].filter((value) => !!value),
+			enabled: () => context.open.value,
+			escapeKey: () => __props.closeOnEscape,
+			outsideFocus: false,
+			outsidePointerDown: () => __props.closeOnPointerDownOutside,
+			onEscapeKeyDown: (event) => emit("escape-key-down", event),
+			onPointerDownOutside: (event) => emit("pointer-down-outside", event),
+			onDismiss: (event) => {
+				emit("dismiss", event);
+				context.setOpen(false, event.originalEvent);
+			}
+		});
+		let mounted = false;
+		function syncDismissableLayer() {
+			if (!mounted || !context.open.value || !element.value) {
+				dismissableLayer.deactivate();
+				return;
+			}
+			dismissableLayer.activate();
+		}
+		function onPointerenter(event) {
+			if (event.pointerType !== "touch") context.cancelPending();
+		}
+		function onPointerleave(event) {
+			if (event.pointerType === "touch") return;
+			const active = element.value?.ownerDocument.activeElement ?? null;
+			if (active && element.value?.contains(active)) return;
+			context.scheduleClose(event);
+		}
+		function onFocusin() {
+			context.cancelPending();
+		}
+		function onFocusout(event) {
+			const next = event.relatedTarget;
+			if (next instanceof Node) {
+				if (element.value?.contains(next)) return;
+				if (context.triggerElement.value?.contains(next)) return;
+			}
+			context.scheduleClose(event);
+		}
+		watch(element, (next, previous) => {
+			if (previous && context.contentElement.value === previous) context.contentElement.value = null;
+			if (next) context.contentElement.value = next;
+			syncDismissableLayer();
+		}, { flush: "post" });
+		watch(() => context.open.value, syncDismissableLayer, { flush: "post" });
+		onMounted(() => {
+			mounted = true;
+			syncDismissableLayer();
+		});
+		onUnmounted(() => {
+			mounted = false;
+			dismissableLayer.dispose();
+			if (context.contentElement.value === element.value) context.contentElement.value = null;
+		});
+		__expose({
+			disabled: context.disabled,
+			element,
+			open: context.open,
+			reason: context.reason,
+			state: context.state
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("span", {
+				"data-vize-ui": "hover-card-content-host",
+				part: "content-host",
+				hidden: present.value && unref(context).open.value ? void 0 : true,
+				"data-state": unref(context).state.value
+			}, [present.value ? (openBlock(), createBlock(portal_default, {
+				key: 0,
+				to: __props.to,
+				disabled: __props.portalDisabled,
+				defer: __props.defer
+			}, {
+				default: withCtx(() => [createVNode(presence_default, {
+					present: unref(context).open.value,
+					"force-mount": __props.forceMount
+				}, {
+					default: withCtx(() => [createVNode(positioner_default, normalizeProps(guardReactiveProps(positionerProps.value)), {
+						default: withCtx(() => [createElementVNode("div", mergeProps({
+							id: unref(context).contentId.value,
+							ref_key: "element",
+							ref: element
+						}, unref(dismissableLayer).layerProps, {
+							"aria-label": __props.ariaLabel,
+							"data-vize-ui": "hover-card-content",
+							part: "content",
+							hidden: unref(context).open.value ? void 0 : true,
+							"data-state": unref(context).state.value,
+							"data-placement": __props.placement,
+							"data-reason": unref(context).reason.value ?? void 0,
+							"data-top-layer": unref(dismissableLayer).isTopLayer.value ? "true" : "false",
+							onPointerenter,
+							onPointerleave,
+							onFocusin,
+							onFocusout
+						}), [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotState.value)), void 0, true)], 16, _hoisted_2)]),
+						_: 3
+					}, 16)]),
+					_: 3
+				}, 8, ["present", "force-mount"])]),
+				_: 3
+			}, 8, [
+				"to",
+				"disabled",
+				"defer"
+			])) : createCommentVNode("v-if", true)], 8, _hoisted_1);
+		};
+	}
+}), [["__scopeId", "data-v-4ea6afa3"]]);
+//#endregion
+//#region src/families/overlays/hover-card/hover-card-trigger.vue?vue&type=script&setup=true&lang.ts
+/** Movement in CSS pixels that cancels a pending touch long-press. */
+const touchSlop = 10;
+//#endregion
+//#region src/families/overlays/hover-card/hover-card-trigger.vue
+var hover_card_trigger_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "hover-card-trigger",
+	props: {
+		as: {
+			type: null,
+			required: false,
+			default: "a"
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: false
+		}
+	},
+	setup(__props, { expose: __expose }) {
+		const context = hoverCardContext.use();
+		const element = useTemplateRef("element");
+		const disabledState = computed(() => __props.disabled || context.disabled.value);
+		const grace = createPointerGrace({ delay: 0 });
+		const hover = useHover({
+			isDisabled: disabledState,
+			onHoverStart: (event) => {
+				stopGraceTracking();
+				context.scheduleOpen(event.originalEvent, "hover");
+			},
+			onHoverEnd: (event) => {
+				context.scheduleClose(event.originalEvent);
+				startGraceTracking(event.x, event.y);
+			}
+		});
+		let graceDocument = null;
+		let touchTimer = null;
+		let touchOrigin = null;
+		let suppressClick = false;
+		onMounted(() => {
+			context.triggerElement.value = element.value;
+		});
+		onUnmounted(() => {
+			if (context.triggerElement.value === element.value) context.triggerElement.value = null;
+		});
+		onScopeDispose(() => {
+			stopGraceTracking();
+			cancelTouch();
+			grace.dispose();
+		});
+		function readRect(target) {
+			const rect = target.getBoundingClientRect();
+			return {
+				height: rect.height,
+				width: rect.width,
+				x: rect.left,
+				y: rect.top
+			};
+		}
+		/**
+		* Keep the card open while the pointer travels from the trigger toward the
+		* card through the safe triangle, and close it once the pointer leaves.
+		*/
+		function onGracePointerMove(event) {
+			const content = context.contentElement.value;
+			if (!context.open.value || !content) {
+				stopGraceTracking();
+				return;
+			}
+			const point = {
+				x: event.clientX,
+				y: event.clientY
+			};
+			grace.setTarget(readRect(content));
+			if (grace.contains(point)) context.cancelPending();
+			else context.scheduleClose(event);
+		}
+		function startGraceTracking(x, y) {
+			const content = context.contentElement.value;
+			if (x === null || y === null || !context.open.value || !content) return;
+			stopGraceTracking();
+			grace.setOrigin({
+				x,
+				y
+			});
+			grace.setTarget(readRect(content));
+			graceDocument = content.ownerDocument;
+			graceDocument.addEventListener("pointermove", onGracePointerMove);
+		}
+		function stopGraceTracking() {
+			graceDocument?.removeEventListener("pointermove", onGracePointerMove);
+			graceDocument = null;
+			grace.setOrigin(null);
+			grace.setTarget(null);
+		}
+		function cancelTouch() {
+			if (touchTimer !== null) clearTimeout(touchTimer);
+			touchTimer = null;
+			touchOrigin = null;
+		}
+		function onPointerdown(event) {
+			if (event.pointerType !== "touch" || disabledState.value) return;
+			if (context.touchBehavior.value !== "long-press") return;
+			cancelTouch();
+			suppressClick = false;
+			touchOrigin = {
+				x: event.clientX,
+				y: event.clientY
+			};
+			touchTimer = setTimeout(() => {
+				touchTimer = null;
+				suppressClick = true;
+				context.setOpen(true, event, "long-press");
+			}, context.longPressDelay.value);
+		}
+		function onPointermove(event) {
+			if (touchOrigin === null || event.pointerType !== "touch") return;
+			if (Math.hypot(event.clientX - touchOrigin.x, event.clientY - touchOrigin.y) > touchSlop) cancelTouch();
+		}
+		function onPointerEnd() {
+			cancelTouch();
+		}
+		function onClick(event) {
+			if (!suppressClick) return;
+			suppressClick = false;
+			event.preventDefault();
+		}
+		function onContextmenu(event) {
+			if (touchTimer !== null || suppressClick) event.preventDefault();
+		}
+		function onFocus(event) {
+			if (!disabledState.value) context.scheduleOpen(event, "focus");
+		}
+		function onBlur(event) {
+			const next = event.relatedTarget;
+			const content = context.contentElement.value;
+			if (content && next instanceof Node && content.contains(next)) return;
+			context.scheduleClose(event);
+		}
+		function onKeydown(event) {
+			if (event.key !== "Escape" || event.defaultPrevented || event.isComposing) return;
+			if (context.open.value && context.setOpen(false, event)) event.preventDefault();
+		}
+		function focus(options) {
+			element.value?.focus(options);
+		}
+		__expose({
+			element,
+			focus
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(__props.as), mergeProps({
+				id: unref(context).triggerId.value,
+				ref_key: "element",
+				ref: element
+			}, unref(hover).hoverProps, {
+				"aria-describedby": unref(context).open.value ? unref(context).contentId.value : void 0,
+				"data-vize-ui": "hover-card-trigger",
+				part: "trigger",
+				"data-state": unref(context).state.value,
+				"data-disabled": disabledState.value ? "true" : void 0,
+				onFocus,
+				onBlur,
+				onKeydown,
+				onPointerdown,
+				onPointermove,
+				onPointerup: onPointerEnd,
+				onPointercancel: onPointerEnd,
+				onClick,
+				onContextmenu
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", {
+					disabled: disabledState.value,
+					open: unref(context).open.value,
+					reason: unref(context).reason.value,
+					state: unref(context).state.value
+				}, void 0, true)]),
+				_: 3
+			}, 16, [
+				"id",
+				"aria-describedby",
+				"data-state",
+				"data-disabled"
+			]);
+		};
+	}
+}), [["__scopeId", "data-v-0da9205b"]]);
+//#endregion
+export { hover_card_content_default as n, hover_card_root_default as r, hover_card_trigger_default as t };

package/dist/hover-card.d.mts

@@ -0,0 +1,3 @@
+import { Af as HoverCardTriggerExpose, Cf as HoverCardPlacement, Df as HoverCardSlotState, Ef as HoverCardRootExpose, Of as HoverCardState, Sf as HoverCardOpenReason, Tf as HoverCardPositionerStrategy, _f as _default, bf as HoverCardDismissEvent, gf as _default$2, hf as _default$3, jf as HoverCardViewport, kf as HoverCardTouchBehavior, vf as HoverCardContentExpose, wf as HoverCardPointerDownOutsideEvent, xf as HoverCardEscapeKeyDownEvent, yf as HoverCardContentSlotState } from "./announcer-DwGlsSL_.mjs";
+import { t as _default$1 } from "./positioner-BYJVA3Uy.mjs";
+export { _default as HoverCard, _default as HoverCardRoot, _default$1 as HoverCardArrow, _default$2 as HoverCardContent, type HoverCardContentExpose, type HoverCardContentSlotState, type HoverCardDismissEvent, type HoverCardEscapeKeyDownEvent, type HoverCardOpenReason, type HoverCardPlacement, type HoverCardPointerDownOutsideEvent, type HoverCardPositionerStrategy, type HoverCardRootExpose, type HoverCardSlotState, type HoverCardState, type HoverCardTouchBehavior, _default$3 as HoverCardTrigger, type HoverCardTriggerExpose, type HoverCardViewport };

package/dist/hover-card.mjs

@@ -0,0 +1,3 @@
+import { n as hover_card_content_default, r as hover_card_root_default, t as hover_card_trigger_default } from "./hover-card-Cexm4O5X.mjs";
+import { t as positioner_arrow_default } from "./positioner-arrow-CNZrXSjb.mjs";
+export { hover_card_root_default as HoverCard, hover_card_root_default as HoverCardRoot, positioner_arrow_default as HoverCardArrow, hover_card_content_default as HoverCardContent, hover_card_trigger_default as HoverCardTrigger };

package/dist/{icon-DhTTndMu.mjs → icon-FXse-MOQ.mjs}

@@ -1,4 +1,4 @@
-import { a as useDeterministicId } from "./deterministic-id-yMq4HfmS.mjs";
+import { a as useDeterministicId } from "./deterministic-id-bMmJU5xD.mjs";
 import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
 import { computed, createBlock, createCommentVNode, createElementBlock, defineComponent, guardReactiveProps, normalizeProps, openBlock, renderSlot, resolveDynamicComponent, toDisplayString, useTemplateRef, withCtx } from "vue";
 //#region src/families/layout/icon/icon.vue?vue&type=script&setup=true&lang.ts

package/dist/icon-button.d.mts

@@ -1,2 +1,2 @@
-import { _a as IconButtonState, ba as IconButtonVariant, da as IconButtonElement, fa as IconButtonExpose, ga as IconButtonSlotState, ha as IconButtonSize, ma as IconButtonProps, oa as _default, pa as IconButtonNameProps, ua as IconButtonBaseProps, va as IconButtonTone, ya as IconButtonType } from "./announcer-BNpDcMK0.mjs";
+import { Bm as IconButtonProps, Gm as IconButtonType, Hm as IconButtonSlotState, Im as IconButtonBaseProps, Km as IconButtonVariant, Lm as IconButtonElement, Mm as _default, Rm as IconButtonExpose, Um as IconButtonState, Vm as IconButtonSize, Wm as IconButtonTone, zm as IconButtonNameProps } from "./announcer-DwGlsSL_.mjs";
 export { _default as IconButton, type IconButtonBaseProps, type IconButtonElement, type IconButtonExpose, type IconButtonNameProps, type IconButtonProps, type IconButtonSize, type IconButtonSlotState, type IconButtonState, type IconButtonTone, type IconButtonType, type IconButtonVariant };

package/dist/icon.d.mts

@@ -1,2 +1,2 @@
-import { Aa as IconStrokeLinejoin, Ca as IconExpose, Da as IconSize, Ea as IconProps, Oa as IconSlotState, Pt as _default, Sa as IconElement, Ta as IconPaint, ca as IconAriaState, ja as IconStrokeWidth, ka as IconStrokeLinecap, la as IconBaseProps, sa as IconAccessibleNameProps, wa as IconImageProps, xa as IconDecorativeProps } from "./announcer-BNpDcMK0.mjs";
+import { $m as IconSize, Fm as IconBaseProps, Jm as IconElement, Nm as IconAccessibleNameProps, Pm as IconAriaState, Qm as IconProps, Xm as IconImageProps, Ym as IconExpose, Zm as IconPaint, _r as _default, eh as IconSlotState, nh as IconStrokeLinejoin, qm as IconDecorativeProps, rh as IconStrokeWidth, th as IconStrokeLinecap } from "./announcer-DwGlsSL_.mjs";
 export { _default as Icon, type IconAccessibleNameProps, type IconAriaState, type IconBaseProps, type IconDecorativeProps, type IconElement, type IconExpose, type IconImageProps, type IconPaint, type IconProps, type IconSize, type IconSlotState, type IconStrokeLinecap, type IconStrokeLinejoin, type IconStrokeWidth };

package/dist/icon.mjs

@@ -1,2 +1,2 @@
-import { t as icon_default } from "./icon-DhTTndMu.mjs";
+import { t as icon_default } from "./icon-FXse-MOQ.mjs";
 export { icon_default as Icon };

package/dist/{id-BYG8aXPF.mjs → id-DpRQPEfi.mjs}

@@ -1,4 +1,4 @@
-import { o as useOptionalDeterministicIdScope, r as provideDeterministicIdScope, t as createDeterministicIdScope } from "./deterministic-id-yMq4HfmS.mjs";
+import { o as useOptionalDeterministicIdScope, r as provideDeterministicIdScope, t as createDeterministicIdScope } from "./deterministic-id-bMmJU5xD.mjs";
 import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
 import { defineComponent, renderSlot, unref, useId } from "vue";
 //#endregion

package/dist/id.mjs

@@ -1,3 +1,3 @@
-import { a as useDeterministicId, i as toDeterministicId, n as deriveDeterministicId, t as createDeterministicIdScope } from "./deterministic-id-yMq4HfmS.mjs";
-import { t as deterministic_id_provider_default } from "./id-BYG8aXPF.mjs";
+import { a as useDeterministicId, i as toDeterministicId, n as deriveDeterministicId, t as createDeterministicIdScope } from "./deterministic-id-bMmJU5xD.mjs";
+import { t as deterministic_id_provider_default } from "./id-DpRQPEfi.mjs";
 export { deterministic_id_provider_default as IdProvider, createDeterministicIdScope, deriveDeterministicId, toDeterministicId, useDeterministicId };