@vuetify/v0 0.0.8 → 0.0.10

package/dist/components-DFGu8N2g.mjs

@@ -0,0 +1,947 @@
+import { r as isSelfClosingTag } from "./htmlElements-BYo-fMlZ.mjs";
+import { a as isNull, u as isString } from "./utilities-C26nB74O.mjs";
+import { At as createContext, Mt as useContext, R as createSingleContext, T as useProxyModel, _ as createStepContext, at as useSelection, it as createSelectionContext, nt as useGroup, tt as createGroupContext, v as useStep, z as useSingle } from "./composables-TCjvMHyU.mjs";
+import { computed, createBlock, createCommentVNode, createPropsRestProxy, defineComponent, guardReactiveProps, mergeModels, mergeProps, normalizeProps, normalizeStyle, onMounted, onUnmounted, openBlock, renderSlot, resolveDynamicComponent, toRef, toValue, unref, useAttrs, useId, useModel, useTemplateRef, vShow, watch, withCtx, withDirectives } from "vue";
+
+//#region src/components/Atom/Atom.vue
+const _sfc_main$18 = /* @__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$18;
+
+//#endregion
+//#region src/components/Avatar/AvatarFallback.vue
+const _sfc_main$17 = /* @__PURE__ */ defineComponent({
+	name: "AvatarFallback",
+	__name: "AvatarFallback",
+	props: {
+		namespace: { default: "v0:avatar" },
+		as: { default: "span" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const context = useContext(__props.namespace);
+		const ticket = context.register({ type: "fallback" });
+		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")]),
+				_: 3
+			}, 8, ["as", "renderless"])) : createCommentVNode("v-if", true);
+		};
+	}
+});
+var AvatarFallback_default = _sfc_main$17;
+
+//#endregion
+//#region src/components/Avatar/AvatarImage.vue
+const _sfc_main$16 = /* @__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 = useContext(__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 bindableProps = toRef(() => ({
+			onError,
+			onLoad,
+			role: "img",
+			...props
+		}));
+		return (_ctx, _cache) => {
+			return withDirectives((openBlock(), createBlock(unref(Atom_default), mergeProps({
+				as: __props.as,
+				renderless: __props.renderless
+			}, bindableProps.value), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(bindableProps.value)))]),
+				_: 3
+			}, 16, ["as", "renderless"])), [[vShow, unref(ticket).isSelected.value]]);
+		};
+	}
+});
+var AvatarImage_default = _sfc_main$16;
+
+//#endregion
+//#region src/components/Avatar/AvatarRoot.vue
+const _sfc_main$15 = /* @__PURE__ */ defineComponent({
+	name: "AvatarRoot",
+	__name: "AvatarRoot",
+	props: {
+		namespace: { default: "v0:avatar" },
+		as: { default: "div" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const [, provideAvatarContext] = createSelectionContext({
+			namespace: __props.namespace,
+			mandatory: "force",
+			multiple: false
+		});
+		provideAvatarContext();
+		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$15;
+
+//#endregion
+//#region src/components/Avatar/index.ts
+const Avatar = {
+	Fallback: AvatarFallback_default,
+	Image: AvatarImage_default,
+	Root: AvatarRoot_default
+};
+
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelActivator.vue
+const _sfc_main$14 = /* @__PURE__ */ defineComponent({
+	name: "ExpansionPanelActivator",
+	__name: "ExpansionPanelActivator",
+	props: {
+		itemNamespace: { default: "v0:expansion-panel-item" },
+		as: { default: "button" },
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const context = useContext(__props.itemNamespace);
+		function onKeydown(e) {
+			if (e.key === "Enter" || e.key === " ") {
+				e.preventDefault();
+				context.ticket.toggle();
+			}
+		}
+		const bindableProps = computed(() => ({
+			"id": context.headerId.value,
+			"role": "button",
+			"tabindex": context.isDisabled.value ? -1 : 0,
+			"aria-expanded": context.ticket.isSelected.value,
+			"aria-controls": context.contentId.value,
+			"aria-disabled": context.isDisabled.value,
+			"isSelected": context.ticket.isSelected.value,
+			"toggle": context.ticket.toggle,
+			"onClick": context.ticket.toggle,
+			onKeydown
+		}));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				id: bindableProps.value.id,
+				"aria-controls": bindableProps.value["aria-controls"],
+				"aria-disabled": bindableProps.value["aria-disabled"],
+				"aria-expanded": bindableProps.value["aria-expanded"],
+				as: __props.as,
+				renderless: __props.renderless,
+				role: bindableProps.value.role,
+				tabindex: bindableProps.value.tabindex,
+				onClick: unref(context).ticket.toggle,
+				onKeydown
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(bindableProps.value)))]),
+				_: 3
+			}, 8, [
+				"id",
+				"aria-controls",
+				"aria-disabled",
+				"aria-expanded",
+				"as",
+				"renderless",
+				"role",
+				"tabindex",
+				"onClick"
+			]);
+		};
+	}
+});
+var ExpansionPanelActivator_default = _sfc_main$14;
+
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelContent.vue
+const _sfc_main$13 = /* @__PURE__ */ defineComponent({
+	name: "ExpansionPanelContent",
+	__name: "ExpansionPanelContent",
+	props: {
+		itemNamespace: { default: "v0:expansion-panel-item" },
+		as: {},
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const context = useContext(__props.itemNamespace);
+		const bindableProps = computed(() => ({
+			"id": context.contentId.value,
+			"role": "region",
+			"aria-labelledby": context.headerId.value,
+			"isSelected": context.ticket.isSelected.value
+		}));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				id: bindableProps.value.id,
+				"aria-labelledby": bindableProps.value["aria-labelledby"],
+				as: __props.as,
+				renderless: __props.renderless,
+				role: bindableProps.value.role
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(bindableProps.value)))]),
+				_: 3
+			}, 8, [
+				"id",
+				"aria-labelledby",
+				"as",
+				"renderless",
+				"role"
+			]);
+		};
+	}
+});
+var ExpansionPanelContent_default = _sfc_main$13;
+
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelItem.vue
+const _sfc_main$12 = /* @__PURE__ */ defineComponent({
+	name: "ExpansionPanelItem",
+	__name: "ExpansionPanelItem",
+	props: {
+		id: {},
+		value: {},
+		disabled: {},
+		namespace: { default: "v0:expansion-panel" },
+		itemNamespace: { default: "v0:expansion-panel-item" },
+		as: {},
+		renderless: { type: Boolean }
+	},
+	setup(__props) {
+		const expansion = useSelection(__props.namespace);
+		const ticket = expansion.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(expansion.disabled));
+		const [, provideItemContext] = createContext(__props.itemNamespace);
+		provideItemContext({
+			ticket,
+			headerId,
+			contentId,
+			isDisabled
+		});
+		onUnmounted(() => {
+			expansion.unregister(ticket.id);
+		});
+		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 ExpansionPanelItem_default = _sfc_main$12;
+
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelRoot.vue
+const _sfc_main$11 = /* @__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 [, provideExpansionControl, context] = createSelectionContext({
+			namespace: __props.namespace,
+			disabled: toRef(() => __props.disabled),
+			enroll: __props.enroll,
+			mandatory: __props.mandatory,
+			multiple: __props.multiple,
+			events: true
+		});
+		const bindableProps = computed(() => ({
+			disabled: toValue(context.disabled),
+			multiple: __props.multiple,
+			select: context.select,
+			unselect: context.unselect,
+			toggle: context.toggle,
+			ariaMultiselectable: __props.multiple
+		}));
+		useProxyModel(context, model, { multiple: __props.multiple });
+		provideExpansionControl(context);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				"aria-multiselectable": bindableProps.value.ariaMultiselectable,
+				as: __props.as,
+				disabled: bindableProps.value.disabled,
+				multiple: bindableProps.value.multiple,
+				renderless: __props.renderless,
+				select: bindableProps.value.select,
+				toggle: bindableProps.value.toggle,
+				unselect: bindableProps.value.unselect
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(bindableProps.value)))]),
+				_: 3
+			}, 8, [
+				"aria-multiselectable",
+				"as",
+				"disabled",
+				"multiple",
+				"renderless",
+				"select",
+				"toggle",
+				"unselect"
+			]);
+		};
+	}
+});
+var ExpansionPanelRoot_default = _sfc_main$11;
+
+//#endregion
+//#region src/components/ExpansionPanel/index.ts
+const ExpansionPanel = {
+	Root: ExpansionPanelRoot_default,
+	Item: ExpansionPanelItem_default,
+	Activator: ExpansionPanelActivator_default,
+	Content: ExpansionPanelContent_default
+};
+
+//#endregion
+//#region src/components/Group/GroupItem.vue
+const _sfc_main$10 = /* @__PURE__ */ defineComponent({
+	name: "GroupItem",
+	__name: "GroupItem",
+	props: {
+		label: {},
+		id: {},
+		disabled: {},
+		value: {},
+		namespace: { default: "v0:group" }
+	},
+	setup(__props) {
+		const group = useGroup(__props.namespace);
+		const ticket = group.register({
+			id: __props.id,
+			value: __props.value,
+			disabled: __props.disabled
+		});
+		const isDisabled = toRef(() => ticket.disabled || group.disabled);
+		onUnmounted(() => {
+			group.unregister(ticket.id);
+		});
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", {
+				id: String(unref(ticket).id),
+				ariaDisabled: toValue(isDisabled.value),
+				ariaSelected: toValue(unref(ticket).isSelected),
+				disabled: toValue(isDisabled.value),
+				isSelected: toValue(unref(ticket).isSelected),
+				label: __props.label,
+				select: unref(ticket).select,
+				toggle: unref(ticket).toggle,
+				unselect: unref(ticket).unselect,
+				value: __props.value
+			});
+		};
+	}
+});
+var GroupItem_default = _sfc_main$10;
+
+//#endregion
+//#region src/components/Group/GroupRoot.vue
+const _sfc_main$9 = /* @__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 [, provideGroupControl, context] = createGroupContext({
+			namespace: __props.namespace,
+			disabled: toRef(() => __props.disabled),
+			enroll: __props.enroll,
+			mandatory: __props.mandatory,
+			events: true
+		});
+		useProxyModel(context, model, { multiple: true });
+		provideGroupControl(context);
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", {
+				ariaMultiselectable: true,
+				disabled: toValue(unref(context).disabled),
+				select: unref(context).select,
+				toggle: unref(context).toggle,
+				unselect: unref(context).unselect
+			});
+		};
+	}
+});
+var GroupRoot_default = _sfc_main$9;
+
+//#endregion
+//#region src/components/Group/index.ts
+const Group = {
+	Root: GroupRoot_default,
+	Item: GroupItem_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;
+		}
+		const bindableProps = toRef(() => ({
+			id,
+			isSelected,
+			toggle
+		}));
+		providePopoverContext({
+			isSelected,
+			toggle,
+			id: id.value
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), mergeProps({
+				as: __props.as,
+				renderless: __props.renderless
+			}, bindableProps.value), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(bindableProps.value)))]),
+				_: 3
+			}, 16, ["as", "renderless"]);
+		};
+	}
+});
+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: `--${popovertarget.value}` }));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				as: __props.as,
+				"data-popover-open": unref(context).isSelected.value ? "" : void 0,
+				popovertarget: popovertarget.value,
+				style: normalizeStyle(style.value),
+				type: __props.as === "button" ? "button" : void 0
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, [
+				"as",
+				"data-popover-open",
+				"popovertarget",
+				"style",
+				"type"
+			]);
+		};
+	}
+});
+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: `--${id.value}`,
+			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);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Atom_default), {
+				id: id.value,
+				ref_key: "ref",
+				ref: ref$1,
+				popover: "",
+				style: normalizeStyle(style.value),
+				onBeforetoggle: onBeforeToggle
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, ["id", "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/SelectionItem.vue
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+	name: "SelectionItem",
+	__name: "SelectionItem",
+	props: {
+		label: {},
+		id: {},
+		disabled: {},
+		value: {},
+		namespace: { default: "v0:selection" }
+	},
+	setup(__props) {
+		const selection = useSelection(__props.namespace);
+		const ticket = selection.register({
+			id: __props.id,
+			value: __props.value,
+			disabled: __props.disabled
+		});
+		const isDisabled = toRef(() => ticket.disabled || selection.disabled);
+		onUnmounted(() => {
+			selection.unregister(ticket.id);
+		});
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", {
+				id: String(unref(ticket).id),
+				ariaDisabled: toValue(isDisabled.value),
+				ariaSelected: toValue(unref(ticket).isSelected),
+				disabled: toValue(isDisabled.value),
+				isSelected: toValue(unref(ticket).isSelected),
+				label: __props.label,
+				select: unref(ticket).select,
+				toggle: unref(ticket).toggle,
+				unselect: unref(ticket).unselect,
+				value: __props.value
+			});
+		};
+	}
+});
+var SelectionItem_default = _sfc_main$5;
+
+//#endregion
+//#region src/components/Selection/SelectionRoot.vue
+const _sfc_main$4 = /* @__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 [, provideSelectionControl, context] = createSelectionContext({
+			namespace: __props.namespace,
+			disabled: toRef(() => __props.disabled),
+			enroll: __props.enroll,
+			mandatory: __props.mandatory,
+			multiple: __props.multiple,
+			events: true
+		});
+		useProxyModel(context, model, { multiple: __props.multiple });
+		provideSelectionControl(context);
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", {
+				ariaMultiselectable: __props.multiple,
+				disabled: toValue(unref(context).disabled),
+				multiple: __props.multiple,
+				select: unref(context).select,
+				toggle: unref(context).toggle,
+				unselect: unref(context).unselect
+			});
+		};
+	}
+});
+var SelectionRoot_default = _sfc_main$4;
+
+//#endregion
+//#region src/components/Selection/index.ts
+const Selection = {
+	Root: SelectionRoot_default,
+	Item: SelectionItem_default
+};
+
+//#endregion
+//#region src/components/Single/SingleItem.vue
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+	name: "SingleItem",
+	__name: "SingleItem",
+	props: {
+		label: {},
+		id: {},
+		disabled: {},
+		value: {},
+		namespace: { default: "v0:single" }
+	},
+	setup(__props) {
+		const single = useSingle(__props.namespace);
+		const ticket = single.register({
+			id: __props.id,
+			value: __props.value,
+			disabled: __props.disabled
+		});
+		const isDisabled = toRef(() => ticket.disabled || single.disabled);
+		onUnmounted(() => {
+			single.unregister(ticket.id);
+		});
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", {
+				id: String(unref(ticket).id),
+				ariaDisabled: toValue(isDisabled.value),
+				ariaSelected: toValue(unref(ticket).isSelected),
+				disabled: toValue(isDisabled.value),
+				isSelected: toValue(unref(ticket).isSelected),
+				label: __props.label,
+				select: unref(ticket).select,
+				toggle: unref(ticket).toggle,
+				unselect: unref(ticket).unselect,
+				value: __props.value
+			});
+		};
+	}
+});
+var SingleItem_default = _sfc_main$3;
+
+//#endregion
+//#region src/components/Single/SingleRoot.vue
+const _sfc_main$2 = /* @__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 [, provideSingleControl, context] = createSingleContext({
+			namespace: __props.namespace,
+			disabled: toRef(() => __props.disabled),
+			enroll: __props.enroll,
+			mandatory: __props.mandatory,
+			events: true
+		});
+		useProxyModel(context, model, { multiple: false });
+		provideSingleControl(context);
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", {
+				ariaMultiselectable: true,
+				disabled: toValue(unref(context).disabled),
+				select: unref(context).select,
+				toggle: unref(context).toggle,
+				unselect: unref(context).unselect
+			});
+		};
+	}
+});
+var SingleRoot_default = _sfc_main$2;
+
+//#endregion
+//#region src/components/Single/index.ts
+const Single = {
+	Root: SingleRoot_default,
+	Item: SingleItem_default
+};
+
+//#endregion
+//#region src/components/Step/StepItem.vue
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+	name: "StepItem",
+	__name: "StepItem",
+	props: {
+		label: {},
+		id: {},
+		disabled: {},
+		value: {},
+		namespace: { default: "v0:step" }
+	},
+	setup(__props) {
+		const step = useStep(__props.namespace);
+		const ticket = step.register({
+			id: __props.id,
+			value: __props.value,
+			disabled: __props.disabled
+		});
+		const isDisabled = toRef(() => ticket.disabled || step.disabled);
+		onUnmounted(() => {
+			step.unregister(ticket.id);
+		});
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", {
+				id: String(unref(ticket).id),
+				ariaDisabled: toValue(isDisabled.value),
+				ariaSelected: toValue(unref(ticket).isSelected),
+				disabled: toValue(isDisabled.value),
+				isSelected: toValue(unref(ticket).isSelected),
+				label: __props.label,
+				select: unref(ticket).select,
+				toggle: unref(ticket).toggle,
+				unselect: unref(ticket).unselect,
+				value: __props.value
+			});
+		};
+	}
+});
+var StepItem_default = _sfc_main$1;
+
+//#endregion
+//#region src/components/Step/StepRoot.vue
+const _sfc_main = /* @__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 [, provideStepControl, context] = createStepContext({
+			namespace: __props.namespace,
+			disabled: toRef(() => __props.disabled),
+			enroll: __props.enroll,
+			mandatory: __props.mandatory,
+			events: true
+		});
+		useProxyModel(context, model, { multiple: false });
+		provideStepControl(context);
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", {
+				ariaMultiselectable: true,
+				disabled: toValue(unref(context).disabled),
+				first: unref(context).first,
+				last: unref(context).last,
+				next: unref(context).next,
+				prev: unref(context).prev,
+				select: unref(context).select,
+				step: unref(context).step,
+				toggle: unref(context).toggle,
+				unselect: unref(context).unselect
+			});
+		};
+	}
+});
+var StepRoot_default = _sfc_main;
+
+//#endregion
+//#region src/components/Step/index.ts
+const Step = {
+	Root: StepRoot_default,
+	Item: StepItem_default
+};
+
+//#endregion
+export { providePopoverContext as a, ExpansionPanel as c, Popover as i, Avatar as l, Single as n, usePopoverContext as o, Selection as r, Group as s, Step as t, Atom_default as u };