ropav 0.2.0 → 0.3.0

package/dist/dropdown-menu.js

@@ -1,3269 +0,0 @@
-import './dropdown-menu.css';
-import { t as useControllableValue } from "./useControllableValue.js";
-import { t as useStylesApi } from "./styles-api.js";
-import { n as toPresenceAttribute, t as toOptionalAttribute } from "./attributes.js";
-import { t as bem } from "./bem.js";
-import { t as useRequiredInject } from "./useRequiredInject.js";
-import { t as clamp } from "./number.js";
-import { t as chevron_right_default } from "./chevron-right.js";
-import { t as resolveHTMLElementRef } from "./componentRef.js";
-import { r as isEventWithinTargets, t as createCancelableCustomEvent } from "./events.js";
-import { n as useOverlayZIndex, r as useOverlayLayer } from "./useOverlayZIndex.js";
-import { t as useFloatingPosition } from "./useFloatingPosition.js";
-import { t as useFloatingTargetLifecycle } from "./useFloatingTargetLifecycle.js";
-import { n as useTeleportTarget, t as provideTeleportTarget } from "./useTeleportTarget.js";
-import { t as useTypeahead } from "./useTypeahead.js";
-import { VaporTeleport, VaporTransition, child, computed, createComponent, createComponentWithFallback, createDynamicComponent, createFor, createIf, createSlot, createTemplateRefSetter, defineVaporComponent, extend, isRef, mergeProps, nextTick, onBeforeUnmount, onMounted, onUnmounted, provide, ref, renderEffect, resolveComponent, setAttr, setDynamicProps, setInsertionState, setStyle, setTemplateRefBinding, setText, shallowRef, template, toDisplayString, txt, unref, useAttrs, useId, watch } from "vue";
-//#region src/utils/geometry.ts
-function getClientPoint(event) {
-	return {
-		x: event.clientX,
-		y: event.clientY
-	};
-}
-function hasMeasuredRect(rect) {
-	return rect.width > 0 || rect.height > 0;
-}
-function isPointInRect(point, rect, padding = 0) {
-	return point.x >= rect.left - padding && point.x <= rect.right + padding && point.y >= rect.top - padding && point.y <= rect.bottom + padding;
-}
-function getTriangleArea(a, b, c) {
-	return Math.abs((a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y)) / 2);
-}
-function isPointInTriangle(point, triangle, tolerance = .5) {
-	const [a, b, c] = triangle;
-	const area = getTriangleArea(a, b, c);
-	const area1 = getTriangleArea(point, b, c);
-	const area2 = getTriangleArea(a, point, c);
-	const area3 = getTriangleArea(a, b, point);
-	return Math.abs(area - (area1 + area2 + area3)) < tolerance;
-}
-function clampPointToRect(point, rect) {
-	return {
-		x: clamp(point.x, rect.left, rect.right),
-		y: clamp(point.y, rect.top, rect.bottom)
-	};
-}
-function createPointRect(point) {
-	return {
-		x: point.x,
-		y: point.y,
-		left: point.x,
-		right: point.x,
-		top: point.y,
-		bottom: point.y,
-		width: 0,
-		height: 0,
-		toJSON: () => ({})
-	};
-}
-//#endregion
-//#region src/components/dropdown-menu/dropdownMenuContext.ts
-var rootKey = Symbol("dropdown-menu-root");
-var menuKey = Symbol("dropdown-menu-content");
-var subKey = Symbol("dropdown-menu-sub");
-var radioGroupKey = Symbol("dropdown-menu-radio-group");
-var checkedKey = Symbol("dropdown-menu-checked");
-function createVirtualAnchor(point) {
-	return { getBoundingClientRect: () => createPointRect(point) };
-}
-function createSelectEvent(originalEvent, value) {
-	return createCancelableCustomEvent("dropdown-menu-select", {
-		originalEvent,
-		value
-	}, originalEvent);
-}
-function createMenuContext(options) {
-	const id = options.parentSub?.menuId ?? options.root.interactionRootMenuId;
-	const interaction = options.parentSub ? options.parentSub.interaction.connectContent({
-		element: () => options.element.value,
-		placement: () => options.actualPlacement.value,
-		stopKeyPropagation: true,
-		onEscape: options.onEscape
-	}) : options.root.interaction.connectRootMenu({
-		element: () => options.element.value,
-		placement: () => options.actualPlacement.value,
-		stopKeyPropagation: true,
-		onEscape: options.onEscape
-	});
-	function connectItem(item) {
-		return interaction.connectItem({
-			id: item.id,
-			element: item.element,
-			textValue: item.textValue,
-			disabled: item.disabled,
-			submenu: item.submenu?.interaction,
-			submenuDirection: () => item.submenu?.actualPlacement.value.startsWith("left") ? "left" : "right",
-			select: item.activate,
-			closeOnSelect: item.closeOnSelect
-		});
-	}
-	const context = {
-		root: options.root,
-		id,
-		element: options.element,
-		actualPlacement: options.actualPlacement,
-		parentSub: options.parentSub,
-		interaction,
-		connectItem
-	};
-	onBeforeUnmount(interaction.dispose);
-	return context;
-}
-function usePrimitiveItem(componentName, props, emitSelect, options) {
-	const menu = useRequiredInject(menuKey, componentName);
-	const generatedId = useId();
-	const id = computed(() => props.id ?? `${generatedId}-item`);
-	const element = ref(null);
-	const isDisabled = computed(() => Boolean(menu.root.disabled.value || props.disabled));
-	function emitSelection(originalEvent) {
-		if (isDisabled.value) return void 0;
-		const selectEvent = createSelectEvent(originalEvent, props.value);
-		emitSelect(selectEvent);
-		options.afterSelect?.();
-		return selectEvent;
-	}
-	const registration = {
-		get id() {
-			return id.value;
-		},
-		element: () => element.value,
-		textValue: () => props.textValue ?? element.value?.textContent?.trim() ?? "",
-		disabled: () => isDisabled.value,
-		activate: emitSelection,
-		closeOnSelect: () => props.closeOnSelect ?? options.defaultCloseOnSelect
-	};
-	let itemInteraction = menu.connectItem(registration);
-	const focused = computed(() => {
-		return id.value === registration.id && itemInteraction.active.value;
-	});
-	watch(id, () => {
-		const previous = itemInteraction;
-		const wasActive = previous.active.value;
-		itemInteraction = menu.connectItem(registration);
-		previous.dispose();
-		if (wasActive) itemInteraction.setActive();
-	}, { flush: "sync" });
-	onBeforeUnmount(() => itemInteraction.dispose());
-	function setElement(value) {
-		resolveHTMLElementRef(value, id.value, (resolved) => {
-			element.value = resolved;
-		});
-	}
-	function activate(originalEvent) {
-		itemInteraction.activate(originalEvent);
-	}
-	function onPointerenter() {
-		if (isDisabled.value) return;
-		itemInteraction.hover();
-	}
-	function select() {
-		itemInteraction.activate(new Event("select"));
-	}
-	return {
-		menu,
-		id,
-		element,
-		isDisabled,
-		focused,
-		checked: options.checked,
-		activate,
-		select,
-		setElement,
-		onPointerenter
-	};
-}
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-checkbox-item.vue
-var dropdown_menu_checkbox_item_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuCheckboxItem",
-	inheritAttrs: false,
-	__name: "dropdown-menu-checkbox-item",
-	props: {
-		modelValue: {
-			type: [Boolean, String],
-			default: void 0
-		},
-		defaultValue: {
-			type: [Boolean, String],
-			default: false
-		},
-		id: {},
-		as: { default: "button" },
-		textValue: {},
-		disabled: {
-			type: Boolean,
-			default: false
-		},
-		destructive: {
-			type: Boolean,
-			default: false
-		},
-		closeOnSelect: {
-			type: Boolean,
-			default: false
-		}
-	},
-	emits: ["select", "update:modelValue"],
-	setup(__props, { emit: __emit }) {
-		const props = __props;
-		const emit = __emit;
-		const attrs = useAttrs();
-		const controllable = useControllableValue({
-			modelValue: () => props.modelValue,
-			defaultValue: () => props.defaultValue,
-			onChange: (value) => emit("update:modelValue", value)
-		});
-		const value = controllable.value;
-		const checked = computed(() => value.value === "indeterminate" ? "mixed" : value.value);
-		const state = computed(() => value.value === "indeterminate" ? "indeterminate" : value.value ? "checked" : "unchecked");
-		function toggleChecked() {
-			const nextValue = value.value === "indeterminate" ? true : !value.value;
-			controllable.setValue(nextValue);
-		}
-		provide(checkedKey, {
-			state,
-			checked: computed(() => value.value !== false)
-		});
-		const { id, isDisabled, focused, activate, select, setElement, onPointerenter } = usePrimitiveItem("RpDropdownMenuCheckboxItem", props, (event) => emit("select", event), {
-			checked,
-			defaultCloseOnSelect: false,
-			afterSelect: toggleChecked
-		});
-		function onClick(event) {
-			if (!event.defaultPrevented) activate(event);
-		}
-		const rootAttrs = computed(() => mergeProps(attrs, {
-			id: id.value,
-			type: props.as === "button" ? "button" : void 0,
-			role: "menuitemcheckbox",
-			tabindex: -1,
-			disabled: props.as === "button" ? toOptionalAttribute(isDisabled.value) : void 0,
-			"aria-disabled": toOptionalAttribute(isDisabled.value),
-			"aria-checked": checked.value,
-			"data-disabled": toOptionalAttribute(isDisabled.value),
-			"data-focused": toOptionalAttribute(focused.value),
-			"data-highlighted": toOptionalAttribute(focused.value),
-			"data-state": state.value,
-			class: bem("rp-dropdown-menu__item", {
-				focused: focused.value,
-				disabled: isDisabled.value,
-				destructive: props.destructive
-			}),
-			onClick,
-			onMouseenter: onPointerenter
-		}));
-		const n1 = createDynamicComponent(() => __props.as, { $: [() => rootAttrs.value] }, extend(() => {
-			return createSlot("default", {
-				focused: () => unref(focused),
-				disabled: () => unref(isDisabled),
-				select: () => unref(select)
-			});
-		}, { _: 8 }), 1);
-		setTemplateRefBinding(n1, () => setElement, void 0, void 0, "setElement");
-		return n1;
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/useDropdownMenuPrimitiveContent.ts
-function useDropdownMenuPrimitiveContent(props, attrs, events, submenu) {
-	const componentName = submenu ? "RpDropdownMenuSubContent" : "RpDropdownMenuContent";
-	const root = useRequiredInject(rootKey, componentName);
-	const sub = submenu ? useRequiredInject(subKey, componentName) : void 0;
-	const generatedId = useId();
-	const id = computed(() => props.id ?? `${generatedId}-${submenu ? "submenu" : "menu"}`);
-	const element = ref(null);
-	const arrowElement = ref(null);
-	const defaultPlacement = submenu ? "right-start" : "bottom-start";
-	const actualPlacement = ref(props.placement ?? defaultPlacement);
-	const isOpen = computed(() => sub ? sub.isOpen.value : root.isOpen.value);
-	const reference = computed(() => sub ? sub.trigger.value : root.reference.value);
-	const menu = createMenuContext({
-		root,
-		element,
-		actualPlacement,
-		parentSub: sub,
-		onEscape(event) {
-			const customEvent = createCancelableCustomEvent("dropdown-menu-escape-key-down", { originalEvent: event }, event);
-			events.escapeKeyDown(customEvent);
-			return !customEvent.defaultPrevented;
-		}
-	});
-	const cleanupDismissal = submenu ? void 0 : root.interaction.connectDismissal({
-		ignoredTargets: () => props.ignore ?? [],
-		pointerDownOutside: events.pointerDownOutside,
-		focusOutside: events.focusOutside,
-		interactOutside: events.interactOutside
-	});
-	const floating = useFloatingPosition({
-		reference,
-		floating: element,
-		arrow: arrowElement,
-		open: isOpen,
-		placement: () => props.placement ?? defaultPlacement,
-		strategy: () => props.strategy ?? "absolute",
-		offset: () => props.offset,
-		flip: () => props.flip !== false,
-		flipOptions: () => props.flipOptions,
-		shift: () => props.shift !== false,
-		collisionPadding: () => props.collisionPadding ?? 8,
-		autoUpdateOptions: () => props.autoUpdateOptions
-	});
-	watch(floating.actualPlacement, (value) => {
-		actualPlacement.value = value;
-	}, { immediate: true });
-	const shouldRender = computed(() => props.forceMount === true || isOpen.value);
-	let layerBranchCleanup;
-	let disconnectInside;
-	provide(menuKey, menu);
-	if (sub) sub.menu = menu;
-	function setElement(value) {
-		resolveHTMLElementRef(value, id.value, (resolved) => {
-			disconnectInside?.();
-			disconnectInside = void 0;
-			layerBranchCleanup?.();
-			layerBranchCleanup = void 0;
-			element.value = resolved;
-			if (resolved) disconnectInside = root.connectInside(resolved);
-			if (!sub) root.layer.element.value = resolved;
-			else if (resolved) layerBranchCleanup = root.layer.registerBranch(resolved);
-		});
-	}
-	watch(isOpen, (open) => {
-		if (!open) return;
-		nextTick(menu.interaction.focusPending);
-	}, {
-		flush: "post",
-		immediate: true
-	});
-	onMounted(() => {
-		if (sub) sub.contentId.value = id.value;
-		else root.contentId.value = id.value;
-		if (isOpen.value) menu.interaction.focusPending();
-	});
-	onBeforeUnmount(() => {
-		cleanupDismissal?.();
-		disconnectInside?.();
-		layerBranchCleanup?.();
-		if (!sub && root.layer.element.value === element.value) root.layer.element.value = null;
-		if (sub) sub.menu = null;
-		else if (root.contentId.value === id.value) root.contentId.value = void 0;
-	});
-	const placementSide = computed(() => floating.actualPlacement.value.split("-")[0]);
-	const placementAlign = computed(() => floating.actualPlacement.value.split("-")[1] ?? "center");
-	const rootAttrs = computed(() => mergeProps(attrs, {
-		id: id.value,
-		role: "menu",
-		tabindex: -1,
-		hidden: toOptionalAttribute(!isOpen.value),
-		class: submenu ? bem("rp-dropdown-menu__submenu", {
-			compound: true,
-			open: isOpen.value
-		}) : bem("rp-dropdown-menu__content", {
-			compound: true,
-			open: isOpen.value
-		}),
-		style: [
-			floating.floatingStyle.value,
-			{ zIndex: root.layer.zIndex.value },
-			!isOpen.value ? { display: "none" } : void 0
-		],
-		"aria-label": props.ariaLabel,
-		"aria-labelledby": props.ariaLabelledby ?? (submenu ? void 0 : root.triggerId.value),
-		"aria-describedby": props.ariaDescribedby,
-		"aria-activedescendant": menu.interaction.activeId.value ?? void 0,
-		"data-state": isOpen.value ? "open" : "closed",
-		"data-placement": floating.actualPlacement.value,
-		"data-side": placementSide.value,
-		"data-align": placementAlign.value,
-		onKeydown: menu.interaction.onKeydown
-	}));
-	function close() {
-		if (sub) sub.close(true);
-		else root.close({ returnFocus: true });
-	}
-	return {
-		id,
-		element,
-		arrowElement,
-		actualPlacement,
-		isOpen,
-		shouldRender,
-		placementSide,
-		rootAttrs,
-		floating,
-		setElement,
-		close
-	};
-}
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-content.vue?vue&type=script&setup=true&vapor=true&lang.ts
-var t0$2 = template("<span class=rp-dropdown-menu__arrow aria-hidden=true>");
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-content.vue
-var dropdown_menu_content_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuContent",
-	inheritAttrs: false,
-	__name: "dropdown-menu-content",
-	props: {
-		id: {},
-		as: { default: "div" },
-		placement: { default: "bottom-start" },
-		offset: {},
-		strategy: { default: "absolute" },
-		flip: {
-			type: Boolean,
-			default: true
-		},
-		flipOptions: {},
-		shift: {
-			type: Boolean,
-			default: true
-		},
-		collisionPadding: { default: 8 },
-		autoUpdateOptions: {},
-		arrow: {
-			type: Boolean,
-			default: false
-		},
-		forceMount: {
-			type: Boolean,
-			default: false
-		},
-		ignore: {},
-		ariaLabel: {},
-		ariaLabelledby: {},
-		ariaDescribedby: {}
-	},
-	emits: [
-		"escapeKeyDown",
-		"pointerDownOutside",
-		"focusOutside",
-		"interactOutside"
-	],
-	setup(__props, { emit: __emit }) {
-		const props = __props;
-		const emit = __emit;
-		const { arrowElement, actualPlacement, isOpen, shouldRender, placementSide, rootAttrs, floating, setElement, close } = useDropdownMenuPrimitiveContent(props, useAttrs(), {
-			escapeKeyDown: (event) => emit("escapeKeyDown", event),
-			pointerDownOutside: (event) => emit("pointerDownOutside", event),
-			focusOutside: (event) => emit("focusOutside", event),
-			interactOutside: (event) => emit("interactOutside", event)
-		}, false);
-		const templateRefs = { arrow: arrowElement };
-		const _setTemplateRef = createTemplateRefSetter();
-		return createIf(() => unref(shouldRender), () => {
-			const n6 = createDynamicComponent(() => __props.as, { $: [() => unref(rootAttrs)] }, extend(() => {
-				return [createIf(() => __props.arrow, () => {
-					const n4 = t0$2();
-					renderEffect(() => {
-						setAttr(n4, "data-side", unref(placementSide));
-						setStyle(n4, unref(floating).arrowStyle.value);
-						_setTemplateRef(n4, templateRefs.arrow);
-					});
-					return n4;
-				}, null, 129), createSlot("default", {
-					isOpen: () => unref(isOpen),
-					placement: () => unref(actualPlacement),
-					close: () => unref(close)
-				})];
-			}, { _: 8 }), 1);
-			setTemplateRefBinding(n6, () => setElement, void 0, void 0, "setElement");
-			return n6;
-		});
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/useDropdownMenuContextTrigger.ts
-function useDropdownMenuContextTrigger(props) {
-	const attrs = useAttrs();
-	const root = useRequiredInject(rootKey, "RpDropdownMenuContextTrigger");
-	const generatedId = useId();
-	const id = computed(() => props.id ?? `${generatedId}-context-trigger`);
-	const element = ref(null);
-	const isDisabled = computed(() => root.disabled.value || props.disabled);
-	let timer;
-	let pointerId;
-	let startPoint;
-	let longPressOpened = false;
-	let suppressUntil = 0;
-	let disconnectInside;
-	function setElement(value) {
-		resolveHTMLElementRef(value, id.value, (resolved) => {
-			disconnectInside?.();
-			disconnectInside = void 0;
-			element.value = resolved;
-			if (resolved) disconnectInside = root.connectInside(resolved);
-			if (!root.triggerId.value) root.triggerId.value = id.value;
-		});
-	}
-	function clearLongPress() {
-		if (timer) clearTimeout(timer);
-		timer = void 0;
-		pointerId = void 0;
-		startPoint = void 0;
-		element.value?.ownerDocument.defaultView?.removeEventListener("scroll", clearLongPress, true);
-	}
-	function openAt(point) {
-		root.setReturnFocus(element.value);
-		root.openAt(point);
-	}
-	function onContextmenu(event) {
-		if (isDisabled.value) return;
-		event.preventDefault();
-		if (Date.now() < suppressUntil) return;
-		openAt({
-			x: event.clientX,
-			y: event.clientY
-		});
-	}
-	function onKeydown(event) {
-		if (isDisabled.value) return;
-		if (event.key !== "ContextMenu" && !(event.shiftKey && event.key === "F10")) return;
-		event.preventDefault();
-		const rect = element.value?.getBoundingClientRect();
-		openAt({
-			x: rect?.left ?? 0,
-			y: rect?.bottom ?? 0
-		});
-	}
-	function onPointerdown(event) {
-		if (isDisabled.value || event.pointerType !== "touch" && event.pointerType !== "pen") return;
-		clearLongPress();
-		pointerId = event.pointerId;
-		startPoint = {
-			x: event.clientX,
-			y: event.clientY
-		};
-		longPressOpened = false;
-		(element.value?.ownerDocument.defaultView)?.addEventListener("scroll", clearLongPress, true);
-		timer = setTimeout(() => {
-			if (!startPoint) return;
-			longPressOpened = true;
-			suppressUntil = Date.now() + 1e3;
-			openAt(startPoint);
-			timer = void 0;
-		}, props.longPressDelay);
-	}
-	function onPointermove(event) {
-		if (event.pointerId !== pointerId || !startPoint) return;
-		if (Math.hypot(event.clientX - startPoint.x, event.clientY - startPoint.y) > (props.longPressTolerance ?? 0)) clearLongPress();
-	}
-	function finishPointer(event) {
-		if (event.pointerId !== pointerId) return;
-		if (longPressOpened) event.preventDefault();
-		clearLongPress();
-	}
-	function onClick(event) {
-		if (Date.now() >= suppressUntil) return;
-		event.preventDefault();
-		event.stopPropagation();
-	}
-	const rootAttrs = computed(() => mergeProps(attrs, {
-		id: id.value,
-		"aria-controls": root.contentId.value,
-		"aria-haspopup": "menu",
-		"aria-disabled": toOptionalAttribute(isDisabled.value),
-		"data-state": root.isOpen.value ? "open" : "closed",
-		"data-disabled": toOptionalAttribute(isDisabled.value),
-		onClick,
-		onContextmenu,
-		onKeydown,
-		onPointerdown,
-		onPointermove,
-		onPointerup: finishPointer,
-		onPointercancel: finishPointer
-	}));
-	onBeforeUnmount(() => {
-		clearLongPress();
-		disconnectInside?.();
-		if (root.triggerId.value === id.value) root.triggerId.value = void 0;
-	});
-	return {
-		isOpen: root.isOpen,
-		rootAttrs,
-		setElement
-	};
-}
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-context-trigger.vue
-var dropdown_menu_context_trigger_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuContextTrigger",
-	inheritAttrs: false,
-	__name: "dropdown-menu-context-trigger",
-	props: {
-		id: {},
-		as: { default: "span" },
-		disabled: {
-			type: Boolean,
-			default: false
-		},
-		longPressDelay: { default: 700 },
-		longPressTolerance: { default: 10 }
-	},
-	setup(__props) {
-		const { isOpen, rootAttrs, setElement } = useDropdownMenuContextTrigger(__props);
-		const n1 = createDynamicComponent(() => __props.as, { $: [() => unref(rootAttrs)] }, extend(() => {
-			return createSlot("default", { isOpen: () => unref(isOpen) });
-		}, { _: 8 }), 1);
-		setTemplateRefBinding(n1, () => setElement, void 0, void 0, "setElement");
-		return n1;
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-item.vue
-var dropdown_menu_item_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuItem",
-	inheritAttrs: false,
-	__name: "dropdown-menu-item",
-	props: {
-		id: {},
-		as: { default: "button" },
-		value: {},
-		textValue: {},
-		disabled: {
-			type: Boolean,
-			default: false
-		},
-		destructive: {
-			type: Boolean,
-			default: false
-		},
-		closeOnSelect: {
-			type: Boolean,
-			default: true
-		}
-	},
-	emits: ["select"],
-	setup(__props, { emit: __emit }) {
-		const props = __props;
-		const emit = __emit;
-		const attrs = useAttrs();
-		const { id, isDisabled, focused, activate, select, setElement, onPointerenter } = usePrimitiveItem("RpDropdownMenuItem", props, (event) => emit("select", event), { defaultCloseOnSelect: true });
-		function onClick(event) {
-			if (!event.defaultPrevented) activate(event);
-		}
-		const rootAttrs = computed(() => mergeProps(attrs, {
-			id: id.value,
-			type: props.as === "button" ? "button" : void 0,
-			role: "menuitem",
-			tabindex: -1,
-			disabled: props.as === "button" ? toOptionalAttribute(isDisabled.value) : void 0,
-			"aria-disabled": toOptionalAttribute(isDisabled.value),
-			"data-disabled": toOptionalAttribute(isDisabled.value),
-			"data-focused": toOptionalAttribute(focused.value),
-			"data-highlighted": toOptionalAttribute(focused.value),
-			class: bem("rp-dropdown-menu__item", {
-				focused: focused.value,
-				disabled: isDisabled.value,
-				destructive: props.destructive
-			}),
-			onClick,
-			onMouseenter: onPointerenter
-		}));
-		const n1 = createDynamicComponent(() => __props.as, { $: [() => rootAttrs.value] }, extend(() => {
-			return createSlot("default", {
-				focused: () => unref(focused),
-				disabled: () => unref(isDisabled),
-				select: () => unref(select)
-			});
-		}, { _: 8 }), 1);
-		setTemplateRefBinding(n1, () => setElement, void 0, void 0, "setElement");
-		return n1;
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-item-indicator.vue
-var dropdown_menu_item_indicator_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuItemIndicator",
-	inheritAttrs: false,
-	__name: "dropdown-menu-item-indicator",
-	props: {
-		as: { default: "span" },
-		forceMount: {
-			type: Boolean,
-			default: false
-		}
-	},
-	setup(__props) {
-		const attrs = useAttrs();
-		const context = useRequiredInject(checkedKey, "RpDropdownMenuItemIndicator");
-		const rootAttrs = computed(() => mergeProps(attrs, {
-			class: "rp-dropdown-menu__indicator",
-			"data-state": context.state.value,
-			"aria-hidden": true
-		}));
-		return createIf(() => __props.forceMount || unref(context).checked.value, () => {
-			return createDynamicComponent(() => __props.as, { $: [() => rootAttrs.value] }, extend(() => {
-				return createSlot("default", {
-					state: () => unref(context).state.value,
-					checked: () => unref(context).checked.value
-				});
-			}, { _: 8 }), 1);
-		});
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-label.vue
-var dropdown_menu_label_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuLabel",
-	inheritAttrs: false,
-	__name: "dropdown-menu-label",
-	props: {
-		id: {},
-		as: { default: "div" }
-	},
-	setup(__props) {
-		const props = __props;
-		const attrs = useAttrs();
-		useRequiredInject(menuKey, "RpDropdownMenuLabel");
-		const rootAttrs = computed(() => mergeProps(attrs, {
-			id: props.id,
-			role: "presentation",
-			class: "rp-dropdown-menu__group-label"
-		}));
-		return createDynamicComponent(() => __props.as, { $: [() => rootAttrs.value] }, extend(() => {
-			return createSlot();
-		}, { _: 8 }), 1);
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-portal.vue
-var dropdown_menu_portal_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuPortal",
-	__name: "dropdown-menu-portal",
-	props: {
-		to: { default: void 0 },
-		disabled: {
-			type: Boolean,
-			default: false
-		},
-		teleport: {
-			type: Boolean,
-			default: true
-		},
-		teleportTo: { default: void 0 }
-	},
-	setup(__props) {
-		const props = __props;
-		const teleportTo = provideTeleportTarget({ get teleportTo() {
-			return props.to ?? props.teleportTo;
-		} });
-		return createComponent(VaporTeleport, {
-			to: () => unref(teleportTo),
-			disabled: () => __props.disabled || !__props.teleport
-		}, extend(() => {
-			return createSlot();
-		}, { _: 8 }), true);
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-radio-group.vue
-var dropdown_menu_radio_group_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuRadioGroup",
-	inheritAttrs: false,
-	__name: "dropdown-menu-radio-group",
-	props: {
-		id: {},
-		as: { default: "div" },
-		modelValue: { default: void 0 },
-		defaultValue: { default: null },
-		ariaLabel: {},
-		ariaLabelledby: {}
-	},
-	emits: ["update:modelValue"],
-	setup(__props, { emit: __emit }) {
-		const props = __props;
-		const emit = __emit;
-		const attrs = useAttrs();
-		useRequiredInject(menuKey, "RpDropdownMenuRadioGroup");
-		const controllable = useControllableValue({
-			modelValue: () => props.modelValue,
-			defaultValue: () => props.defaultValue,
-			onChange: (value) => {
-				if (value !== null) emit("update:modelValue", value);
-			}
-		});
-		const value = controllable.value;
-		function select(nextValue) {
-			if (value.value === nextValue) return;
-			controllable.setValue(nextValue);
-		}
-		provide(radioGroupKey, {
-			value,
-			select
-		});
-		const rootAttrs = computed(() => mergeProps(attrs, {
-			id: props.id,
-			role: "group",
-			class: "rp-dropdown-menu__radio-group",
-			"aria-label": props.ariaLabel,
-			"aria-labelledby": props.ariaLabelledby
-		}));
-		return createDynamicComponent(() => __props.as, { $: [() => rootAttrs.value] }, extend(() => {
-			return createSlot("default", { value: () => unref(value) });
-		}, { _: 8 }), 1);
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-radio-item.vue
-var dropdown_menu_radio_item_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuRadioItem",
-	inheritAttrs: false,
-	__name: "dropdown-menu-radio-item",
-	props: {
-		value: {},
-		id: {},
-		as: { default: "button" },
-		textValue: {},
-		disabled: {
-			type: Boolean,
-			default: false
-		},
-		destructive: {
-			type: Boolean,
-			default: false
-		},
-		closeOnSelect: {
-			type: Boolean,
-			default: false
-		}
-	},
-	emits: ["select"],
-	setup(__props, { emit: __emit }) {
-		const props = __props;
-		const emit = __emit;
-		const attrs = useAttrs();
-		const group = useRequiredInject(radioGroupKey, "RpDropdownMenuRadioItem");
-		const isChecked = computed(() => group.value.value === props.value);
-		const checked = computed(() => isChecked.value);
-		const state = computed(() => isChecked.value ? "checked" : "unchecked");
-		provide(checkedKey, {
-			state,
-			checked: isChecked
-		});
-		const { id, isDisabled, focused, activate, select, setElement, onPointerenter } = usePrimitiveItem("RpDropdownMenuRadioItem", props, (event) => emit("select", event), {
-			checked,
-			defaultCloseOnSelect: false,
-			afterSelect: () => group.select(props.value)
-		});
-		function onClick(event) {
-			if (!event.defaultPrevented) activate(event);
-		}
-		const rootAttrs = computed(() => mergeProps(attrs, {
-			id: id.value,
-			type: props.as === "button" ? "button" : void 0,
-			role: "menuitemradio",
-			tabindex: -1,
-			disabled: props.as === "button" ? toOptionalAttribute(isDisabled.value) : void 0,
-			"aria-disabled": toOptionalAttribute(isDisabled.value),
-			"aria-checked": checked.value,
-			"data-disabled": toOptionalAttribute(isDisabled.value),
-			"data-focused": toOptionalAttribute(focused.value),
-			"data-highlighted": toOptionalAttribute(focused.value),
-			"data-state": state.value,
-			class: bem("rp-dropdown-menu__item", {
-				focused: focused.value,
-				disabled: isDisabled.value,
-				destructive: props.destructive
-			}),
-			onClick,
-			onMouseenter: onPointerenter
-		}));
-		const n1 = createDynamicComponent(() => __props.as, { $: [() => rootAttrs.value] }, extend(() => {
-			return createSlot("default", {
-				focused: () => unref(focused),
-				disabled: () => unref(isDisabled),
-				select: () => unref(select)
-			});
-		}, { _: 8 }), 1);
-		setTemplateRefBinding(n1, () => setElement, void 0, void 0, "setElement");
-		return n1;
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/dropdownMenuInteractionNavigation.ts
-function createDropdownMenuInteractionNavigation({ host, registry, closeRoot }) {
-	const state = registry.state;
-	function closeMenu(menuId, focusParent = false) {
-		const menu = registry.getMenu(menuId);
-		const menuState = state.getMenuState(menuId);
-		if (!menu && !menuState || menuId === host.rootMenuId) return false;
-		const wasOpen = registry.isMenuOpen(menuId);
-		closeSubmenus(menuId);
-		const shouldRestoreParent = focusParent || registry.activeMenuId.value === menuId;
-		if (wasOpen) state.setMenuOpen(menuId, false);
-		state.clearPendingMenuFocus(menuId);
-		state.clearMenuState(menuId);
-		if (shouldRestoreParent) {
-			const parentItem = state.getParentItem(menuId);
-			if (!parentItem || !registry.setActive(parentItem.id, focusParent)) {
-				const parentMenuId = parentItem?.menuId ?? host.rootMenuId;
-				registry.activeMenuId.value = parentMenuId;
-				registry.activeItemId.value = state.getActiveIdValue(parentMenuId);
-				if (focusParent) registry.focusMenuElement(parentMenuId);
-			}
-		}
-		return wasOpen;
-	}
-	function closeSubmenus(menuId, exceptMenuId) {
-		for (const item of state.getItems(menuId)) {
-			const submenuId = item.submenuId?.();
-			if (!submenuId || submenuId === exceptMenuId) continue;
-			closeMenu(submenuId, false);
-		}
-	}
-	function closeAllSubmenus() {
-		closeSubmenus(host.rootMenuId);
-		for (const menuId of state.getMenuIds()) if (menuId !== host.rootMenuId && registry.isMenuOpen(menuId)) closeMenu(menuId, false);
-	}
-	function focusMenu(menuId, target = "first") {
-		const enabledItems = state.getEnabledItems(menuId);
-		const item = target === "last" ? enabledItems.at(-1) : enabledItems[0];
-		registry.focusMenuElement(menuId);
-		if (!item) {
-			state.clearMenuState(menuId);
-			registry.activeMenuId.value = menuId;
-			const parentItem = state.getParentItem(menuId);
-			if (parentItem) registry.activeItemId.value = parentItem.id;
-			return false;
-		}
-		return registry.setActive(item.id);
-	}
-	function openMenu(menuId, focus = "first") {
-		const menu = registry.getMenu(menuId);
-		const menuState = state.getMenuState(menuId);
-		if (!menu && !menuState || menuId === host.rootMenuId) return false;
-		const parentItem = state.getParentItem(menuId);
-		if (!parentItem || parentItem.disabled()) return false;
-		closeSubmenus(parentItem.menuId, menuId);
-		state.setPendingMenuFocus(menuId, focus);
-		state.setMenuOpen(menuId, true);
-		if (focus && menu) focusMenu(menuId, focus);
-		return true;
-	}
-	function selectItem(id, originalEvent = new Event("select")) {
-		const item = registry.getItem(id);
-		if (!item || item.disabled()) return;
-		const selectEvent = item.select?.(originalEvent);
-		if (selectEvent && !selectEvent.defaultPrevented && (item.closeOnSelect?.() ?? true)) closeRoot({ focusTrigger: true });
-	}
-	function activateItem(id, originalEvent = new Event("select")) {
-		const item = registry.getItem(id);
-		if (!item || item.disabled()) return;
-		const submenuId = item.submenuId?.();
-		if (submenuId) {
-			openMenu(submenuId, "first");
-			return;
-		}
-		selectItem(id, originalEvent);
-	}
-	function hoverItem(id, openSubmenu = false) {
-		const item = registry.getItem(id);
-		if (!item || item.disabled()) return;
-		registry.setActive(id);
-		const submenuId = item.submenuId?.();
-		if (openSubmenu && submenuId) openMenu(submenuId, false);
-		else closeSubmenus(item.menuId, submenuId && registry.isMenuOpen(submenuId) ? submenuId : void 0);
-	}
-	function reconcileOpenSubmenus() {
-		for (const menuId of state.getMenuIds()) {
-			if (menuId === host.rootMenuId || !registry.isMenuOpen(menuId)) continue;
-			const parentItem = state.getParentItem(menuId);
-			if (!parentItem || parentItem.disabled()) closeMenu(menuId, false);
-		}
-	}
-	function reconcile(menuId) {
-		const menuIds = menuId ? [menuId] : state.getRegisteredMenuIds();
-		for (const id of menuIds) {
-			const activeId = state.getActiveIdValue(id);
-			if (!activeId) continue;
-			const currentItems = state.getItems(id);
-			const activeIndex = currentItems.findIndex((item) => item.id === activeId);
-			const activeItem = currentItems[activeIndex];
-			if (activeItem && !activeItem.disabled()) continue;
-			state.chooseNeighbor(id, Math.max(0, activeIndex));
-		}
-		reconcileOpenSubmenus();
-	}
-	return {
-		closeMenu,
-		closeSubmenus,
-		closeAllSubmenus,
-		focusMenu,
-		openMenu,
-		selectItem,
-		activateItem,
-		hoverItem,
-		reconcile,
-		reconcileOpenSubmenus
-	};
-}
-//#endregion
-//#region src/components/dropdown-menu/dropdownMenuInteractionRegistry.ts
-function compareItems(left, right) {
-	const leftElement = left.element();
-	const rightElement = right.element();
-	if (leftElement && rightElement && leftElement !== rightElement && typeof Node !== "undefined") {
-		const position = leftElement.compareDocumentPosition(rightElement);
-		if (position & Node.DOCUMENT_POSITION_FOLLOWING) return -1;
-		if (position & Node.DOCUMENT_POSITION_PRECEDING) return 1;
-	}
-	return (left.order?.() ?? 0) - (right.order?.() ?? 0);
-}
-function scrollItemIntoView(item) {
-	nextTick(() => item.element()?.scrollIntoView?.({ block: "nearest" }));
-}
-function createDropdownMenuInteractionRegistry(host, navigation) {
-	const menus = /* @__PURE__ */ new Map();
-	const menuStates = /* @__PURE__ */ new Map();
-	const items = /* @__PURE__ */ new Map();
-	const activeIds = ref(/* @__PURE__ */ new Map());
-	const activeItemId = ref(null);
-	const activeMenuId = ref(host.rootMenuId);
-	const pendingRootFocus = ref("first");
-	const pendingMenuFocus = /* @__PURE__ */ new Map();
-	function getMenu(id) {
-		return menus.get(id);
-	}
-	function getMenuState(id) {
-		return menuStates.get(id);
-	}
-	function getItem(id) {
-		return items.get(id);
-	}
-	function getItems(menuId) {
-		return [...items.values()].filter((item) => item.menuId === menuId).sort(compareItems);
-	}
-	function getEnabledItems(menuId) {
-		return getItems(menuId).filter((item) => !item.disabled());
-	}
-	function getActiveIdValue(menuId) {
-		return activeIds.value.get(menuId) ?? null;
-	}
-	function setActiveId(menuId, id) {
-		const next = new Map(activeIds.value);
-		if (id) next.set(menuId, id);
-		else next.delete(menuId);
-		activeIds.value = next;
-	}
-	function getActiveId(menuId) {
-		return computed(() => getActiveIdValue(menuId));
-	}
-	function isMenuOpen(menuId) {
-		if (menuId === host.rootMenuId) return host.isOpen.value;
-		return menuStates.get(menuId)?.isOpen() ?? menus.get(menuId)?.isOpen() ?? false;
-	}
-	function focusMenuElement(menuId) {
-		nextTick(() => {
-			const menu = menus.get(menuId);
-			(menu?.focusTarget?.() ?? menu?.element())?.focus();
-		});
-	}
-	function clearMenuState(menuId) {
-		const activeId = getActiveIdValue(menuId);
-		if (activeId && activeItemId.value === activeId) activeItemId.value = null;
-		setActiveId(menuId, null);
-	}
-	function setActive(id, focusElement = false) {
-		if (id === null) {
-			clearMenuState(activeMenuId.value);
-			activeItemId.value = null;
-			return true;
-		}
-		const item = items.get(id);
-		if (!item || item.disabled()) return false;
-		setActiveId(item.menuId, item.id);
-		activeItemId.value = item.id;
-		activeMenuId.value = item.menuId;
-		pendingMenuFocus.delete(item.menuId);
-		if (focusElement) focusMenuElement(item.menuId);
-		scrollItemIntoView(item);
-		return true;
-	}
-	function isActive(id) {
-		return getActiveIdValue(items.get(id)?.menuId ?? "") === id;
-	}
-	function getParentItem(menuId) {
-		const parentItemId = menus.get(menuId)?.parentItemId?.();
-		if (parentItemId) {
-			const parentItem = items.get(parentItemId);
-			if (parentItem) return parentItem;
-		}
-		return [...items.values()].find((item) => item.submenuId?.() === menuId);
-	}
-	function setMenuOpen(menuId, open) {
-		const state = menuStates.get(menuId);
-		if (state) state.setOpen(open);
-		else menus.get(menuId)?.setOpen?.(open);
-	}
-	function chooseNeighbor(menuId, previousIndex) {
-		const currentItems = getItems(menuId);
-		const nextCandidates = currentItems.slice(Math.max(0, previousIndex));
-		const previousCandidates = [];
-		for (let index = Math.max(0, previousIndex) - 1; index >= 0; index -= 1) {
-			const item = currentItems[index];
-			if (item) previousCandidates.push(item);
-		}
-		const next = [...nextCandidates, ...previousCandidates].find((item) => !item.disabled());
-		if (next) setActive(next.id);
-		else {
-			clearMenuState(menuId);
-			focusMenuElement(menuId);
-		}
-	}
-	function unregisterItem(id) {
-		const item = items.get(id);
-		if (!item) return;
-		const previousIndex = getItems(item.menuId).findIndex((current) => current.id === id);
-		const submenuId = item.submenuId?.();
-		if (submenuId) navigation.closeMenu(submenuId, false);
-		items.delete(id);
-		if (getActiveIdValue(item.menuId) === id) chooseNeighbor(item.menuId, previousIndex);
-		navigation.reconcileOpenSubmenus();
-	}
-	function registerItem(registration) {
-		const previous = items.get(registration.id);
-		if (previous && previous.menuId !== registration.menuId && getActiveIdValue(previous.menuId) === previous.id) clearMenuState(previous.menuId);
-		items.set(registration.id, registration);
-		if (isMenuOpen(registration.menuId) && !getActiveIdValue(registration.menuId) && !registration.disabled()) {
-			const enabledItems = getEnabledItems(registration.menuId);
-			const candidate = pendingMenuFocus.get(registration.menuId) === "last" ? enabledItems.at(-1) : enabledItems[0];
-			if (candidate) setActive(candidate.id);
-		} else navigation.reconcile(registration.menuId);
-		return () => {
-			if (items.get(registration.id) === registration) unregisterItem(registration.id);
-		};
-	}
-	function unregisterMenu(id) {
-		if (!menus.get(id)) return;
-		navigation.closeSubmenus(id);
-		if (id !== host.rootMenuId) navigation.closeMenu(id, false);
-		clearMenuState(id);
-		menus.delete(id);
-	}
-	function registerMenu(registration) {
-		menus.set(registration.id, registration);
-		const pending = pendingMenuFocus.get(registration.id);
-		if (registration.isOpen() && pending) nextTick(() => navigation.focusMenu(registration.id, pending));
-		return () => {
-			if (menus.get(registration.id) === registration) unregisterMenu(registration.id);
-		};
-	}
-	function registerMenuState(registration) {
-		menuStates.set(registration.id, registration);
-		return () => {
-			if (menuStates.get(registration.id) !== registration) return;
-			menuStates.delete(registration.id);
-			pendingMenuFocus.delete(registration.id);
-			if (!menus.has(registration.id)) clearMenuState(registration.id);
-		};
-	}
-	return {
-		activeItemId,
-		activeMenuId,
-		pendingRootFocus,
-		registerMenu,
-		unregisterMenu,
-		registerMenuState,
-		registerItem,
-		unregisterItem,
-		getActiveId,
-		getItem,
-		getMenu,
-		isActive,
-		isMenuOpen,
-		setActive,
-		focusMenuElement,
-		state: {
-			getMenuState,
-			getItems,
-			getEnabledItems,
-			getActiveIdValue,
-			clearMenuState,
-			getParentItem,
-			setMenuOpen,
-			chooseNeighbor,
-			getMenuIds: () => /* @__PURE__ */ new Set([...menus.keys(), ...menuStates.keys()]),
-			getRegisteredMenuIds: () => [...menus.keys()],
-			getPendingMenuFocus: (menuId) => pendingMenuFocus.get(menuId),
-			setPendingMenuFocus: (menuId, focus) => pendingMenuFocus.set(menuId, focus),
-			clearPendingMenuFocus: (menuId) => pendingMenuFocus.delete(menuId)
-		}
-	};
-}
-//#endregion
-//#region src/components/dropdown-menu/useDropdownMenuInteractionDismissal.ts
-function createOutsideEvent(originalEvent) {
-	return createCancelableCustomEvent("dropdown-menu-interact-outside", { originalEvent }, originalEvent);
-}
-function blockNextDocumentClick(document) {
-	function blockDocumentClick(event) {
-		if (event.cancelable) event.preventDefault();
-		event.stopPropagation();
-		document.removeEventListener("click", blockDocumentClick, true);
-	}
-	document.addEventListener("click", blockDocumentClick, true);
-	document.defaultView?.setTimeout(() => document.removeEventListener("click", blockDocumentClick, true), 1e3);
-}
-function useDropdownMenuInteractionDismissal({ host, registry, closeRoot }) {
-	const inside = /* @__PURE__ */ new Set();
-	let dismissal;
-	let layerInteraction;
-	function registerInside(element) {
-		inside.add(element);
-		layerInteraction?.refresh();
-	}
-	function unregisterInside(element) {
-		inside.delete(element);
-		layerInteraction?.refresh();
-	}
-	function emitOutside(type, originalEvent) {
-		const outsideEvent = createOutsideEvent(originalEvent);
-		if (type === "pointer") dismissal?.pointerDownOutside?.(outsideEvent);
-		else dismissal?.focusOutside?.(outsideEvent);
-		dismissal?.interactOutside?.(outsideEvent);
-		return outsideEvent;
-	}
-	function blockModalInteraction(event) {
-		if (!host.modal.value) return;
-		if (event.cancelable) event.preventDefault();
-		event.stopPropagation();
-		const listenerDocument = event.currentTarget;
-		if (event.type === "pointerdown" && listenerDocument?.nodeType === 9) blockNextDocumentClick(listenerDocument);
-	}
-	function shouldIgnoreOutside(event) {
-		return isEventWithinTargets(event, (dismissal?.ignoredTargets() ?? []).map((target) => isRef(target) ? target.value : target));
-	}
-	function onDocumentPointer(event) {
-		if (shouldIgnoreOutside(event)) return;
-		const outsideEvent = emitOutside("pointer", event);
-		blockModalInteraction(event);
-		if (!outsideEvent.defaultPrevented) closeRoot({ focusTrigger: host.modal.value });
-	}
-	function onDocumentFocus(event) {
-		if (shouldIgnoreOutside(event)) return;
-		const outsideEvent = emitOutside("focus", event);
-		blockModalInteraction(event);
-		if (!outsideEvent.defaultPrevented) closeRoot({ focusTrigger: host.modal.value });
-		else if (host.modal.value) registry.focusMenuElement(registry.activeMenuId.value);
-	}
-	function registerDismissal(registration) {
-		layerInteraction?.();
-		dismissal = registration;
-		layerInteraction = host.connectLayerInteraction({
-			inside: () => [...inside],
-			pointerDownOutside: onDocumentPointer,
-			focusOutside: onDocumentFocus
-		});
-		return () => {
-			if (dismissal !== registration) return;
-			dismissal = void 0;
-			layerInteraction?.();
-			layerInteraction = void 0;
-		};
-	}
-	return {
-		registerInside,
-		unregisterInside,
-		registerDismissal
-	};
-}
-//#endregion
-//#region src/components/dropdown-menu/useDropdownMenuInteractionKeyboard.ts
-function getPlacementSide(placement) {
-	return placement.split("-")[0];
-}
-function useDropdownMenuInteractionKeyboard({ host, registry, navigation, openRoot, closeRoot }) {
-	const state = registry.state;
-	const typeaheadMenuId = ref(host.rootMenuId);
-	const typeahead = useTypeahead({
-		items: () => state.getItems(typeaheadMenuId.value),
-		activeIndex: () => state.getItems(typeaheadMenuId.value).findIndex((item) => item.id === state.getActiveIdValue(typeaheadMenuId.value)),
-		getKey: (item) => item.id,
-		getTextValue: (item) => item.textValue(),
-		isDisabled: (item) => item.disabled(),
-		scopeKey: () => typeaheadMenuId.value,
-		onMatch(item) {
-			registry.setActive(item.id);
-			navigation.closeSubmenus(item.menuId);
-		}
-	});
-	function move(menuId, direction) {
-		const enabledItems = state.getEnabledItems(menuId);
-		if (enabledItems.length === 0) {
-			state.clearMenuState(menuId);
-			return;
-		}
-		const currentIndex = enabledItems.findIndex((item) => item.id === state.getActiveIdValue(menuId));
-		const item = enabledItems[((currentIndex < 0 ? direction === 1 ? -1 : 0 : currentIndex) + direction + enabledItems.length) % enabledItems.length];
-		if (item) {
-			registry.setActive(item.id);
-			navigation.closeSubmenus(menuId);
-		}
-	}
-	function handleHorizontalKey(menuId, event, activeItem) {
-		const menu = registry.getMenu(menuId);
-		const isRight = event.key === "ArrowRight";
-		if (menuId !== host.rootMenuId && menu) {
-			if (isRight === (getPlacementSide(menu.placement()) === "left")) {
-				event.preventDefault();
-				if (menu.stopKeyPropagation) event.stopPropagation();
-				navigation.closeMenu(menuId, true);
-				return;
-			}
-		}
-		const submenuId = activeItem?.submenuId?.();
-		if (!activeItem || activeItem.disabled() || !submenuId) return;
-		const submenu = registry.getMenu(submenuId);
-		if (isRight !== (activeItem.submenuDirection?.() !== "left" && (!submenu || getPlacementSide(submenu.placement()) !== "left"))) return;
-		event.preventDefault();
-		if (menu?.stopKeyPropagation) event.stopPropagation();
-		navigation.openMenu(submenuId, "first");
-	}
-	function onMenuKeydown(menuId, event) {
-		const menu = registry.getMenu(menuId);
-		typeaheadMenuId.value = menuId;
-		if (typeahead.handleKey(event)) {
-			if (menu?.stopKeyPropagation) event.stopPropagation();
-			return;
-		}
-		const activeId = state.getActiveIdValue(menuId);
-		const activeItem = activeId ? registry.getItem(activeId) : void 0;
-		const stop = () => {
-			if (menu?.stopKeyPropagation) event.stopPropagation();
-		};
-		switch (event.key) {
-			case "ArrowDown":
-				event.preventDefault();
-				stop();
-				move(menuId, 1);
-				break;
-			case "ArrowUp":
-				event.preventDefault();
-				stop();
-				move(menuId, -1);
-				break;
-			case "Home":
-				event.preventDefault();
-				stop();
-				navigation.focusMenu(menuId, "first");
-				navigation.closeSubmenus(menuId);
-				break;
-			case "End":
-				event.preventDefault();
-				stop();
-				navigation.focusMenu(menuId, "last");
-				navigation.closeSubmenus(menuId);
-				break;
-			case "ArrowRight":
-			case "ArrowLeft":
-				handleHorizontalKey(menuId, event, activeItem);
-				break;
-			case "Enter":
-			case " ":
-				event.preventDefault();
-				stop();
-				if (activeItem) navigation.activateItem(activeItem.id, event);
-				break;
-			case "Escape":
-				event.preventDefault();
-				stop();
-				if (menu?.onEscape && !menu.onEscape(event)) return;
-				if (!navigation.closeMenu(menuId, true)) closeRoot({ focusTrigger: true });
-				break;
-			case "Tab":
-				closeRoot();
-				break;
-		}
-	}
-	function onTriggerKeydown(event, beforeOpen) {
-		if (host.disabled.value) return;
-		switch (event.key) {
-			case "Enter":
-			case " ":
-			case "ArrowDown":
-				event.preventDefault();
-				beforeOpen?.();
-				openRoot("first");
-				break;
-			case "ArrowUp":
-				event.preventDefault();
-				beforeOpen?.();
-				openRoot("last");
-				break;
-			case "Escape":
-				closeRoot({ focusTrigger: true });
-				break;
-		}
-	}
-	return {
-		onMenuKeydown,
-		onTriggerKeydown,
-		resetTypeahead: typeahead.reset
-	};
-}
-//#endregion
-//#region src/components/dropdown-menu/dropdownMenuInteraction.ts
-function resolveOpenFocusTarget(options) {
-	if (typeof options === "string") return options;
-	return options?.focus ?? "first";
-}
-function resolveKeyboardMenuId(rootMenuId, registry, event) {
-	const activeItemId = registry.activeItemId.value;
-	const activeItem = activeItemId ? registry.getItem(activeItemId) : void 0;
-	const openSubmenuId = activeItem?.submenuId?.();
-	if (openSubmenuId && registry.isMenuOpen(openSubmenuId)) {
-		if (event.key === "Escape") return openSubmenuId;
-		const opensLeft = activeItem?.submenuDirection?.() === "left" || registry.getMenu(openSubmenuId)?.placement().startsWith("left");
-		if (event.key === (opensLeft ? "ArrowRight" : "ArrowLeft")) return openSubmenuId;
-	}
-	if ([
-		"ArrowLeft",
-		"ArrowRight",
-		"Escape"
-	].includes(event.key) && registry.activeMenuId.value !== rootMenuId) return registry.activeMenuId.value;
-	return activeItem?.menuId ?? registry.activeMenuId.value;
-}
-function useDropdownMenuInteraction(host) {
-	let navigation;
-	const registry = createDropdownMenuInteractionRegistry(host, {
-		closeMenu: (menuId, focusParent) => navigation.closeMenu(menuId, focusParent),
-		closeSubmenus: (menuId, exceptMenuId) => navigation.closeSubmenus(menuId, exceptMenuId),
-		focusMenu: (menuId, target) => navigation.focusMenu(menuId, target),
-		reconcile: (menuId) => navigation.reconcile(menuId),
-		reconcileOpenSubmenus: () => navigation.reconcileOpenSubmenus()
-	});
-	function open(options) {
-		if (host.disabled.value) return;
-		host.beforeOpen?.();
-		registry.pendingRootFocus.value = resolveOpenFocusTarget(options);
-		host.setOpen(true);
-		navigation.focusMenu(host.rootMenuId, registry.pendingRootFocus.value);
-	}
-	function close(options = {}) {
-		host.beforeClose?.();
-		host.setOpen(false);
-		registry.pendingRootFocus.value = false;
-		navigation.closeAllSubmenus();
-		registry.state.clearMenuState(host.rootMenuId);
-		registry.activeItemId.value = null;
-		registry.activeMenuId.value = host.rootMenuId;
-		keyboard.resetTypeahead();
-		if (options.focusTrigger || options.returnFocus) host.focusTrigger();
-	}
-	function toggle() {
-		if (host.isOpen.value) close({ returnFocus: true });
-		else open();
-	}
-	function onTriggerClick(beforeToggle) {
-		beforeToggle?.();
-		toggle();
-	}
-	navigation = createDropdownMenuInteractionNavigation({
-		host,
-		registry,
-		closeRoot: close
-	});
-	const keyboard = useDropdownMenuInteractionKeyboard({
-		host,
-		registry,
-		navigation,
-		openRoot: open,
-		closeRoot: close
-	});
-	const dismissal = useDropdownMenuInteractionDismissal({
-		host,
-		registry,
-		closeRoot: close
-	});
-	function connectItem(menuId, options) {
-		const registration = {
-			id: options.id,
-			menuId,
-			element: options.element,
-			textValue: options.textValue,
-			disabled: options.disabled,
-			order: options.order,
-			submenuId: options.submenu ? () => options.submenu?.id : void 0,
-			submenuDirection: options.submenuDirection,
-			select: options.select,
-			closeOnSelect: options.closeOnSelect
-		};
-		const disconnect = registry.registerItem(registration);
-		const stopReconciliation = watch([
-			options.disabled,
-			options.element,
-			() => options.submenu?.id
-		], () => navigation.reconcile(menuId), { flush: "sync" });
-		let disposed = false;
-		return {
-			active: computed(() => registry.isActive(options.id)),
-			submenuOpen: computed(() => options.submenu ? registry.isMenuOpen(options.submenu.id) : false),
-			setActive: (focusElement = false) => registry.setActive(options.id, focusElement),
-			openSubmenu: (focus = "first") => options.submenu?.open(focus) ?? false,
-			closeSubmenu: (focusParent = false) => options.submenu?.close(focusParent) ?? false,
-			select: (originalEvent) => navigation.selectItem(options.id, originalEvent),
-			activate: (originalEvent) => navigation.activateItem(options.id, originalEvent),
-			hover(openSubmenu = false) {
-				navigation.hoverItem(options.id, openSubmenu);
-				return Boolean(options.submenu && registry.isMenuOpen(options.submenu.id));
-			},
-			dispose() {
-				if (disposed) return;
-				disposed = true;
-				stopReconciliation();
-				disconnect();
-			}
-		};
-	}
-	function connectMenu(id, options, state, getRequestedFocus) {
-		const disconnect = registry.registerMenu({
-			id,
-			...options,
-			...state
-		});
-		const items = /* @__PURE__ */ new Set();
-		let disposed = false;
-		return {
-			activeId: registry.getActiveId(id),
-			connectItem(itemOptions) {
-				const item = connectItem(id, itemOptions);
-				const dispose = item.dispose;
-				item.dispose = () => {
-					dispose();
-					items.delete(item);
-				};
-				items.add(item);
-				return item;
-			},
-			clearActive: () => {
-				registry.setActive(null);
-			},
-			focusPending() {
-				const pending = id === host.rootMenuId ? registry.pendingRootFocus.value : getRequestedFocus?.() ?? registry.state.getPendingMenuFocus(id);
-				return navigation.focusMenu(id, pending || "first");
-			},
-			onKeydown: (event) => keyboard.onMenuKeydown(id, event),
-			dispose() {
-				if (disposed) return;
-				disposed = true;
-				for (const item of items) item.dispose();
-				disconnect();
-			}
-		};
-	}
-	function connectRootMenu(options) {
-		return connectMenu(host.rootMenuId, options, { isOpen: () => host.isOpen.value });
-	}
-	function connectSubmenu(options) {
-		const disconnectState = registry.registerMenuState(options);
-		let requestedFocus;
-		const stopStateSync = watch(options.isOpen, (isOpen) => {
-			if (isOpen) return;
-			requestedFocus = void 0;
-			navigation.closeMenu(options.id, false);
-		}, { flush: "sync" });
-		let content;
-		let disposed = false;
-		return {
-			id: options.id,
-			open(focus = "first") {
-				requestedFocus = focus;
-				return navigation.openMenu(options.id, focus);
-			},
-			close(focusParent = false) {
-				requestedFocus = void 0;
-				return navigation.closeMenu(options.id, focusParent);
-			},
-			connectContent(menuOptions) {
-				const previous = content;
-				content = connectMenu(options.id, menuOptions, options, () => requestedFocus);
-				previous?.dispose();
-				return content;
-			},
-			dispose() {
-				if (disposed) return;
-				disposed = true;
-				content?.dispose();
-				stopStateSync();
-				disconnectState();
-			}
-		};
-	}
-	function connectInside(element) {
-		dismissal.registerInside(element);
-		let connected = true;
-		return () => {
-			if (!connected) return;
-			connected = false;
-			dismissal.unregisterInside(element);
-		};
-	}
-	watch(host.disabled, (disabled) => {
-		if (disabled) close();
-	});
-	watch(host.isOpen, (isOpen) => {
-		if (!isOpen) {
-			navigation.closeAllSubmenus();
-			registry.state.clearMenuState(host.rootMenuId);
-			registry.activeItemId.value = null;
-			registry.activeMenuId.value = host.rootMenuId;
-			keyboard.resetTypeahead();
-			return;
-		}
-		const focus = registry.pendingRootFocus.value || "first";
-		navigation.focusMenu(host.rootMenuId, focus);
-	}, { immediate: true });
-	return {
-		activeItemId: registry.activeItemId,
-		connectRootMenu,
-		connectSubmenu,
-		connectInside,
-		connectDismissal: dismissal.registerDismissal,
-		open,
-		close,
-		toggle,
-		onTriggerClick,
-		onTriggerKeydown: keyboard.onTriggerKeydown,
-		onMenuKeydown: (event) => keyboard.onMenuKeydown(resolveKeyboardMenuId(host.rootMenuId, registry, event), event)
-	};
-}
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-root.vue
-var dropdown_menu_root_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuRoot",
-	__name: "dropdown-menu-root",
-	props: {
-		id: {},
-		open: {
-			type: Boolean,
-			default: void 0
-		},
-		defaultOpen: {
-			type: Boolean,
-			default: false
-		},
-		baseZIndex: {},
-		disabled: {
-			type: Boolean,
-			default: false
-		},
-		modal: {
-			type: Boolean,
-			default: true
-		},
-		target: { default: null },
-		virtualAnchor: { default: null }
-	},
-	emits: ["update:open"],
-	setup(__props, { expose: __expose, emit: __emit }) {
-		const props = __props;
-		const emit = __emit;
-		const generatedId = useId();
-		const id = computed(() => props.id ?? `${generatedId}-dropdown-menu`);
-		const controllableOpen = useControllableValue({
-			modelValue: () => props.open,
-			defaultValue: () => props.defaultOpen,
-			onChange: (nextOpen) => emit("update:open", nextOpen)
-		});
-		const isOpen = controllableOpen.value;
-		const disabled = computed(() => props.disabled);
-		const modal = computed(() => props.modal);
-		const trigger = ref(null);
-		const triggerId = ref();
-		const contentId = ref();
-		const activeReference = shallowRef(null);
-		const { reference: configuredReference } = useFloatingTargetLifecycle({
-			target: () => props.target ?? props.virtualAnchor,
-			fallback: trigger
-		});
-		const reference = computed(() => activeReference.value ?? configuredReference.value);
-		const contentElement = ref(null);
-		let returnFocusElement = null;
-		const baseZIndex = useOverlayZIndex({
-			baseZIndex: () => props.baseZIndex,
-			defaultBaseZIndex: 100,
-			aboveParent: false
-		});
-		const layer = useOverlayLayer({
-			active: computed(() => isOpen.value && !disabled.value),
-			element: contentElement,
-			baseZIndex
-		});
-		function setOpen(value) {
-			if (value && disabled.value) return;
-			if (isOpen.value !== value) controllableOpen.setValue(value);
-		}
-		function rememberFocus() {
-			if (typeof document === "undefined" || returnFocusElement) return;
-			const activeElement = document.activeElement;
-			if (activeElement instanceof HTMLElement) returnFocusElement = activeElement;
-		}
-		function focusReturnTarget() {
-			const target = returnFocusElement ?? trigger.value;
-			nextTick(() => target?.focus());
-		}
-		const interactionRootMenuId = `${generatedId}-interaction-root`;
-		const interaction = useDropdownMenuInteraction({
-			rootMenuId: interactionRootMenuId,
-			isOpen,
-			disabled,
-			modal,
-			setOpen,
-			connectLayerInteraction: layer.connectInteraction,
-			focusTrigger: focusReturnTarget,
-			beforeOpen: rememberFocus
-		});
-		const { open, close, toggle } = interaction;
-		function openAt(point, options) {
-			activeReference.value = createVirtualAnchor(point);
-			open(options);
-		}
-		let disconnectTrigger;
-		function setTrigger(element, nextId) {
-			disconnectTrigger?.();
-			disconnectTrigger = void 0;
-			trigger.value = element;
-			triggerId.value = nextId;
-			if (element) disconnectTrigger = interaction.connectInside(element);
-		}
-		const context = {
-			id,
-			isOpen,
-			disabled,
-			modal,
-			trigger,
-			triggerId,
-			contentId,
-			reference,
-			interactionRootMenuId,
-			layer,
-			interaction,
-			open,
-			close,
-			toggle,
-			openAt,
-			setTrigger,
-			setReference(nextReference) {
-				activeReference.value = nextReference;
-			},
-			setReturnFocus(element) {
-				returnFocusElement = element;
-			},
-			connectInside: interaction.connectInside
-		};
-		const slotProps = computed(() => ({
-			isOpen: isOpen.value,
-			open,
-			close,
-			toggle,
-			openAt
-		}));
-		watch(isOpen, (value) => {
-			if (!value) activeReference.value = null;
-		}, { flush: "sync" });
-		provide(rootKey, context);
-		onBeforeUnmount(() => disconnectTrigger?.());
-		__expose({
-			open,
-			close,
-			toggle,
-			openAt
-		});
-		return createSlot("default", { $: [() => slotProps.value] });
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-separator.vue
-var dropdown_menu_separator_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuSeparator",
-	inheritAttrs: false,
-	__name: "dropdown-menu-separator",
-	props: {
-		id: {},
-		as: { default: "div" },
-		orientation: { default: "horizontal" }
-	},
-	setup(__props) {
-		const props = __props;
-		const attrs = useAttrs();
-		useRequiredInject(menuKey, "RpDropdownMenuSeparator");
-		const rootAttrs = computed(() => mergeProps(attrs, {
-			id: props.id,
-			role: "separator",
-			"aria-orientation": props.orientation,
-			class: "rp-dropdown-menu__separator",
-			"data-orientation": props.orientation
-		}));
-		return createDynamicComponent(() => __props.as, { $: [() => rootAttrs.value] }, null, 1);
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-sub.vue
-var dropdown_menu_sub_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuSub",
-	__name: "dropdown-menu-sub",
-	props: {
-		open: {
-			type: Boolean,
-			default: void 0
-		},
-		defaultOpen: {
-			type: Boolean,
-			default: false
-		}
-	},
-	emits: ["update:open"],
-	setup(__props, { emit: __emit }) {
-		const props = __props;
-		const emit = __emit;
-		const parentMenu = useRequiredInject(menuKey, "RpDropdownMenuSub");
-		const menuId = `${useId()}-interaction-menu`;
-		const controllableOpen = useControllableValue({
-			modelValue: () => props.open,
-			defaultValue: () => props.defaultOpen,
-			onChange: (open) => emit("update:open", open)
-		});
-		const isOpen = controllableOpen.value;
-		const trigger = ref(null);
-		const contentId = ref();
-		const actualPlacement = ref("right-start");
-		function setOpen(value) {
-			if (isOpen.value !== value) controllableOpen.setValue(value);
-		}
-		const interaction = parentMenu.root.interaction.connectSubmenu({
-			id: menuId,
-			parentItemId: () => trigger.value?.id,
-			isOpen: () => isOpen.value,
-			setOpen
-		});
-		const context = {
-			menuId,
-			isOpen,
-			trigger,
-			contentId,
-			actualPlacement,
-			menu: null,
-			interaction,
-			open(focus = "first") {
-				if (!interaction.open(focus)) setOpen(true);
-			},
-			close(focusParent = false) {
-				if (!interaction.close(focusParent)) setOpen(false);
-			}
-		};
-		provide(subKey, context);
-		onBeforeUnmount(interaction.dispose);
-		return createSlot("default", {
-			isOpen: () => unref(isOpen),
-			open: () => context.open,
-			close: () => context.close
-		});
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-sub-content.vue
-var dropdown_menu_sub_content_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuSubContent",
-	inheritAttrs: false,
-	__name: "dropdown-menu-sub-content",
-	props: {
-		placement: { default: "right-start" },
-		id: {},
-		as: { default: "div" },
-		offset: {},
-		strategy: { default: "absolute" },
-		flip: {
-			type: Boolean,
-			default: true
-		},
-		flipOptions: {},
-		shift: {
-			type: Boolean,
-			default: true
-		},
-		collisionPadding: { default: 8 },
-		autoUpdateOptions: {},
-		forceMount: {
-			type: Boolean,
-			default: false
-		},
-		ariaLabel: {},
-		ariaLabelledby: {},
-		ariaDescribedby: {}
-	},
-	emits: [
-		"escapeKeyDown",
-		"pointerDownOutside",
-		"focusOutside",
-		"interactOutside"
-	],
-	setup(__props, { emit: __emit }) {
-		const props = __props;
-		const emit = __emit;
-		const { actualPlacement, isOpen, shouldRender, rootAttrs, setElement, close } = useDropdownMenuPrimitiveContent(props, useAttrs(), {
-			escapeKeyDown: (event) => emit("escapeKeyDown", event),
-			pointerDownOutside: (event) => emit("pointerDownOutside", event),
-			focusOutside: (event) => emit("focusOutside", event),
-			interactOutside: (event) => emit("interactOutside", event)
-		}, true);
-		return createIf(() => unref(shouldRender), () => {
-			const n3 = createDynamicComponent(() => __props.as, { $: [() => unref(rootAttrs)] }, extend(() => {
-				return createSlot("default", {
-					isOpen: () => unref(isOpen),
-					placement: () => unref(actualPlacement),
-					close: () => unref(close)
-				});
-			}, { _: 8 }), 1);
-			setTemplateRefBinding(n3, () => setElement, void 0, void 0, "setElement");
-			return n3;
-		});
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-sub-trigger.vue
-var dropdown_menu_sub_trigger_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuSubTrigger",
-	inheritAttrs: false,
-	__name: "dropdown-menu-sub-trigger",
-	props: {
-		id: {},
-		as: { default: "button" },
-		textValue: {},
-		disabled: {
-			type: Boolean,
-			default: false
-		}
-	},
-	setup(__props) {
-		const props = __props;
-		const attrs = useAttrs();
-		const menu = useRequiredInject(menuKey, "RpDropdownMenuSubTrigger");
-		const sub = useRequiredInject(subKey, "RpDropdownMenuSubTrigger");
-		const generatedId = useId();
-		const id = computed(() => props.id ?? `${generatedId}-sub-trigger`);
-		const isDisabled = computed(() => menu.root.disabled.value || props.disabled);
-		const registration = {
-			get id() {
-				return id.value;
-			},
-			element: () => sub.trigger.value,
-			textValue: () => props.textValue ?? sub.trigger.value?.textContent?.trim() ?? "",
-			disabled: () => isDisabled.value,
-			activate: () => void 0,
-			submenu: sub
-		};
-		let itemInteraction = menu.connectItem(registration);
-		const focused = computed(() => {
-			return id.value === registration.id && itemInteraction.active.value;
-		});
-		watch(id, () => {
-			const previous = itemInteraction;
-			const wasActive = previous.active.value;
-			itemInteraction = menu.connectItem(registration);
-			previous.dispose();
-			if (wasActive) itemInteraction.setActive();
-		}, { flush: "sync" });
-		onBeforeUnmount(() => itemInteraction.dispose());
-		function setElement(value) {
-			resolveHTMLElementRef(value, id.value, (resolved) => {
-				sub.trigger.value = resolved;
-			});
-		}
-		function onMouseenter() {
-			if (isDisabled.value) return;
-			itemInteraction.hover(true);
-		}
-		function onClick(event) {
-			if (!event.defaultPrevented && !isDisabled.value) itemInteraction.activate(event);
-		}
-		const rootAttrs = computed(() => mergeProps(attrs, {
-			id: id.value,
-			type: props.as === "button" ? "button" : void 0,
-			role: "menuitem",
-			tabindex: -1,
-			disabled: props.as === "button" ? toOptionalAttribute(isDisabled.value) : void 0,
-			"aria-disabled": toOptionalAttribute(isDisabled.value),
-			"aria-haspopup": "menu",
-			"aria-expanded": sub.isOpen.value,
-			"aria-controls": sub.contentId.value,
-			"data-disabled": toOptionalAttribute(isDisabled.value),
-			"data-focused": toOptionalAttribute(focused.value),
-			"data-highlighted": toOptionalAttribute(focused.value),
-			"data-state": sub.isOpen.value ? "open" : "closed",
-			class: bem("rp-dropdown-menu__item", {
-				focused: focused.value,
-				disabled: isDisabled.value,
-				submenu: true,
-				open: sub.isOpen.value
-			}),
-			onClick,
-			onMouseenter
-		}));
-		const n1 = createDynamicComponent(() => __props.as, { $: [() => rootAttrs.value] }, extend(() => {
-			return createSlot("default", {
-				focused: () => focused.value,
-				disabled: () => isDisabled.value,
-				isOpen: () => unref(sub).isOpen.value,
-				open: () => unref(sub).open,
-				close: () => unref(sub).close
-			});
-		}, { _: 8 }), 1);
-		setTemplateRefBinding(n1, () => setElement);
-		return n1;
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-trigger.vue
-var dropdown_menu_trigger_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuTrigger",
-	inheritAttrs: false,
-	__name: "dropdown-menu-trigger",
-	props: {
-		id: {},
-		as: { default: "button" },
-		disabled: {
-			type: Boolean,
-			default: false
-		}
-	},
-	setup(__props) {
-		const props = __props;
-		const attrs = useAttrs();
-		const root = useRequiredInject(rootKey, "RpDropdownMenuTrigger");
-		const generatedId = useId();
-		const id = computed(() => props.id ?? `${generatedId}-trigger`);
-		const element = ref(null);
-		const isDisabled = computed(() => root.disabled.value || props.disabled);
-		function setElement(value) {
-			resolveHTMLElementRef(value, id.value, (resolved) => {
-				element.value = resolved;
-				root.setTrigger(resolved, id.value);
-			});
-		}
-		function prepareReference() {
-			root.setReference(element.value);
-			root.setReturnFocus(element.value);
-		}
-		function onClick(event) {
-			if (event.defaultPrevented || isDisabled.value) return;
-			root.interaction.onTriggerClick(prepareReference);
-		}
-		function onKeydown(event) {
-			if (isDisabled.value) return;
-			root.interaction.onTriggerKeydown(event, prepareReference);
-		}
-		const rootAttrs = computed(() => mergeProps(attrs, {
-			id: id.value,
-			type: props.as === "button" ? "button" : void 0,
-			disabled: props.as === "button" ? toOptionalAttribute(isDisabled.value) : void 0,
-			"aria-controls": root.contentId.value,
-			"aria-expanded": root.isOpen.value,
-			"aria-haspopup": "menu",
-			"aria-disabled": props.as === "button" ? void 0 : toOptionalAttribute(isDisabled.value),
-			"data-state": root.isOpen.value ? "open" : "closed",
-			"data-disabled": toOptionalAttribute(isDisabled.value),
-			onClick,
-			onKeydown
-		}));
-		onBeforeUnmount(() => root.setTrigger(null));
-		const n1 = createDynamicComponent(() => __props.as, { $: [() => rootAttrs.value] }, extend(() => {
-			return createSlot("default", { isOpen: () => unref(root).isOpen.value });
-		}, { _: 8 }), 1);
-		setTemplateRefBinding(n1, () => setElement);
-		return n1;
-	}
-});
-//#endregion
-//#region src/utils/indexPath.ts
-function getPathKey(path) {
-	return path.length === 0 ? "root" : path.join("-");
-}
-function arePathsEqual(a, b) {
-	return a.length === b.length && a.every((part, index) => part === b[index]);
-}
-function isPathPrefix(prefix, path) {
-	return prefix.length <= path.length && prefix.every((part, index) => part === path[index]);
-}
-function normalizePath(indexOrPath) {
-	return Array.isArray(indexOrPath) ? indexOrPath : [indexOrPath];
-}
-var DEFAULT_FOCUS_TARGET = "first";
-function getItemClass(item, focused, disabled, hasSubmenu, submenuOpen) {
-	return bem("rp-dropdown-menu__item", {
-		focused,
-		disabled,
-		destructive: item.destructive,
-		submenu: hasSubmenu,
-		open: submenuOpen
-	});
-}
-function hasItemSubmenu(item) {
-	return (item.children?.length ?? 0) > 0;
-}
-function hasNestedItems(items) {
-	return items.some(hasItemSubmenu);
-}
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-item-row.vue?vue&type=script&setup=true&vapor=true&lang.ts
-var t0$1 = template("<div>");
-var t1$1 = template("<div class=rp-dropdown-menu__item-wrap role=none><button></button>", 1);
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-item-row.vue
-var dropdown_menu_item_row_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuItemRow",
-	__name: "dropdown-menu-item-row",
-	props: {
-		context: {},
-		index: {},
-		item: {},
-		parentPath: {}
-	},
-	setup(__props) {
-		const props = __props;
-		const path = computed(() => [...props.parentPath, props.index]);
-		const hasSubmenu = computed(() => hasItemSubmenu(props.item));
-		const focused = computed(() => props.context.isItemFocused(path.value));
-		const disabled = computed(() => Boolean(props.item.disabled));
-		const submenuOpen = computed(() => hasSubmenu.value && props.context.isSubmenuOpen(path.value));
-		const itemProps = computed(() => props.context.getItemProps(props.item, path.value, focused.value, disabled.value, submenuOpen.value));
-		const publicItemProps = computed(() => ({
-			...itemProps.value,
-			...props.context.getPublicPartAttrs?.("item", { class: itemProps.value.class })
-		}));
-		const slotProps = computed(() => props.context.getItemSlotProps(props.item, path.value, focused.value, disabled.value, submenuOpen.value));
-		const itemElement = ref(null);
-		const submenuElement = ref(null);
-		const templateRefs = {
-			item: itemElement,
-			submenu: submenuElement
-		};
-		const { actualPlacement, floatingStyle } = useFloatingPosition({
-			reference: itemElement,
-			floating: submenuElement,
-			open: submenuOpen,
-			placement: props.context.getSubmenuPlacement,
-			strategy: props.context.getStrategy,
-			offset: () => 4,
-			flip: props.context.getFlip,
-			flipOptions: props.context.getFlipOptions,
-			shift: props.context.getShift,
-			collisionPadding: props.context.getCollisionPadding,
-			autoUpdateOptions: props.context.getAutoUpdateOptions
-		});
-		const submenuProps = computed(() => props.context.getSubmenuProps(props.item, path.value, true));
-		const publicSubmenuProps = computed(() => ({
-			...submenuProps.value,
-			...props.context.getPublicPartAttrs?.("submenu", {
-				class: submenuProps.value.class,
-				style: floatingStyle.value
-			})
-		}));
-		const placementSide = computed(() => actualPlacement.value.split("-")[0]);
-		function getChildKey(index, child) {
-			return `${getPathKey([...path.value, index])}:${String(child.value)}`;
-		}
-		const _component_DropdownMenuItemRow__self = resolveComponent("DropdownMenuItemRow", true);
-		const n10 = t1$1();
-		const n1 = child(n10);
-		renderEffect(() => setDynamicProps(n1, [publicItemProps.value]));
-		setInsertionState(n1, null, 0);
-		createSlot("item", { $: [() => slotProps.value] });
-		setTemplateRefBinding(n1, () => templateRefs.item);
-		setInsertionState(n10, null, 1);
-		createIf(() => hasSubmenu.value && submenuOpen.value, () => {
-			const n9 = t0$1();
-			renderEffect(() => setDynamicProps(n9, [publicSubmenuProps.value, {
-				"data-state": "open",
-				"data-placement": unref(actualPlacement),
-				"data-side": placementSide.value
-			}]));
-			setInsertionState(n9, null, 0);
-			createFor(() => __props.item.children ?? [], (_for_item0, _for_key0) => {
-				return createComponentWithFallback(_component_DropdownMenuItemRow__self, {
-					context: () => __props.context,
-					index: () => _for_key0.value,
-					item: () => _for_item0.value,
-					"parent-path": () => path.value
-				}, { "item": extend((childSlotProps) => {
-					return createSlot("item", { $: [() => childSlotProps] });
-				}, { _: 8 }) });
-			}, (child, childIndex) => getChildKey(childIndex, child), 3);
-			setTemplateRefBinding(n9, () => templateRefs.submenu);
-			return n9;
-		});
-		return n10;
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu-items.vue
-var dropdown_menu_items_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenuItems",
-	__name: "dropdown-menu-items",
-	props: {
-		context: {},
-		items: {},
-		parentPath: { default: () => [] }
-	},
-	setup(__props) {
-		const props = __props;
-		function getItemKey(index, item) {
-			return `${getPathKey([...props.parentPath, index])}:${String(item.value)}`;
-		}
-		return createFor(() => __props.items, (_for_item0, _for_key0) => {
-			return createComponent(dropdown_menu_item_row_default, {
-				context: () => __props.context,
-				index: () => _for_key0.value,
-				item: () => _for_item0.value,
-				"parent-path": () => __props.parentPath
-			}, { "item": extend((slotProps) => {
-				return createSlot("item", { $: [() => slotProps] });
-			}, { _: 8 }) });
-		}, (item, index) => getItemKey(index, item), 2);
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/dropdownMenuDataModel.ts
-function createDataIndexState(rootMenuId) {
-	return {
-		entries: [],
-		itemIdByPath: /* @__PURE__ */ new Map(),
-		pathByItemId: /* @__PURE__ */ new Map(),
-		menuIdByPath: /* @__PURE__ */ new Map([["root", rootMenuId]]),
-		pathByMenuId: /* @__PURE__ */ new Map([[rootMenuId, []]]),
-		primaryItemId: /* @__PURE__ */ new WeakMap(),
-		occurrences: /* @__PURE__ */ new Map()
-	};
-}
-function getOccurrenceItemId(item, state, getStableItemId) {
-	const occurrence = state.occurrences.get(item) ?? 0;
-	state.occurrences.set(item, occurrence + 1);
-	const stableItemId = getStableItemId(item);
-	return {
-		occurrence,
-		itemId: occurrence === 0 ? stableItemId : `${stableItemId}-copy-${occurrence}`
-	};
-}
-function indexItems(items, parentPath, ownerMenuId, state, getStableItemId) {
-	for (const [order, item] of items.entries()) {
-		const path = [...parentPath, order];
-		const pathKey = getPathKey(path);
-		const { itemId, occurrence } = getOccurrenceItemId(item, state, getStableItemId);
-		const submenuMenuId = hasItemSubmenu(item) ? `${itemId}-menu` : void 0;
-		state.entries.push({
-			item,
-			path,
-			itemId,
-			ownerMenuId,
-			order,
-			submenuMenuId
-		});
-		state.itemIdByPath.set(pathKey, itemId);
-		state.pathByItemId.set(itemId, path);
-		if (occurrence === 0) state.primaryItemId.set(item, itemId);
-		if (!submenuMenuId) continue;
-		state.menuIdByPath.set(pathKey, submenuMenuId);
-		state.pathByMenuId.set(submenuMenuId, path);
-		indexItems(item.children ?? [], path, submenuMenuId, state, getStableItemId);
-	}
-}
-function buildDropdownMenuDataIndex(items, rootMenuId, getStableItemId) {
-	const state = createDataIndexState(rootMenuId);
-	indexItems(items, [], rootMenuId, state, getStableItemId);
-	return {
-		entries: state.entries,
-		itemIdByPath: state.itemIdByPath,
-		pathByItemId: state.pathByItemId,
-		menuIdByPath: state.menuIdByPath,
-		pathByMenuId: state.pathByMenuId,
-		primaryItemId: state.primaryItemId
-	};
-}
-function getDropdownMenuDataCollectionState(items) {
-	const state = [];
-	function collect(currentItems) {
-		state.push(currentItems.length);
-		for (const item of currentItems) {
-			const children = item.children;
-			state.push(item, Boolean(item.disabled), children);
-			if (children) collect(children);
-		}
-	}
-	collect(items);
-	return state;
-}
-//#endregion
-//#region src/components/dropdown-menu/useDropdownMenuDataRegistration.ts
-function getCurrentPath(index, entry) {
-	return index.pathByItemId.get(entry.itemId) ?? entry.path;
-}
-function useDropdownMenuDataRegistration({ props, items, rootMenuId, interaction, rootMenu, menuRef, getItemElement, getSubmenuElement, isSubmenuOpeningLeft, onSelect }) {
-	const openMenuIds = ref(/* @__PURE__ */ new Set());
-	const itemIdentity = /* @__PURE__ */ new WeakMap();
-	let nextItemIdentity = 0;
-	let itemInteractions = /* @__PURE__ */ new Map();
-	let menuInteractions = /* @__PURE__ */ new Map([[rootMenuId, rootMenu]]);
-	let submenuInteractions = /* @__PURE__ */ new Map();
-	function getStableItemId(item) {
-		const existing = itemIdentity.get(item);
-		if (existing) return existing;
-		nextItemIdentity += 1;
-		const id = `${rootMenuId}-item-${nextItemIdentity}`;
-		itemIdentity.set(item, id);
-		return id;
-	}
-	const registrationIndex = shallowRef(buildDropdownMenuDataIndex([], rootMenuId, getStableItemId));
-	const collectionState = computed(() => getDropdownMenuDataCollectionState(items.value));
-	function setMenuOpen(id, open) {
-		const next = new Set(openMenuIds.value);
-		if (open) next.add(id);
-		else next.delete(id);
-		openMenuIds.value = next;
-	}
-	function connectSubmenu(index, entry) {
-		const submenuMenuId = entry.submenuMenuId;
-		if (!submenuMenuId) return void 0;
-		const submenu = interaction.connectSubmenu({
-			id: submenuMenuId,
-			parentItemId: () => entry.itemId,
-			isOpen: () => openMenuIds.value.has(submenuMenuId),
-			setOpen: (open) => setMenuOpen(submenuMenuId, open)
-		});
-		return {
-			menu: submenu.connectContent({
-				element: () => getSubmenuElement(getCurrentPath(index, entry)),
-				focusTarget: () => menuRef.value,
-				placement: () => {
-					return getSubmenuElement(getCurrentPath(index, entry))?.dataset.placement ?? "right-start";
-				}
-			}),
-			submenu
-		};
-	}
-	function createSelectEvent(entry, originalEvent) {
-		const event = new CustomEvent("dropdown-menu-select", {
-			cancelable: true,
-			detail: {
-				originalEvent,
-				value: entry.item.value
-			}
-		});
-		onSelect?.(entry.item, event);
-		return event;
-	}
-	function connectItem(index, entry, nextMenus, nextSubmenus) {
-		const menu = nextMenus.get(entry.ownerMenuId);
-		if (!menu) return void 0;
-		return menu.connectItem({
-			id: entry.itemId,
-			element: () => getItemElement(getCurrentPath(index, entry)),
-			textValue: () => entry.item.label,
-			disabled: () => Boolean(entry.item.disabled || props.disabled),
-			order: () => entry.order,
-			submenu: entry.submenuMenuId ? nextSubmenus.get(entry.submenuMenuId) : void 0,
-			submenuDirection: () => isSubmenuOpeningLeft(getCurrentPath(index, entry)) ? "left" : "right",
-			select: (originalEvent) => createSelectEvent(entry, originalEvent),
-			closeOnSelect: () => props.closeOnSelect !== false
-		});
-	}
-	function registerItems() {
-		const nextIndex = buildDropdownMenuDataIndex(items.value, rootMenuId, getStableItemId);
-		const nextItems = /* @__PURE__ */ new Map();
-		const nextMenus = /* @__PURE__ */ new Map([[rootMenuId, rootMenu]]);
-		const nextSubmenus = /* @__PURE__ */ new Map();
-		for (const entry of nextIndex.entries) {
-			const connection = connectSubmenu(nextIndex, entry);
-			if (!entry.submenuMenuId || !connection) continue;
-			nextMenus.set(entry.submenuMenuId, connection.menu);
-			nextSubmenus.set(entry.submenuMenuId, connection.submenu);
-		}
-		for (const entry of nextIndex.entries) {
-			const item = connectItem(nextIndex, entry, nextMenus, nextSubmenus);
-			if (item) nextItems.set(entry.itemId, item);
-		}
-		for (const item of itemInteractions.values()) item.dispose();
-		for (const submenu of submenuInteractions.values()) submenu.dispose();
-		itemInteractions = nextItems;
-		menuInteractions = nextMenus;
-		submenuInteractions = nextSubmenus;
-		registrationIndex.value = nextIndex;
-	}
-	watch(collectionState, registerItems, { immediate: true });
-	onBeforeUnmount(() => {
-		for (const item of itemInteractions.values()) item.dispose();
-		for (const submenu of submenuInteractions.values()) submenu.dispose();
-	});
-	return {
-		openMenuIds,
-		registrationIndex,
-		getItemInteraction: (id) => itemInteractions.get(id),
-		getMenuInteraction: (id) => menuInteractions.get(id)
-	};
-}
-//#endregion
-//#region src/components/dropdown-menu/useDropdownMenuHoverIntent.ts
-var SAFE_TRIANGLE_PADDING = 2;
-var SAFE_TRIANGLE_ORIGIN_OFFSET = 2;
-var SAFE_TRIANGLE_TIMEOUT = 400;
-function getDropdownMenuSafeTriangle({ itemRect, submenuRect, origin }) {
-	const measuredItemRect = itemRect && hasMeasuredRect(itemRect) ? itemRect : null;
-	const opensRight = !measuredItemRect || submenuRect.left >= measuredItemRect.right;
-	const edgeX = opensRight ? submenuRect.left : submenuRect.right;
-	const boundedOrigin = measuredItemRect ? clampPointToRect(origin, measuredItemRect) : origin;
-	return [
-		{
-			x: boundedOrigin.x + (opensRight ? -2 : SAFE_TRIANGLE_ORIGIN_OFFSET),
-			y: boundedOrigin.y
-		},
-		{
-			x: edgeX,
-			y: submenuRect.top - SAFE_TRIANGLE_PADDING
-		},
-		{
-			x: edgeX,
-			y: submenuRect.bottom + SAFE_TRIANGLE_PADDING
-		}
-	];
-}
-function useDropdownMenuHoverIntent({ openSubmenuPath, getItemElement, getSubmenuElement }) {
-	const safeTriangleOrigin = ref(null);
-	let latestPointerPoint = null;
-	let pendingHover = null;
-	let pendingHoverTimer;
-	function clearPendingHover() {
-		pendingHover = null;
-		if (pendingHoverTimer !== void 0) {
-			window.clearTimeout(pendingHoverTimer);
-			pendingHoverTimer = void 0;
-		}
-	}
-	function resetHoverIntent() {
-		safeTriangleOrigin.value = null;
-		latestPointerPoint = null;
-		clearPendingHover();
-	}
-	function getFallbackTriangleOrigin(path) {
-		const itemRect = getItemElement(path)?.getBoundingClientRect();
-		if (!itemRect) return null;
-		const submenuRect = getSubmenuElement(path)?.getBoundingClientRect();
-		return {
-			x: !submenuRect || submenuRect.left >= itemRect.right ? itemRect.right : itemRect.left,
-			y: itemRect.top + itemRect.height / 2
-		};
-	}
-	function trackSubmenuOpen(path, point) {
-		safeTriangleOrigin.value = point ?? getFallbackTriangleOrigin(path);
-		clearPendingHover();
-	}
-	function isPointInCurrentSubmenu(point) {
-		if (openSubmenuPath.value.length === 0) return false;
-		const submenuRect = getSubmenuElement(openSubmenuPath.value)?.getBoundingClientRect();
-		return submenuRect ? isPointInRect(point, submenuRect, SAFE_TRIANGLE_PADDING) : false;
-	}
-	function getSafeTriangle(path) {
-		const submenuRect = getSubmenuElement(path)?.getBoundingClientRect();
-		const itemRect = getItemElement(path)?.getBoundingClientRect();
-		const origin = safeTriangleOrigin.value ?? getFallbackTriangleOrigin(path);
-		if (!submenuRect || !origin) return null;
-		return getDropdownMenuSafeTriangle({
-			itemRect: itemRect ?? null,
-			submenuRect,
-			origin
-		});
-	}
-	function updateSafeTriangleOrigin(point) {
-		if (openSubmenuPath.value.length === 0) return;
-		const itemRect = getItemElement(openSubmenuPath.value)?.getBoundingClientRect();
-		if (itemRect && isPointInRect(point, itemRect)) safeTriangleOrigin.value = point;
-	}
-	function shouldDelayHover(path, point) {
-		if (openSubmenuPath.value.length === 0) return false;
-		if (arePathsEqual(path, openSubmenuPath.value)) return false;
-		if (isPathPrefix(openSubmenuPath.value, path)) return false;
-		if (isPointInCurrentSubmenu(point)) return true;
-		const triangle = getSafeTriangle(openSubmenuPath.value);
-		return triangle ? isPointInTriangle(point, triangle) : false;
-	}
-	function delayHoveredItem(item, path, commit) {
-		pendingHover = {
-			item,
-			path
-		};
-		if (pendingHoverTimer !== void 0) window.clearTimeout(pendingHoverTimer);
-		pendingHoverTimer = window.setTimeout(() => {
-			if (!pendingHover) return;
-			const nextHover = pendingHover;
-			if (latestPointerPoint && isPointInCurrentSubmenu(latestPointerPoint)) {
-				clearPendingHover();
-				return;
-			}
-			commit(nextHover.item, nextHover.path);
-		}, SAFE_TRIANGLE_TIMEOUT);
-	}
-	function handleItemHover(item, path, event, commit) {
-		const point = event ? getClientPoint(event) : void 0;
-		latestPointerPoint = point ?? latestPointerPoint;
-		if (point && shouldDelayHover(path, point)) {
-			delayHoveredItem(item, path, commit);
-			return;
-		}
-		commit(item, path, point);
-	}
-	function handleMenuMousemove(event, commit) {
-		const point = getClientPoint(event);
-		latestPointerPoint = point;
-		updateSafeTriangleOrigin(point);
-		if (!pendingHover) return;
-		if (shouldDelayHover(pendingHover.path, point)) return;
-		const nextHover = pendingHover;
-		commit(nextHover.item, nextHover.path, point);
-	}
-	onUnmounted(clearPendingHover);
-	return {
-		clearPendingHover,
-		resetHoverIntent,
-		trackSubmenuOpen,
-		handleItemHover,
-		handleMenuMousemove
-	};
-}
-//#endregion
-//#region src/components/dropdown-menu/useDropdownMenuDataController.ts
-function useDropdownMenuDataController({ props, items, rootMenuId, menuId, menuRef, actualPlacement, interaction, rootMenu, onSelect }) {
-	function getItemId(path) {
-		return `${menuId.value}-item-${getPathKey(path)}`;
-	}
-	function getSubmenuId(path) {
-		return `${menuId.value}-submenu-${getPathKey(path)}`;
-	}
-	function getItemElement(path) {
-		return typeof document === "undefined" ? null : document.getElementById(getItemId(path));
-	}
-	function getSubmenuElement(path) {
-		return typeof document === "undefined" ? null : document.getElementById(getSubmenuId(path));
-	}
-	function isSubmenuOpeningLeft(path) {
-		const submenuRect = getSubmenuElement(path)?.getBoundingClientRect();
-		const itemRect = getItemElement(path)?.getBoundingClientRect();
-		if (submenuRect && itemRect && hasMeasuredRect(submenuRect) && hasMeasuredRect(itemRect)) return submenuRect.right <= itemRect.left;
-		return actualPlacement.value.endsWith("end");
-	}
-	const { openMenuIds, registrationIndex, getItemInteraction, getMenuInteraction } = useDropdownMenuDataRegistration({
-		props,
-		items,
-		rootMenuId,
-		interaction,
-		rootMenu,
-		menuRef,
-		getItemElement,
-		getSubmenuElement,
-		isSubmenuOpeningLeft,
-		onSelect
-	});
-	function getDataItemId(path) {
-		return registrationIndex.value.itemIdByPath.get(getPathKey(path));
-	}
-	const focusedPath = computed({
-		get() {
-			const id = interaction.activeItemId.value;
-			return id ? [...registrationIndex.value.pathByItemId.get(id) ?? []] : [];
-		},
-		set(path) {
-			const itemId = path.length > 0 ? getDataItemId(path) : void 0;
-			if (itemId) getItemInteraction(itemId)?.setActive();
-			else rootMenu.clearActive();
-		}
-	});
-	const focusedIndex = computed(() => focusedPath.value[0] ?? -1);
-	const activeDescendantId = computed(() => focusedPath.value.length === 0 ? void 0 : getItemId(focusedPath.value));
-	const openSubmenuPath = computed(() => {
-		let deepest = [];
-		for (const id of openMenuIds.value) {
-			const path = registrationIndex.value.pathByMenuId.get(id);
-			if (path && path.length > deepest.length) deepest = path;
-		}
-		return [...deepest];
-	});
-	function isItemFocused(indexOrPath) {
-		const id = getDataItemId(normalizePath(indexOrPath));
-		return Boolean(id && interaction.activeItemId.value === id);
-	}
-	function isSubmenuOpen(path) {
-		const itemId = getDataItemId(path);
-		return itemId ? getItemInteraction(itemId)?.submenuOpen.value ?? false : false;
-	}
-	function openSubmenu(path, focus = DEFAULT_FOCUS_TARGET, point) {
-		const itemId = getDataItemId(path);
-		if (!(itemId ? getItemInteraction(itemId) : void 0)?.openSubmenu(focus)) return false;
-		hoverIntent.trackSubmenuOpen(path, point);
-		return true;
-	}
-	function closeSubmenu(path) {
-		const itemId = getDataItemId(path);
-		const closed = itemId ? getItemInteraction(itemId)?.closeSubmenu(false) ?? false : false;
-		if (closed) hoverIntent.resetHoverIntent();
-		return closed;
-	}
-	function commitHoveredItem(item, path, point) {
-		const itemId = getDataItemId(path);
-		const itemInteraction = itemId ? getItemInteraction(itemId) : void 0;
-		if (!itemInteraction) return;
-		hoverIntent.clearPendingHover();
-		const hasSubmenu = hasItemSubmenu(item);
-		const opened = itemInteraction.hover(hasSubmenu);
-		if (hasSubmenu && opened) hoverIntent.trackSubmenuOpen(path, point);
-	}
-	const hoverIntent = useDropdownMenuHoverIntent({
-		openSubmenuPath,
-		getItemElement,
-		getSubmenuElement
-	});
-	function focusHoveredItem(item, indexOrPath, event) {
-		if (item.disabled) return;
-		hoverIntent.handleItemHover(item, normalizePath(indexOrPath), event, commitHoveredItem);
-	}
-	function selectItem(item, originalEvent = new Event("select")) {
-		const id = registrationIndex.value.primaryItemId.get(item);
-		if (id) getItemInteraction(id)?.select(originalEvent);
-	}
-	function activateItem(_item, path, event) {
-		const id = getDataItemId(path);
-		if (id) getItemInteraction(id)?.activate(event);
-	}
-	function getMenuActiveDescendant(path) {
-		const pathKey = getPathKey(path);
-		const activeId = getMenuInteraction(registrationIndex.value.menuIdByPath.get(pathKey) ?? rootMenuId)?.activeId.value;
-		const activePath = activeId ? registrationIndex.value.pathByItemId.get(activeId) : void 0;
-		return activePath ? getItemId(activePath) : void 0;
-	}
-	return {
-		focusedPath,
-		focusedIndex,
-		activeDescendantId,
-		getItemId,
-		getSubmenuId,
-		getItemElement,
-		getMenuActiveDescendant,
-		isItemFocused,
-		isSubmenuOpen,
-		openSubmenu,
-		closeSubmenu,
-		focusHoveredItem,
-		onMenuMousemove: (event) => hoverIntent.handleMenuMousemove(event, commitHoveredItem),
-		resetHoverIntent: hoverIntent.resetHoverIntent,
-		selectItem,
-		activateItem
-	};
-}
-//#endregion
-//#region src/components/dropdown-menu/useDropdownMenuPortalPosition.ts
-function useDropdownMenuPortalPosition(options) {
-	const floating = useFloatingPosition({
-		reference: options.reference,
-		floating: options.menuRef,
-		arrow: options.arrowRef,
-		open: options.isVisible,
-		placement: () => options.placement.value,
-		strategy: () => options.props.strategy ?? "absolute",
-		offset: () => options.props.offset,
-		flip: () => options.props.flip !== false,
-		flipOptions: () => options.props.flipOptions,
-		shift: () => options.props.shift !== false,
-		collisionPadding: () => options.props.collisionPadding ?? 8,
-		autoUpdateOptions: () => options.props.autoUpdateOptions
-	});
-	return {
-		actualPlacement: floating.actualPlacement,
-		arrowStyle: floating.arrowStyle,
-		contentStyle: floating.floatingStyle
-	};
-}
-//#endregion
-//#region src/components/dropdown-menu/useDropdownMenuPresentation.ts
-function useDropdownMenuPresentation({ props, menuId, isDisabled, isVisible, isExplicitTarget, actualPlacement, contentHasSubmenu, activeDescendantId, interaction, resetHoverIntent, onMenuMousemove, open, close, toggle }) {
-	const rootClass = computed(() => bem("rp-dropdown-menu", {
-		[`placement-${actualPlacement.value}`]: true,
-		target: isExplicitTarget.value,
-		open: isVisible.value,
-		disabled: isDisabled.value
-	}));
-	const contentClass = computed(() => bem("rp-dropdown-menu__content", { "has-submenu": contentHasSubmenu.value }));
-	const triggerProps = computed(() => ({
-		"aria-controls": isDisabled.value ? void 0 : menuId.value,
-		"aria-expanded": isDisabled.value ? void 0 : isVisible.value,
-		"aria-haspopup": "menu",
-		disabled: isDisabled.value || void 0,
-		onClick: () => interaction.onTriggerClick(),
-		onKeydown: (event) => interaction.onTriggerKeydown(event)
-	}));
-	function onMenuKeydown(event) {
-		resetHoverIntent();
-		interaction.onMenuKeydown(event);
-	}
-	return {
-		rootClass,
-		contentClass,
-		triggerProps,
-		contentProps: computed(() => ({
-			id: menuId.value,
-			role: "menu",
-			tabindex: -1,
-			"aria-label": props.ariaLabel || void 0,
-			"aria-activedescendant": activeDescendantId.value,
-			onKeydown: onMenuKeydown,
-			onMousemove: onMenuMousemove,
-			onMouseleave: resetHoverIntent
-		})),
-		slotProps: computed(() => ({
-			triggerProps: triggerProps.value,
-			isOpen: isVisible.value,
-			open,
-			close,
-			toggle
-		})),
-		onMenuKeydown
-	};
-}
-//#endregion
-//#region src/components/dropdown-menu/useDropdownMenuRenderItems.ts
-function useDropdownMenuRenderItems({ props, actualPlacement, items, getItemId, getSubmenuId, getMenuActiveDescendant, getItemElement, isItemFocused, isSubmenuOpen, activateItem, focusHoveredItem, selectItem, openSubmenu, closeSubmenu, close }) {
-	const renderedItems = computed(() => getRenderedItems(items.value));
-	function getRenderedItems(dropdownItems, parentPath = []) {
-		return dropdownItems.map((item, index) => {
-			const path = [...parentPath, index];
-			const level = parentPath.length;
-			const focused = isItemFocused(path);
-			const disabled = Boolean(item.disabled);
-			const hasSubmenu = hasItemSubmenu(item);
-			const submenuOpen = hasSubmenu && isSubmenuOpen(path);
-			return {
-				item,
-				index,
-				key: `${getPathKey(path)}:${String(item.value)}`,
-				path,
-				level,
-				focused,
-				disabled,
-				hasSubmenu,
-				submenuOpen,
-				props: getItemProps(item, path, focused, disabled, submenuOpen),
-				submenuProps: submenuOpen ? getSubmenuProps(item, path, true) : void 0,
-				slotProps: getItemSlotProps(item, path, focused, disabled, submenuOpen),
-				children: submenuOpen ? getRenderedItems(item.children ?? [], path) : []
-			};
-		});
-	}
-	function getItemProps(item, indexOrPath, focused = isItemFocused(indexOrPath), disabled = Boolean(item.disabled), submenuOpen) {
-		const path = normalizePath(indexOrPath);
-		const hasSubmenu = hasItemSubmenu(item);
-		const resolvedSubmenuOpen = submenuOpen ?? (hasSubmenu ? isSubmenuOpen(path) : false);
-		return {
-			id: getItemId(path),
-			type: "button",
-			role: "menuitem",
-			tabindex: -1,
-			class: getItemClass(item, focused, disabled, hasSubmenu, resolvedSubmenuOpen),
-			"aria-controls": hasSubmenu ? getSubmenuId(path) : void 0,
-			"aria-expanded": hasSubmenu ? resolvedSubmenuOpen : void 0,
-			"aria-haspopup": hasSubmenu ? "menu" : void 0,
-			"aria-disabled": disabled || void 0,
-			"data-disabled": toPresenceAttribute(disabled),
-			"data-highlighted": toPresenceAttribute(focused),
-			"data-submenu": toPresenceAttribute(hasSubmenu),
-			onClick: (event) => activateItem(item, path, event),
-			onMouseenter: (event) => focusHoveredItem(item, path, event)
-		};
-	}
-	function getSubmenuProps(item, path, submenuOpen = isSubmenuOpen(path)) {
-		return {
-			id: getSubmenuId(path),
-			role: "menu",
-			class: bem("rp-dropdown-menu__submenu", {
-				open: submenuOpen,
-				"has-submenu": hasNestedItems(item.children ?? [])
-			}),
-			"aria-label": item.label,
-			"aria-activedescendant": getMenuActiveDescendant(path)
-		};
-	}
-	function getItemSlotProps(item, indexOrPath, focused = isItemFocused(indexOrPath), disabled = Boolean(item.disabled), submenuOpen) {
-		const path = normalizePath(indexOrPath);
-		const hasSubmenu = hasItemSubmenu(item);
-		const resolvedSubmenuOpen = submenuOpen ?? (hasSubmenu ? isSubmenuOpen(path) : false);
-		return {
-			item,
-			index: path[path.length - 1] ?? -1,
-			path,
-			level: path.length - 1,
-			focused,
-			disabled,
-			hasSubmenu,
-			isSubmenuOpen: resolvedSubmenuOpen,
-			select: () => selectItem(item),
-			openSubmenu: (focus = DEFAULT_FOCUS_TARGET) => openSubmenu(path, focus),
-			closeSubmenu: () => closeSubmenu(path),
-			close
-		};
-	}
-	return {
-		renderedItems,
-		renderContext: {
-			isItemFocused,
-			isSubmenuOpen,
-			getItemProps,
-			getSubmenuProps,
-			getItemSlotProps,
-			getItemElement,
-			getSubmenuPlacement: () => actualPlacement.value.endsWith("end") ? "left-start" : "right-start",
-			getStrategy: () => props.strategy ?? "absolute",
-			getFlip: () => props.flip !== false,
-			getFlipOptions: () => props.flipOptions,
-			getShift: () => props.shift !== false,
-			getCollisionPadding: () => props.collisionPadding ?? 8,
-			getAutoUpdateOptions: () => props.autoUpdateOptions
-		},
-		getItemProps,
-		getItemSlotProps
-	};
-}
-//#endregion
-//#region src/components/dropdown-menu/useDropdownMenuTargetBindings.ts
-var TARGET_ATTRIBUTES = [
-	"aria-controls",
-	"aria-expanded",
-	"aria-haspopup",
-	"aria-disabled"
-];
-function syncTargetAttributes(target, id, visible, disabled) {
-	if (disabled) {
-		target.removeAttribute("aria-controls");
-		target.removeAttribute("aria-expanded");
-		target.removeAttribute("aria-haspopup");
-		target.setAttribute("aria-disabled", "true");
-		return;
-	}
-	target.setAttribute("aria-controls", id);
-	target.setAttribute("aria-expanded", String(visible));
-	target.setAttribute("aria-haspopup", "menu");
-	target.removeAttribute("aria-disabled");
-}
-function useDropdownMenuTargetBindings({ interaction, rootRef, menuRef, targetLifecycle, menuId, isVisible, isDisabled, ignoredTargets, pointerDownOutside, focusOutside, interactOutside }) {
-	function watchInside(source) {
-		watch(source, (element, _previous, onCleanup) => {
-			if (element) onCleanup(interaction.connectInside(element));
-		}, { immediate: true });
-	}
-	watchInside(rootRef);
-	watchInside(menuRef);
-	const cleanupDismissal = interaction.connectDismissal({
-		ignoredTargets,
-		pointerDownOutside,
-		focusOutside,
-		interactOutside
-	});
-	const onClick = () => interaction.onTriggerClick();
-	const onKeydown = (event) => interaction.onTriggerKeydown(event);
-	targetLifecycle.bindTarget({
-		connect: (target) => interaction.connectInside(target),
-		listeners: [["click", onClick], ["keydown", onKeydown]],
-		attributes: {
-			names: TARGET_ATTRIBUTES,
-			apply: (target) => {
-				syncTargetAttributes(target, menuId.value, isVisible.value, isDisabled.value);
-			}
-		}
-	});
-	onBeforeUnmount(cleanupDismissal);
-}
-//#endregion
-//#region src/components/dropdown-menu/useDropdownMenu.ts
-function useDropdownMenu(props, emit = {}) {
-	const rootRef = ref(null);
-	const menuRef = ref(null);
-	const arrowRef = ref(null);
-	const generatedId = useId();
-	const interactionRootMenuId = `${generatedId}-interaction-root`;
-	const controllableOpen = useControllableValue({
-		modelValue: () => props.open,
-		defaultValue: () => false,
-		onChange: (open) => emit.openChange?.(open)
-	});
-	const menuId = computed(() => props.id ?? `${generatedId}-menu`);
-	const placement = computed(() => props.placement ?? "bottom-start");
-	const teleportTo = useTeleportTarget(() => props.teleportTo);
-	const shouldTeleport = computed(() => props.teleport !== false);
-	const targetLifecycle = useFloatingTargetLifecycle({
-		target: () => props.target,
-		fallback: rootRef
-	});
-	const { isExplicitTarget, reference, targetElement } = targetLifecycle;
-	const visibleItems = computed(() => props.items ?? []);
-	const isDisabled = computed(() => Boolean(props.disabled));
-	const modal = computed(() => Boolean(props.modal));
-	const isOpen = controllableOpen.value;
-	const isVisible = computed(() => isOpen.value && !isDisabled.value);
-	const layer = useOverlayLayer({
-		active: isVisible,
-		element: menuRef,
-		baseZIndex: useOverlayZIndex({
-			baseZIndex: () => props.baseZIndex,
-			defaultBaseZIndex: 100,
-			aboveParent: false
-		})
-	});
-	const contentHasSubmenu = computed(() => hasNestedItems(visibleItems.value));
-	const isEmpty = computed(() => visibleItems.value.length === 0);
-	const { actualPlacement, arrowStyle, contentStyle } = useDropdownMenuPortalPosition({
-		props,
-		reference,
-		menuRef,
-		arrowRef,
-		isVisible,
-		placement
-	});
-	const placementSide = computed(() => actualPlacement.value.split("-")[0]);
-	function focusTrigger() {
-		nextTick(() => {
-			if (targetElement.value instanceof HTMLElement) {
-				targetElement.value.focus();
-				return;
-			}
-			rootRef.value?.querySelector("[aria-haspopup=\"menu\"]")?.focus();
-		});
-	}
-	function setOpen(nextOpen) {
-		if (nextOpen && isDisabled.value) return;
-		if (isOpen.value !== nextOpen) controllableOpen.setValue(nextOpen);
-	}
-	let resetHoverIntent;
-	const interaction = useDropdownMenuInteraction({
-		rootMenuId: interactionRootMenuId,
-		isOpen: isVisible,
-		disabled: isDisabled,
-		modal,
-		setOpen,
-		connectLayerInteraction: layer.connectInteraction,
-		focusTrigger,
-		beforeOpen: () => resetHoverIntent(),
-		beforeClose: () => resetHoverIntent()
-	});
-	const open = interaction.open;
-	const close = (options = {}) => interaction.close(options);
-	const toggle = interaction.toggle;
-	const rootMenu = interaction.connectRootMenu({
-		element: () => menuRef.value,
-		placement: () => actualPlacement.value
-	});
-	const dataController = useDropdownMenuDataController({
-		props,
-		items: visibleItems,
-		rootMenuId: interactionRootMenuId,
-		menuId,
-		menuRef,
-		actualPlacement,
-		interaction,
-		rootMenu,
-		onSelect: (item, event) => emit.select?.(item, event)
-	});
-	resetHoverIntent = dataController.resetHoverIntent;
-	const { renderedItems, renderContext, getItemProps, getItemSlotProps } = useDropdownMenuRenderItems({
-		props,
-		actualPlacement,
-		items: visibleItems,
-		getItemId: dataController.getItemId,
-		getSubmenuId: dataController.getSubmenuId,
-		getMenuActiveDescendant: dataController.getMenuActiveDescendant,
-		getItemElement: dataController.getItemElement,
-		isItemFocused: dataController.isItemFocused,
-		isSubmenuOpen: dataController.isSubmenuOpen,
-		activateItem: dataController.activateItem,
-		focusHoveredItem: dataController.focusHoveredItem,
-		selectItem: dataController.selectItem,
-		openSubmenu: dataController.openSubmenu,
-		closeSubmenu: dataController.closeSubmenu,
-		close
-	});
-	const presentation = useDropdownMenuPresentation({
-		props,
-		menuId,
-		isDisabled,
-		isVisible,
-		isExplicitTarget,
-		actualPlacement,
-		contentHasSubmenu,
-		activeDescendantId: dataController.activeDescendantId,
-		interaction,
-		resetHoverIntent,
-		onMenuMousemove: dataController.onMenuMousemove,
-		open,
-		close,
-		toggle
-	});
-	useDropdownMenuTargetBindings({
-		interaction,
-		rootRef,
-		menuRef,
-		targetLifecycle,
-		menuId,
-		isVisible,
-		isDisabled,
-		ignoredTargets: () => props.ignore ?? [],
-		pointerDownOutside: emit.pointerDownOutside,
-		focusOutside: emit.focusOutside,
-		interactOutside: emit.interactOutside
-	});
-	const layeredContentStyle = computed(() => ({
-		...contentStyle.value,
-		zIndex: layer.zIndex.value
-	}));
-	onBeforeUnmount(rootMenu.dispose);
-	return {
-		rootRef,
-		menuRef,
-		arrowRef,
-		menuId,
-		isVisible,
-		isEmpty,
-		visibleItems,
-		renderedItems,
-		renderContext,
-		focusedIndex: dataController.focusedIndex,
-		focusedPath: dataController.focusedPath,
-		activeDescendantId: dataController.activeDescendantId,
-		rootClass: presentation.rootClass,
-		contentClass: presentation.contentClass,
-		contentStyle: layeredContentStyle,
-		arrowStyle,
-		actualPlacement,
-		placementSide,
-		isTargetMode: isExplicitTarget,
-		teleportTo,
-		shouldTeleport,
-		triggerProps: presentation.triggerProps,
-		contentProps: presentation.contentProps,
-		slotProps: presentation.slotProps,
-		open,
-		close,
-		toggle,
-		selectItem: dataController.selectItem,
-		openSubmenu: dataController.openSubmenu,
-		closeSubmenu: dataController.closeSubmenu,
-		onItemMouseenter: dataController.focusHoveredItem,
-		onTriggerKeydown: (event) => interaction.onTriggerKeydown(event),
-		onMenuKeydown: presentation.onMenuKeydown,
-		getItemProps,
-		getItemSlotProps
-	};
-}
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu.vue?vue&type=script&setup=true&vapor=true&lang.ts
-var t0 = template("<span class=rp-dropdown-menu__arrow aria-hidden=true>");
-var t1 = template("No actions", 2);
-var t2 = template("<div>");
-var t3 = template("<span> </span>");
-var t4 = template("<kbd> ");
-var t5 = template("<span>");
-var t6 = template("<span>", 1);
-//#endregion
-//#region src/components/dropdown-menu/dropdown-menu.vue
-var dropdown_menu_default = /* @__PURE__ */ defineVaporComponent({
-	name: "RpDropdownMenu",
-	inheritAttrs: false,
-	__name: "dropdown-menu",
-	props: {
-		id: {},
-		baseZIndex: {},
-		items: { default: () => [] },
-		open: {
-			type: Boolean,
-			default: void 0
-		},
-		disabled: {
-			type: Boolean,
-			default: false
-		},
-		closeOnSelect: {
-			type: Boolean,
-			default: true
-		},
-		ariaLabel: {},
-		modal: {
-			type: Boolean,
-			default: false
-		},
-		ignore: {},
-		target: {},
-		placement: { default: "bottom-start" },
-		strategy: { default: "absolute" },
-		offset: {},
-		flip: {
-			type: Boolean,
-			default: true
-		},
-		flipOptions: {},
-		shift: {
-			type: Boolean,
-			default: true
-		},
-		collisionPadding: { default: 8 },
-		autoUpdateOptions: {},
-		arrow: {
-			type: Boolean,
-			default: false
-		},
-		teleport: {
-			type: Boolean,
-			default: true
-		},
-		teleportTo: {},
-		classNames: {},
-		styles: {}
-	},
-	emits: [
-		"update:open",
-		"select",
-		"pointerDownOutside",
-		"focusOutside",
-		"interactOutside"
-	],
-	setup(__props, { emit: __emit }) {
-		const props = __props;
-		const emit = __emit;
-		const { rootRef, menuRef, arrowRef, isVisible, isEmpty, visibleItems, renderContext, rootClass, contentClass, contentStyle, arrowStyle, actualPlacement, placementSide, isTargetMode, teleportTo, shouldTeleport, contentProps, slotProps } = useDropdownMenu(props, {
-			openChange: (open) => emit("update:open", open),
-			select: (item, event) => emit("select", item, event),
-			pointerDownOutside: (event) => emit("pointerDownOutside", event),
-			focusOutside: (event) => emit("focusOutside", event),
-			interactOutside: (event) => emit("interactOutside", event)
-		});
-		const templateRefs = {
-			root: rootRef,
-			menu: menuRef,
-			arrow: arrowRef
-		};
-		const { getPartAttrs, getRootAttrs } = useStylesApi(props, "root");
-		const state = computed(() => isVisible.value ? "open" : "closed");
-		const rootAttrs = computed(() => getRootAttrs({
-			class: rootClass.value,
-			"data-state": state.value,
-			"data-disabled": toPresenceAttribute(props.disabled)
-		}));
-		const publicSlotProps = computed(() => {
-			const partAttrs = getPartAttrs("trigger");
-			return {
-				...slotProps.value,
-				triggerProps: {
-					...slotProps.value.triggerProps,
-					...props.classNames?.trigger !== void 0 ? { class: partAttrs.class } : {},
-					...props.styles?.trigger !== void 0 ? { style: partAttrs.style } : {},
-					"data-state": state.value,
-					"data-disabled": toPresenceAttribute(props.disabled)
-				}
-			};
-		});
-		const publicContentProps = computed(() => ({
-			...contentProps.value,
-			...getPartAttrs("content", {
-				class: contentClass.value,
-				style: contentStyle.value
-			}),
-			"data-state": state.value,
-			"data-placement": actualPlacement.value
-		}));
-		const publicRenderContext = computed(() => ({
-			...renderContext,
-			getPublicPartAttrs: getPartAttrs
-		}));
-		const _setTemplateRef = createTemplateRefSetter();
-		const n29 = t6();
-		renderEffect(() => setDynamicProps(n29, [rootAttrs.value]));
-		setInsertionState(n29, null, 0);
-		createIf(() => !unref(isTargetMode), () => {
-			return createSlot("default", { $: [() => publicSlotProps.value] });
-		});
-		setInsertionState(n29, null, 1);
-		createComponent(VaporTeleport, {
-			to: () => unref(teleportTo),
-			disabled: () => !unref(shouldTeleport)
-		}, () => {
-			return createComponent(VaporTransition, { name: "rp-dropdown-menu-content" }, extend(() => {
-				return createIf(() => unref(isVisible), () => {
-					const n26 = t2();
-					renderEffect(() => setDynamicProps(n26, [publicContentProps.value, { "data-side": unref(placementSide) }]));
-					setInsertionState(n26, null, 0);
-					createIf(() => __props.arrow, () => {
-						const n7 = t0();
-						renderEffect(() => {
-							setAttr(n7, "data-side", unref(placementSide));
-							setStyle(n7, unref(arrowStyle));
-							_setTemplateRef(n7, templateRefs.arrow);
-						});
-						return n7;
-					});
-					setInsertionState(n26, null, 1);
-					createIf(() => unref(isEmpty), () => {
-						const n13 = t2();
-						renderEffect(() => setDynamicProps(n13, [unref(getPartAttrs)("empty", { class: "rp-dropdown-menu__empty" })]));
-						setInsertionState(n13, null, 0);
-						createSlot("empty", null, () => {
-							return t1();
-						});
-						return n13;
-					});
-					setInsertionState(n26, null, 2);
-					createComponent(dropdown_menu_items_default, {
-						items: () => unref(visibleItems),
-						context: () => publicRenderContext.value
-					}, { "item": extend((itemSlotProps) => {
-						return [createSlot("item", { $: [() => itemSlotProps] }, () => {
-							const n16 = t3();
-							const x16 = txt(n16);
-							renderEffect(() => {
-								setDynamicProps(n16, [unref(getPartAttrs)("label", { class: "rp-dropdown-menu__label" })]);
-								setText(x16, toDisplayString(itemSlotProps.item.label));
-							});
-							return [n16, createIf(() => itemSlotProps.item.shortcut, () => {
-								const n19 = t4();
-								const x19 = txt(n19);
-								renderEffect(() => {
-									setDynamicProps(n19, [unref(getPartAttrs)("shortcut", { class: "rp-dropdown-menu__shortcut" })]);
-									setText(x19, toDisplayString(itemSlotProps.item.shortcut));
-								});
-								return n19;
-							}, null, 129)];
-						}), createIf(() => itemSlotProps.hasSubmenu, () => {
-							const n23 = t5();
-							renderEffect(() => setDynamicProps(n23, [unref(getPartAttrs)("submenuIndicator", { class: "rp-dropdown-menu__submenu-icon" }), { "aria-hidden": "true" }]));
-							setInsertionState(n23, null, 0);
-							createComponent(unref(chevron_right_default));
-							return n23;
-						}, null, 129)];
-					}, { _: 8 }) });
-					setTemplateRefBinding(n26, () => templateRefs.menu, _setTemplateRef);
-					return n26;
-				}, null, 129);
-			}, { _: 8 }));
-		});
-		setTemplateRefBinding(n29, () => templateRefs.root);
-		return n29;
-	}
-});
-//#endregion
-//#region src/components/dropdown-menu/types.ts
-var dropdownMenuParts = [
-	"root",
-	"trigger",
-	"content",
-	"item",
-	"label",
-	"shortcut",
-	"submenu",
-	"submenuIndicator",
-	"empty"
-];
-//#endregion
-//#region src/components/dropdown-menu/index.ts
-var DropdownMenuItem = dropdown_menu_item_default;
-//#endregion
-export { dropdown_menu_content_default as _, dropdown_menu_trigger_default as a, dropdown_menu_sub_default as c, dropdown_menu_radio_item_default as d, dropdown_menu_radio_group_default as f, dropdown_menu_context_trigger_default as g, dropdown_menu_item_indicator_default as h, useDropdownMenu as i, dropdown_menu_separator_default as l, dropdown_menu_label_default as m, dropdownMenuParts as n, dropdown_menu_sub_trigger_default as o, dropdown_menu_portal_default as p, dropdown_menu_default as r, dropdown_menu_sub_content_default as s, DropdownMenuItem as t, dropdown_menu_root_default as u, dropdown_menu_checkbox_item_default as v };