solid-baseui 0.1.0-alpha.0

package/dist/lib/server/MenuSubmenuTrigger-DA4gsv6z.js

@@ -0,0 +1,2072 @@
+import { getStateAttributesProps } from "./internals/getStateAttributesProps.js";
+import { N as triggerPress, O as siblingOpen, S as listNavigation, d as imperativeAction, u as focusOut, y as itemPress } from "./internals/reasons.js";
+import { n as resolveClass, t as resolveStyle } from "./resolveStyle-XCSFDHAL.js";
+import { createChangeEventDetails } from "./internals/createBaseUIEventDetails.js";
+import { transitionStatusMapping } from "./internals/stateAttributesMapping.js";
+import { composeEventHandlers } from "./internals/composeEventHandlers.js";
+import { t as runOnceAnimationsFinish } from "./runOnceAnimationsFinish-DCHzXWZU.js";
+import { o as isElementVisible } from "./dom-Crg_2R-j.js";
+import { t as createAnchorPositioning } from "./createAnchorPositioning-C-cVOPwz.js";
+import { t as InternalBackdrop } from "./InternalBackdrop-C_iDPVR-.js";
+import { t as createAnchoredPopupScrollLock } from "./createAnchoredPopupScrollLock-DFuUrykR.js";
+import { c as useFloatingTree, i as createFloatingNode, n as FloatingTreeContext, r as FloatingTreeStore, s as useFloatingParentNodeId, t as FloatingParentNodeContext } from "./FloatingTree-z1JPD1dR.js";
+import { a as createPopupPresence, n as createTriggerRegistration, o as createDismiss, t as PopupStore } from "./PopupStore-DEs3FAEe.js";
+import { n as createInitialPositioning, r as createHoverInteraction, t as safePolygon } from "./safePolygon-CAm5RJGv.js";
+import { t as createTransitionStatus } from "./createTransitionStatus-BTlrerSS.js";
+import { a as triggerOpenStateMapping, h as tabbable, n as popupStateMapping, o as PopupPortal, r as popupTransitionStateMapping } from "./popupStateMapping-nKoUwoke.js";
+import { t as FocusManager } from "./FocusManager-BrbZVWME.js";
+import { r as attachPopupHandle } from "./PopupHandle-DthPgNjy.js";
+import { a as stopButtonInteraction, r as preventButtonInteraction } from "./buttonSemantics-BSwDxJhh.js";
+import { t as setRef } from "./setRef-Bt70sW7c.js";
+import { n as useDirection } from "./DirectionContext-YORWLF08.js";
+import { n as useMenubarContext } from "./MenubarContext-C-62rMnO.js";
+import { n as useToolbarRootContext } from "./ToolbarRootContext-DD-qe7s8.js";
+import { Dynamic, escape, memo, mergeProps, ssrElement } from "@solidjs/web";
+import { $REFRESH, Show, createContext, createEffect, createMemo, createSignal, createUniqueId, omit, onCleanup, untrack, useContext } from "solid-js";
+//#region src/context-menu/root/ContextMenuRootContext.ts
+var MISSING_CONTEXT$8 = Symbol("ContextMenuRootContext");
+var ContextMenuRootContext = createContext(MISSING_CONTEXT$8);
+function useContextMenuRootContext(optional = true) {
+	const context = useContext(ContextMenuRootContext);
+	if (context === MISSING_CONTEXT$8) {
+		if (optional) return;
+		throw new Error("Base UI: ContextMenuRootContext is missing. ContextMenu parts must be placed within <ContextMenu.Root>.");
+	}
+	return context;
+}
+//#endregion
+//#region src/menu/store/MenuCollection.ts
+var MenuCollection = class {
+	registrations = /* @__PURE__ */ new Map();
+	revision;
+	setRevision;
+	constructor() {
+		const [revision, setRevision] = createSignal(0, { ownedWrite: true });
+		this.revision = revision;
+		this.setRevision = setRevision;
+	}
+	register(item) {
+		this.registrations.set(item.token, item);
+		this.touch();
+		return () => {
+			if (this.registrations.delete(item.token)) this.touch();
+		};
+	}
+	touch() {
+		this.setRevision((value) => value + 1);
+	}
+	items() {
+		this.revision();
+		return Array.from(this.registrations.values()).sort(compareItems);
+	}
+	indexOf(token) {
+		return this.items().findIndex((item) => item.token === token);
+	}
+	labels() {
+		return this.items().map((item) => {
+			const explicit = item.label();
+			if (explicit !== void 0) return explicit;
+			return item.element()?.textContent?.trim() || null;
+		});
+	}
+	elements() {
+		return this.items().map((item) => item.element());
+	}
+	availableIndices() {
+		return this.items().flatMap((item, index) => {
+			const element = item.element();
+			return element && !element.matches(":disabled") && isElementVisible(element) ? [index] : [];
+		});
+	}
+};
+function compareItems(a, b) {
+	const elementA = a.element();
+	const elementB = b.element();
+	if (!elementA || !elementB || elementA === elementB) return 0;
+	const position = elementA.compareDocumentPosition(elementB);
+	if (position & Node.DOCUMENT_POSITION_FOLLOWING) return -1;
+	if (position & Node.DOCUMENT_POSITION_PRECEDING) return 1;
+	return 0;
+}
+//#endregion
+//#region src/menu/store/MenuStore.ts
+var MenuStore = class extends PopupStore {
+	parentStore;
+	collection = new MenuCollection();
+	disabled;
+	modal;
+	orientation;
+	loopFocus;
+	highlightItemOnHover;
+	closeParentOnEsc;
+	direction;
+	contextMenu;
+	ownTree;
+	ownParentNodeId;
+	menubarAccessor;
+	setMenubarSignal;
+	triggerMenubars = /* @__PURE__ */ new Map();
+	activeIndexAccessor;
+	setActiveIndexSignal;
+	activeElementAccessor;
+	setActiveElementSignal;
+	openMethodAccessor;
+	setOpenMethodSignal;
+	openMethodValue = null;
+	openReasonAccessor;
+	setOpenReasonSignal;
+	instantTypeAccessor;
+	setInstantTypeSignal;
+	typingAccessor;
+	setTypingSignal;
+	hoverEnabledAccessor;
+	setHoverEnabledSignal;
+	allowMouseEnterAccessor;
+	setAllowMouseEnterSignal;
+	beforeContentGuardAccessor;
+	setBeforeContentGuardSignal;
+	afterTriggerGuardAccessor;
+	setAfterTriggerGuardSignal;
+	pendingFocus = null;
+	typed = "";
+	typeaheadTimer;
+	allowTouchToClose = true;
+	allowTouchToCloseTimer;
+	ownAllowMouseUpTrigger = false;
+	constructor(options) {
+		super(options);
+		this.ownTree = options.tree;
+		this.parentStore = options.parentStore;
+		this.ownParentNodeId = options.parentNodeId;
+		const [menubar, setMenubar] = createSignal(options.menubar, { ownedWrite: true });
+		this.menubarAccessor = menubar;
+		this.setMenubarSignal = setMenubar;
+		this.disabled = () => options.disabled() || Boolean(this.parentStore?.disabled()) || Boolean(this.menubar()?.disabled());
+		this.modal = () => this.menubar() ? false : options.modal();
+		this.orientation = options.orientation;
+		this.loopFocus = options.loopFocus;
+		this.highlightItemOnHover = options.highlightItemOnHover;
+		this.closeParentOnEsc = options.closeParentOnEsc;
+		this.direction = options.direction;
+		this.contextMenu = options.parentStore?.contextMenu ?? options.contextMenu;
+		const [activeIndex, setActiveIndex] = createSignal(null, { ownedWrite: true });
+		this.activeIndexAccessor = activeIndex;
+		this.setActiveIndexSignal = setActiveIndex;
+		const [activeElement, setActiveElement] = createSignal(null, { ownedWrite: true });
+		this.activeElementAccessor = activeElement;
+		this.setActiveElementSignal = setActiveElement;
+		const [openMethod, setOpenMethod] = createSignal(null, { ownedWrite: true });
+		this.openMethodAccessor = openMethod;
+		this.setOpenMethodSignal = setOpenMethod;
+		const [openReason, setOpenReason] = createSignal(null, { ownedWrite: true });
+		this.openReasonAccessor = openReason;
+		this.setOpenReasonSignal = setOpenReason;
+		const [instantType, setInstantType] = createSignal(void 0, { ownedWrite: true });
+		this.instantTypeAccessor = instantType;
+		this.setInstantTypeSignal = setInstantType;
+		const [typing, setTyping] = createSignal(false, { ownedWrite: true });
+		this.typingAccessor = typing;
+		this.setTypingSignal = setTyping;
+		const [hoverEnabled, setHoverEnabled] = createSignal(true, { ownedWrite: true });
+		this.hoverEnabledAccessor = hoverEnabled;
+		this.setHoverEnabledSignal = setHoverEnabled;
+		const [allowMouseEnter, setAllowMouseEnter] = createSignal(false, { ownedWrite: true });
+		this.allowMouseEnterAccessor = allowMouseEnter;
+		this.setAllowMouseEnterSignal = setAllowMouseEnter;
+		const [beforeContentGuard, setBeforeContentGuard] = createSignal(null, { ownedWrite: true });
+		this.beforeContentGuardAccessor = beforeContentGuard;
+		this.setBeforeContentGuardSignal = setBeforeContentGuard;
+		const [afterTriggerGuard, setAfterTriggerGuard] = createSignal(null, { ownedWrite: true });
+		this.afterTriggerGuardAccessor = afterTriggerGuard;
+		this.setAfterTriggerGuardSignal = setAfterTriggerGuard;
+	}
+	get allowMouseUpTrigger() {
+		return this.parentStore?.allowMouseUpTrigger ?? this.menubar()?.allowMouseUpTrigger.value ?? this.ownAllowMouseUpTrigger;
+	}
+	set allowMouseUpTrigger(value) {
+		if (this.parentStore) this.parentStore.allowMouseUpTrigger = value;
+		else if (this.menubar()) this.menubar().allowMouseUpTrigger.value = value;
+		else this.ownAllowMouseUpTrigger = value;
+	}
+	menubar() {
+		return this.parentStore?.menubar() ?? this.menubarAccessor();
+	}
+	tree() {
+		return this.parentStore?.tree() ?? this.menubar()?.tree ?? this.ownTree;
+	}
+	parentNodeId() {
+		if (this.parentStore) return this.ownParentNodeId;
+		return this.menubar()?.nodeId ?? this.ownParentNodeId;
+	}
+	registerMenubarTrigger(id, context) {
+		this.triggerMenubars.set(id, context);
+		if (this.activeTriggerId() === id) this.setMenubarSignal(context);
+		return () => {
+			if (this.triggerMenubars.get(id) === context) this.triggerMenubars.delete(id);
+		};
+	}
+	forwardMenubarTrigger(id, context) {
+		this.triggerMenubars.set(id, context);
+		if (this.activeTriggerId() === id) this.setMenubarSignal(context);
+	}
+	activateMenubarTrigger(id) {
+		this.setMenubarSignal(this.triggerMenubars.get(id));
+	}
+	rootStore() {
+		return this.parentStore?.rootStore() ?? this;
+	}
+	rootNodeId() {
+		return this.menubar()?.rootId() ?? this.rootStore().context.floatingRoot.context.nodeId;
+	}
+	relayKeyboardEvent(event) {
+		this.menubar()?.relayKeyboardEvent(event);
+	}
+	activeIndex() {
+		const element = this.activeElementAccessor();
+		if (element) {
+			const index = this.collection.elements().indexOf(element);
+			return index === -1 ? null : index;
+		}
+		return this.activeIndexAccessor();
+	}
+	activeElement() {
+		return this.activeElementAccessor();
+	}
+	isItemActive(element) {
+		return element !== null && this.activeElementAccessor() === element;
+	}
+	setActiveIndex(index, focus = false) {
+		const element = index === null ? null : this.collection.elements()[index] ?? null;
+		this.setActiveIndexSignal(index);
+		this.setActiveElementSignal(element);
+		if (focus && element) {
+			element.focus({ preventScroll: true });
+			element.scrollIntoView?.({ block: "nearest" });
+		}
+	}
+	setActiveElement(element) {
+		this.setActiveElementSignal(element);
+		this.setActiveIndexSignal(element ? this.collection.elements().indexOf(element) : null);
+	}
+	openMethod() {
+		this.openMethodAccessor();
+		return this.openMethodValue;
+	}
+	setOpenMethod(value) {
+		this.openMethodValue = value;
+		this.setOpenMethodSignal(value);
+	}
+	openChangeReason() {
+		return this.openReasonAccessor();
+	}
+	instantType() {
+		return this.instantTypeAccessor();
+	}
+	setInstantType(value) {
+		this.setInstantTypeSignal(value);
+	}
+	typing() {
+		return this.typingAccessor();
+	}
+	hoverEnabled() {
+		return this.hoverEnabledAccessor();
+	}
+	setHoverEnabled(value) {
+		this.setHoverEnabledSignal(value);
+	}
+	allowMouseEnter() {
+		return this.allowMouseEnterAccessor();
+	}
+	setAllowMouseEnter(value) {
+		this.setAllowMouseEnterSignal(value);
+	}
+	beforeContentGuard() {
+		return this.beforeContentGuardAccessor();
+	}
+	setBeforeContentGuard(element) {
+		this.setBeforeContentGuardSignal(element);
+	}
+	afterTriggerGuard() {
+		return this.afterTriggerGuardAccessor();
+	}
+	setAfterTriggerGuard(element) {
+		this.setAfterTriggerGuardSignal(element);
+	}
+	setPendingFocus(value) {
+		this.pendingFocus = value;
+	}
+	focusPendingItem() {
+		if (!this.pendingFocus) return false;
+		const available = this.collection.availableIndices();
+		const index = this.pendingFocus === "first" ? available[0] : available[available.length - 1];
+		if (index === void 0) return false;
+		this.setActiveIndex(index, true);
+		const element = this.collection.elements()[index];
+		const focused = Boolean(element && element.ownerDocument.activeElement === element);
+		if (focused) this.pendingFocus = null;
+		return focused;
+	}
+	navigate(event) {
+		const available = this.collection.availableIndices();
+		if (available.length === 0) return false;
+		const orientation = this.orientation();
+		const rtl = this.direction() === "rtl";
+		const forwardKey = orientation === "vertical" ? "ArrowDown" : rtl ? "ArrowLeft" : "ArrowRight";
+		if (![
+			forwardKey,
+			orientation === "vertical" ? "ArrowUp" : rtl ? "ArrowRight" : "ArrowLeft",
+			"Home",
+			"End"
+		].includes(event.key)) return false;
+		event.preventDefault();
+		event.stopPropagation();
+		const current = this.activeIndex();
+		let position = current === null ? -1 : available.indexOf(current);
+		if (event.key === "Home") position = 0;
+		else if (event.key === "End") position = available.length - 1;
+		else if (current === null) position = event.key === forwardKey ? 0 : available.length - 1;
+		else {
+			const delta = event.key === forwardKey ? 1 : -1;
+			position += delta;
+			if (this.loopFocus()) position = (position + available.length) % available.length;
+			else position = Math.max(0, Math.min(available.length - 1, position));
+		}
+		this.setActiveIndex(available[position], true);
+		return true;
+	}
+	handleTypeahead(event) {
+		if (event.key.length !== 1 || event.ctrlKey || event.metaKey || event.altKey) return false;
+		if (event.key === " " && this.typed === "") return false;
+		event.preventDefault();
+		event.stopPropagation();
+		const labels = this.collection.labels();
+		const available = new Set(this.collection.availableIndices());
+		const repeated = this.typed.length > 0 && [...this.typed].every((character) => character.toLocaleLowerCase() === event.key.toLocaleLowerCase());
+		this.typed = repeated ? event.key : this.typed + event.key;
+		this.setTypingSignal(true);
+		clearTimeout(this.typeaheadTimer);
+		this.typeaheadTimer = setTimeout(() => {
+			this.typed = "";
+			this.setTypingSignal(false);
+		}, 500);
+		const query = this.typed.toLocaleLowerCase();
+		const start = (this.activeIndex() ?? -1) + 1;
+		for (let offset = 0; offset < labels.length; offset += 1) {
+			const index = (start + offset) % labels.length;
+			if (available.has(index) && labels[index]?.toLocaleLowerCase().startsWith(query)) {
+				this.setActiveIndex(index, true);
+				return true;
+			}
+		}
+		return true;
+	}
+	handleTriggerKeyDown(event, trigger) {
+		if (this.disabled()) return;
+		const menubar = this.menubar();
+		if (menubar) {
+			if (this.open()) return;
+			const openKey = menubar.orientation() === "horizontal" ? "ArrowDown" : this.direction() === "rtl" ? "ArrowLeft" : "ArrowRight";
+			if (event.key !== openKey) return;
+			event.preventDefault();
+			event.stopPropagation();
+			this.setOpenMethod("keyboard");
+			this.setPendingFocus("first");
+			this.setOpen(true, createChangeEventDetails(listNavigation, event, trigger));
+			return;
+		}
+		if (this.open()) {
+			if (this.navigate(event)) return;
+			return;
+		}
+		const orientation = this.orientation();
+		const rtl = this.direction() === "rtl";
+		const firstKey = orientation === "vertical" ? "ArrowDown" : rtl ? "ArrowLeft" : "ArrowRight";
+		const lastKey = orientation === "vertical" ? "ArrowUp" : rtl ? "ArrowRight" : "ArrowLeft";
+		if (event.key !== firstKey && event.key !== lastKey) return;
+		event.preventDefault();
+		event.stopPropagation();
+		this.setOpenMethod("keyboard");
+		this.setPendingFocus(event.key === firstKey ? "first" : "last");
+		this.setOpen(true, createChangeEventDetails(listNavigation, event, trigger));
+	}
+	closeTree(event, reason) {
+		this.tree().events.emit("close", {
+			event,
+			reason
+		});
+	}
+	setOpen(open, details) {
+		if (!open && !this.open()) return false;
+		if (!open && details.trigger == null) details.trigger = this.track().activeTriggerElement ?? void 0;
+		if (open && details.trigger?.id) this.activateMenubarTrigger(details.trigger.id);
+		if (!super.setOpen(open, details)) return false;
+		this.setOpenReasonSignal(details.reason);
+		if (open && details.reason === "imperative-action") this.setOpenMethod(null);
+		if (open && details.reason === "trigger-hover") this.setOpenMethod("mouse");
+		const keyboardClick = (details.reason === "trigger-press" || details.reason === "item-press") && details.event.type === "click" && details.event.detail === 0;
+		if (this.menubar() && (details.reason === "trigger-focus" || details.reason === "focus-out" || details.reason === "trigger-hover" || details.reason === "list-navigation" || details.reason === "sibling-open")) this.setInstantTypeSignal("group");
+		else if (keyboardClick) this.setInstantTypeSignal("click");
+		else if (!open && (details.reason === "escape-key" || details.reason === "none")) this.setInstantTypeSignal("dismiss");
+		else if (details.reason !== "trigger-hover") this.setInstantTypeSignal(void 0);
+		return true;
+	}
+	resetAfterObservedClose() {
+		this.setActiveIndex(null);
+		this.setOpenMethod(null);
+		this.setAllowMouseEnter(false);
+		if (!this.menubar()) this.allowMouseUpTrigger = false;
+		this.pendingFocus = null;
+	}
+	dispose() {
+		clearTimeout(this.typeaheadTimer);
+		clearTimeout(this.allowTouchToCloseTimer);
+	}
+	shouldCommitOpenChange(open, details) {
+		const event = details.event;
+		if (!open && event?.type === "click" && event.pointerType === "touch" && !this.allowTouchToClose) return false;
+		clearTimeout(this.allowTouchToCloseTimer);
+		if (open && details.reason === "trigger-focus") {
+			this.allowTouchToClose = false;
+			this.allowTouchToCloseTimer = setTimeout(() => {
+				this.allowTouchToClose = true;
+			}, 300);
+		} else this.allowTouchToClose = true;
+		return true;
+	}
+};
+//#endregion
+//#region src/menu/submenu-root/MenuSubmenuRootContext.ts
+var MISSING_CONTEXT$7 = Symbol("MenuSubmenuRootContext");
+var MenuSubmenuRootContext = createContext(MISSING_CONTEXT$7);
+function useMenuSubmenuRootContext(optional = false) {
+	const context = useContext(MenuSubmenuRootContext);
+	if (context === MISSING_CONTEXT$7) {
+		if (optional) return;
+		throw new Error("Base UI: <Menu.SubmenuTrigger> must be placed in <Menu.SubmenuRoot>.");
+	}
+	return context;
+}
+//#endregion
+//#region src/menu/root/MenuRootContext.ts
+var MISSING_CONTEXT$6 = Symbol("MenuRootContext");
+var MenuRootContext = createContext(MISSING_CONTEXT$6);
+function useMenuRootContext(optional = false) {
+	const context = useContext(MenuRootContext);
+	if (context === MISSING_CONTEXT$6) {
+		if (optional) return;
+		throw new Error("Base UI: MenuRootContext is missing. Menu parts must be placed within <Menu.Root>.");
+	}
+	return context;
+}
+//#endregion
+//#region src/menu/root/MenuRoot.tsx
+/** Groups all parts of the menu without rendering an element. */
+function MenuRoot(props) {
+	const contextMenuContext = useContextMenuRootContext(true);
+	const menubarContext = useMenubarContext(true);
+	const ambientMenu = useMenuRootContext(true);
+	const submenu = useMenuSubmenuRootContext(true);
+	const contextMenu = contextMenuContext && !ambientMenu ? contextMenuContext : void 0;
+	const parentStore = contextMenu ? void 0 : submenu?.parentStore;
+	const inheritedTree = useFloatingTree();
+	const inheritedParentNodeId = useFloatingParentNodeId();
+	const direction = useDirection();
+	const menubar = parentStore ? void 0 : menubarContext;
+	const tree = contextMenu ? new FloatingTreeStore() : untrack(() => parentStore?.tree()) ?? menubar?.tree ?? inheritedTree ?? new FloatingTreeStore();
+	const nodeId = createUniqueId();
+	const floatingId = createUniqueId();
+	const controlledOpen = untrack(() => props.open !== void 0);
+	const controlledTriggerId = untrack(() => props.triggerId !== void 0);
+	const nested = parentStore !== void 0;
+	const store = new MenuStore({
+		controlledOpen: () => controlledOpen ? props.open : void 0,
+		controlledTriggerId: () => controlledTriggerId ? props.triggerId : void 0,
+		floatingId,
+		nested,
+		nodeId,
+		onOpenChange: () => props.onOpenChange,
+		onOpenChangeComplete: () => props.onOpenChangeComplete,
+		tree,
+		parentStore,
+		parentNodeId: contextMenu ? null : menubar?.nodeId ?? inheritedParentNodeId,
+		disabled: () => props.disabled ?? false,
+		modal: () => nested ? false : props.modal ?? true,
+		orientation: () => props.orientation ?? "vertical",
+		loopFocus: () => props.loopFocus ?? true,
+		highlightItemOnHover: () => props.highlightItemOnHover ?? true,
+		closeParentOnEsc: () => props.closeParentOnEsc ?? false,
+		direction,
+		contextMenu,
+		menubar
+	});
+	store.update({
+		open: controlledOpen ? Boolean(untrack(() => props.open)) : Boolean(untrack(() => props.defaultOpen)),
+		activeTriggerId: untrack(() => props.defaultTriggerId ?? null)
+	});
+	store.configureTriggerUnmount({ closeOnActiveTriggerUnmount: false });
+	const payload = store.access((state) => state.payload);
+	const node = createFloatingNode({
+		tree: () => store.tree(),
+		id: nodeId,
+		parentId: () => store.parentNodeId(),
+		context: () => store.context.floatingRoot
+	});
+	const [backdropElement, setBackdropElement] = createSignal(null, { ownedWrite: true });
+	const [internalBackdropElement, setInternalBackdropElement] = createSignal(null, { ownedWrite: true });
+	const presence = createPopupPresence(store, () => store.track().popupElement, { onUnmount: () => {
+		store.setHoverEnabled(true);
+		store.setInstantType(void 0);
+	} });
+	const context = {
+		store,
+		node,
+		nested,
+		presence,
+		contextMenu: store.contextMenu,
+		backdropElement,
+		setBackdropElement,
+		internalBackdropElement,
+		setInternalBackdropElement,
+		beforeContentGuard: () => store.beforeContentGuard(),
+		setBeforeContentGuard: (element) => store.setBeforeContentGuard(element),
+		afterTriggerGuard: () => store.afterTriggerGuard(),
+		setAfterTriggerGuard: (element) => store.setAfterTriggerGuard(element)
+	};
+	store.context.floatingRoot.context.data.insideElements = () => [
+		backdropElement(),
+		internalBackdropElement(),
+		store.menubar()?.rootElement()
+	];
+	attachPopupHandle(() => props.handle, store);
+	let allowOutsidePressTimer;
+	const dismiss = createDismiss({
+		context: store.context.floatingRoot,
+		tree: () => store.tree(),
+		enabled: () => !store.disabled(),
+		bubbles: () => ({ escapeKey: nested && store.closeParentOnEsc() }),
+		outsidePress: () => () => {
+			if (!contextMenu || store.context.floatingRoot.context.data.openEvent?.type === "contextmenu") return true;
+			return contextMenu.allowOutsidePressDismissal.current;
+		},
+		outsidePressEvent: () => ({
+			mouse: "sloppy",
+			touch: "sloppy"
+		})
+	});
+	store.setInteractionProps({
+		activeTriggerProps: { onKeyDown: dismiss.onKeyDown },
+		inactiveTriggerProps: { onKeyDown: dismiss.onKeyDown },
+		popupProps: { onKeyDown: dismiss.onKeyDown }
+	});
+	let contextMenuOpen = false;
+	createEffect(() => store.open(), (open) => {
+		if (!contextMenu || open === contextMenuOpen) return;
+		contextMenuOpen = open;
+		clearTimeout(allowOutsidePressTimer);
+		contextMenu.allowOutsidePressDismissal.current = false;
+		if (open) allowOutsidePressTimer = setTimeout(() => {
+			contextMenu.allowOutsidePressDismissal.current = true;
+		}, 500);
+	});
+	createEffect(() => ({
+		open: store.open(),
+		activeTriggerId: store.activeTriggerId()
+	}), () => untrack(() => store.reconcileTriggers()));
+	let observedOpen = untrack(() => store.open());
+	createEffect(() => store.open(), (open) => {
+		if (observedOpen && !open) untrack(() => {
+			store.context.floatingRoot.syncOpenEvent(false, void 0);
+			store.resetAfterObservedClose();
+		});
+		observedOpen = open;
+	});
+	createEffect(() => ({
+		open: store.open(),
+		mounted: presence.mounted(),
+		items: store.collection.items()
+	}), ({ open, mounted }) => {
+		if (!open || !mounted) return;
+		let canceled = false;
+		let frame = 0;
+		let attempts = 0;
+		const focusKeyboardItem = () => {
+			untrack(() => {
+				if (canceled || !store.open() || store.openMethod() !== "keyboard") return;
+				if (!store.focusPendingItem()) store.activeElement()?.focus({ preventScroll: true });
+				attempts += 1;
+				if (attempts < 4) frame = requestAnimationFrame(focusKeyboardItem);
+			});
+		};
+		queueMicrotask(() => {
+			untrack(() => {
+				store.focusPendingItem();
+				if (store.openMethod() === "keyboard") frame = requestAnimationFrame(focusKeyboardItem);
+			});
+		});
+		return () => {
+			canceled = true;
+			cancelAnimationFrame(frame);
+		};
+	});
+	createEffect(() => ({
+		open: store.open(),
+		reason: store.openChangeReason(),
+		tree: store.tree(),
+		parentNodeId: store.parentNodeId()
+	}), ({ open, reason, tree: currentTree, parentNodeId: currentParentNodeId }) => {
+		untrack(() => {
+			currentTree.events.emit("menuopenchange", {
+				open,
+				nodeId,
+				parentNodeId: currentParentNodeId,
+				reason
+			});
+		});
+	});
+	createEffect(() => store.tree(), (currentTree) => currentTree.events.on("close", ({ event, reason }) => {
+		if (store.open()) store.setOpen(false, createChangeEventDetails(reason, event));
+	}));
+	const actions = {
+		unmount: presence.forceUnmount,
+		close() {
+			store.setOpen(false, createChangeEventDetails(imperativeAction));
+		}
+	};
+	createEffect(() => props.actionsRef, (ref) => {
+		ref?.(actions);
+	});
+	function MenuRootContent() {
+		const child = createMemo(() => props.children);
+		const initialChild = untrack(child);
+		let content = initialChild;
+		if (typeof initialChild === "function") content = initialChild.name === "bound read" && Object.prototype.hasOwnProperty.call(initialChild, $REFRESH) ? memo(() => {
+			return escape(child());
+		}) : untrack(() => initialChild({ payload }));
+		return content;
+	}
+	onCleanup(() => {
+		clearTimeout(allowOutsidePressTimer);
+		store.dispose();
+		store.clearInteractionProps();
+		delete store.context.floatingRoot.context.data.insideElements;
+	});
+	return MenuRootContext({
+		value: context,
+		get children() {
+			return FloatingTreeContext({
+				value: tree,
+				get children() {
+					return FloatingParentNodeContext({
+						get value() {
+							return node.id ?? null;
+						},
+						get children() {
+							return MenuRootContent({});
+						}
+					});
+				}
+			});
+		}
+	});
+}
+//#endregion
+//#region src/menu/utils/mergeMenuStyles.ts
+function mergeMenuStyles(internal, external) {
+	if (typeof external === "string") {
+		const serialized = Object.entries(internal).filter((entry) => entry[1] != null).map(([property, value]) => `${property}:${String(value)}`).join(";");
+		return serialized ? `${serialized};${external}` : external;
+	}
+	return {
+		...internal,
+		...external || void 0
+	};
+}
+//#endregion
+//#region src/menu/backdrop/MenuBackdrop.tsx
+/** A presentational overlay displayed beneath the menu popup. */
+function MenuBackdrop(props) {
+	const context = useMenuRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const state = createMemo(() => ({
+		open: context.store.open(),
+		transitionStatus: context.store.track().transitionStatus
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeMenuStyles({
+		"pointer-events": context.store.openChangeReason() === "trigger-hover" ? "none" : void 0,
+		"user-select": "none",
+		"-webkit-user-select": "none"
+	}, resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), popupTransitionStateMapping));
+	const others = omit(allProps, "as", "class", "ref", "style");
+	let backdrop = null;
+	onCleanup(() => {
+		if (context.backdropElement() === backdrop) context.setBackdropElement(null);
+	});
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [((element) => {
+			backdrop = element;
+			context.setBackdropElement(element);
+		}), internalProps.ref],
+		role: "presentation",
+		get hidden() {
+			return !context.presence.mounted();
+		},
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/menu/portal/MenuPortalContext.ts
+var MISSING_CONTEXT$5 = Symbol("MenuPortalContext");
+var MenuPortalContext = createContext(MISSING_CONTEXT$5);
+function useMenuPortalContext() {
+	const context = useContext(MenuPortalContext);
+	if (context === MISSING_CONTEXT$5) throw new Error("Base UI: <Menu.Positioner> must be placed within <Menu.Portal>.");
+	return context;
+}
+//#endregion
+//#region src/menu/portal/MenuPortal.tsx
+/** Moves the menu layer into a portal appended to the document body by default. */
+function MenuPortal(props) {
+	const context = useMenuRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const keepMounted = createMemo(() => internalProps.keepMounted ?? false);
+	const shouldRender = createMemo(() => context.presence.mounted() || keepMounted());
+	const state = {};
+	const classValue = createMemo(() => resolveClass(props.class, state));
+	const styleValue = createMemo(() => resolveStyle(props.style, state));
+	const others = omit(allProps, "as", "class", "container", "keepMounted", "ref", "style");
+	const portalContext = { keepMounted };
+	return Show({
+		get when() {
+			return shouldRender();
+		},
+		get children() {
+			return MenuPortalContext({
+				value: portalContext,
+				get children() {
+					return PopupPortal(mergeProps({
+						get as() {
+							return props.as;
+						},
+						get container() {
+							return internalProps.container;
+						},
+						ref: (element) => {
+							if (internalProps.ref) setRef(internalProps.ref, element);
+						},
+						get ["class"]() {
+							return classValue();
+						},
+						get style() {
+							return styleValue();
+						}
+					}, others, { get children() {
+						return props.children;
+					} }));
+				}
+			});
+		}
+	});
+}
+//#endregion
+//#region src/menu/utils/stateAttributesMapping.ts
+var menuPositionerStateMapping = {
+	...popupStateMapping,
+	nested: (value) => value ? { "data-nested": "" } : null
+};
+var menuPopupStateMapping = {
+	...popupTransitionStateMapping,
+	nested: (value) => value ? { "data-nested": "" } : null
+};
+var menuViewportStateMapping = { activationDirection: (value) => value ? { "data-activation-direction": value } : null };
+var CHECKED = { "data-checked": "" };
+var UNCHECKED = { "data-unchecked": "" };
+var menuItemStateMapping = { checked: (value) => value ? CHECKED : UNCHECKED };
+//#endregion
+//#region src/menu/positioner/MenuPositionerContext.ts
+var MISSING_CONTEXT$4 = Symbol("MenuPositionerContext");
+var MenuPositionerContext = createContext(MISSING_CONTEXT$4);
+function useMenuPositionerContext(optional = false) {
+	const context = useContext(MenuPositionerContext);
+	if (context === MISSING_CONTEXT$4) {
+		if (optional) return;
+		throw new Error("Base UI: <Menu.Positioner> is missing.");
+	}
+	return context;
+}
+//#endregion
+//#region src/menu/positioner/MenuPositioner.tsx
+/** Positions the menu popup against its active trigger or a custom anchor. */
+function MenuPositioner(props) {
+	useMenuPortalContext();
+	const context = useMenuRootContext();
+	const direction = useDirection();
+	const internalProps = props;
+	const allProps = props;
+	const [element, setElement] = createSignal(null, { ownedWrite: true });
+	const contextMenuRoot = context.contextMenu !== void 0 && !context.nested;
+	const reference = createMemo(() => resolveAnchor(internalProps.anchor) ?? (contextMenuRoot ? context.contextMenu?.anchor() : void 0) ?? context.store.context.floatingRoot.referenceElement());
+	const align = () => internalProps.align ?? (context.nested || contextMenuRoot || context.store.menubar() ? "start" : "center");
+	const hasContextMenuDefaultOffsets = () => contextMenuRoot && internalProps.side === void 0 && align() !== "center";
+	const collisionAvoidance = () => internalProps.collisionAvoidance ?? { fallbackAxisSide: context.nested ? "end" : "none" };
+	const positioning = createAnchorPositioning({
+		reference,
+		floating: element,
+		mounted: context.presence.mounted,
+		direction,
+		positionMethod: () => context.contextMenu ? "fixed" : internalProps.positionMethod ?? "absolute",
+		side: () => internalProps.side ?? (context.nested || context.store.menubar()?.orientation() === "vertical" ? "inline-end" : "bottom"),
+		sideOffset: () => internalProps.sideOffset ?? (hasContextMenuDefaultOffsets() ? -5 : 0),
+		align,
+		alignOffset: () => internalProps.alignOffset ?? (hasContextMenuDefaultOffsets() ? 2 : 0),
+		collisionBoundary: () => internalProps.collisionBoundary ?? "clipping-ancestors",
+		collisionPadding: () => internalProps.collisionPadding ?? 5,
+		arrowPadding: () => contextMenuRoot ? 0 : internalProps.arrowPadding ?? 5,
+		sticky: () => internalProps.sticky ?? false,
+		disableAnchorTracking: () => internalProps.disableAnchorTracking ?? false,
+		collisionAvoidance,
+		shiftRootBoundary: () => contextMenuRoot ? "layoutViewport" : void 0,
+		shiftCrossAxis: () => contextMenuRoot && !("side" in collisionAvoidance() && collisionAvoidance().side === "flip"),
+		adaptiveOriginMiddleware: () => context.store.track().adaptiveOriginMiddleware
+	});
+	const initialPositioning = createInitialPositioning(() => context.store.open(), () => positioning.state().isPositioned);
+	const state = createMemo(() => ({
+		open: context.store.open(),
+		side: positioning.renderedSide(),
+		align: positioning.renderedAlign(),
+		anchorHidden: positioning.anchorHidden(),
+		nested: context.nested,
+		instant: context.store.instantType() ?? (initialPositioning() ? "initial" : void 0)
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeMenuStyles({
+		...positioning.styles(),
+		"pointer-events": context.store.open() ? void 0 : "none"
+	}, resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), menuPositionerStateMapping));
+	const others = omit(allProps, "align", "alignOffset", "anchor", "arrowPadding", "as", "class", "collisionAvoidance", "collisionBoundary", "collisionPadding", "disableAnchorTracking", "positionMethod", "ref", "side", "sideOffset", "sticky", "style");
+	const modalNonHover = createMemo(() => !context.nested && context.store.modal() && context.store.openChangeReason() !== "trigger-hover");
+	const menubarModal = createMemo(() => context.store.menubar()?.modal() ?? false);
+	const modalPolicy = createMemo(() => menubarModal() || modalNonHover());
+	let previousTrigger = null;
+	let handoffController;
+	let closeTimer;
+	createAnchoredPopupScrollLock({
+		enabled: () => context.store.open() && modalPolicy(),
+		touchOpen: () => context.store.openMethod() === "touch",
+		positioner: element,
+		reference: () => context.store.track().activeTriggerElement
+	});
+	createEffect(() => positioning.state().placement, (placement) => {
+		context.store.context.floatingRoot.context.data.placement = placement;
+	});
+	createEffect(() => ({
+		positioned: positioning.state().isPositioned,
+		open: context.store.open(),
+		method: context.store.openMethod()
+	}), ({ positioned, open, method }) => {
+		if (positioned && open && method === "keyboard") queueMicrotask(() => {
+			untrack(() => {
+				if (!context.store.focusPendingItem()) context.store.activeElement()?.focus({ preventScroll: true });
+			});
+		});
+	});
+	createEffect(() => ({
+		trigger: context.store.track().activeTriggerElement,
+		positioner: element(),
+		open: context.store.open()
+	}), ({ trigger, positioner, open }) => {
+		if (!open) {
+			previousTrigger = null;
+			handoffController?.abort();
+			return;
+		}
+		const previous = previousTrigger;
+		if (trigger) previousTrigger = trigger;
+		if (!previous || !trigger || previous === trigger || !positioner) return;
+		context.store.setInstantType(void 0);
+		handoffController?.abort();
+		const controller = new AbortController();
+		handoffController = controller;
+		runOnceAnimationsFinish(positioner, () => context.store.setInstantType("trigger-change"), controller.signal);
+		return () => controller.abort();
+	});
+	createEffect(() => context.store.tree(), (tree) => tree.events.on("menuopenchange", (details) => {
+		if (details.open && details.parentNodeId === context.node.id) context.store.setHoverEnabled(false);
+		if (details.open && details.nodeId !== context.node.id && details.parentNodeId === context.store.parentNodeId()) {
+			context.store.setOpen(false, createChangeEventDetails(siblingOpen));
+			return;
+		}
+		if (!details.open && context.store.parentNodeId() !== null && details.nodeId === context.store.parentNodeId()) context.store.setOpen(false, createChangeEventDetails(details.reason ?? "sibling-open"));
+	}));
+	createEffect(() => context.store.tree(), (tree) => tree.events.on("itemhover", ({ nodeId, target }) => {
+		if (!context.store.open() || nodeId !== context.store.parentNodeId()) return;
+		if (target === context.store.track().activeTriggerElement) {
+			clearTimeout(closeTimer);
+			closeTimer = void 0;
+			return;
+		}
+		if (closeTimer !== void 0) return;
+		const close = () => context.store.setOpen(false, createChangeEventDetails(siblingOpen));
+		const delay = context.store.track().closeDelay;
+		if (delay > 0) closeTimer = setTimeout(() => {
+			closeTimer = void 0;
+			close();
+		}, delay);
+		else close();
+	}));
+	createEffect(() => context.store.open(), (open) => {
+		if (!open) {
+			clearTimeout(closeTimer);
+			closeTimer = void 0;
+		}
+	});
+	onCleanup(() => {
+		clearTimeout(closeTimer);
+		handoffController?.abort();
+		delete context.store.context.floatingRoot.context.data.placement;
+		if (context.store.state.positionerElement === untrack(element)) context.store.setPositionerElement(null);
+	});
+	function ModalBackdrop() {
+		let backdrop = null;
+		onCleanup(() => {
+			if (context.internalBackdropElement() === backdrop) context.setInternalBackdropElement(null);
+		});
+		return InternalBackdrop({
+			ref: (value) => {
+				backdrop = value;
+				context.setInternalBackdropElement(value);
+			},
+			get cutout() {
+				return context.store.menubar()?.rootElement() ?? context.store.track().activeTriggerElement;
+			},
+			get open() {
+				return context.store.open();
+			}
+		});
+	}
+	return MenuPositionerContext({
+		value: positioning,
+		get children() {
+			return [Show({
+				get when() {
+					return memo(() => {
+						return !!context.presence.mounted();
+					})() ? modalPolicy() : context.presence.mounted();
+				},
+				get children() {
+					return ModalBackdrop({});
+				}
+			}), Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [((value) => {
+					setElement(value);
+					context.store.setPositionerElement(value);
+				}), internalProps.ref],
+				role: "presentation",
+				get hidden() {
+					return !context.presence.mounted();
+				},
+				get inert() {
+					return !context.store.open() || void 0;
+				},
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				}
+			}, stateAttributes, others))];
+		}
+	});
+}
+function resolveAnchor(anchor) {
+	if (typeof anchor === "function") return anchor();
+	if (anchor && "current" in anchor) return anchor.current;
+	return anchor;
+}
+//#endregion
+//#region src/menu/popup/MenuPopup.tsx
+var COMPOSITE_KEYS = /* @__PURE__ */ new Set([
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"Home",
+	"End"
+]);
+/** A container for the menu items. */
+function MenuPopup(props) {
+	const context = useMenuRootContext();
+	const positioner = useMenuPositionerContext();
+	const insideToolbar = useToolbarRootContext(true) !== void 0;
+	const internalProps = props;
+	const allProps = props;
+	const contextMenuRoot = context.contextMenu !== void 0 && !context.nested;
+	const state = createMemo(() => ({
+		transitionStatus: context.store.track().transitionStatus,
+		side: positioner.renderedSide(),
+		align: positioner.renderedAlign(),
+		open: context.store.open(),
+		nested: context.nested,
+		instant: context.store.instantType()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), menuPopupStateMapping));
+	const id = createMemo(() => internalProps.id ?? context.store.context.floatingId);
+	const others = omit(allProps, "as", "class", "finalFocus", "id", "onClick", "onKeyDown", "onMouseMove", "ref", "style");
+	let popupElement = null;
+	function handleKeyDown(event) {
+		const dismissHandler = context.store.state.popupProps.onKeyDown;
+		if (typeof dismissHandler === "function") dismissHandler(event);
+		if (context.store.disabled()) return;
+		if (event.key === "Tab") {
+			event.preventDefault();
+			const rootStore = context.store.rootStore();
+			const trigger = (context.nested && event.shiftKey ? context.store : rootStore).track().activeTriggerElement;
+			const target = event.shiftKey ? trigger : getNextTabTarget(trigger, rootStore.rootNodeId());
+			if (context.nested && event.shiftKey) context.store.setOpen(false, createChangeEventDetails(focusOut, event));
+			else rootStore.closeTree(event, focusOut);
+			queueMicrotask(() => target?.focus({ preventScroll: true }));
+			return;
+		}
+		if (context.store.handleTypeahead(event)) return;
+		if (event.defaultPrevented || context.store.navigate(event)) return;
+		if (context.nested && context.store.parentStore) {
+			const closeKey = context.store.parentStore.orientation() === "vertical" ? context.store.direction() === "rtl" ? "ArrowRight" : "ArrowLeft" : "ArrowUp";
+			if (event.key === closeKey) {
+				event.preventDefault();
+				event.stopPropagation();
+				const trigger = context.store.track().activeTriggerElement;
+				context.store.setOpen(false, createChangeEventDetails(listNavigation, event));
+				trigger?.focus({ preventScroll: true });
+			}
+		}
+		if (!event.defaultPrevented && !event.cancelBubble) context.store.relayKeyboardEvent(event);
+	}
+	const onKeyDown = composeEventHandlers(() => internalProps.onKeyDown, () => handleKeyDown, () => (event) => {
+		if (insideToolbar && COMPOSITE_KEYS.has(event.key)) event.stopPropagation();
+	});
+	const onMouseMove = composeEventHandlers(() => internalProps.onMouseMove, () => () => {
+		context.store.setAllowMouseEnter(true);
+		if (context.nested) context.store.setHoverEnabled(false);
+	});
+	const onClick = composeEventHandlers(() => internalProps.onClick, () => () => context.store.setHoverEnabled(false));
+	const defaultReturnFocus = () => untrack(() => {
+		const reason = context.store.openChangeReason();
+		if (reason === "focus-out" || context.store.menubar() && (reason === "sibling-open" || reason === "list-navigation")) return false;
+		if (context.store.menubar() && !context.store.track().activeTriggerElement && reason === "outside-press") return false;
+		return true;
+	});
+	createEffect(() => id(), (currentId) => context.store.setPopupId(currentId));
+	createEffect(() => context.store.track().popupElement, (element) => {
+		if (!element || typeof MutationObserver === "undefined") return;
+		const observer = new MutationObserver(() => context.store.collection.touch());
+		observer.observe(element, {
+			childList: true,
+			subtree: true,
+			characterData: true
+		});
+		return () => observer.disconnect();
+	});
+	onCleanup(() => {
+		if (context.store.state.popupElement === popupElement) context.store.setPopupElement(null);
+	});
+	function PopupElement() {
+		return Dynamic(mergeProps({
+			get component() {
+				return props.as ?? "div";
+			},
+			ref: [((element) => {
+				popupElement = element;
+				context.store.setPopupElement(element);
+			}), internalProps.ref],
+			get id() {
+				return id();
+			},
+			role: "menu",
+			tabIndex: -1,
+			"data-base-ui-focusable": "",
+			get ["data-rootownerid"]() {
+				return context.store.rootNodeId();
+			},
+			get ["aria-labelledby"]() {
+				return context.store.track().activeTriggerElement?.id || void 0;
+			},
+			get ["aria-orientation"]() {
+				return context.store.orientation();
+			},
+			get ["class"]() {
+				return classValue();
+			},
+			get style() {
+				return styleValue();
+			},
+			onClick,
+			onMouseMove,
+			onKeyDown
+		}, stateAttributes, others));
+	}
+	return FocusManager({
+		get context() {
+			return context.store.context.floatingRoot;
+		},
+		get tree() {
+			return context.store.tree();
+		},
+		get disabled() {
+			return !context.presence.mounted();
+		},
+		initialFocus: () => {
+			return untrack(() => {
+				if (context.store.focusPendingItem()) return false;
+				if (context.store.openMethod() === "keyboard" && context.store.collection.availableIndices().length > 0) return false;
+				return context.store.openChangeReason() === "trigger-hover" || context.nested ? false : true;
+			});
+		},
+		get returnFocus() {
+			return internalProps.finalFocus ?? defaultReturnFocus;
+		},
+		modal: contextMenuRoot,
+		restoreFocus: true,
+		get openInteractionType() {
+			return context.store.openMethod();
+		},
+		get previousFocusableElement() {
+			return context.store.track().activeTriggerElement;
+		},
+		get nextFocusableElement() {
+			return memo(() => {
+				return !!(context.nested || context.store.menubar());
+			})() ? void 0 : context.store.afterTriggerGuard.bind(context.store);
+		},
+		get beforeContentGuardRef() {
+			return memo(() => {
+				return !!(context.nested || context.store.menubar());
+			})() ? void 0 : context.store.setBeforeContentGuard.bind(context.store);
+		},
+		get children() {
+			return PopupElement({});
+		}
+	});
+}
+function getNextTabTarget(trigger, rootOwnerId) {
+	if (!trigger) return null;
+	const elements = tabbable(trigger.ownerDocument.body).filter((element) => !element.hasAttribute("data-base-ui-focus-guard") && !element.closest(`[data-rootownerid="${rootOwnerId}"]`));
+	const index = elements.indexOf(trigger);
+	return index === -1 ? null : elements[index + 1] ?? null;
+}
+//#endregion
+//#region src/menu/arrow/MenuArrow.tsx
+/** Displays an element positioned against the menu anchor. */
+function MenuArrow(props) {
+	const context = useMenuRootContext();
+	const positioner = useMenuPositionerContext();
+	const internalProps = props;
+	const allProps = props;
+	const state = createMemo(() => ({
+		open: context.store.open(),
+		side: positioner.renderedSide(),
+		align: positioner.renderedAlign(),
+		uncentered: positioner.arrowUncentered()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => mergeMenuStyles(positioner.arrowStyles(), resolveStyle(props.style, state())));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), popupStateMapping));
+	const others = omit(allProps, "as", "class", "ref", "style");
+	let arrowElement = null;
+	onCleanup(() => {
+		if (arrowElement) positioner.setArrowElement(null);
+	});
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [((element) => {
+			arrowElement = element;
+			positioner.setArrowElement(element);
+		}), internalProps.ref],
+		"aria-hidden": "true",
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/menu/group/MenuGroupContext.ts
+var MISSING_CONTEXT$3 = Symbol("MenuGroupContext");
+var MenuGroupContext = createContext(MISSING_CONTEXT$3);
+function useMenuGroupContext() {
+	const context = useContext(MenuGroupContext);
+	if (context === MISSING_CONTEXT$3) throw new Error("Base UI: <Menu.GroupLabel> must be placed within <Menu.Group> or <Menu.RadioGroup>.");
+	return context;
+}
+//#endregion
+//#region src/menu/group/MenuGroup.tsx
+/** Groups related menu items. */
+function MenuGroup(props) {
+	const internalProps = props;
+	const allProps = props;
+	const [labelId, setLabelId] = createSignal();
+	const context = {
+		labelId,
+		setLabelId
+	};
+	const state = {};
+	const classValue = createMemo(() => resolveClass(props.class, state));
+	const styleValue = createMemo(() => resolveStyle(props.style, state));
+	const others = omit(allProps, "as", "class", "ref", "style");
+	return MenuGroupContext({
+		value: context,
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [internalProps.ref],
+				role: "group",
+				get ["aria-labelledby"]() {
+					return labelId();
+				},
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				}
+			}, others));
+		}
+	});
+}
+//#endregion
+//#region src/menu/group-label/MenuGroupLabel.tsx
+/** An accessible label for a menu group. */
+function MenuGroupLabel(props) {
+	const context = useMenuGroupContext();
+	const internalProps = props;
+	const allProps = props;
+	const generatedId = `base-ui-${createUniqueId()}`;
+	const id = createMemo(() => internalProps.id || generatedId);
+	const state = {};
+	const classValue = createMemo(() => resolveClass(props.class, state));
+	const styleValue = createMemo(() => resolveStyle(props.style, state));
+	const others = omit(allProps, "as", "class", "id", "ref", "style");
+	createEffect(() => id(), (currentId) => {
+		context.setLabelId(currentId);
+		return () => {
+			if (context.labelId() === currentId) context.setLabelId(void 0);
+		};
+	});
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [internalProps.ref],
+		get id() {
+			return id();
+		},
+		role: "presentation",
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, others));
+}
+//#endregion
+//#region src/menu/item/createMenuItem.ts
+function createMenuItem(options) {
+	const token = Symbol("menu-item");
+	const [element, setElement] = createSignal(null, { ownedWrite: true });
+	const unregister = options.store.collection.register({
+		token,
+		element,
+		label: options.label
+	});
+	const index = createMemo(() => options.store.collection.indexOf(token));
+	const highlighted = createMemo(() => options.store.isItemActive(element()));
+	onCleanup(unregister);
+	return {
+		element,
+		setElement(value) {
+			setElement(value);
+			options.store.collection.touch();
+		},
+		index,
+		highlighted,
+		onFocus(event) {
+			untrack(() => options.store.setActiveElement(event.currentTarget));
+		},
+		onBlur(event) {
+			untrack(() => {
+				const current = event.currentTarget;
+				if (options.store.activeElement() === current && event.relatedTarget !== current) options.store.setActiveElement(null);
+			});
+		},
+		onMouseMove(event) {
+			options.store.tree().events.emit("itemhover", {
+				nodeId: options.store.context.floatingRoot.context.nodeId,
+				target: event.currentTarget
+			});
+			if (options.store.highlightItemOnHover()) {
+				const current = event.currentTarget;
+				options.store.setActiveElement(current);
+				if (options.store.allowMouseEnter()) current.focus({ preventScroll: true });
+			}
+		},
+		onMouseUp(event) {
+			const contextMenu = options.store.contextMenu;
+			if (contextMenu) {
+				const initialCursorPoint = contextMenu.initialCursorPoint.current;
+				contextMenu.initialCursorPoint.current = null;
+				if (initialCursorPoint && Math.abs(event.clientX - initialCursorPoint.x) <= 1 && Math.abs(event.clientY - initialCursorPoint.y) <= 1) return;
+				if (!isMacPlatform() && event.button === 2) return;
+			}
+			if (!options.submenu && options.store.allowMouseUpTrigger && (!contextMenu || event.button === 2)) dispatchClickWithModifiers(event.currentTarget, event, 1);
+		},
+		onKeyDown(event, nativeButton) {
+			if (event.target !== event.currentTarget) return;
+			if (event.key === " " && options.store.typing()) {
+				event.preventDefault();
+				event.preventBaseUIHandler();
+				return;
+			}
+			if (event.key !== "Enter" && event.key !== " ") return;
+			const current = event.currentTarget;
+			if (current.tagName === "A" && Boolean(current.href) && event.key === "Enter") return;
+			if (nativeButton && current.tagName === "BUTTON" && event.key === "Enter") return;
+			event.preventDefault();
+			event.preventBaseUIHandler();
+			dispatchClickWithModifiers(current, event, 0);
+		},
+		onKeyUp(event, nativeButton) {
+			if (nativeButton && event.target === event.currentTarget && event.currentTarget.tagName === "BUTTON" && event.key === " ") event.preventDefault();
+		},
+		close(event) {
+			options.store.closeTree(event, "item-press");
+		}
+	};
+}
+function isMacPlatform() {
+	if (typeof navigator === "undefined") return false;
+	const platform = navigator.platform.toLowerCase();
+	return !(/^i(os$|p)/.test(platform) || platform === "macintel" && navigator.maxTouchPoints > 1) && platform.startsWith("mac");
+}
+function dispatchClickWithModifiers(target, source, detail, onCreate) {
+	const EventConstructor = target.ownerDocument.defaultView?.MouseEvent ?? MouseEvent;
+	const mouseSource = "button" in source ? source : null;
+	const event = new EventConstructor("click", {
+		bubbles: true,
+		cancelable: true,
+		composed: true,
+		detail,
+		button: mouseSource?.button ?? 0,
+		buttons: mouseSource?.buttons ?? 0,
+		clientX: mouseSource?.clientX ?? 0,
+		clientY: mouseSource?.clientY ?? 0,
+		shiftKey: source.shiftKey,
+		ctrlKey: source.ctrlKey,
+		altKey: source.altKey,
+		metaKey: source.metaKey
+	});
+	onCreate?.(event);
+	target.dispatchEvent(event);
+	return event;
+}
+function preventDisabledMenuItemActivation(event) {
+	if (event.key === "Enter" || event.key === " ") {
+		event.preventDefault();
+		event.preventBaseUIHandler();
+	}
+}
+//#endregion
+//#region src/menu/item/MenuItem.tsx
+/** An individual interactive item in the menu. */
+function MenuItem(props) {
+	const context = useMenuRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const nativeButton = createMemo(() => internalProps.nativeButton ?? false);
+	const disabled = createMemo(() => Boolean(internalProps.disabled || context.store.disabled()));
+	const closeOnClick = createMemo(() => internalProps.closeOnClick ?? true);
+	const item = createMenuItem({
+		store: context.store,
+		label: () => internalProps.label
+	});
+	const state = createMemo(() => ({
+		disabled: disabled(),
+		highlighted: item.highlighted()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state()));
+	const others = omit(allProps, "as", "class", "closeOnClick", "disabled", "id", "label", "nativeButton", "onClick", "onFocus", "onBlur", "onKeyDown", "onKeyUp", "onMouseMove", "onMouseUp", "ref", "style");
+	const onClick = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onClick, () => (event) => {
+		if (closeOnClick()) item.close(event);
+	});
+	const onKeyDown = composeEventHandlers(() => untrack(() => disabled() ? preventDisabledMenuItemActivation : void 0), () => internalProps.onKeyDown, () => (event) => item.onKeyDown(event, nativeButton()));
+	const onKeyUp = composeEventHandlers(() => untrack(() => disabled() ? stopButtonInteraction : void 0), () => internalProps.onKeyUp, () => (event) => item.onKeyUp(event, nativeButton()));
+	const onMouseMove = composeEventHandlers(() => internalProps.onMouseMove, () => item.onMouseMove);
+	const onMouseUp = composeEventHandlers(() => internalProps.onMouseUp, () => item.onMouseUp);
+	const onFocus = composeEventHandlers(() => internalProps.onFocus, () => item.onFocus);
+	const onBlur = composeEventHandlers(() => internalProps.onBlur, () => item.onBlur);
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "div";
+		},
+		ref: [((element) => item.setElement(element)), internalProps.ref],
+		get id() {
+			return internalProps.id;
+		},
+		get type() {
+			return nativeButton() ? "button" : void 0;
+		},
+		role: "menuitem",
+		get tabIndex() {
+			return context.store.open() && item.highlighted() ? 0 : -1;
+		},
+		get ["aria-disabled"]() {
+			return disabled() ? "true" : void 0;
+		},
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		},
+		onClick,
+		onFocus,
+		onBlur,
+		onKeyDown,
+		onKeyUp,
+		onMouseMove,
+		onMouseUp
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/menu/checkbox-item/MenuCheckboxItemContext.ts
+var MISSING_CONTEXT$2 = Symbol("MenuCheckboxItemContext");
+var MenuCheckboxItemContext = createContext(MISSING_CONTEXT$2);
+function useMenuCheckboxItemContext() {
+	const context = useContext(MenuCheckboxItemContext);
+	if (context === MISSING_CONTEXT$2) throw new Error("Base UI: <Menu.CheckboxItemIndicator> must be placed within <Menu.CheckboxItem>.");
+	return context;
+}
+//#endregion
+//#region src/menu/checkbox-item/MenuCheckboxItem.tsx
+/** A menu item that toggles a setting on or off. */
+function MenuCheckboxItem(props) {
+	const context = useMenuRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const controlled = untrack(() => internalProps.checked !== void 0);
+	const [uncontrolledChecked, setUncontrolledChecked] = createSignal(untrack(() => internalProps.defaultChecked ?? false), { ownedWrite: true });
+	const checked = createMemo(() => controlled ? Boolean(internalProps.checked) : uncontrolledChecked());
+	const nativeButton = createMemo(() => internalProps.nativeButton ?? false);
+	const disabled = createMemo(() => Boolean(internalProps.disabled || context.store.disabled()));
+	const closeOnClick = createMemo(() => internalProps.closeOnClick ?? false);
+	const item = createMenuItem({
+		store: context.store,
+		label: () => internalProps.label
+	});
+	const state = createMemo(() => ({
+		disabled: disabled(),
+		highlighted: item.highlighted(),
+		checked: checked()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), menuItemStateMapping));
+	const others = omit(allProps, "as", "checked", "class", "closeOnClick", "defaultChecked", "disabled", "id", "label", "nativeButton", "onBlur", "onCheckedChange", "onClick", "onFocus", "onKeyDown", "onKeyUp", "onMouseMove", "onMouseUp", "ref", "style");
+	function toggle(event) {
+		const nextChecked = !checked();
+		const details = createChangeEventDetails(itemPress, event, void 0, { preventUnmountOnClose() {} });
+		internalProps.onCheckedChange?.(nextChecked, details);
+		if (!details.isCanceled && !controlled) setUncontrolledChecked(nextChecked);
+	}
+	const onClick = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onClick, () => toggle, () => (event) => {
+		if (closeOnClick()) item.close(event);
+	});
+	const onKeyDown = composeEventHandlers(() => untrack(() => disabled() ? preventDisabledMenuItemActivation : void 0), () => internalProps.onKeyDown, () => (event) => item.onKeyDown(event, nativeButton()));
+	const onKeyUp = composeEventHandlers(() => untrack(() => disabled() ? stopButtonInteraction : void 0), () => internalProps.onKeyUp, () => (event) => item.onKeyUp(event, nativeButton()));
+	const onFocus = composeEventHandlers(() => internalProps.onFocus, () => item.onFocus);
+	const onBlur = composeEventHandlers(() => internalProps.onBlur, () => item.onBlur);
+	const onMouseMove = composeEventHandlers(() => internalProps.onMouseMove, () => item.onMouseMove);
+	const onMouseUp = composeEventHandlers(() => internalProps.onMouseUp, () => item.onMouseUp);
+	return MenuCheckboxItemContext({
+		value: state,
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [((value) => item.setElement(value)), internalProps.ref],
+				get id() {
+					return internalProps.id;
+				},
+				get type() {
+					return nativeButton() ? "button" : void 0;
+				},
+				role: "menuitemcheckbox",
+				get tabIndex() {
+					return context.store.open() && item.highlighted() ? 0 : -1;
+				},
+				get ["aria-checked"]() {
+					return checked() ? "true" : "false";
+				},
+				get ["aria-disabled"]() {
+					return disabled() ? "true" : void 0;
+				},
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				},
+				onClick,
+				onFocus,
+				onBlur,
+				onKeyDown,
+				onKeyUp,
+				onMouseMove,
+				onMouseUp
+			}, stateAttributes, others));
+		}
+	});
+}
+//#endregion
+//#region src/menu/checkbox-item-indicator/MenuCheckboxItemIndicator.tsx
+/** Indicates whether the enclosing checkbox item is checked. */
+function MenuCheckboxItemIndicator(props) {
+	const itemState = useMenuCheckboxItemContext();
+	const internalProps = props;
+	const allProps = props;
+	const transition = createTransitionStatus(() => itemState().checked);
+	const shouldRender = createMemo(() => (internalProps.keepMounted ?? false) || transition.mounted());
+	const state = createMemo(() => ({
+		...itemState(),
+		transitionStatus: transition.transitionStatus()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), {
+		...menuItemStateMapping,
+		...transitionStatusMapping
+	}));
+	const others = omit(allProps, "as", "class", "keepMounted", "ref", "style");
+	let element;
+	let latestChecked = false;
+	createEffect(() => ({
+		checked: itemState().checked,
+		status: transition.transitionStatus(),
+		element
+	}), (current) => {
+		latestChecked = current.checked;
+		if (current.checked || current.status !== "ending" || !current.element) return;
+		const controller = new AbortController();
+		runOnceAnimationsFinish(current.element, () => {
+			if (!latestChecked) transition.setMounted(false);
+		}, controller.signal);
+		return () => controller.abort();
+	});
+	return Show({
+		get when() {
+			return shouldRender();
+		},
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "span";
+				},
+				ref: [((value) => element = value), internalProps.ref],
+				"aria-hidden": "true",
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				}
+			}, stateAttributes, others));
+		}
+	});
+}
+//#endregion
+//#region src/menu/link-item/MenuLinkItem.tsx
+/** A link in the menu that navigates to another page or section. */
+function MenuLinkItem(props) {
+	const context = useMenuRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const closeOnClick = createMemo(() => internalProps.closeOnClick ?? false);
+	const disabled = createMemo(() => context.store.disabled());
+	const item = createMenuItem({
+		store: context.store,
+		label: () => internalProps.label
+	});
+	const state = createMemo(() => ({ highlighted: item.highlighted() }));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state()));
+	const others = omit(allProps, "as", "class", "closeOnClick", "id", "label", "onClick", "onFocus", "onBlur", "onKeyDown", "onKeyUp", "onMouseMove", "onMouseUp", "ref", "style");
+	const onClick = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onClick, () => (event) => {
+		if (closeOnClick()) item.close(event);
+	});
+	const onKeyDown = composeEventHandlers(() => untrack(() => disabled() ? preventDisabledMenuItemActivation : void 0), () => internalProps.onKeyDown, () => (event) => item.onKeyDown(event, false));
+	const onKeyUp = composeEventHandlers(() => untrack(() => disabled() ? stopButtonInteraction : void 0), () => internalProps.onKeyUp, () => (event) => item.onKeyUp(event, false));
+	const onMouseMove = composeEventHandlers(() => internalProps.onMouseMove, () => item.onMouseMove);
+	const onMouseUp = composeEventHandlers(() => internalProps.onMouseUp, () => item.onMouseUp);
+	const onFocus = composeEventHandlers(() => internalProps.onFocus, () => item.onFocus);
+	const onBlur = composeEventHandlers(() => internalProps.onBlur, () => item.onBlur);
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "a";
+		},
+		ref: [((element) => item.setElement(element)), internalProps.ref],
+		get id() {
+			return internalProps.id;
+		},
+		role: "menuitem",
+		get tabIndex() {
+			return context.store.open() && item.highlighted() ? 0 : -1;
+		},
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		},
+		onClick,
+		onFocus,
+		onBlur,
+		onKeyDown,
+		onKeyUp,
+		onMouseMove,
+		onMouseUp
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/menu/radio-group/MenuRadioGroupContext.ts
+var MISSING_CONTEXT$1 = Symbol("MenuRadioGroupContext");
+var MenuRadioGroupContext = createContext(MISSING_CONTEXT$1);
+function useMenuRadioGroupContext() {
+	const context = useContext(MenuRadioGroupContext);
+	if (context === MISSING_CONTEXT$1) throw new Error("Base UI: <Menu.RadioItem> must be placed within <Menu.RadioGroup>.");
+	return context;
+}
+//#endregion
+//#region src/menu/radio-group/MenuRadioGroup.tsx
+/** Groups related radio items. */
+function MenuRadioGroup(props) {
+	const internalProps = props;
+	const allProps = props;
+	const controlled = untrack(() => internalProps.value !== void 0);
+	const [uncontrolledValue, setUncontrolledValue] = createSignal(untrack(() => internalProps.defaultValue), { ownedWrite: true });
+	const [labelId, setLabelId] = createSignal();
+	const value = createMemo(() => controlled ? internalProps.value : uncontrolledValue());
+	const disabled = createMemo(() => internalProps.disabled ?? false);
+	const state = createMemo(() => ({ disabled: disabled() }));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state()));
+	const others = omit(allProps, "aria-labelledby", "as", "class", "defaultValue", "disabled", "onValueChange", "ref", "style", "value");
+	const groupContext = {
+		labelId,
+		setLabelId
+	};
+	const radioContext = {
+		value,
+		disabled,
+		setValue(nextValue, details) {
+			internalProps.onValueChange?.(nextValue, details);
+			if (!details.isCanceled && !controlled) setUncontrolledValue(() => nextValue);
+		}
+	};
+	return MenuGroupContext({
+		value: groupContext,
+		get children() {
+			return MenuRadioGroupContext({
+				value: radioContext,
+				get children() {
+					return Dynamic(mergeProps({
+						get component() {
+							return props.as ?? "div";
+						},
+						ref: [internalProps.ref],
+						role: "group",
+						get ["aria-labelledby"]() {
+							return internalProps["aria-labelledby"] ?? labelId();
+						},
+						get ["aria-disabled"]() {
+							return disabled() ? "true" : void 0;
+						},
+						get ["class"]() {
+							return classValue();
+						},
+						get style() {
+							return styleValue();
+						}
+					}, stateAttributes, others));
+				}
+			});
+		}
+	});
+}
+//#endregion
+//#region src/menu/radio-item/MenuRadioItemContext.ts
+var MISSING_CONTEXT = Symbol("MenuRadioItemContext");
+var MenuRadioItemContext = createContext(MISSING_CONTEXT);
+function useMenuRadioItemContext() {
+	const context = useContext(MenuRadioItemContext);
+	if (context === MISSING_CONTEXT) throw new Error("Base UI: <Menu.RadioItemIndicator> must be placed within <Menu.RadioItem>.");
+	return context;
+}
+//#endregion
+//#region src/menu/radio-item/MenuRadioItem.tsx
+/** A radio item within a menu radio group. */
+function MenuRadioItem(props) {
+	const context = useMenuRootContext();
+	const group = useMenuRadioGroupContext();
+	const internalProps = props;
+	const allProps = props;
+	const nativeButton = createMemo(() => internalProps.nativeButton ?? false);
+	const disabled = createMemo(() => Boolean(internalProps.disabled || group.disabled() || context.store.disabled()));
+	const closeOnClick = createMemo(() => internalProps.closeOnClick ?? false);
+	const checked = createMemo(() => group.value() === internalProps.value);
+	const item = createMenuItem({
+		store: context.store,
+		label: () => internalProps.label
+	});
+	const state = createMemo(() => ({
+		disabled: disabled(),
+		highlighted: item.highlighted(),
+		checked: checked()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), menuItemStateMapping));
+	const others = omit(allProps, "as", "class", "closeOnClick", "disabled", "id", "label", "nativeButton", "onBlur", "onClick", "onFocus", "onKeyDown", "onKeyUp", "onMouseMove", "onMouseUp", "ref", "style", "value");
+	function select(event) {
+		const details = createChangeEventDetails(itemPress, event, void 0, { preventUnmountOnClose() {} });
+		group.setValue(internalProps.value, details);
+	}
+	const onClick = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onClick, () => select, () => (event) => {
+		if (closeOnClick()) item.close(event);
+	});
+	const onKeyDown = composeEventHandlers(() => untrack(() => disabled() ? preventDisabledMenuItemActivation : void 0), () => internalProps.onKeyDown, () => (event) => item.onKeyDown(event, nativeButton()));
+	const onKeyUp = composeEventHandlers(() => untrack(() => disabled() ? stopButtonInteraction : void 0), () => internalProps.onKeyUp, () => (event) => item.onKeyUp(event, nativeButton()));
+	const onFocus = composeEventHandlers(() => internalProps.onFocus, () => item.onFocus);
+	const onBlur = composeEventHandlers(() => internalProps.onBlur, () => item.onBlur);
+	const onMouseMove = composeEventHandlers(() => internalProps.onMouseMove, () => item.onMouseMove);
+	const onMouseUp = composeEventHandlers(() => internalProps.onMouseUp, () => item.onMouseUp);
+	return MenuRadioItemContext({
+		value: state,
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [((value) => item.setElement(value)), internalProps.ref],
+				get id() {
+					return internalProps.id;
+				},
+				get type() {
+					return nativeButton() ? "button" : void 0;
+				},
+				role: "menuitemradio",
+				get tabIndex() {
+					return context.store.open() && item.highlighted() ? 0 : -1;
+				},
+				get ["aria-checked"]() {
+					return checked() ? "true" : "false";
+				},
+				get ["aria-disabled"]() {
+					return disabled() ? "true" : void 0;
+				},
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				},
+				onClick,
+				onFocus,
+				onBlur,
+				onKeyDown,
+				onKeyUp,
+				onMouseMove,
+				onMouseUp
+			}, stateAttributes, others));
+		}
+	});
+}
+//#endregion
+//#region src/menu/radio-item-indicator/MenuRadioItemIndicator.tsx
+/** Indicates whether the enclosing radio item is selected. */
+function MenuRadioItemIndicator(props) {
+	const itemState = useMenuRadioItemContext();
+	const internalProps = props;
+	const allProps = props;
+	const transition = createTransitionStatus(() => itemState().checked);
+	const shouldRender = createMemo(() => (internalProps.keepMounted ?? false) || transition.mounted());
+	const state = createMemo(() => ({
+		...itemState(),
+		transitionStatus: transition.transitionStatus()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), {
+		...menuItemStateMapping,
+		...transitionStatusMapping
+	}));
+	const others = omit(allProps, "as", "class", "keepMounted", "ref", "style");
+	let element;
+	let latestChecked = false;
+	createEffect(() => ({
+		checked: itemState().checked,
+		status: transition.transitionStatus(),
+		element
+	}), (current) => {
+		latestChecked = current.checked;
+		if (current.checked || current.status !== "ending" || !current.element) return;
+		const controller = new AbortController();
+		runOnceAnimationsFinish(current.element, () => {
+			if (!latestChecked) transition.setMounted(false);
+		}, controller.signal);
+		return () => controller.abort();
+	});
+	return Show({
+		get when() {
+			return shouldRender();
+		},
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "span";
+				},
+				ref: [((value) => element = value), internalProps.ref],
+				"aria-hidden": "true",
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				}
+			}, stateAttributes, others));
+		}
+	});
+}
+//#endregion
+//#region src/menu/submenu-root/MenuSubmenuRoot.tsx
+/** Groups all parts of a submenu without rendering an element. */
+function MenuSubmenuRoot(props) {
+	const parent = useMenuRootContext();
+	return MenuSubmenuRootContext({
+		get value() {
+			return { parentStore: parent.store };
+		},
+		get children() {
+			return MenuRoot(props);
+		}
+	});
+}
+//#endregion
+//#region src/menu/submenu-trigger/MenuSubmenuTrigger.tsx
+/** A menu item that opens a submenu. */
+function MenuSubmenuTrigger(props) {
+	const submenu = useMenuSubmenuRootContext();
+	const child = useMenuRootContext();
+	const parentStore = submenu.parentStore;
+	const internalProps = props;
+	const allProps = props;
+	const id = createMemo(() => internalProps.id || `base-ui-${child.node.id}-trigger`);
+	const nativeButton = createMemo(() => internalProps.nativeButton ?? false);
+	const openOnHover = createMemo(() => internalProps.openOnHover ?? true);
+	const delay = createMemo(() => internalProps.delay ?? 100);
+	const closeDelay = createMemo(() => internalProps.closeDelay ?? 0);
+	const disabled = createMemo(() => Boolean(internalProps.disabled || child.store.disabled() || parentStore.disabled()));
+	const item = createMenuItem({
+		store: parentStore,
+		label: () => internalProps.label,
+		submenu: true
+	});
+	const open = createMemo(() => child.store.open());
+	const state = createMemo(() => ({
+		disabled: disabled(),
+		highlighted: item.highlighted(),
+		open: open()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), triggerOpenStateMapping));
+	const omitExpanded = createMemo(() => open() && isApplePlatform() && (child.store.openChangeReason() === "list-navigation" || child.store.openMethod() === "keyboard"));
+	const others = omit(allProps, "as", "class", "closeDelay", "delay", "disabled", "id", "label", "nativeButton", "onClick", "onFocus", "onBlur", "onKeyDown", "onKeyUp", "onMouseDown", "onMouseMove", "onMouseUp", "onMouseEnter", "openOnHover", "ref", "style");
+	createTriggerRegistration(() => child.store, id, item.element, () => ({ closeDelay: closeDelay() }));
+	let mouseDownHandled = false;
+	function setSubmenuOpen(nextOpen, event, reason) {
+		const element = item.element();
+		if (!element || disabled()) return;
+		child.store.setOpenMethod(event instanceof KeyboardEvent || event.detail === 0 ? "keyboard" : "mouse");
+		child.store.setPendingFocus(nextOpen ? "first" : null);
+		child.store.setOpen(nextOpen, createChangeEventDetails(reason, event, element));
+	}
+	function handleKeyDown(event) {
+		const openKey = parentStore.orientation() === "vertical" ? parentStore.direction() === "rtl" ? "ArrowLeft" : "ArrowRight" : "ArrowDown";
+		if (event.key === openKey) {
+			event.preventDefault();
+			event.stopPropagation();
+			event.preventBaseUIHandler();
+			setSubmenuOpen(true, event, listNavigation);
+			return;
+		}
+		item.onKeyDown(event, nativeButton());
+	}
+	const onClick = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onClick, () => (event) => {
+		if (mouseDownHandled) {
+			mouseDownHandled = false;
+			return;
+		}
+		if (!openOnHover() || event.detail === 0) setSubmenuOpen(openOnHover() ? true : !open(), event, triggerPress);
+	});
+	const onMouseDown = composeEventHandlers(() => untrack(() => disabled() ? preventButtonInteraction : void 0), () => internalProps.onMouseDown, () => (event) => {
+		if (!openOnHover() && event.button === 0) {
+			mouseDownHandled = true;
+			setSubmenuOpen(!open(), event, triggerPress);
+		}
+	});
+	const onKeyDown = composeEventHandlers(() => untrack(() => disabled() ? preventDisabledMenuItemActivation : void 0), () => internalProps.onKeyDown, () => handleDismissKeyDown, () => handleKeyDown);
+	const onKeyUp = composeEventHandlers(() => untrack(() => disabled() ? stopButtonInteraction : void 0), () => internalProps.onKeyUp, () => (event) => item.onKeyUp(event, nativeButton()));
+	const onMouseMove = composeEventHandlers(() => internalProps.onMouseMove, () => item.onMouseMove);
+	const onMouseUp = composeEventHandlers(() => internalProps.onMouseUp, () => item.onMouseUp);
+	const onFocus = composeEventHandlers(() => internalProps.onFocus, () => item.onFocus);
+	const onBlur = composeEventHandlers(() => internalProps.onBlur, () => item.onBlur);
+	const onMouseEnter = composeEventHandlers(() => internalProps.onMouseEnter, () => () => {
+		if (parentStore.highlightItemOnHover()) parentStore.setActiveElement(item.element());
+	});
+	function handleDismissKeyDown(event) {
+		const handler = child.store.state.activeTriggerProps.onKeyDown;
+		if (typeof handler === "function") handler(event);
+	}
+	function HoverInteraction() {
+		createHoverInteraction({
+			context: child.store.context.floatingRoot,
+			reference: item.element,
+			floating: () => child.store.track().positionerElement,
+			tree: () => child.store.tree(),
+			enabled: () => child.store.hoverEnabled() && openOnHover() && !disabled(),
+			delay: () => ({
+				open: delay(),
+				close: closeDelay()
+			}),
+			restMs: delay,
+			handleClose: () => safePolygon({ blockPointerEvents: true }),
+			mouseOnly: () => true,
+			shouldOpen: () => delay() === 0 || parentStore.allowMouseEnter(),
+			blockPointerEventsScope: () => parentStore.track().popupElement,
+			guardStaleOpen: () => true
+		});
+		return null;
+	}
+	return [HoverInteraction({}), Show({
+		get when() {
+			return props.as;
+		},
+		get fallback() {
+			return ssrElement("div", () => {
+				return mergeProps({
+					get id() {
+						return id();
+					},
+					role: "menuitem",
+					get tabIndex() {
+						return open() || item.highlighted() ? 0 : -1;
+					},
+					"aria-haspopup": "menu",
+					get ["aria-expanded"]() {
+						return omitExpanded() ? void 0 : open() ? "true" : "false";
+					},
+					get ["aria-controls"]() {
+						return child.store.triggerPopupId(id());
+					},
+					get ["aria-disabled"]() {
+						return disabled() ? "true" : void 0;
+					},
+					get ["class"]() {
+						return classValue();
+					},
+					get style() {
+						return styleValue();
+					}
+				}, stateAttributes, others);
+			}, void 0, true);
+		},
+		children: (component) => Dynamic(mergeProps({
+			get component() {
+				return component();
+			},
+			ref: [((element) => {
+				item.setElement(element);
+			}), internalProps.ref],
+			get id() {
+				return id();
+			},
+			get type() {
+				return nativeButton() ? "button" : void 0;
+			},
+			role: "menuitem",
+			get tabIndex() {
+				return open() || item.highlighted() ? 0 : -1;
+			},
+			"aria-haspopup": "menu",
+			get ["aria-expanded"]() {
+				return memo(() => {
+					return !!omitExpanded();
+				})() ? void 0 : open() ? "true" : "false";
+			},
+			get ["aria-controls"]() {
+				return child.store.triggerPopupId(id());
+			},
+			get ["aria-disabled"]() {
+				return disabled() ? "true" : void 0;
+			},
+			get ["class"]() {
+				return classValue();
+			},
+			get style() {
+				return styleValue();
+			},
+			onClick,
+			onFocus,
+			onBlur,
+			onKeyDown,
+			onKeyUp,
+			onMouseEnter,
+			onMouseDown,
+			onMouseMove,
+			onMouseUp
+		}, stateAttributes, others))
+	})];
+}
+function isApplePlatform() {
+	if (typeof navigator === "undefined") return false;
+	return /Mac|iPhone|iPad|iPod/i.test(`${navigator.platform} ${navigator.userAgent}`);
+}
+//#endregion
+export { useMenuRootContext as C, useContextMenuRootContext as E, MenuRootContext as S, ContextMenuRootContext as T, menuViewportStateMapping as _, MenuRadioGroup as a, mergeMenuStyles as b, MenuCheckboxItem as c, MenuGroupLabel as d, MenuGroup as f, useMenuPositionerContext as g, MenuPositioner as h, MenuRadioItem as i, MenuItem as l, MenuPopup as m, MenuSubmenuRoot as n, MenuLinkItem as o, MenuArrow as p, MenuRadioItemIndicator as r, MenuCheckboxItemIndicator as s, MenuSubmenuTrigger as t, dispatchClickWithModifiers as u, MenuPortal as v, MenuStore as w, MenuRoot as x, MenuBackdrop as y };