@vuetify/v0 0.0.14 → 0.0.16

package/dist/components-Dk00OFL2.mjs

@@ -0,0 +1,1445 @@
+import { r as isSelfClosingTag } from "./htmlElements-BYo-fMlZ.mjs";
+import { c as isNull, l as isNullOrUndefined, p as isString, r as genId } from "./utilities-DQWf_4V_.mjs";
+import { F as createSelection, N as useProxyModel, Y as createContext, c as useLocale, g as createPagination, k as createGroup, p as createSingle, t as createStep, y as createOverflow, z as useRegistry } from "./useStep-Bqhi_DDs.mjs";
+import { t as IN_BROWSER } from "./globals-Rnihe4SF.mjs";
+import { computed, createBlock, createCommentVNode, createPropsRestProxy, createTextVNode, defineComponent, guardReactiveProps, mergeModels, mergeProps, normalizeProps, onBeforeUnmount, onMounted, onUnmounted, openBlock, renderSlot, resolveDynamicComponent, shallowRef, toDisplayString, toRef, toValue, unref, useAttrs, useId, useModel, useTemplateRef, vShow, watch, withCtx, withDirectives } from "vue";
+
+//#region src/components/Atom/Atom.vue
+const _sfc_main$26 = /* @__PURE__ */ defineComponent({
+	name: "Atom",
+	__name: "Atom",
+	props: {
+		as: { default: "div" },
+		renderless: {
+			type: Boolean,
+			default: false
+		}
+	},
+	setup(__props, { expose: __expose }) {
+		const element = useTemplateRef("element");
+		__expose({ element });
+		const attrs = useAttrs();
+		const isSelfClosing = toRef(() => /* @__PURE__ */ isString(__props.as) && isSelfClosingTag(__props.as));
+		const slotProps = toRef(() => attrs);
+		return (_ctx, _cache) => {
+			return __props.renderless || unref(isNull)(__props.as) ? renderSlot(_ctx.$slots, "default", normalizeProps(mergeProps({ key: 0 }, slotProps.value))) : !isSelfClosing.value ? (openBlock(), createBlock(resolveDynamicComponent(__props.as), mergeProps({ key: 1 }, slotProps.value, {
+				ref_key: "element",
+				ref: element
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 16)) : (openBlock(), createBlock(resolveDynamicComponent(__props.as), mergeProps({
+				key: 2,
+				ref_key: "element",
+				ref: element
+			}, slotProps.value), null, 16));
+		};
+	}
+});
+var Atom_default = _sfc_main$26;
+
+//#endregion
+//#region src/components/Avatar/AvatarRoot.vue
+const [useAvatarRoot, provideAvatarContext] = createContext();
+const _sfc_main$25 = /* @__PURE__ */ defineComponent({
+	name: "AvatarRoot",
+	__name: "AvatarRoot",
+	props: {
+		namespace: { default: "v0:avatar" },
+		as: { default: "div" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const selection = createSelection({
+			mandatory: "force",
+			multiple: false
+		});
+		provideAvatarContext(__props.namespace, selection);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				as: __props.as,
+				renderless: __props.renderless
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, ["as", "renderless"]);
+		};
+	}
+});
+var AvatarRoot_default = _sfc_main$25;
+
+//#endregion
+//#region src/components/Avatar/AvatarFallback.vue
+const _sfc_main$24 = /* @__PURE__ */ defineComponent({
+	name: "AvatarFallback",
+	__name: "AvatarFallback",
+	props: {
+		namespace: { default: "v0:avatar" },
+		as: { default: "span" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const context = useAvatarRoot(__props.namespace);
+		const ticket = context.register({ type: "fallback" });
+		const slotProps = toRef(() => ({ isSelected: ticket.isSelected.value }));
+		onUnmounted(() => context.unregister(ticket.id));
+		return (_ctx, _cache) => {
+			return unref(ticket).isSelected.value ? (openBlock(), createBlock(unref(Atom_default), {
+				key: 0,
+				as: __props.as,
+				renderless: __props.renderless
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 8, ["as", "renderless"])) : createCommentVNode("v-if", true);
+		};
+	}
+});
+var AvatarFallback_default = _sfc_main$24;
+
+//#endregion
+//#region src/components/Avatar/AvatarImage.vue
+const _sfc_main$23 = /* @__PURE__ */ defineComponent({
+	name: "AvatarImage",
+	inheritAttrs: false,
+	__name: "AvatarImage",
+	props: {
+		src: {},
+		priority: { default: 0 },
+		namespace: { default: "v0:avatar" },
+		as: { default: "img" },
+		renderless: { type: Boolean }
+	},
+	emits: ["load", "error"],
+	setup(__props, { emit: __emit }) {
+		const props = createPropsRestProxy(__props, [
+			"as",
+			"renderless",
+			"priority",
+			"namespace"
+		]);
+		const emit = __emit;
+		const context = useAvatarRoot(__props.namespace);
+		const ticket = context.register({
+			priority: __props.priority,
+			type: "image",
+			disabled: true
+		});
+		function onLoad(e) {
+			ticket.disabled = false;
+			ticket.select();
+			emit("load", e);
+		}
+		function onError(e) {
+			ticket.disabled = true;
+			const first = context.seek("first");
+			if (first) context.select(first.id);
+			emit("error", e);
+		}
+		onUnmounted(() => {
+			context.unregister(ticket.id);
+		});
+		const slotProps = toRef(() => ({
+			isSelected: ticket.isSelected.value,
+			attrs: {
+				role: "img",
+				onLoad,
+				onError,
+				...props
+			}
+		}));
+		return (_ctx, _cache) => {
+			return withDirectives((openBlock(), createBlock(unref(Atom_default), mergeProps(slotProps.value.attrs, {
+				as: __props.as,
+				renderless: __props.renderless
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 16, ["as", "renderless"])), [[vShow, unref(ticket).isSelected.value]]);
+		};
+	}
+});
+var AvatarImage_default = _sfc_main$23;
+
+//#endregion
+//#region src/components/Avatar/index.ts
+const Avatar = {
+	Fallback: AvatarFallback_default,
+	Image: AvatarImage_default,
+	Root: AvatarRoot_default
+};
+
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelRoot.vue
+const [useExpansionPanelRoot, provideExpansionPanelSelection] = createContext();
+const _sfc_main$22 = /* @__PURE__ */ defineComponent({
+	name: "ExpansionPanelRoot",
+	__name: "ExpansionPanelRoot",
+	props: /* @__PURE__ */ mergeModels({
+		namespace: { default: "v0:expansion-panel" },
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		enroll: {
+			type: Boolean,
+			default: false
+		},
+		mandatory: {
+			type: [Boolean, String],
+			default: false
+		},
+		multiple: {
+			type: Boolean,
+			default: false
+		},
+		as: {},
+		renderless: { type: Boolean }
+	}, {
+		"modelValue": {},
+		"modelModifiers": {}
+	}),
+	emits: /* @__PURE__ */ mergeModels(["update:model-value"], ["update:modelValue"]),
+	setup(__props) {
+		const model = useModel(__props, "modelValue");
+		const isDisabled = toRef(() => __props.disabled);
+		const selection = createSelection({
+			disabled: isDisabled,
+			enroll: __props.enroll,
+			mandatory: __props.mandatory,
+			multiple: __props.multiple,
+			events: true
+		});
+		useProxyModel(selection, model, { multiple: __props.multiple });
+		const slotProps = toRef(() => ({
+			isDisabled,
+			select: selection.select,
+			unselect: selection.unselect,
+			toggle: selection.toggle
+		}));
+		provideExpansionPanelSelection(__props.namespace, selection);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				as: __props.as,
+				renderless: __props.renderless
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 8, ["as", "renderless"]);
+		};
+	}
+});
+var ExpansionPanelRoot_default = _sfc_main$22;
+
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelItem.vue
+const [useExpansionPanelItem, provideExpansionPanelItem] = createContext({ suffix: "item" });
+const _sfc_main$21 = /* @__PURE__ */ defineComponent({
+	name: "ExpansionPanelItem",
+	__name: "ExpansionPanelItem",
+	props: {
+		id: {},
+		value: {},
+		disabled: {},
+		namespace: { default: "v0:expansion-panel" },
+		as: {},
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const selection = useExpansionPanelRoot(__props.namespace);
+		const ticket = selection.register({
+			id: __props.id,
+			value: __props.value,
+			disabled: __props.disabled
+		});
+		const headerId = toRef(() => `${ticket.id}-header`);
+		const contentId = toRef(() => `${ticket.id}-content`);
+		const isDisabled = toRef(() => toValue(ticket.disabled) || toValue(selection.disabled));
+		const slotProps = toRef(() => ({
+			isSelected: ticket.isSelected.value,
+			isDisabled: isDisabled.value,
+			attrs: { "data-selected": ticket.isSelected.value || void 0 }
+		}));
+		onBeforeUnmount(() => selection.unregister(ticket.id));
+		provideExpansionPanelItem(__props.namespace, {
+			ticket,
+			headerId,
+			contentId,
+			isDisabled
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), mergeProps(slotProps.value.attrs, {
+				as: __props.as,
+				renderless: __props.renderless
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 16, ["as", "renderless"]);
+		};
+	}
+});
+var ExpansionPanelItem_default = _sfc_main$21;
+
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelActivator.vue
+const _sfc_main$20 = /* @__PURE__ */ defineComponent({
+	name: "ExpansionPanelActivator",
+	__name: "ExpansionPanelActivator",
+	props: {
+		namespace: { default: "v0:expansion-panel" },
+		as: { default: "button" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const item = useExpansionPanelItem(__props.namespace);
+		function onKeydown(e) {
+			if (e.key === "Enter" || e.key === " ") {
+				e.preventDefault();
+				item.ticket.toggle();
+			}
+		}
+		const slotProps = toRef(() => ({
+			isDisabled: item.isDisabled.value,
+			isSelected: item.ticket.isSelected.value,
+			toggle: item.ticket.toggle,
+			attrs: {
+				"id": item.headerId.value,
+				"role": __props.as === "button" ? void 0 : "button",
+				"tabindex": item.isDisabled.value ? -1 : 0,
+				"aria-expanded": item.ticket.isSelected.value,
+				"aria-controls": item.contentId.value,
+				"aria-disabled": item.isDisabled.value,
+				"data-disabled": item.isDisabled.value || void 0,
+				"data-selected": item.ticket.isSelected.value || void 0,
+				"disabled": __props.as === "button" ? item.isDisabled.value : void 0,
+				"type": __props.as === "button" ? "button" : void 0,
+				"onClick": item.ticket.toggle,
+				onKeydown
+			}
+		}));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), mergeProps(slotProps.value.attrs, {
+				as: __props.as,
+				renderless: __props.renderless
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 16, ["as", "renderless"]);
+		};
+	}
+});
+var ExpansionPanelActivator_default = _sfc_main$20;
+
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelContent.vue
+const _sfc_main$19 = /* @__PURE__ */ defineComponent({
+	name: "ExpansionPanelContent",
+	__name: "ExpansionPanelContent",
+	props: {
+		namespace: { default: "v0:expansion-panel" },
+		as: { default: "div" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const item = useExpansionPanelItem(__props.namespace);
+		const slotProps = toRef(() => ({
+			isSelected: item.ticket.isSelected.value,
+			attrs: {
+				"data-selected": item.ticket.isSelected.value,
+				"id": item.contentId.value,
+				"role": "region",
+				"aria-labelledby": item.headerId.value,
+				"hidden": !item.ticket.isSelected.value
+			}
+		}));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), mergeProps(slotProps.value.attrs, {
+				as: __props.as,
+				renderless: __props.renderless
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 16, ["as", "renderless"]);
+		};
+	}
+});
+var ExpansionPanelContent_default = _sfc_main$19;
+
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelHeader.vue
+const _sfc_main$18 = /* @__PURE__ */ defineComponent({
+	name: "ExpansionPanelHeader",
+	__name: "ExpansionPanelHeader",
+	props: {
+		namespace: { default: "v0:expansion-panel" },
+		as: { default: "h3" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const item = useExpansionPanelItem(__props.namespace);
+		const slotProps = toRef(() => ({
+			isSelected: item.ticket.isSelected.value,
+			attrs: { "data-selected": item.ticket.isSelected.value || void 0 }
+		}));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), mergeProps(slotProps.value.attrs, {
+				as: __props.as,
+				renderless: __props.renderless
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 16, ["as", "renderless"]);
+		};
+	}
+});
+var ExpansionPanelHeader_default = _sfc_main$18;
+
+//#endregion
+//#region src/components/ExpansionPanel/index.ts
+const ExpansionPanel = {
+	Root: ExpansionPanelRoot_default,
+	Item: ExpansionPanelItem_default,
+	Header: ExpansionPanelHeader_default,
+	Activator: ExpansionPanelActivator_default,
+	Content: ExpansionPanelContent_default
+};
+
+//#endregion
+//#region src/components/Group/GroupRoot.vue
+const [useGroupRoot, provideGroupRoot] = createContext();
+const _sfc_main$17 = /* @__PURE__ */ defineComponent({
+	name: "GroupRoot",
+	__name: "GroupRoot",
+	props: /* @__PURE__ */ mergeModels({
+		namespace: { default: "v0:group" },
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		enroll: {
+			type: Boolean,
+			default: false
+		},
+		mandatory: {
+			type: [Boolean, String],
+			default: false
+		}
+	}, {
+		"modelValue": {},
+		"modelModifiers": {}
+	}),
+	emits: ["update:modelValue"],
+	setup(__props) {
+		const model = useModel(__props, "modelValue");
+		const group = createGroup({
+			disabled: toRef(() => __props.disabled),
+			enroll: __props.enroll,
+			mandatory: __props.mandatory,
+			events: true
+		});
+		useProxyModel(group, model, { multiple: true });
+		provideGroupRoot(__props.namespace, group);
+		const slotProps = toRef(() => ({
+			isDisabled: toValue(group.disabled),
+			isNoneSelected: group.isNoneSelected.value,
+			isAllSelected: group.isAllSelected.value,
+			isMixed: group.isMixed.value,
+			select: group.select,
+			unselect: group.unselect,
+			toggle: group.toggle,
+			selectAll: group.selectAll,
+			unselectAll: group.unselectAll,
+			toggleAll: group.toggleAll,
+			attrs: { "aria-multiselectable": true }
+		}));
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)));
+		};
+	}
+});
+var GroupRoot_default = _sfc_main$17;
+
+//#endregion
+//#region src/components/Group/GroupItem.vue
+const _sfc_main$16 = /* @__PURE__ */ defineComponent({
+	name: "GroupItem",
+	__name: "GroupItem",
+	props: {
+		id: {},
+		label: {},
+		value: {},
+		disabled: {},
+		indeterminate: { default: false },
+		namespace: { default: "v0:group" }
+	},
+	setup(__props) {
+		const group = useGroupRoot(__props.namespace);
+		const ticket = group.register({
+			id: __props.id,
+			value: __props.value,
+			disabled: __props.disabled,
+			indeterminate: __props.indeterminate
+		});
+		const isDisabled = toRef(() => toValue(ticket.disabled) || toValue(group.disabled));
+		onUnmounted(() => {
+			group.unregister(ticket.id);
+		});
+		const slotProps = toRef(() => ({
+			id: String(ticket.id),
+			label: __props.label,
+			value: __props.value,
+			isSelected: toValue(ticket.isSelected),
+			isMixed: toValue(ticket.isMixed),
+			isDisabled: toValue(isDisabled),
+			select: ticket.select,
+			unselect: ticket.unselect,
+			toggle: ticket.toggle,
+			mix: ticket.mix,
+			unmix: ticket.unmix,
+			attrs: {
+				"aria-selected": toValue(ticket.isSelected),
+				"aria-disabled": toValue(isDisabled),
+				"data-selected": toValue(ticket.isSelected) || void 0,
+				"data-disabled": toValue(isDisabled) || void 0,
+				"data-mixed": toValue(ticket.isMixed) || void 0
+			}
+		}));
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)));
+		};
+	}
+});
+var GroupItem_default = _sfc_main$16;
+
+//#endregion
+//#region src/components/Group/index.ts
+const Group = {
+	Root: GroupRoot_default,
+	Item: GroupItem_default
+};
+
+//#endregion
+//#region src/components/Pagination/PaginationRoot.vue
+const [usePaginationRoot, providePaginationRoot] = createContext();
+const [usePaginationControls, providePaginationControls] = createContext({ suffix: "controls" });
+const [usePaginationItems, providePaginationItems] = createContext({ suffix: "items" });
+const _sfc_main$15 = /* @__PURE__ */ defineComponent({
+	name: "PaginationRoot",
+	__name: "PaginationRoot",
+	props: /* @__PURE__ */ mergeModels({
+		namespace: { default: "v0:pagination" },
+		size: { default: 1 },
+		totalVisible: {},
+		itemsPerPage: { default: 10 },
+		ellipsis: {
+			type: [String, Boolean],
+			default: "..."
+		},
+		as: { default: "nav" },
+		renderless: { type: Boolean }
+	}, {
+		"modelValue": { default: 1 },
+		"modelModifiers": {}
+	}),
+	emits: /* @__PURE__ */ mergeModels(["update:model-value"], ["update:modelValue"]),
+	setup(__props) {
+		const page = useModel(__props, "modelValue");
+		const locale = useLocale();
+		const controls = useRegistry();
+		const items = useRegistry();
+		const atom = useTemplateRef("atom");
+		const itemWidth = shallowRef(0);
+		const itemGap = shallowRef(0);
+		const overflow = createOverflow({
+			container: () => atom.value?.element,
+			itemWidth,
+			gap: itemGap
+		});
+		watch([() => items.size, () => overflow.width.value], () => {
+			if (!IN_BROWSER) return;
+			const el = items.seek("first")?.value;
+			const root = overflow.container.value;
+			if (!el || !root) return;
+			const rootStyle = getComputedStyle(root);
+			const style = getComputedStyle(el);
+			const marginX = Number.parseFloat(style.marginLeft) + Number.parseFloat(style.marginRight);
+			const gapX = Number.parseFloat(rootStyle.gap) || 0;
+			itemWidth.value = el.offsetWidth + marginX;
+			itemGap.value = gapX;
+		}, { flush: "post" });
+		const pagination = createPagination({
+			page,
+			visible: computed(() => {
+				const totalCap = overflow.capacity.value;
+				if (totalCap === Infinity) return __props.totalVisible ?? Infinity;
+				const pageCap = Math.max(0, totalCap - controls.size);
+				const noVisible = /* @__PURE__ */ isNullOrUndefined(__props.totalVisible);
+				if (pageCap > 0) return noVisible ? pageCap : Math.min(__props.totalVisible, pageCap);
+				return noVisible ? 1 : __props.totalVisible;
+			}),
+			ellipsis: __props.ellipsis,
+			size: () => __props.size,
+			itemsPerPage: () => __props.itemsPerPage
+		});
+		const slotProps = toRef(() => ({
+			page: pagination.page.value,
+			size: pagination.size,
+			pages: pagination.pages,
+			itemsPerPage: pagination.itemsPerPage,
+			items: pagination.items.value,
+			pageStart: pagination.pageStart.value,
+			pageStop: pagination.pageStop.value,
+			isFirst: pagination.isFirst.value,
+			isLast: pagination.isLast.value,
+			first: pagination.first,
+			last: pagination.last,
+			next: pagination.next,
+			prev: pagination.prev,
+			select: pagination.select,
+			attrs: { "aria-label": locale.t("Pagination.label", void 0, "Pagination") }
+		}));
+		providePaginationRoot(__props.namespace, pagination);
+		providePaginationControls(__props.namespace, controls);
+		providePaginationItems(__props.namespace, items);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), mergeProps({
+				ref_key: "atom",
+				ref: atom
+			}, slotProps.value.attrs, {
+				as: __props.as,
+				renderless: __props.renderless
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 16, ["as", "renderless"]);
+		};
+	}
+});
+var PaginationRoot_default = _sfc_main$15;
+
+//#endregion
+//#region src/components/Pagination/PaginationEllipsis.vue
+const _sfc_main$14 = /* @__PURE__ */ defineComponent({
+	name: "PaginationEllipsis",
+	__name: "PaginationEllipsis",
+	props: {
+		namespace: { default: "v0:pagination" },
+		ellipsis: {},
+		id: { default: () => /* @__PURE__ */ genId() },
+		as: { default: "span" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const pagination = usePaginationRoot(__props.namespace);
+		const items = usePaginationItems(__props.namespace);
+		const atom = useTemplateRef("atom");
+		watch(() => atom.value?.element, (el) => {
+			if (!el) return;
+			items.register({
+				id: __props.id,
+				value: el
+			});
+		}, { immediate: true });
+		const resolvedEllipsis = toRef(() => __props.ellipsis ?? pagination.ellipsis);
+		const slotProps = toRef(() => ({
+			ellipsis: resolvedEllipsis.value,
+			attrs: { "aria-hidden": "true" }
+		}));
+		onBeforeUnmount(() => items.unregister(__props.id));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), mergeProps({
+				ref_key: "atom",
+				ref: atom
+			}, slotProps.value.attrs, {
+				as: __props.as,
+				renderless: __props.renderless
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)), () => [createTextVNode(toDisplayString(resolvedEllipsis.value), 1)])]),
+				_: 3
+			}, 16, ["as", "renderless"]);
+		};
+	}
+});
+var PaginationEllipsis_default = _sfc_main$14;
+
+//#endregion
+//#region src/components/Pagination/PaginationFirst.vue
+const _sfc_main$13 = /* @__PURE__ */ defineComponent({
+	name: "PaginationFirst",
+	__name: "PaginationFirst",
+	props: {
+		namespace: { default: "v0:pagination" },
+		disabled: { type: Boolean },
+		id: { default: () => /* @__PURE__ */ genId() },
+		as: { default: "button" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const locale = useLocale();
+		const pagination = usePaginationRoot(__props.namespace);
+		const controls = usePaginationControls(__props.namespace);
+		const atom = useTemplateRef("atom");
+		watch(() => atom.value?.element, (el) => {
+			if (!el) return;
+			controls.register({
+				id: __props.id,
+				value: el
+			});
+		}, { immediate: true });
+		const isDisabled = toRef(() => __props.disabled || pagination.isFirst.value);
+		function first() {
+			if (isDisabled.value) return;
+			pagination.first();
+		}
+		const slotProps = toRef(() => ({
+			isDisabled: isDisabled.value,
+			first,
+			attrs: {
+				"aria-label": locale.t("Pagination.first", void 0, "Go to first page"),
+				"aria-disabled": __props.as === "button" ? void 0 : isDisabled.value,
+				"data-disabled": isDisabled.value || void 0,
+				"disabled": __props.as === "button" ? isDisabled.value : void 0,
+				"type": __props.as === "button" ? "button" : void 0,
+				"onClick": first
+			}
+		}));
+		onBeforeUnmount(() => controls.unregister(__props.id));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), mergeProps({
+				ref_key: "atom",
+				ref: atom
+			}, slotProps.value.attrs, {
+				as: __props.as,
+				renderless: __props.renderless
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 16, ["as", "renderless"]);
+		};
+	}
+});
+var PaginationFirst_default = _sfc_main$13;
+
+//#endregion
+//#region src/components/Pagination/PaginationItem.vue
+const _sfc_main$12 = /* @__PURE__ */ defineComponent({
+	name: "PaginationItem",
+	__name: "PaginationItem",
+	props: {
+		namespace: { default: "v0:pagination" },
+		value: {},
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		id: { default: () => /* @__PURE__ */ genId() },
+		as: { default: "button" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const locale = useLocale();
+		const pagination = usePaginationRoot(__props.namespace);
+		const items = usePaginationItems(__props.namespace);
+		const atom = useTemplateRef("atom");
+		watch(() => atom.value?.element, (el) => {
+			if (!el) return;
+			items.register({
+				id: __props.id,
+				value: el
+			});
+		}, { immediate: true });
+		const isSelected = toRef(() => pagination.page.value === __props.value);
+		const ariaLabel = toRef(() => {
+			return isSelected.value ? locale.t("Pagination.currentPage", { page: __props.value }, `Page ${__props.value}, current page`) : locale.t("Pagination.goToPage", { page: __props.value }, `Go to page ${__props.value}`);
+		});
+		function select() {
+			if (__props.disabled) return;
+			pagination.select(__props.value);
+		}
+		const slotProps = toRef(() => ({
+			page: __props.value,
+			isSelected: isSelected.value,
+			isDisabled: __props.disabled,
+			select,
+			attrs: {
+				"aria-label": ariaLabel.value,
+				"aria-current": isSelected.value ? "page" : void 0,
+				"data-selected": isSelected.value || void 0,
+				"data-disabled": __props.disabled || void 0,
+				"disabled": __props.as === "button" ? __props.disabled : void 0,
+				"type": __props.as === "button" ? "button" : void 0,
+				"onClick": select
+			}
+		}));
+		onBeforeUnmount(() => items.unregister(__props.id));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), mergeProps({
+				ref_key: "atom",
+				ref: atom
+			}, slotProps.value.attrs, {
+				as: __props.as,
+				renderless: __props.renderless
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 16, ["as", "renderless"]);
+		};
+	}
+});
+var PaginationItem_default = _sfc_main$12;
+
+//#endregion
+//#region src/components/Pagination/PaginationLast.vue
+const _sfc_main$11 = /* @__PURE__ */ defineComponent({
+	name: "PaginationLast",
+	__name: "PaginationLast",
+	props: {
+		namespace: { default: "v0:pagination" },
+		disabled: { type: Boolean },
+		id: { default: () => /* @__PURE__ */ genId() },
+		as: { default: "button" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const locale = useLocale();
+		const pagination = usePaginationRoot(__props.namespace);
+		const controls = usePaginationControls(__props.namespace);
+		const atom = useTemplateRef("atom");
+		watch(() => atom.value?.element, (el) => {
+			if (!el) return;
+			controls.register({
+				id: __props.id,
+				value: el
+			});
+		}, { immediate: true });
+		const isDisabled = toRef(() => __props.disabled || pagination.isLast.value);
+		function last() {
+			if (isDisabled.value) return;
+			pagination.last();
+		}
+		const slotProps = toRef(() => ({
+			isDisabled: isDisabled.value,
+			last,
+			attrs: {
+				"aria-label": locale.t("Pagination.last", void 0, "Go to last page"),
+				"aria-disabled": __props.as === "button" ? void 0 : isDisabled.value,
+				"data-disabled": isDisabled.value || void 0,
+				"disabled": __props.as === "button" ? isDisabled.value : void 0,
+				"type": __props.as === "button" ? "button" : void 0,
+				"onClick": last
+			}
+		}));
+		onBeforeUnmount(() => controls.unregister(__props.id));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), mergeProps({
+				ref_key: "atom",
+				ref: atom
+			}, slotProps.value.attrs, {
+				as: __props.as,
+				renderless: __props.renderless
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 16, ["as", "renderless"]);
+		};
+	}
+});
+var PaginationLast_default = _sfc_main$11;
+
+//#endregion
+//#region src/components/Pagination/PaginationNext.vue
+const _sfc_main$10 = /* @__PURE__ */ defineComponent({
+	name: "PaginationNext",
+	__name: "PaginationNext",
+	props: {
+		namespace: { default: "v0:pagination" },
+		disabled: { type: Boolean },
+		id: { default: () => /* @__PURE__ */ genId() },
+		as: { default: "button" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const locale = useLocale();
+		const pagination = usePaginationRoot(__props.namespace);
+		const controls = usePaginationControls(__props.namespace);
+		const atom = useTemplateRef("atom");
+		watch(() => atom.value?.element, (el) => {
+			if (!el) return;
+			controls.register({
+				id: __props.id,
+				value: el
+			});
+		}, { immediate: true });
+		const isDisabled = toRef(() => __props.disabled || pagination.isLast.value);
+		function next() {
+			if (isDisabled.value) return;
+			pagination.next();
+		}
+		const slotProps = toRef(() => ({
+			isDisabled: isDisabled.value,
+			next,
+			attrs: {
+				"aria-label": locale.t("Pagination.next", void 0, "Go to next page"),
+				"aria-disabled": __props.as === "button" ? void 0 : isDisabled.value,
+				"data-disabled": isDisabled.value || void 0,
+				"disabled": __props.as === "button" ? isDisabled.value : void 0,
+				"type": __props.as === "button" ? "button" : void 0,
+				"onClick": next
+			}
+		}));
+		onBeforeUnmount(() => controls.unregister(__props.id));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), mergeProps({
+				ref_key: "atom",
+				ref: atom
+			}, slotProps.value.attrs, {
+				as: __props.as,
+				renderless: __props.renderless
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 16, ["as", "renderless"]);
+		};
+	}
+});
+var PaginationNext_default = _sfc_main$10;
+
+//#endregion
+//#region src/components/Pagination/PaginationPrev.vue
+const _sfc_main$9 = /* @__PURE__ */ defineComponent({
+	name: "PaginationPrev",
+	__name: "PaginationPrev",
+	props: {
+		namespace: { default: "v0:pagination" },
+		disabled: { type: Boolean },
+		id: { default: () => /* @__PURE__ */ genId() },
+		as: { default: "button" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const locale = useLocale();
+		const pagination = usePaginationRoot(__props.namespace);
+		const controls = usePaginationControls(__props.namespace);
+		const atom = useTemplateRef("atom");
+		watch(() => atom.value?.element, (el) => {
+			if (!el) return;
+			controls.register({
+				id: __props.id,
+				value: el
+			});
+		}, { immediate: true });
+		const isDisabled = toRef(() => __props.disabled || pagination.isFirst.value);
+		function prev() {
+			if (isDisabled.value) return;
+			pagination.prev();
+		}
+		const slotProps = toRef(() => ({
+			isDisabled: isDisabled.value,
+			prev,
+			attrs: {
+				"aria-label": locale.t("Pagination.prev", void 0, "Go to previous page"),
+				"aria-disabled": __props.as === "button" ? void 0 : isDisabled.value,
+				"data-disabled": isDisabled.value || void 0,
+				"disabled": __props.as === "button" ? isDisabled.value : void 0,
+				"type": __props.as === "button" ? "button" : void 0,
+				"onClick": prev
+			}
+		}));
+		onBeforeUnmount(() => controls.unregister(__props.id));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), mergeProps({
+				ref_key: "atom",
+				ref: atom
+			}, slotProps.value.attrs, {
+				as: __props.as,
+				renderless: __props.renderless
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 16, ["as", "renderless"]);
+		};
+	}
+});
+var PaginationPrev_default = _sfc_main$9;
+
+//#endregion
+//#region src/components/Pagination/index.ts
+const Pagination = {
+	Root: PaginationRoot_default,
+	Item: PaginationItem_default,
+	First: PaginationFirst_default,
+	Prev: PaginationPrev_default,
+	Ellipsis: PaginationEllipsis_default,
+	Next: PaginationNext_default,
+	Last: PaginationLast_default
+};
+
+//#endregion
+//#region src/components/Popover/PopoverRoot.vue
+const [usePopoverContext, providePopoverContext] = createContext("Popover");
+const _sfc_main$8 = /* @__PURE__ */ defineComponent({
+	name: "PopoverRoot",
+	__name: "PopoverRoot",
+	props: /* @__PURE__ */ mergeModels({
+		id: {},
+		as: { default: null },
+		renderless: { type: Boolean }
+	}, {
+		"modelValue": {
+			type: Boolean,
+			default: false
+		},
+		"modelModifiers": {}
+	}),
+	emits: ["update:modelValue"],
+	setup(__props) {
+		const props = createPropsRestProxy(__props, ["as"]);
+		const isSelected = useModel(__props, "modelValue");
+		const id = toRef(() => props.id ?? useId());
+		function toggle() {
+			isSelected.value = !isSelected.value;
+		}
+		providePopoverContext({
+			isSelected,
+			toggle,
+			id: toValue(id)
+		});
+		const slotProps = toRef(() => ({
+			id: toValue(id),
+			isSelected: isSelected.value,
+			toggle
+		}));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				as: __props.as,
+				renderless: ""
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 8, ["as"]);
+		};
+	}
+});
+var PopoverRoot_default = _sfc_main$8;
+
+//#endregion
+//#region src/components/Popover/PopoverAnchor.vue
+const _sfc_main$7 = /* @__PURE__ */ defineComponent({
+	name: "PopoverAnchor",
+	__name: "PopoverAnchor",
+	props: {
+		target: {},
+		as: { default: "button" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const props = createPropsRestProxy(__props, ["as"]);
+		const context = usePopoverContext();
+		const popovertarget = toRef(() => props.target ?? context.id);
+		const style = toRef(() => ({ anchorName: `--${toValue(popovertarget)}` }));
+		const slotProps = toRef(() => ({
+			isOpen: context.isSelected.value,
+			attrs: {
+				"popovertarget": toValue(popovertarget),
+				"type": __props.as === "button" ? "button" : void 0,
+				"data-popover-open": context.isSelected.value ? "" : void 0
+			}
+		}));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), mergeProps({
+				as: __props.as,
+				style: style.value
+			}, slotProps.value.attrs), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 16, ["as", "style"]);
+		};
+	}
+});
+var PopoverAnchor_default = _sfc_main$7;
+
+//#endregion
+//#region src/components/Popover/PopoverContent.vue
+const _sfc_main$6 = /* @__PURE__ */ defineComponent({
+	name: "PopoverContent",
+	__name: "PopoverContent",
+	props: {
+		id: {},
+		positionArea: { default: "bottom" },
+		positionTry: { default: "most-width bottom" },
+		as: {},
+		renderless: { type: Boolean }
+	},
+	emits: ["beforetoggle"],
+	setup(__props, { emit: __emit }) {
+		const props = createPropsRestProxy(__props, ["positionArea", "positionTry"]);
+		const emit = __emit;
+		const context = usePopoverContext();
+		const ref$1 = useTemplateRef("ref");
+		const id = toRef(() => props.id ?? context.id);
+		const style = toRef(() => ({
+			positionArea: __props.positionArea,
+			positionAnchor: `--${toValue(id)}`,
+			positionTry: __props.positionTry
+		}));
+		onMounted(() => {
+			if (context.isSelected.value) ref$1.value?.element?.showPopover();
+		});
+		watch(context.isSelected, (isOpen) => {
+			const element = ref$1.value?.element;
+			if (!element) return;
+			if (isOpen) element.showPopover?.();
+			else element.hidePopover?.();
+		});
+		function onBeforeToggle(e) {
+			context.isSelected.value = e.newState === "open";
+			emit("beforetoggle", e);
+		}
+		const slotProps = toRef(() => ({
+			isOpen: context.isSelected.value,
+			attrs: {
+				id: toValue(id),
+				popover: ""
+			}
+		}));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), mergeProps({
+				ref_key: "ref",
+				ref: ref$1,
+				style: style.value
+			}, slotProps.value.attrs, { onBeforetoggle: onBeforeToggle }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))]),
+				_: 3
+			}, 16, ["style"]);
+		};
+	}
+});
+var PopoverContent_default = _sfc_main$6;
+
+//#endregion
+//#region src/components/Popover/index.ts
+const Popover = {
+	Root: PopoverRoot_default,
+	Anchor: PopoverAnchor_default,
+	Content: PopoverContent_default
+};
+
+//#endregion
+//#region src/components/Selection/SelectionRoot.vue
+const [useSelectionRoot, provideSelectionRoot] = createContext();
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+	name: "SelectionRoot",
+	__name: "SelectionRoot",
+	props: /* @__PURE__ */ mergeModels({
+		namespace: { default: "v0:selection" },
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		enroll: {
+			type: Boolean,
+			default: false
+		},
+		mandatory: {
+			type: [Boolean, String],
+			default: false
+		},
+		multiple: {
+			type: Boolean,
+			default: false
+		}
+	}, {
+		"modelValue": {},
+		"modelModifiers": {}
+	}),
+	emits: ["update:modelValue"],
+	setup(__props) {
+		const model = useModel(__props, "modelValue");
+		const selection = createSelection({
+			disabled: toRef(() => __props.disabled),
+			enroll: __props.enroll,
+			mandatory: __props.mandatory,
+			multiple: __props.multiple,
+			events: true
+		});
+		useProxyModel(selection, model, { multiple: __props.multiple });
+		provideSelectionRoot(__props.namespace, selection);
+		const slotProps = toRef(() => ({
+			isDisabled: toValue(selection.disabled),
+			multiple: __props.multiple,
+			select: selection.select,
+			unselect: selection.unselect,
+			toggle: selection.toggle,
+			attrs: { "aria-multiselectable": __props.multiple }
+		}));
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)));
+		};
+	}
+});
+var SelectionRoot_default = _sfc_main$5;
+
+//#endregion
+//#region src/components/Selection/SelectionItem.vue
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+	name: "SelectionItem",
+	__name: "SelectionItem",
+	props: {
+		id: {},
+		label: {},
+		value: {},
+		disabled: {},
+		namespace: { default: "v0:selection" }
+	},
+	setup(__props) {
+		const selection = useSelectionRoot(__props.namespace);
+		const ticket = selection.register({
+			id: __props.id,
+			value: __props.value,
+			disabled: __props.disabled
+		});
+		const isDisabled = toRef(() => toValue(ticket.disabled) || toValue(selection.disabled));
+		onUnmounted(() => {
+			selection.unregister(ticket.id);
+		});
+		const slotProps = toRef(() => ({
+			id: String(ticket.id),
+			label: __props.label,
+			value: __props.value,
+			isSelected: toValue(ticket.isSelected),
+			isDisabled: toValue(isDisabled),
+			select: ticket.select,
+			unselect: ticket.unselect,
+			toggle: ticket.toggle,
+			attrs: {
+				"aria-selected": toValue(ticket.isSelected),
+				"aria-disabled": toValue(isDisabled),
+				"data-selected": toValue(ticket.isSelected) || void 0,
+				"data-disabled": toValue(isDisabled) || void 0
+			}
+		}));
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)));
+		};
+	}
+});
+var SelectionItem_default = _sfc_main$4;
+
+//#endregion
+//#region src/components/Selection/index.ts
+const Selection = {
+	Root: SelectionRoot_default,
+	Item: SelectionItem_default
+};
+
+//#endregion
+//#region src/components/Single/SingleRoot.vue
+const [useSingleRoot, provideSingleRoot] = createContext();
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+	name: "SingleRoot",
+	__name: "SingleRoot",
+	props: /* @__PURE__ */ mergeModels({
+		namespace: { default: "v0:single" },
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		enroll: {
+			type: Boolean,
+			default: false
+		},
+		mandatory: {
+			type: [Boolean, String],
+			default: false
+		}
+	}, {
+		"modelValue": {},
+		"modelModifiers": {}
+	}),
+	emits: ["update:modelValue"],
+	setup(__props) {
+		const model = useModel(__props, "modelValue");
+		const single = createSingle({
+			disabled: toRef(() => __props.disabled),
+			enroll: __props.enroll,
+			mandatory: __props.mandatory,
+			events: true
+		});
+		useProxyModel(single, model, { multiple: false });
+		provideSingleRoot(__props.namespace, single);
+		const slotProps = toRef(() => ({
+			isDisabled: toValue(single.disabled),
+			select: single.select,
+			unselect: single.unselect,
+			toggle: single.toggle,
+			attrs: { "aria-multiselectable": false }
+		}));
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)));
+		};
+	}
+});
+var SingleRoot_default = _sfc_main$3;
+
+//#endregion
+//#region src/components/Single/SingleItem.vue
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+	name: "SingleItem",
+	__name: "SingleItem",
+	props: {
+		id: {},
+		label: {},
+		value: {},
+		disabled: {},
+		namespace: { default: "v0:single" }
+	},
+	setup(__props) {
+		const single = useSingleRoot(__props.namespace);
+		const ticket = single.register({
+			id: __props.id,
+			value: __props.value,
+			disabled: __props.disabled
+		});
+		const isDisabled = toRef(() => toValue(ticket.disabled) || toValue(single.disabled));
+		onUnmounted(() => {
+			single.unregister(ticket.id);
+		});
+		const slotProps = toRef(() => ({
+			id: String(ticket.id),
+			label: __props.label,
+			value: __props.value,
+			isSelected: toValue(ticket.isSelected),
+			isDisabled: toValue(isDisabled),
+			select: ticket.select,
+			unselect: ticket.unselect,
+			toggle: ticket.toggle,
+			attrs: {
+				"aria-selected": toValue(ticket.isSelected),
+				"aria-disabled": toValue(isDisabled),
+				"data-selected": toValue(ticket.isSelected) || void 0,
+				"data-disabled": toValue(isDisabled) || void 0
+			}
+		}));
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)));
+		};
+	}
+});
+var SingleItem_default = _sfc_main$2;
+
+//#endregion
+//#region src/components/Single/index.ts
+const Single = {
+	Root: SingleRoot_default,
+	Item: SingleItem_default
+};
+
+//#endregion
+//#region src/components/Step/StepRoot.vue
+const [useStepRoot, provideStepRoot] = createContext();
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+	name: "StepRoot",
+	__name: "StepRoot",
+	props: /* @__PURE__ */ mergeModels({
+		namespace: { default: "v0:step" },
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		enroll: {
+			type: Boolean,
+			default: false
+		},
+		mandatory: {
+			type: [Boolean, String],
+			default: false
+		}
+	}, {
+		"modelValue": {},
+		"modelModifiers": {}
+	}),
+	emits: ["update:modelValue"],
+	setup(__props) {
+		const model = useModel(__props, "modelValue");
+		const step = createStep({
+			disabled: toRef(() => __props.disabled),
+			enroll: __props.enroll,
+			mandatory: __props.mandatory,
+			events: true
+		});
+		useProxyModel(step, model, { multiple: false });
+		provideStepRoot(__props.namespace, step);
+		const slotProps = toRef(() => ({
+			isDisabled: toValue(step.disabled),
+			first: step.first,
+			last: step.last,
+			next: step.next,
+			prev: step.prev,
+			step: step.step,
+			select: step.select,
+			unselect: step.unselect,
+			toggle: step.toggle,
+			attrs: { "aria-multiselectable": false }
+		}));
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)));
+		};
+	}
+});
+var StepRoot_default = _sfc_main$1;
+
+//#endregion
+//#region src/components/Step/StepItem.vue
+const _sfc_main = /* @__PURE__ */ defineComponent({
+	name: "StepItem",
+	__name: "StepItem",
+	props: {
+		id: {},
+		label: {},
+		value: {},
+		disabled: {},
+		namespace: { default: "v0:step" }
+	},
+	setup(__props) {
+		const step = useStepRoot(__props.namespace);
+		const ticket = step.register({
+			id: __props.id,
+			value: __props.value,
+			disabled: __props.disabled
+		});
+		const isDisabled = toRef(() => toValue(ticket.disabled) || toValue(step.disabled));
+		onUnmounted(() => {
+			step.unregister(ticket.id);
+		});
+		const slotProps = toRef(() => ({
+			id: String(ticket.id),
+			label: __props.label,
+			value: __props.value,
+			isSelected: toValue(ticket.isSelected),
+			isDisabled: toValue(isDisabled),
+			select: ticket.select,
+			unselect: ticket.unselect,
+			toggle: ticket.toggle,
+			attrs: {
+				"aria-selected": toValue(ticket.isSelected),
+				"aria-disabled": toValue(isDisabled),
+				"data-selected": toValue(ticket.isSelected) || void 0,
+				"data-disabled": toValue(isDisabled) || void 0
+			}
+		}));
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)));
+		};
+	}
+});
+var StepItem_default = _sfc_main;
+
+//#endregion
+//#region src/components/Step/index.ts
+const Step = {
+	Root: StepRoot_default,
+	Item: StepItem_default
+};
+
+//#endregion
+export { useAvatarRoot as A, ExpansionPanel as C, useExpansionPanelRoot as D, provideExpansionPanelSelection as E, Avatar as O, useGroupRoot as S, useExpansionPanelItem as T, usePaginationControls as _, provideSingleRoot as a, Group as b, provideSelectionRoot as c, providePopoverContext as d, usePopoverContext as f, providePaginationRoot as g, providePaginationItems as h, Single as i, Atom_default as j, provideAvatarContext as k, useSelectionRoot as l, providePaginationControls as m, provideStepRoot as n, useSingleRoot as o, Pagination as p, useStepRoot as r, Selection as s, Step as t, Popover as u, usePaginationItems as v, provideExpansionPanelItem as w, provideGroupRoot as x, usePaginationRoot as y };