@youcan/celeste 0.6.101 → 0.7.0

package/dist/cjs/chunks/Teleport.cjs

@@ -0,0 +1,51 @@
+require("./chunk.cjs");
+const require_dist = require("./dist.cjs");
+const require_ConfigProvider = require("./ConfigProvider.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Teleport/Teleport.js
+var Teleport_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "Teleport",
+	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;
+		const configContext = require_ConfigProvider.injectConfigProviderContext({});
+		const target = (0, vue.computed)(() => props.to ?? configContext.teleportTo?.value ?? "body");
+		const isMounted = require_dist.useMounted();
+		return (_ctx, _cache) => {
+			return (0, vue.unref)(isMounted) || _ctx.forceMount ? ((0, vue.openBlock)(), (0, vue.createBlock)(vue.Teleport, {
+				key: 0,
+				to: target.value,
+				disabled: _ctx.disabled,
+				defer: _ctx.defer
+			}, [(0, vue.renderSlot)(_ctx.$slots, "default")], 8, [
+				"to",
+				"disabled",
+				"defer"
+			])) : (0, vue.createCommentVNode)("v-if", true);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "Teleport_default", {
+	enumerable: true,
+	get: function() {
+		return Teleport_default;
+	}
+});

package/dist/cjs/chunks/ToggleGroupRoot.cjs

@@ -0,0 +1,188 @@
+require("./chunk.cjs");
+const require_ohash_D__AXeF1 = require("./ohash.D__AXeF1.cjs");
+const require_createContext = require("./createContext.cjs");
+const require_isValueEqualOrExist = require("./isValueEqualOrExist.cjs");
+const require_dist = require("./dist.cjs");
+const require_Primitive = require("./Primitive.cjs");
+const require_useDirection = require("./useDirection.cjs");
+const require_useFormControl = require("./useFormControl.cjs");
+const require_useForwardExpose = require("./useForwardExpose.cjs");
+const require_VisuallyHiddenInput = require("./VisuallyHiddenInput.cjs");
+const require_RovingFocusGroup = require("./RovingFocusGroup.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useSingleOrMultipleValue.js
+/**
+* Validates the props and it makes sure that the types are coherent with each other
+*
+* 1. If type, defaultValue, and modelValue are all undefined, throw an error.
+* 2. If modelValue and defaultValue are defined and not of the same type, throw an error.
+* 3. If type is defined:
+*    a. If type is 'single' and either modelValue or defaultValue is an array, log an error and return 'multiple'.
+*    b. If type is 'multiple' and neither modelValue nor defaultValue is an array, log an error and return 'single'.
+* 4. Return 'multiple' if modelValue is an array, else return 'single'.
+*/
+function validateProps({ type, defaultValue, modelValue }) {
+	const value = modelValue || defaultValue;
+	if (modelValue !== void 0 || defaultValue !== void 0) return Array.isArray(value) ? "multiple" : "single";
+	else return type ?? "single";
+}
+function getDefaultType({ type, defaultValue, modelValue }) {
+	if (type) return type;
+	return validateProps({
+		type,
+		defaultValue,
+		modelValue
+	});
+}
+function getDefaultValue({ type, defaultValue }) {
+	if (defaultValue !== void 0) return defaultValue;
+	return type === "single" ? void 0 : [];
+}
+function useSingleOrMultipleValue(props, emits) {
+	const type = (0, vue.computed)(() => getDefaultType(props));
+	const modelValue = require_dist.useVModel(props, "modelValue", emits, {
+		defaultValue: getDefaultValue(props),
+		passive: props.modelValue === void 0,
+		deep: true
+	});
+	function changeModelValue(value) {
+		if (type.value === "single") modelValue.value = require_ohash_D__AXeF1.isEqual(value, modelValue.value) ? void 0 : value;
+		else {
+			const modelValueArray = Array.isArray(modelValue.value) ? [...modelValue.value || []] : [modelValue.value].filter(Boolean);
+			if (require_isValueEqualOrExist.isValueEqualOrExist(modelValueArray, value)) {
+				const index = modelValueArray.findIndex((i) => require_ohash_D__AXeF1.isEqual(i, value));
+				modelValueArray.splice(index, 1);
+			} else modelValueArray.push(value);
+			modelValue.value = modelValueArray;
+		}
+	}
+	return {
+		modelValue,
+		changeModelValue,
+		isSingle: (0, vue.computed)(() => type.value === "single")
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/ToggleGroup/ToggleGroupRoot.js
+var [injectToggleGroupRootContext, provideToggleGroupRootContext] = /* @__PURE__ */ require_createContext.createContext("ToggleGroupRoot");
+var ToggleGroupRoot_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "ToggleGroupRoot",
+	props: {
+		rovingFocus: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		orientation: {
+			type: String,
+			required: false
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		loop: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		},
+		name: {
+			type: String,
+			required: false
+		},
+		required: {
+			type: Boolean,
+			required: false
+		},
+		type: {
+			type: String,
+			required: false
+		},
+		modelValue: {
+			type: null,
+			required: false
+		},
+		defaultValue: {
+			type: null,
+			required: false
+		}
+	},
+	emits: ["update:modelValue"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { loop, rovingFocus, disabled, dir: propDir } = (0, vue.toRefs)(props);
+		const dir = require_useDirection.useDirection(propDir);
+		const { forwardRef, currentElement } = require_useForwardExpose.useForwardExpose();
+		const { modelValue, changeModelValue, isSingle } = useSingleOrMultipleValue(props, emits);
+		const isFormControl = require_useFormControl.useFormControl(currentElement);
+		provideToggleGroupRootContext({
+			isSingle,
+			modelValue,
+			changeModelValue,
+			dir,
+			orientation: props.orientation,
+			loop,
+			rovingFocus,
+			disabled
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)((0, vue.unref)(rovingFocus) ? (0, vue.unref)(require_RovingFocusGroup.RovingFocusGroup_default) : (0, vue.unref)(require_Primitive.Primitive)), {
+				"as-child": "",
+				orientation: (0, vue.unref)(rovingFocus) ? _ctx.orientation : void 0,
+				dir: (0, vue.unref)(dir),
+				loop: (0, vue.unref)(rovingFocus) ? (0, vue.unref)(loop) : void 0
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(require_Primitive.Primitive), {
+					ref: (0, vue.unref)(forwardRef),
+					role: "group",
+					"as-child": _ctx.asChild,
+					as: _ctx.as
+				}, {
+					default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", { modelValue: (0, vue.unref)(modelValue) }), (0, vue.unref)(isFormControl) && _ctx.name ? ((0, vue.openBlock)(), (0, vue.createBlock)(require_VisuallyHiddenInput.VisuallyHiddenInput_default, {
+						key: 0,
+						name: _ctx.name,
+						required: _ctx.required,
+						value: (0, vue.unref)(modelValue)
+					}, null, 8, [
+						"name",
+						"required",
+						"value"
+					])) : (0, vue.createCommentVNode)("v-if", true)]),
+					_: 3
+				}, 8, ["as-child", "as"])]),
+				_: 3
+			}, 8, [
+				"orientation",
+				"dir",
+				"loop"
+			]);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "ToggleGroupRoot_default", {
+	enumerable: true,
+	get: function() {
+		return ToggleGroupRoot_default;
+	}
+});
+Object.defineProperty(exports, "injectToggleGroupRootContext", {
+	enumerable: true,
+	get: function() {
+		return injectToggleGroupRootContext;
+	}
+});

package/dist/cjs/chunks/TooltipProvider.cjs

@@ -0,0 +1,87 @@
+require("./chunk.cjs");
+const require_createContext = require("./createContext.cjs");
+const require_dist = require("./dist.cjs");
+const require_useForwardExpose = require("./useForwardExpose.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Tooltip/TooltipProvider.js
+var [injectTooltipProviderContext, provideTooltipProviderContext] = /* @__PURE__ */ require_createContext.createContext("TooltipProvider");
+var TooltipProvider_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	inheritAttrs: false,
+	__name: "TooltipProvider",
+	props: {
+		delayDuration: {
+			type: Number,
+			required: false,
+			default: 700
+		},
+		skipDelayDuration: {
+			type: Number,
+			required: false,
+			default: 300
+		},
+		disableHoverableContent: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		disableClosingTrigger: {
+			type: Boolean,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		ignoreNonKeyboardFocus: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		content: {
+			type: Object,
+			required: false
+		}
+	},
+	setup(__props) {
+		const { delayDuration, skipDelayDuration, disableHoverableContent, disableClosingTrigger, ignoreNonKeyboardFocus, disabled, content } = (0, vue.toRefs)(__props);
+		require_useForwardExpose.useForwardExpose();
+		const isOpenDelayed = (0, vue.ref)(true);
+		const isPointerInTransitRef = (0, vue.ref)(false);
+		const { start: startTimer, stop: clearTimer } = require_dist.useTimeoutFn(() => {
+			isOpenDelayed.value = true;
+		}, skipDelayDuration, { immediate: false });
+		provideTooltipProviderContext({
+			isOpenDelayed,
+			delayDuration,
+			onOpen() {
+				clearTimer();
+				isOpenDelayed.value = false;
+			},
+			onClose() {
+				startTimer();
+			},
+			isPointerInTransitRef,
+			disableHoverableContent,
+			disableClosingTrigger,
+			disabled,
+			ignoreNonKeyboardFocus,
+			content
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.renderSlot)(_ctx.$slots, "default");
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "TooltipProvider_default", {
+	enumerable: true,
+	get: function() {
+		return TooltipProvider_default;
+	}
+});
+Object.defineProperty(exports, "injectTooltipProviderContext", {
+	enumerable: true,
+	get: function() {
+		return injectTooltipProviderContext;
+	}
+});

package/dist/cjs/chunks/TooltipRoot.cjs

@@ -0,0 +1,145 @@
+require("./chunk.cjs");
+const require_createContext = require("./createContext.cjs");
+const require_dist = require("./dist.cjs");
+const require_useForwardExpose = require("./useForwardExpose.cjs");
+const require_PopperRoot = require("./PopperRoot.cjs");
+const require_TooltipProvider = require("./TooltipProvider.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Tooltip/utils.js
+var TOOLTIP_OPEN = "tooltip.open";
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Tooltip/TooltipRoot.js
+var [injectTooltipRootContext, provideTooltipRootContext] = /* @__PURE__ */ require_createContext.createContext("TooltipRoot");
+var TooltipRoot_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "TooltipRoot",
+	props: {
+		defaultOpen: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		open: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		delayDuration: {
+			type: Number,
+			required: false,
+			default: void 0
+		},
+		disableHoverableContent: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		disableClosingTrigger: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		ignoreNonKeyboardFocus: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		}
+	},
+	emits: ["update:open"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		require_useForwardExpose.useForwardExpose();
+		const providerContext = require_TooltipProvider.injectTooltipProviderContext();
+		const disableHoverableContent = (0, vue.computed)(() => props.disableHoverableContent ?? providerContext.disableHoverableContent.value);
+		const disableClosingTrigger = (0, vue.computed)(() => props.disableClosingTrigger ?? providerContext.disableClosingTrigger.value);
+		const disableTooltip = (0, vue.computed)(() => props.disabled ?? providerContext.disabled.value);
+		const delayDuration = (0, vue.computed)(() => props.delayDuration ?? providerContext.delayDuration.value);
+		const ignoreNonKeyboardFocus = (0, vue.computed)(() => props.ignoreNonKeyboardFocus ?? providerContext.ignoreNonKeyboardFocus.value);
+		const open = require_dist.useVModel(props, "open", emit, {
+			defaultValue: props.defaultOpen,
+			passive: props.open === void 0
+		});
+		(0, vue.watch)(open, (isOpen) => {
+			if (!providerContext.onClose) return;
+			if (isOpen) {
+				providerContext.onOpen();
+				document.dispatchEvent(new CustomEvent(TOOLTIP_OPEN));
+			} else providerContext.onClose();
+		});
+		const wasOpenDelayedRef = (0, vue.ref)(false);
+		const trigger = (0, vue.ref)();
+		const stateAttribute = (0, vue.computed)(() => {
+			if (!open.value) return "closed";
+			return wasOpenDelayedRef.value ? "delayed-open" : "instant-open";
+		});
+		const { start: startTimer, stop: clearTimer } = require_dist.useTimeoutFn(() => {
+			wasOpenDelayedRef.value = true;
+			open.value = true;
+		}, delayDuration, { immediate: false });
+		function handleOpen() {
+			clearTimer();
+			wasOpenDelayedRef.value = false;
+			open.value = true;
+		}
+		function handleClose() {
+			clearTimer();
+			open.value = false;
+		}
+		function handleDelayedOpen() {
+			startTimer();
+		}
+		provideTooltipRootContext({
+			contentId: "",
+			open,
+			stateAttribute,
+			trigger,
+			onTriggerChange(el) {
+				trigger.value = el;
+			},
+			onTriggerEnter() {
+				if (providerContext.isOpenDelayed.value) handleDelayedOpen();
+				else handleOpen();
+			},
+			onTriggerLeave() {
+				if (disableHoverableContent.value) handleClose();
+				else clearTimer();
+			},
+			onOpen: handleOpen,
+			onClose: handleClose,
+			disableHoverableContent,
+			disableClosingTrigger,
+			disabled: disableTooltip,
+			ignoreNonKeyboardFocus
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_PopperRoot.PopperRoot_default), null, {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", { open: (0, vue.unref)(open) })]),
+				_: 3
+			});
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "TOOLTIP_OPEN", {
+	enumerable: true,
+	get: function() {
+		return TOOLTIP_OPEN;
+	}
+});
+Object.defineProperty(exports, "TooltipRoot_default", {
+	enumerable: true,
+	get: function() {
+		return TooltipRoot_default;
+	}
+});
+Object.defineProperty(exports, "injectTooltipRootContext", {
+	enumerable: true,
+	get: function() {
+		return injectTooltipRootContext;
+	}
+});

package/dist/cjs/chunks/VisuallyHidden.cjs

@@ -0,0 +1,65 @@
+require("./chunk.cjs");
+const require_Primitive = require("./Primitive.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/VisuallyHidden/VisuallyHidden.js
+var VisuallyHidden_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "VisuallyHidden",
+	props: {
+		feature: {
+			type: String,
+			required: false,
+			default: "focusable"
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "span"
+		}
+	},
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), {
+				as: _ctx.as,
+				"as-child": _ctx.asChild,
+				"aria-hidden": _ctx.feature === "focusable" || _ctx.feature === "fully-hidden" ? "true" : void 0,
+				"data-hidden": _ctx.feature === "fully-hidden" ? "" : void 0,
+				tabindex: _ctx.feature === "fully-hidden" ? "-1" : void 0,
+				style: {
+					position: "absolute",
+					border: 0,
+					width: "1px",
+					height: "1px",
+					padding: 0,
+					margin: "-1px",
+					overflow: "hidden",
+					clip: "rect(0, 0, 0, 0)",
+					clipPath: "inset(50%)",
+					whiteSpace: "nowrap",
+					wordWrap: "normal",
+					top: "-1px",
+					left: "-1px"
+				}
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, [
+				"as",
+				"as-child",
+				"aria-hidden",
+				"data-hidden",
+				"tabindex"
+			]);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "VisuallyHidden_default", {
+	enumerable: true,
+	get: function() {
+		return VisuallyHidden_default;
+	}
+});

package/dist/cjs/chunks/VisuallyHiddenInput.cjs

@@ -0,0 +1,146 @@
+require("./chunk.cjs");
+const require_usePrimitiveElement = require("./usePrimitiveElement.cjs");
+const require_VisuallyHidden = require("./VisuallyHidden.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/VisuallyHidden/VisuallyHiddenInputBubble.js
+var VisuallyHiddenInputBubble_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	inheritAttrs: false,
+	__name: "VisuallyHiddenInputBubble",
+	props: {
+		name: {
+			type: String,
+			required: true
+		},
+		value: {
+			type: null,
+			required: true
+		},
+		checked: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		required: {
+			type: Boolean,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		feature: {
+			type: String,
+			required: false,
+			default: "fully-hidden"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const { primitiveElement, currentElement } = require_usePrimitiveElement.usePrimitiveElement();
+		(0, vue.watch)((0, vue.computed)(() => props.checked ?? props.value), (cur, prev) => {
+			if (!currentElement.value) return;
+			const input = currentElement.value;
+			const inputProto = window.HTMLInputElement.prototype;
+			const setValue = Object.getOwnPropertyDescriptor(inputProto, "value").set;
+			if (setValue && cur !== prev) {
+				const inputEvent = new Event("input", { bubbles: true });
+				const changeEvent = new Event("change", { bubbles: true });
+				setValue.call(input, cur);
+				input.dispatchEvent(inputEvent);
+				input.dispatchEvent(changeEvent);
+			}
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)(require_VisuallyHidden.VisuallyHidden_default, (0, vue.mergeProps)({
+				ref_key: "primitiveElement",
+				ref: primitiveElement
+			}, {
+				...props,
+				..._ctx.$attrs
+			}, { as: "input" }), null, 16);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/VisuallyHidden/VisuallyHiddenInput.js
+var VisuallyHiddenInput_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	inheritAttrs: false,
+	__name: "VisuallyHiddenInput",
+	props: {
+		name: {
+			type: String,
+			required: true
+		},
+		value: {
+			type: null,
+			required: true
+		},
+		checked: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		required: {
+			type: Boolean,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		feature: {
+			type: String,
+			required: false,
+			default: "fully-hidden"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const isFormArrayEmptyAndRequired = (0, vue.computed)(() => typeof props.value === "object" && Array.isArray(props.value) && props.value.length === 0 && props.required);
+		const parsedValue = (0, vue.computed)(() => {
+			if (typeof props.value === "string" || typeof props.value === "number" || typeof props.value === "boolean" || props.value === null || props.value === void 0) return [{
+				name: props.name,
+				value: props.value
+			}];
+			else if (typeof props.value === "object" && Array.isArray(props.value)) return props.value.flatMap((obj, index) => {
+				if (typeof obj === "object") return Object.entries(obj).map(([key, value]) => ({
+					name: `${props.name}[${index}][${key}]`,
+					value
+				}));
+				else return {
+					name: `${props.name}[${index}]`,
+					value: obj
+				};
+			});
+			else if (props.value !== null && typeof props.value === "object" && !Array.isArray(props.value)) return Object.entries(props.value).map(([key, value]) => ({
+				name: `${props.name}[${key}]`,
+				value
+			}));
+			return [];
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, null, [(0, vue.createCommentVNode)(" We render single input if it's required "), isFormArrayEmptyAndRequired.value ? ((0, vue.openBlock)(), (0, vue.createBlock)(VisuallyHiddenInputBubble_default, (0, vue.mergeProps)({ key: _ctx.name }, {
+				...props,
+				..._ctx.$attrs
+			}, {
+				name: _ctx.name,
+				value: _ctx.value
+			}), null, 16, ["name", "value"])) : ((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, { key: 1 }, (0, vue.renderList)(parsedValue.value, (parsed) => {
+				return (0, vue.openBlock)(), (0, vue.createBlock)(VisuallyHiddenInputBubble_default, (0, vue.mergeProps)({ key: parsed.name }, { ref_for: true }, {
+					...props,
+					..._ctx.$attrs
+				}, {
+					name: parsed.name,
+					value: parsed.value
+				}), null, 16, ["name", "value"]);
+			}), 128))], 2112);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "VisuallyHiddenInput_default", {
+	enumerable: true,
+	get: function() {
+		return VisuallyHiddenInput_default;
+	}
+});

package/dist/cjs/chunks/alert.cjs

@@ -1,4 +1,4 @@
-require("./dist.cjs");
+require("./chunk.cjs");
 const require_clsx = require("./clsx.cjs");
 const require_crypto = require("../crypto.cjs");
 const require__plugin_vue_export_helper = require("./_plugin-vue_export-helper.cjs");
@@ -93,7 +93,7 @@ var alert_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.
 });
 //#endregion
 //#region src/components/alert/alert.vue
-var alert_default = /* @__PURE__ */ require__plugin_vue_export_helper._plugin_vue_export_helper_default(alert_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-43d8e868"]]);
+var alert_default = /* @__PURE__ */ require__plugin_vue_export_helper._plugin_vue_export_helper_default(alert_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-472863f9"]]);
 //#endregion
 Object.defineProperty(exports, "alert_default", {
 	enumerable: true,