@preply/ds-web-lib 10.0.0 → 11.1.0

package/dist/DropdownMenu.primitives-BrsTBvMk.js

@@ -0,0 +1,4007 @@
+"use client";
+import { t as Icon } from "./Icon-CixAeOSd.js";
+import { t as require_jsx_runtime } from "./jsx-runtime-i4KUlhDu.js";
+import { a as useMergedRefs, c as DROPDOWN_COLLISION_AVOIDANCE, f as useRefWithInit, l as EMPTY_ARRAY$1, r as mergeProps, s as DISABLED_TRANSITIONS_STYLE, t as useRenderElement, u as EMPTY_OBJECT } from "./useRenderElement-ZBds6eRN.js";
+import { S as useEventCallback, b as createChangeEventDetails, c as getParentNode, d as isElement, f as isHTMLElement, l as getWindow, p as isLastTraversableNode, x as useIsoLayoutEffect } from "./floating-ui.utils.dom-CoeTbDZx.js";
+import { t as useId$1 } from "./useId-CJsH-2wV.js";
+import { t as useBaseUiId } from "./useBaseUiId-CWAD_PSs.js";
+import { $ as contains, A as inertValue, B as floor, C as FloatingNode, D as useFloatingTree, E as useFloatingParentNodeId, F as useOpenChangeComplete, G as getSide, H as getAlignmentAxis, I as useLatestRef, J as isVirtualClick, K as getSideAxis, L as COMPOSITE_KEYS, M as popupStateMapping, N as pressableTriggerOpenStateMapping, O as Timeout, P as triggerOpenStateMapping, Q as activeElement, R as clamp, S as createAttribute, T as useFloatingNodeId, U as getAxisLength, V as getAlignment, W as getPaddingObject, X as stopEvent, Y as isVirtualPointerEvent, Z as getNodeChildren, _ as useClick, a as useInteractions, at as matchesFocusVisible, b as enqueueFocus, c as useDismiss, ct as ARROW_RIGHT, d as limitShift, dt as isSafari, et as getDocument, f as offset, ft as transitionStatusMapping, g as autoUpdate, h as useFloating$1, i as useRole, it as isTypeableElement, k as useTimeout, l as flip, lt as ARROW_UP, m as size, n as useScrollLock, nt as getTarget, ot as ARROW_DOWN, p as shift, pt as useTransitionStatus, q as isMouseLikePointerType, r as InternalBackdrop, rt as isTypeableCombobox, s as useFloatingRootContext, st as ARROW_LEFT, t as useOpenInteractionType, tt as getFloatingFocusElement, u as hide, ut as isMac, v as FloatingFocusManager, w as FloatingTree, x as ownerDocument, y as FloatingPortal, z as evaluate } from "./useOpenInteractionType-D8vA_ZKI.js";
+import { n as useCompositeRootContext, t as useButton } from "./useButton-DHTh3Hm7.js";
+import { t as useBreakpointMatch } from "./useBreakpointMatch-D9a3CTNK.js";
+import * as React$1 from "react";
+import { createContext, forwardRef, useContext, useId } from "react";
+import { getDatasetProps } from "@preply/ds-web-core";
+import * as ReactDOM$1 from "react-dom";
+import { usePortalElement } from "@preply/ds-web-root";
+import TokyoUICheck from "@preply/ds-media-icons/dist/24/TokyoUICheck.svg";
+import TokyoUIChevronRight from "@preply/ds-media-icons/dist/24/TokyoUIChevronRight.svg";
+import './assets/DropdownMenu.css';//#region ../../node_modules/@base-ui-components/utils/esm/useControlled.js
+function useControlled({ controlled, default: defaultProp, name, state = "value" }) {
+	const { current: isControlled } = React$1.useRef(controlled !== void 0);
+	const [valueState, setValue] = React$1.useState(defaultProp);
+	const value = isControlled ? controlled : valueState;
+	if (process.env.NODE_ENV !== "production") {
+		React$1.useEffect(() => {
+			if (isControlled !== (controlled !== void 0)) console.error([
+				`Base UI: A component is changing the ${isControlled ? "" : "un"}controlled ${state} state of ${name} to be ${isControlled ? "un" : ""}controlled.`,
+				"Elements should not switch from uncontrolled to controlled (or vice versa).",
+				`Decide between using a controlled or uncontrolled ${name} element for the lifetime of the component.`,
+				"The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.",
+				"More info: https://fb.me/react-controlled-components"
+			].join("\n"));
+		}, [
+			state,
+			name,
+			controlled
+		]);
+		const { current: defaultValue } = React$1.useRef(defaultProp);
+		React$1.useEffect(() => {
+			if (!isControlled && JSON.stringify(defaultValue) !== JSON.stringify(defaultProp)) console.error([`Base UI: A component is changing the default ${state} state of an uncontrolled ${name} after being initialized. To suppress this warning opt to use a controlled ${name}.`].join("\n"));
+		}, [JSON.stringify(defaultProp)]);
+	}
+	return [value, React$1.useCallback((newValue) => {
+		if (!isControlled) setValue(newValue);
+	}, [])];
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/composite/list/CompositeListContext.js
+var CompositeListContext = /* @__PURE__ */ React$1.createContext({
+	register: () => {},
+	unregister: () => {},
+	subscribeMapChange: () => {
+		return () => {};
+	},
+	elementsRef: { current: [] },
+	nextIndexRef: { current: 0 }
+});
+if (process.env.NODE_ENV !== "production") CompositeListContext.displayName = "CompositeListContext";
+function useCompositeListContext() {
+	return React$1.useContext(CompositeListContext);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/composite/list/CompositeList.js
+var import_jsx_runtime = require_jsx_runtime();
+/**
+* Provides context for a list of items in a composite component.
+* @internal
+*/
+function CompositeList(props) {
+	const { children, elementsRef, labelsRef, onMapChange } = props;
+	const nextIndexRef = React$1.useRef(0);
+	const listeners = useRefWithInit(createListeners).current;
+	const map = useRefWithInit(createMap).current;
+	const [mapTick, setMapTick] = React$1.useState(EMPTY_OBJECT);
+	const lastTickRef = React$1.useRef(mapTick);
+	const register = useEventCallback((node, metadata) => {
+		map.set(node, metadata !== null && metadata !== void 0 ? metadata : null);
+		lastTickRef.current = {};
+		setMapTick(lastTickRef.current);
+	});
+	const unregister = useEventCallback((node) => {
+		map.delete(node);
+		lastTickRef.current = {};
+		setMapTick(lastTickRef.current);
+	});
+	const sortedMap = React$1.useMemo(() => {
+		disableEslintWarning(mapTick);
+		const newMap = /* @__PURE__ */ new Map();
+		Array.from(map.keys()).sort(sortByDocumentPosition).forEach((node, index) => {
+			var _map$get;
+			const metadata = (_map$get = map.get(node)) !== null && _map$get !== void 0 ? _map$get : {};
+			newMap.set(node, {
+				...metadata,
+				index
+			});
+		});
+		return newMap;
+	}, [map, mapTick]);
+	useIsoLayoutEffect(() => {
+		if (typeof MutationObserver !== "function" || sortedMap.size === 0) return;
+		const mutationObserver = new MutationObserver((entries) => {
+			const diff = /* @__PURE__ */ new Set();
+			const updateDiff = (node) => diff.has(node) ? diff.delete(node) : diff.add(node);
+			entries.forEach((entry) => {
+				entry.removedNodes.forEach(updateDiff);
+				entry.addedNodes.forEach(updateDiff);
+			});
+			if (diff.size === 0) {
+				lastTickRef.current = {};
+				setMapTick(lastTickRef.current);
+			}
+		});
+		sortedMap.forEach((_, node) => {
+			if (node.parentElement) mutationObserver.observe(node.parentElement, { childList: true });
+		});
+		return () => {
+			mutationObserver.disconnect();
+		};
+	}, [sortedMap]);
+	useIsoLayoutEffect(() => {
+		if (lastTickRef.current === mapTick) {
+			if (elementsRef.current.length !== sortedMap.size) elementsRef.current.length = sortedMap.size;
+			if (labelsRef && labelsRef.current.length !== sortedMap.size) labelsRef.current.length = sortedMap.size;
+			nextIndexRef.current = sortedMap.size;
+		}
+		onMapChange === null || onMapChange === void 0 || onMapChange(sortedMap);
+	}, [
+		onMapChange,
+		sortedMap,
+		elementsRef,
+		labelsRef,
+		mapTick
+	]);
+	const subscribeMapChange = useEventCallback((fn) => {
+		listeners.add(fn);
+		return () => {
+			listeners.delete(fn);
+		};
+	});
+	useIsoLayoutEffect(() => {
+		listeners.forEach((l) => l(sortedMap));
+	}, [listeners, sortedMap]);
+	const contextValue = React$1.useMemo(() => ({
+		register,
+		unregister,
+		subscribeMapChange,
+		elementsRef,
+		labelsRef,
+		nextIndexRef
+	}), [
+		register,
+		unregister,
+		subscribeMapChange,
+		elementsRef,
+		labelsRef,
+		nextIndexRef
+	]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CompositeListContext.Provider, {
+		value: contextValue,
+		children
+	});
+}
+function createMap() {
+	return /* @__PURE__ */ new Map();
+}
+function createListeners() {
+	return /* @__PURE__ */ new Set();
+}
+function sortByDocumentPosition(a, b) {
+	const position = a.compareDocumentPosition(b);
+	if (position & Node.DOCUMENT_POSITION_FOLLOWING || position & Node.DOCUMENT_POSITION_CONTAINED_BY) return -1;
+	if (position & Node.DOCUMENT_POSITION_PRECEDING || position & Node.DOCUMENT_POSITION_CONTAINS) return 1;
+	return 0;
+}
+function disableEslintWarning(_) {}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/direction-provider/DirectionContext.js
+/**
+* @internal
+*/
+var DirectionContext = /* @__PURE__ */ React$1.createContext(void 0);
+if (process.env.NODE_ENV !== "production") DirectionContext.displayName = "DirectionContext";
+function useDirection(optional = true) {
+	var _context$direction;
+	const context = React$1.useContext(DirectionContext);
+	if (context === void 0 && !optional) throw new Error("Base UI: DirectionContext is missing.");
+	return (_context$direction = context === null || context === void 0 ? void 0 : context.direction) !== null && _context$direction !== void 0 ? _context$direction : "ltr";
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/composite/list/useCompositeListItem.js
+var IndexGuessBehavior = /* @__PURE__ */ function(IndexGuessBehavior) {
+	IndexGuessBehavior[IndexGuessBehavior["None"] = 0] = "None";
+	IndexGuessBehavior[IndexGuessBehavior["GuessFromOrder"] = 1] = "GuessFromOrder";
+	return IndexGuessBehavior;
+}({});
+/**
+* Used to register a list item and its index (DOM position) in the `CompositeList`.
+*/
+function useCompositeListItem(params = {}) {
+	const { label, metadata, textRef, indexGuessBehavior, index: externalIndex } = params;
+	const { register, unregister, subscribeMapChange, elementsRef, labelsRef, nextIndexRef } = useCompositeListContext();
+	const indexRef = React$1.useRef(-1);
+	const [index, setIndex] = React$1.useState(externalIndex !== null && externalIndex !== void 0 ? externalIndex : indexGuessBehavior === IndexGuessBehavior.GuessFromOrder ? () => {
+		if (indexRef.current === -1) {
+			const newIndex = nextIndexRef.current;
+			nextIndexRef.current += 1;
+			indexRef.current = newIndex;
+		}
+		return indexRef.current;
+	} : -1);
+	const componentRef = React$1.useRef(null);
+	const ref = React$1.useCallback((node) => {
+		componentRef.current = node;
+		if (index !== -1 && node !== null) {
+			elementsRef.current[index] = node;
+			if (labelsRef) {
+				var _textRef$current$text, _textRef$current;
+				const isLabelDefined = label !== void 0;
+				labelsRef.current[index] = isLabelDefined ? label : (_textRef$current$text = textRef === null || textRef === void 0 || (_textRef$current = textRef.current) === null || _textRef$current === void 0 ? void 0 : _textRef$current.textContent) !== null && _textRef$current$text !== void 0 ? _textRef$current$text : node.textContent;
+			}
+		}
+	}, [
+		index,
+		elementsRef,
+		labelsRef,
+		label,
+		textRef
+	]);
+	useIsoLayoutEffect(() => {
+		if (externalIndex != null) return;
+		const node = componentRef.current;
+		if (node) {
+			register(node, metadata);
+			return () => {
+				unregister(node);
+			};
+		}
+	}, [
+		externalIndex,
+		register,
+		unregister,
+		metadata
+	]);
+	useIsoLayoutEffect(() => {
+		if (externalIndex != null) return;
+		return subscribeMapChange((map) => {
+			var _map$get;
+			const i = componentRef.current ? (_map$get = map.get(componentRef.current)) === null || _map$get === void 0 ? void 0 : _map$get.index : null;
+			if (i != null) setIndex(i);
+		});
+	}, [
+		externalIndex,
+		subscribeMapChange,
+		setIndex
+	]);
+	return React$1.useMemo(() => ({
+		ref,
+		index
+	}), [index, ref]);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/utils/composite.js
+function isDifferentGridRow(index, cols, prevRow) {
+	return Math.floor(index / cols) !== prevRow;
+}
+function isIndexOutOfListBounds(listRef, index) {
+	return index < 0 || index >= listRef.current.length;
+}
+function getMinListIndex(listRef, disabledIndices) {
+	return findNonDisabledListIndex(listRef, { disabledIndices });
+}
+function getMaxListIndex(listRef, disabledIndices) {
+	return findNonDisabledListIndex(listRef, {
+		decrement: true,
+		startingIndex: listRef.current.length,
+		disabledIndices
+	});
+}
+function findNonDisabledListIndex(listRef, { startingIndex = -1, decrement = false, disabledIndices, amount = 1 } = {}) {
+	let index = startingIndex;
+	do
+		index += decrement ? -amount : amount;
+	while (index >= 0 && index <= listRef.current.length - 1 && isListIndexDisabled(listRef, index, disabledIndices));
+	return index;
+}
+function getGridNavigatedIndex(listRef, { event, orientation, loop, rtl, cols, disabledIndices, minIndex, maxIndex, prevIndex, stopEvent: stop = false }) {
+	let nextIndex = prevIndex;
+	const rows = [];
+	const rowIndexMap = {};
+	let hasRoleRow = false;
+	{
+		let currentRowEl = null;
+		let currentRowIndex = -1;
+		listRef.current.forEach((el, idx) => {
+			if (el == null) return;
+			const rowEl = el.closest("[role=\"row\"]");
+			if (rowEl) hasRoleRow = true;
+			if (rowEl !== currentRowEl || currentRowIndex === -1) {
+				currentRowEl = rowEl;
+				currentRowIndex += 1;
+				rows[currentRowIndex] = [];
+			}
+			rows[currentRowIndex].push(idx);
+			rowIndexMap[idx] = currentRowIndex;
+		});
+	}
+	const hasDomRows = hasRoleRow && rows.length > 0 && rows.some((row) => row.length !== cols);
+	function navigateVertically(direction) {
+		if (!hasDomRows || prevIndex === -1) return;
+		const currentRow = rowIndexMap[prevIndex];
+		if (currentRow == null) return;
+		const colInRow = rows[currentRow].indexOf(prevIndex);
+		let nextRow = direction === "up" ? currentRow - 1 : currentRow + 1;
+		if (loop) {
+			if (nextRow < 0) nextRow = rows.length - 1;
+			else if (nextRow >= rows.length) nextRow = 0;
+		}
+		const visited = /* @__PURE__ */ new Set();
+		while (nextRow >= 0 && nextRow < rows.length && !visited.has(nextRow)) {
+			visited.add(nextRow);
+			const targetRow = rows[nextRow];
+			if (targetRow.length === 0) {
+				nextRow = direction === "up" ? nextRow - 1 : nextRow + 1;
+				continue;
+			}
+			const clampedCol = Math.min(colInRow, targetRow.length - 1);
+			for (let col = clampedCol; col >= 0; col -= 1) {
+				const candidate = targetRow[col];
+				if (!isListIndexDisabled(listRef, candidate, disabledIndices)) return candidate;
+			}
+			nextRow = direction === "up" ? nextRow - 1 : nextRow + 1;
+			if (loop) {
+				if (nextRow < 0) nextRow = rows.length - 1;
+				else if (nextRow >= rows.length) nextRow = 0;
+			}
+		}
+	}
+	if (event.key === "ArrowUp") {
+		const domBasedCandidate = navigateVertically("up");
+		if (domBasedCandidate !== void 0) {
+			if (stop) stopEvent(event);
+			nextIndex = domBasedCandidate;
+		} else {
+			if (stop) stopEvent(event);
+			if (prevIndex === -1) nextIndex = maxIndex;
+			else {
+				nextIndex = findNonDisabledListIndex(listRef, {
+					startingIndex: nextIndex,
+					amount: cols,
+					decrement: true,
+					disabledIndices
+				});
+				if (loop && (prevIndex - cols < minIndex || nextIndex < 0)) {
+					const col = prevIndex % cols;
+					const maxCol = maxIndex % cols;
+					const offset = maxIndex - (maxCol - col);
+					if (maxCol === col) nextIndex = maxIndex;
+					else nextIndex = maxCol > col ? offset : offset - cols;
+				}
+			}
+			if (isIndexOutOfListBounds(listRef, nextIndex)) nextIndex = prevIndex;
+		}
+	}
+	if (event.key === "ArrowDown") {
+		const domBasedCandidate = navigateVertically("down");
+		if (domBasedCandidate !== void 0) {
+			if (stop) stopEvent(event);
+			nextIndex = domBasedCandidate;
+		} else {
+			if (stop) stopEvent(event);
+			if (prevIndex === -1) nextIndex = minIndex;
+			else {
+				nextIndex = findNonDisabledListIndex(listRef, {
+					startingIndex: prevIndex,
+					amount: cols,
+					disabledIndices
+				});
+				if (loop && prevIndex + cols > maxIndex) nextIndex = findNonDisabledListIndex(listRef, {
+					startingIndex: prevIndex % cols - cols,
+					amount: cols,
+					disabledIndices
+				});
+			}
+			if (isIndexOutOfListBounds(listRef, nextIndex)) nextIndex = prevIndex;
+		}
+	}
+	if (orientation === "both") {
+		const prevRow = floor(prevIndex / cols);
+		if (event.key === (rtl ? "ArrowLeft" : "ArrowRight")) {
+			if (stop) stopEvent(event);
+			if (prevIndex % cols !== cols - 1) {
+				nextIndex = findNonDisabledListIndex(listRef, {
+					startingIndex: prevIndex,
+					disabledIndices
+				});
+				if (loop && isDifferentGridRow(nextIndex, cols, prevRow)) nextIndex = findNonDisabledListIndex(listRef, {
+					startingIndex: prevIndex - prevIndex % cols - 1,
+					disabledIndices
+				});
+			} else if (loop) nextIndex = findNonDisabledListIndex(listRef, {
+				startingIndex: prevIndex - prevIndex % cols - 1,
+				disabledIndices
+			});
+			if (isDifferentGridRow(nextIndex, cols, prevRow)) nextIndex = prevIndex;
+		}
+		if (event.key === (rtl ? "ArrowRight" : "ArrowLeft")) {
+			if (stop) stopEvent(event);
+			if (prevIndex % cols !== 0) {
+				nextIndex = findNonDisabledListIndex(listRef, {
+					startingIndex: prevIndex,
+					decrement: true,
+					disabledIndices
+				});
+				if (loop && isDifferentGridRow(nextIndex, cols, prevRow)) nextIndex = findNonDisabledListIndex(listRef, {
+					startingIndex: prevIndex + (cols - prevIndex % cols),
+					decrement: true,
+					disabledIndices
+				});
+			} else if (loop) nextIndex = findNonDisabledListIndex(listRef, {
+				startingIndex: prevIndex + (cols - prevIndex % cols),
+				decrement: true,
+				disabledIndices
+			});
+			if (isDifferentGridRow(nextIndex, cols, prevRow)) nextIndex = prevIndex;
+		}
+		const lastRow = floor(maxIndex / cols) === prevRow;
+		if (isIndexOutOfListBounds(listRef, nextIndex)) if (loop && lastRow) nextIndex = event.key === (rtl ? "ArrowRight" : "ArrowLeft") ? maxIndex : findNonDisabledListIndex(listRef, {
+			startingIndex: prevIndex - prevIndex % cols - 1,
+			disabledIndices
+		});
+		else nextIndex = prevIndex;
+	}
+	return nextIndex;
+}
+/** For each cell index, gets the item index that occupies that cell */
+function createGridCellMap(sizes, cols, dense) {
+	const cellMap = [];
+	let startIndex = 0;
+	sizes.forEach(({ width, height }, index) => {
+		if (width > cols) {
+			if (process.env.NODE_ENV !== "production") throw new Error(`[Floating UI]: Invalid grid - item width at index ${index} is greater than grid columns`);
+		}
+		let itemPlaced = false;
+		if (dense) startIndex = 0;
+		while (!itemPlaced) {
+			const targetCells = [];
+			for (let i = 0; i < width; i += 1) for (let j = 0; j < height; j += 1) targetCells.push(startIndex + i + j * cols);
+			if (startIndex % cols + width <= cols && targetCells.every((cell) => cellMap[cell] == null)) {
+				targetCells.forEach((cell) => {
+					cellMap[cell] = index;
+				});
+				itemPlaced = true;
+			} else startIndex += 1;
+		}
+	});
+	return [...cellMap];
+}
+/** Gets cell index of an item's corner or -1 when index is -1. */
+function getGridCellIndexOfCorner(index, sizes, cellMap, cols, corner) {
+	if (index === -1) return -1;
+	const firstCellIndex = cellMap.indexOf(index);
+	const sizeItem = sizes[index];
+	switch (corner) {
+		case "tl": return firstCellIndex;
+		case "tr":
+			if (!sizeItem) return firstCellIndex;
+			return firstCellIndex + sizeItem.width - 1;
+		case "bl":
+			if (!sizeItem) return firstCellIndex;
+			return firstCellIndex + (sizeItem.height - 1) * cols;
+		case "br": return cellMap.lastIndexOf(index);
+		default: return -1;
+	}
+}
+/** Gets all cell indices that correspond to the specified indices */
+function getGridCellIndices(indices, cellMap) {
+	return cellMap.flatMap((index, cellIndex) => indices.includes(index) ? [cellIndex] : []);
+}
+function isListIndexDisabled(listRef, index, disabledIndices) {
+	if (typeof disabledIndices === "function") return disabledIndices(index);
+	if (disabledIndices) return disabledIndices.includes(index);
+	const element = listRef.current[index];
+	return element == null || element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true";
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/hooks/useHover.js
+var safePolygonIdentifier = createAttribute("safe-polygon");
+function getDelay(value, prop, pointerType) {
+	if (pointerType && !isMouseLikePointerType(pointerType)) return 0;
+	if (typeof value === "number") return value;
+	if (typeof value === "function") {
+		const result = value();
+		if (typeof result === "number") return result;
+		return result === null || result === void 0 ? void 0 : result[prop];
+	}
+	return value === null || value === void 0 ? void 0 : value[prop];
+}
+function getRestMs(value) {
+	if (typeof value === "function") return value();
+	return value;
+}
+/**
+* Opens the floating element while hovering over the reference element, like
+* CSS `:hover`.
+* @see https://floating-ui.com/docs/useHover
+*/
+function useHover(context, props = {}) {
+	const { open, onOpenChange, dataRef, events, elements } = context;
+	const { enabled = true, delay = 0, handleClose = null, mouseOnly = false, restMs = 0, move = true } = props;
+	const tree = useFloatingTree();
+	const parentId = useFloatingParentNodeId();
+	const handleCloseRef = useLatestRef(handleClose);
+	const delayRef = useLatestRef(delay);
+	const openRef = useLatestRef(open);
+	const restMsRef = useLatestRef(restMs);
+	const pointerTypeRef = React$1.useRef(void 0);
+	const timeout = useTimeout();
+	const handlerRef = React$1.useRef(void 0);
+	const restTimeout = useTimeout();
+	const blockMouseMoveRef = React$1.useRef(true);
+	const performedPointerEventsMutationRef = React$1.useRef(false);
+	const unbindMouseMoveRef = React$1.useRef(() => {});
+	const restTimeoutPendingRef = React$1.useRef(false);
+	const isHoverOpen = useEventCallback(() => {
+		var _dataRef$current$open;
+		const type = (_dataRef$current$open = dataRef.current.openEvent) === null || _dataRef$current$open === void 0 ? void 0 : _dataRef$current$open.type;
+		return (type === null || type === void 0 ? void 0 : type.includes("mouse")) && type !== "mousedown";
+	});
+	React$1.useEffect(() => {
+		if (!enabled) return;
+		function onOpenChangeLocal(details) {
+			if (!details.open) {
+				timeout.clear();
+				restTimeout.clear();
+				blockMouseMoveRef.current = true;
+				restTimeoutPendingRef.current = false;
+			}
+		}
+		events.on("openchange", onOpenChangeLocal);
+		return () => {
+			events.off("openchange", onOpenChangeLocal);
+		};
+	}, [
+		enabled,
+		events,
+		timeout,
+		restTimeout
+	]);
+	React$1.useEffect(() => {
+		if (!enabled) return;
+		if (!handleCloseRef.current) return;
+		if (!open) return;
+		function onLeave(event) {
+			if (isHoverOpen()) onOpenChange(false, createChangeEventDetails("trigger-hover", event));
+		}
+		const html = getDocument(elements.floating).documentElement;
+		html.addEventListener("mouseleave", onLeave);
+		return () => {
+			html.removeEventListener("mouseleave", onLeave);
+		};
+	}, [
+		elements.floating,
+		open,
+		onOpenChange,
+		enabled,
+		handleCloseRef,
+		isHoverOpen
+	]);
+	const closeWithDelay = React$1.useCallback((event, runElseBranch = true) => {
+		const closeDelay = getDelay(delayRef.current, "close", pointerTypeRef.current);
+		if (closeDelay && !handlerRef.current) timeout.start(closeDelay, () => onOpenChange(false, createChangeEventDetails("trigger-hover", event)));
+		else if (runElseBranch) {
+			timeout.clear();
+			onOpenChange(false, createChangeEventDetails("trigger-hover", event));
+		}
+	}, [
+		delayRef,
+		onOpenChange,
+		timeout
+	]);
+	const cleanupMouseMoveHandler = useEventCallback(() => {
+		unbindMouseMoveRef.current();
+		handlerRef.current = void 0;
+	});
+	const clearPointerEvents = useEventCallback(() => {
+		if (performedPointerEventsMutationRef.current) {
+			const body = getDocument(elements.floating).body;
+			body.style.pointerEvents = "";
+			body.removeAttribute(safePolygonIdentifier);
+			performedPointerEventsMutationRef.current = false;
+		}
+	});
+	const isClickLikeOpenEvent = useEventCallback(() => {
+		return dataRef.current.openEvent ? ["click", "mousedown"].includes(dataRef.current.openEvent.type) : false;
+	});
+	React$1.useEffect(() => {
+		if (!enabled) return;
+		function onReferenceMouseEnter(event) {
+			timeout.clear();
+			blockMouseMoveRef.current = false;
+			if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current) || getRestMs(restMsRef.current) > 0 && !getDelay(delayRef.current, "open")) return;
+			const openDelay = getDelay(delayRef.current, "open", pointerTypeRef.current);
+			if (openDelay) timeout.start(openDelay, () => {
+				if (!openRef.current) onOpenChange(true, createChangeEventDetails("trigger-hover", event));
+			});
+			else if (!open) onOpenChange(true, createChangeEventDetails("trigger-hover", event));
+		}
+		function onReferenceMouseLeave(event) {
+			if (isClickLikeOpenEvent()) {
+				clearPointerEvents();
+				return;
+			}
+			unbindMouseMoveRef.current();
+			const doc = getDocument(elements.floating);
+			restTimeout.clear();
+			restTimeoutPendingRef.current = false;
+			if (handleCloseRef.current && dataRef.current.floatingContext) {
+				if (!open) timeout.clear();
+				handlerRef.current = handleCloseRef.current({
+					...dataRef.current.floatingContext,
+					tree,
+					x: event.clientX,
+					y: event.clientY,
+					onClose() {
+						clearPointerEvents();
+						cleanupMouseMoveHandler();
+						if (!isClickLikeOpenEvent()) closeWithDelay(event, true);
+					}
+				});
+				const handler = handlerRef.current;
+				doc.addEventListener("mousemove", handler);
+				unbindMouseMoveRef.current = () => {
+					doc.removeEventListener("mousemove", handler);
+				};
+				return;
+			}
+			if (pointerTypeRef.current === "touch" ? !contains(elements.floating, event.relatedTarget) : true) closeWithDelay(event);
+		}
+		function onScrollMouseLeave(event) {
+			var _handleCloseRef$curre;
+			if (isClickLikeOpenEvent()) return;
+			if (!dataRef.current.floatingContext) return;
+			(_handleCloseRef$curre = handleCloseRef.current) === null || _handleCloseRef$curre === void 0 || _handleCloseRef$curre.call(handleCloseRef, {
+				...dataRef.current.floatingContext,
+				tree,
+				x: event.clientX,
+				y: event.clientY,
+				onClose() {
+					clearPointerEvents();
+					cleanupMouseMoveHandler();
+					if (!isClickLikeOpenEvent()) closeWithDelay(event);
+				}
+			})(event);
+		}
+		function onFloatingMouseEnter() {
+			timeout.clear();
+		}
+		function onFloatingMouseLeave(event) {
+			if (!isClickLikeOpenEvent()) closeWithDelay(event, false);
+		}
+		if (isElement(elements.domReference)) {
+			const reference = elements.domReference;
+			const floating = elements.floating;
+			if (open) reference.addEventListener("mouseleave", onScrollMouseLeave);
+			if (move) reference.addEventListener("mousemove", onReferenceMouseEnter, { once: true });
+			reference.addEventListener("mouseenter", onReferenceMouseEnter);
+			reference.addEventListener("mouseleave", onReferenceMouseLeave);
+			if (floating) {
+				floating.addEventListener("mouseleave", onScrollMouseLeave);
+				floating.addEventListener("mouseenter", onFloatingMouseEnter);
+				floating.addEventListener("mouseleave", onFloatingMouseLeave);
+			}
+			return () => {
+				if (open) reference.removeEventListener("mouseleave", onScrollMouseLeave);
+				if (move) reference.removeEventListener("mousemove", onReferenceMouseEnter);
+				reference.removeEventListener("mouseenter", onReferenceMouseEnter);
+				reference.removeEventListener("mouseleave", onReferenceMouseLeave);
+				if (floating) {
+					floating.removeEventListener("mouseleave", onScrollMouseLeave);
+					floating.removeEventListener("mouseenter", onFloatingMouseEnter);
+					floating.removeEventListener("mouseleave", onFloatingMouseLeave);
+				}
+			};
+		}
+	}, [
+		elements,
+		enabled,
+		context,
+		mouseOnly,
+		move,
+		closeWithDelay,
+		cleanupMouseMoveHandler,
+		clearPointerEvents,
+		onOpenChange,
+		open,
+		openRef,
+		tree,
+		delayRef,
+		handleCloseRef,
+		dataRef,
+		isClickLikeOpenEvent,
+		restMsRef,
+		timeout,
+		restTimeout
+	]);
+	useIsoLayoutEffect(() => {
+		var _handleCloseRef$curre2;
+		if (!enabled) return;
+		if (open && ((_handleCloseRef$curre2 = handleCloseRef.current) === null || _handleCloseRef$curre2 === void 0 || (_handleCloseRef$curre2 = _handleCloseRef$curre2.__options) === null || _handleCloseRef$curre2 === void 0 ? void 0 : _handleCloseRef$curre2.blockPointerEvents) && isHoverOpen()) {
+			performedPointerEventsMutationRef.current = true;
+			const floatingEl = elements.floating;
+			if (isElement(elements.domReference) && floatingEl) {
+				var _tree$nodesRef$curren;
+				const body = getDocument(elements.floating).body;
+				body.setAttribute(safePolygonIdentifier, "");
+				const ref = elements.domReference;
+				const parentFloating = tree === null || tree === void 0 || (_tree$nodesRef$curren = tree.nodesRef.current.find((node) => node.id === parentId)) === null || _tree$nodesRef$curren === void 0 || (_tree$nodesRef$curren = _tree$nodesRef$curren.context) === null || _tree$nodesRef$curren === void 0 ? void 0 : _tree$nodesRef$curren.elements.floating;
+				if (parentFloating) parentFloating.style.pointerEvents = "";
+				body.style.pointerEvents = "none";
+				ref.style.pointerEvents = "auto";
+				floatingEl.style.pointerEvents = "auto";
+				return () => {
+					body.style.pointerEvents = "";
+					ref.style.pointerEvents = "";
+					floatingEl.style.pointerEvents = "";
+				};
+			}
+		}
+	}, [
+		enabled,
+		open,
+		parentId,
+		elements,
+		tree,
+		handleCloseRef,
+		isHoverOpen
+	]);
+	useIsoLayoutEffect(() => {
+		if (!open) {
+			pointerTypeRef.current = void 0;
+			restTimeoutPendingRef.current = false;
+			cleanupMouseMoveHandler();
+			clearPointerEvents();
+		}
+	}, [
+		open,
+		cleanupMouseMoveHandler,
+		clearPointerEvents
+	]);
+	React$1.useEffect(() => {
+		return () => {
+			cleanupMouseMoveHandler();
+			timeout.clear();
+			restTimeout.clear();
+		};
+	}, [
+		enabled,
+		elements.domReference,
+		cleanupMouseMoveHandler,
+		timeout,
+		restTimeout
+	]);
+	React$1.useEffect(() => {
+		return clearPointerEvents;
+	}, [clearPointerEvents]);
+	const reference = React$1.useMemo(() => {
+		function setPointerRef(event) {
+			pointerTypeRef.current = event.pointerType;
+		}
+		return {
+			onPointerDown: setPointerRef,
+			onPointerEnter: setPointerRef,
+			onMouseMove(event) {
+				const { nativeEvent } = event;
+				function handleMouseMove() {
+					if (!blockMouseMoveRef.current && !openRef.current) onOpenChange(true, createChangeEventDetails("trigger-hover", nativeEvent));
+				}
+				if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current)) return;
+				if (open || getRestMs(restMsRef.current) === 0) return;
+				if (restTimeoutPendingRef.current && event.movementX ** 2 + event.movementY ** 2 < 2) return;
+				restTimeout.clear();
+				if (pointerTypeRef.current === "touch") handleMouseMove();
+				else {
+					restTimeoutPendingRef.current = true;
+					restTimeout.start(getRestMs(restMsRef.current), handleMouseMove);
+				}
+			}
+		};
+	}, [
+		mouseOnly,
+		onOpenChange,
+		open,
+		openRef,
+		restMsRef,
+		restTimeout
+	]);
+	return React$1.useMemo(() => enabled ? { reference } : {}, [enabled, reference]);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/hooks/useFloating.js
+/**
+* Provides data to position a floating element and context to add interactions.
+* @see https://floating-ui.com/docs/useFloating
+*/
+function useFloating(options = {}) {
+	const { nodeId } = options;
+	const internalRootContext = useFloatingRootContext({
+		...options,
+		elements: {
+			reference: null,
+			floating: null,
+			...options.elements
+		}
+	});
+	const rootContext = options.rootContext || internalRootContext;
+	const computedElements = rootContext.elements;
+	const [domReferenceState, setDomReference] = React$1.useState(null);
+	const [positionReference, setPositionReferenceRaw] = React$1.useState(null);
+	const domReference = (computedElements === null || computedElements === void 0 ? void 0 : computedElements.domReference) || domReferenceState;
+	const domReferenceRef = React$1.useRef(null);
+	const tree = useFloatingTree();
+	useIsoLayoutEffect(() => {
+		if (domReference) domReferenceRef.current = domReference;
+	}, [domReference]);
+	const position = useFloating$1({
+		...options,
+		elements: {
+			...computedElements,
+			...positionReference && { reference: positionReference }
+		}
+	});
+	const setPositionReference = React$1.useCallback((node) => {
+		const computedPositionReference = isElement(node) ? {
+			getBoundingClientRect: () => node.getBoundingClientRect(),
+			getClientRects: () => node.getClientRects(),
+			contextElement: node
+		} : node;
+		setPositionReferenceRaw(computedPositionReference);
+		position.refs.setReference(computedPositionReference);
+	}, [position.refs]);
+	const setReference = React$1.useCallback((node) => {
+		if (isElement(node) || node === null) {
+			domReferenceRef.current = node;
+			setDomReference(node);
+		}
+		if (isElement(position.refs.reference.current) || position.refs.reference.current === null || node !== null && !isElement(node)) position.refs.setReference(node);
+	}, [position.refs]);
+	const refs = React$1.useMemo(() => ({
+		...position.refs,
+		setReference,
+		setPositionReference,
+		domReference: domReferenceRef
+	}), [
+		position.refs,
+		setReference,
+		setPositionReference
+	]);
+	const elements = React$1.useMemo(() => ({
+		...position.elements,
+		domReference
+	}), [position.elements, domReference]);
+	const context = React$1.useMemo(() => ({
+		...position,
+		...rootContext,
+		refs,
+		elements,
+		nodeId
+	}), [
+		position,
+		refs,
+		elements,
+		nodeId,
+		rootContext
+	]);
+	useIsoLayoutEffect(() => {
+		rootContext.dataRef.current.floatingContext = context;
+		const node = tree === null || tree === void 0 ? void 0 : tree.nodesRef.current.find((n) => n.id === nodeId);
+		if (node) node.context = context;
+	});
+	return React$1.useMemo(() => ({
+		...position,
+		context,
+		refs,
+		elements
+	}), [
+		position,
+		refs,
+		elements,
+		context
+	]);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/hooks/useFocus.js
+var isMacSafari = isMac && isSafari;
+/**
+* Opens the floating element while the reference element has focus, like CSS
+* `:focus`.
+* @see https://floating-ui.com/docs/useFocus
+*/
+function useFocus(context, props = {}) {
+	const { open, onOpenChange, events, dataRef, elements } = context;
+	const { enabled = true, visibleOnly = true } = props;
+	const blockFocusRef = React$1.useRef(false);
+	const timeout = useTimeout();
+	const keyboardModalityRef = React$1.useRef(true);
+	React$1.useEffect(() => {
+		if (!enabled) return;
+		const win = getWindow(elements.domReference);
+		function onBlur() {
+			if (!open && isHTMLElement(elements.domReference) && elements.domReference === activeElement(getDocument(elements.domReference))) blockFocusRef.current = true;
+		}
+		function onKeyDown() {
+			keyboardModalityRef.current = true;
+		}
+		function onPointerDown() {
+			keyboardModalityRef.current = false;
+		}
+		win.addEventListener("blur", onBlur);
+		if (isMacSafari) {
+			win.addEventListener("keydown", onKeyDown, true);
+			win.addEventListener("pointerdown", onPointerDown, true);
+		}
+		return () => {
+			win.removeEventListener("blur", onBlur);
+			if (isMacSafari) {
+				win.removeEventListener("keydown", onKeyDown, true);
+				win.removeEventListener("pointerdown", onPointerDown, true);
+			}
+		};
+	}, [
+		elements.domReference,
+		open,
+		enabled
+	]);
+	React$1.useEffect(() => {
+		if (!enabled) return;
+		function onOpenChangeLocal(details) {
+			if (details.reason === "trigger-press" || details.reason === "escape-key") blockFocusRef.current = true;
+		}
+		events.on("openchange", onOpenChangeLocal);
+		return () => {
+			events.off("openchange", onOpenChangeLocal);
+		};
+	}, [events, enabled]);
+	const reference = React$1.useMemo(() => ({
+		onMouseLeave() {
+			blockFocusRef.current = false;
+		},
+		onFocus(event) {
+			if (blockFocusRef.current) return;
+			const target = getTarget(event.nativeEvent);
+			if (visibleOnly && isElement(target)) {
+				if (isMacSafari && !event.relatedTarget) {
+					if (!keyboardModalityRef.current && !isTypeableElement(target)) return;
+				} else if (!matchesFocusVisible(target)) return;
+			}
+			onOpenChange(true, createChangeEventDetails("trigger-focus", event.nativeEvent));
+		},
+		onBlur(event) {
+			blockFocusRef.current = false;
+			const relatedTarget = event.relatedTarget;
+			const nativeEvent = event.nativeEvent;
+			const movedToFocusGuard = isElement(relatedTarget) && relatedTarget.hasAttribute(createAttribute("focus-guard")) && relatedTarget.getAttribute("data-type") === "outside";
+			timeout.start(0, () => {
+				var _dataRef$current$floa;
+				const activeEl = activeElement(elements.domReference ? elements.domReference.ownerDocument : document);
+				if (!relatedTarget && activeEl === elements.domReference) return;
+				if (contains((_dataRef$current$floa = dataRef.current.floatingContext) === null || _dataRef$current$floa === void 0 ? void 0 : _dataRef$current$floa.refs.floating.current, activeEl) || contains(elements.domReference, activeEl) || movedToFocusGuard) return;
+				onOpenChange(false, createChangeEventDetails("trigger-focus", nativeEvent));
+			});
+		}
+	}), [
+		dataRef,
+		elements.domReference,
+		onOpenChange,
+		visibleOnly,
+		timeout
+	]);
+	return React$1.useMemo(() => enabled ? { reference } : {}, [enabled, reference]);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/hooks/useListNavigation.js
+var ESCAPE = "Escape";
+function doSwitch(orientation, vertical, horizontal) {
+	switch (orientation) {
+		case "vertical": return vertical;
+		case "horizontal": return horizontal;
+		default: return vertical || horizontal;
+	}
+}
+function isMainOrientationKey(key, orientation) {
+	return doSwitch(orientation, key === "ArrowUp" || key === "ArrowDown", key === "ArrowLeft" || key === "ArrowRight");
+}
+function isMainOrientationToEndKey(key, orientation, rtl) {
+	return doSwitch(orientation, key === "ArrowDown", rtl ? key === "ArrowLeft" : key === "ArrowRight") || key === "Enter" || key === " " || key === "";
+}
+function isCrossOrientationOpenKey(key, orientation, rtl) {
+	return doSwitch(orientation, rtl ? key === ARROW_LEFT : key === ARROW_RIGHT, key === ARROW_DOWN);
+}
+function isCrossOrientationCloseKey(key, orientation, rtl, cols) {
+	const vertical = rtl ? key === ARROW_RIGHT : key === ARROW_LEFT;
+	const horizontal = key === ARROW_UP;
+	if (orientation === "both" || orientation === "horizontal" && cols && cols > 1) return key === ESCAPE;
+	return doSwitch(orientation, vertical, horizontal);
+}
+/**
+* Adds arrow key-based navigation of a list of items, either using real DOM
+* focus or virtual focus.
+* @see https://floating-ui.com/docs/useListNavigation
+*/
+function useListNavigation(context, props) {
+	const { open, onOpenChange, elements } = context;
+	const { listRef, activeIndex, onNavigate: onNavigateProp = () => {}, enabled = true, selectedIndex = null, allowEscape = false, loop = false, nested = false, rtl = false, virtual = false, focusItemOnOpen = "auto", focusItemOnHover = true, openOnArrowKeyDown = true, disabledIndices = void 0, orientation = "vertical", parentOrientation, cols = 1, scrollItemIntoView = true, itemSizes, dense = false, id } = props;
+	if (process.env.NODE_ENV !== "production") {
+		if (allowEscape) {
+			if (!loop) console.warn("`useListNavigation` looping must be enabled to allow escaping.");
+			if (!virtual) console.warn("`useListNavigation` must be virtual to allow escaping.");
+		}
+		if (orientation === "vertical" && cols > 1) console.warn("In grid list navigation mode (`cols` > 1), the `orientation` should", "be either \"horizontal\" or \"both\".");
+	}
+	const floatingFocusElementRef = useLatestRef(getFloatingFocusElement(elements.floating));
+	const parentId = useFloatingParentNodeId();
+	const tree = useFloatingTree();
+	useIsoLayoutEffect(() => {
+		context.dataRef.current.orientation = orientation;
+	}, [context, orientation]);
+	const typeableComboboxReference = isTypeableCombobox(elements.domReference);
+	const focusItemOnOpenRef = React$1.useRef(focusItemOnOpen);
+	const indexRef = React$1.useRef(selectedIndex !== null && selectedIndex !== void 0 ? selectedIndex : -1);
+	const keyRef = React$1.useRef(null);
+	const isPointerModalityRef = React$1.useRef(true);
+	const onNavigate = useEventCallback((event) => {
+		onNavigateProp(indexRef.current === -1 ? null : indexRef.current, event);
+	});
+	const previousOnNavigateRef = React$1.useRef(onNavigate);
+	const previousMountedRef = React$1.useRef(!!elements.floating);
+	const previousOpenRef = React$1.useRef(open);
+	const forceSyncFocusRef = React$1.useRef(false);
+	const forceScrollIntoViewRef = React$1.useRef(false);
+	const disabledIndicesRef = useLatestRef(disabledIndices);
+	const latestOpenRef = useLatestRef(open);
+	const scrollItemIntoViewRef = useLatestRef(scrollItemIntoView);
+	const selectedIndexRef = useLatestRef(selectedIndex);
+	const focusItem = useEventCallback(() => {
+		function runFocus(item) {
+			if (virtual) tree === null || tree === void 0 || tree.events.emit("virtualfocus", item);
+			else enqueueFocus(item, {
+				sync: forceSyncFocusRef.current,
+				preventScroll: true
+			});
+		}
+		const initialItem = listRef.current[indexRef.current];
+		const forceScrollIntoView = forceScrollIntoViewRef.current;
+		if (initialItem) runFocus(initialItem);
+		(forceSyncFocusRef.current ? (v) => v() : requestAnimationFrame)(() => {
+			const waitedItem = listRef.current[indexRef.current] || initialItem;
+			if (!waitedItem) return;
+			if (!initialItem) runFocus(waitedItem);
+			const scrollIntoViewOptions = scrollItemIntoViewRef.current;
+			if (scrollIntoViewOptions && item && (forceScrollIntoView || !isPointerModalityRef.current)) {
+				var _waitedItem$scrollInt;
+				(_waitedItem$scrollInt = waitedItem.scrollIntoView) === null || _waitedItem$scrollInt === void 0 || _waitedItem$scrollInt.call(waitedItem, typeof scrollIntoViewOptions === "boolean" ? {
+					block: "nearest",
+					inline: "nearest"
+				} : scrollIntoViewOptions);
+			}
+		});
+	});
+	useIsoLayoutEffect(() => {
+		if (!enabled) return;
+		if (open && elements.floating) {
+			if (focusItemOnOpenRef.current && selectedIndex != null) {
+				forceScrollIntoViewRef.current = true;
+				indexRef.current = selectedIndex;
+				onNavigate();
+			}
+		} else if (previousMountedRef.current) {
+			indexRef.current = -1;
+			previousOnNavigateRef.current();
+		}
+	}, [
+		enabled,
+		open,
+		elements.floating,
+		selectedIndex,
+		onNavigate
+	]);
+	useIsoLayoutEffect(() => {
+		if (!enabled) return;
+		if (!open) {
+			forceSyncFocusRef.current = false;
+			return;
+		}
+		if (!elements.floating) return;
+		if (activeIndex == null) {
+			forceSyncFocusRef.current = false;
+			if (selectedIndexRef.current != null) return;
+			if (previousMountedRef.current) {
+				indexRef.current = -1;
+				focusItem();
+			}
+			if ((!previousOpenRef.current || !previousMountedRef.current) && focusItemOnOpenRef.current && (keyRef.current != null || focusItemOnOpenRef.current === true && keyRef.current == null)) {
+				let runs = 0;
+				const waitForListPopulated = () => {
+					if (listRef.current[0] == null) {
+						if (runs < 2) (runs ? requestAnimationFrame : queueMicrotask)(waitForListPopulated);
+						runs += 1;
+					} else {
+						indexRef.current = keyRef.current == null || isMainOrientationToEndKey(keyRef.current, orientation, rtl) || nested ? getMinListIndex(listRef, disabledIndicesRef.current) : getMaxListIndex(listRef, disabledIndicesRef.current);
+						keyRef.current = null;
+						onNavigate();
+					}
+				};
+				waitForListPopulated();
+			}
+		} else if (!isIndexOutOfListBounds(listRef, activeIndex)) {
+			indexRef.current = activeIndex;
+			focusItem();
+			forceScrollIntoViewRef.current = false;
+		}
+	}, [
+		enabled,
+		open,
+		elements.floating,
+		activeIndex,
+		selectedIndexRef,
+		nested,
+		listRef,
+		orientation,
+		rtl,
+		onNavigate,
+		focusItem,
+		disabledIndicesRef
+	]);
+	useIsoLayoutEffect(() => {
+		var _nodes$find;
+		if (!enabled || elements.floating || !tree || virtual || !previousMountedRef.current) return;
+		const nodes = tree.nodesRef.current;
+		const parent = (_nodes$find = nodes.find((node) => node.id === parentId)) === null || _nodes$find === void 0 || (_nodes$find = _nodes$find.context) === null || _nodes$find === void 0 ? void 0 : _nodes$find.elements.floating;
+		const activeEl = activeElement(getDocument(elements.floating));
+		const treeContainsActiveEl = nodes.some((node) => node.context && contains(node.context.elements.floating, activeEl));
+		if (parent && !treeContainsActiveEl && isPointerModalityRef.current) parent.focus({ preventScroll: true });
+	}, [
+		enabled,
+		elements.floating,
+		tree,
+		parentId,
+		virtual
+	]);
+	useIsoLayoutEffect(() => {
+		previousOnNavigateRef.current = onNavigate;
+		previousOpenRef.current = open;
+		previousMountedRef.current = !!elements.floating;
+	});
+	useIsoLayoutEffect(() => {
+		if (!open) {
+			keyRef.current = null;
+			focusItemOnOpenRef.current = focusItemOnOpen;
+		}
+	}, [open, focusItemOnOpen]);
+	const hasActiveIndex = activeIndex != null;
+	const item = React$1.useMemo(() => {
+		function syncCurrentTarget(event) {
+			if (!latestOpenRef.current) return;
+			const index = listRef.current.indexOf(event.currentTarget);
+			if (index !== -1 && indexRef.current !== index) {
+				indexRef.current = index;
+				onNavigate(event);
+			}
+		}
+		return {
+			onFocus(event) {
+				forceSyncFocusRef.current = true;
+				syncCurrentTarget(event);
+			},
+			onClick: ({ currentTarget }) => currentTarget.focus({ preventScroll: true }),
+			onMouseMove(event) {
+				forceSyncFocusRef.current = true;
+				forceScrollIntoViewRef.current = false;
+				if (focusItemOnHover) syncCurrentTarget(event);
+			},
+			onPointerLeave(event) {
+				if (!isPointerModalityRef.current || event.pointerType === "touch") return;
+				forceSyncFocusRef.current = true;
+				const relatedTarget = event.relatedTarget;
+				if (!focusItemOnHover || listRef.current.includes(relatedTarget)) return;
+				indexRef.current = -1;
+				onNavigate(event);
+				if (!virtual) {
+					var _floatingFocusElement;
+					(_floatingFocusElement = floatingFocusElementRef.current) === null || _floatingFocusElement === void 0 || _floatingFocusElement.focus({ preventScroll: true });
+				}
+			}
+		};
+	}, [
+		latestOpenRef,
+		floatingFocusElementRef,
+		focusItemOnHover,
+		listRef,
+		onNavigate,
+		virtual
+	]);
+	const getParentOrientation = React$1.useCallback(() => {
+		var _tree$nodesRef$curren;
+		return parentOrientation !== null && parentOrientation !== void 0 ? parentOrientation : tree === null || tree === void 0 || (_tree$nodesRef$curren = tree.nodesRef.current.find((node) => node.id === parentId)) === null || _tree$nodesRef$curren === void 0 || (_tree$nodesRef$curren = _tree$nodesRef$curren.context) === null || _tree$nodesRef$curren === void 0 || (_tree$nodesRef$curren = _tree$nodesRef$curren.dataRef) === null || _tree$nodesRef$curren === void 0 ? void 0 : _tree$nodesRef$curren.current.orientation;
+	}, [
+		parentId,
+		tree,
+		parentOrientation
+	]);
+	const commonOnKeyDown = useEventCallback((event) => {
+		isPointerModalityRef.current = false;
+		forceSyncFocusRef.current = true;
+		if (event.which === 229) return;
+		if (!latestOpenRef.current && event.currentTarget === floatingFocusElementRef.current) return;
+		if (nested && isCrossOrientationCloseKey(event.key, orientation, rtl, cols)) {
+			if (!isMainOrientationKey(event.key, getParentOrientation())) stopEvent(event);
+			onOpenChange(false, createChangeEventDetails("list-navigation", event.nativeEvent));
+			if (isHTMLElement(elements.domReference)) if (virtual) tree === null || tree === void 0 || tree.events.emit("virtualfocus", elements.domReference);
+			else elements.domReference.focus();
+			return;
+		}
+		const currentIndex = indexRef.current;
+		const minIndex = getMinListIndex(listRef, disabledIndices);
+		const maxIndex = getMaxListIndex(listRef, disabledIndices);
+		if (!typeableComboboxReference) {
+			if (event.key === "Home") {
+				stopEvent(event);
+				indexRef.current = minIndex;
+				onNavigate(event);
+			}
+			if (event.key === "End") {
+				stopEvent(event);
+				indexRef.current = maxIndex;
+				onNavigate(event);
+			}
+		}
+		if (cols > 1) {
+			const sizes = itemSizes || Array.from({ length: listRef.current.length }, () => ({
+				width: 1,
+				height: 1
+			}));
+			const cellMap = createGridCellMap(sizes, cols, dense);
+			const minGridIndex = cellMap.findIndex((index) => index != null && !isListIndexDisabled(listRef, index, disabledIndices));
+			const maxGridIndex = cellMap.reduce((foundIndex, index, cellIndex) => index != null && !isListIndexDisabled(listRef, index, disabledIndices) ? cellIndex : foundIndex, -1);
+			const index = cellMap[getGridNavigatedIndex({ current: cellMap.map((itemIndex) => itemIndex != null ? listRef.current[itemIndex] : null) }, {
+				event,
+				orientation,
+				loop,
+				rtl,
+				cols,
+				disabledIndices: getGridCellIndices([...(typeof disabledIndices !== "function" ? disabledIndices : null) || listRef.current.map((_, listIndex) => isListIndexDisabled(listRef, listIndex, disabledIndices) ? listIndex : void 0), void 0], cellMap),
+				minIndex: minGridIndex,
+				maxIndex: maxGridIndex,
+				prevIndex: getGridCellIndexOfCorner(indexRef.current > maxIndex ? minIndex : indexRef.current, sizes, cellMap, cols, event.key === "ArrowDown" ? "bl" : event.key === (rtl ? "ArrowLeft" : "ArrowRight") ? "tr" : "tl"),
+				stopEvent: true
+			})];
+			if (index != null) {
+				indexRef.current = index;
+				onNavigate(event);
+			}
+			if (orientation === "both") return;
+		}
+		if (isMainOrientationKey(event.key, orientation)) {
+			stopEvent(event);
+			if (open && !virtual && activeElement(event.currentTarget.ownerDocument) === event.currentTarget) {
+				indexRef.current = isMainOrientationToEndKey(event.key, orientation, rtl) ? minIndex : maxIndex;
+				onNavigate(event);
+				return;
+			}
+			if (isMainOrientationToEndKey(event.key, orientation, rtl)) if (loop) if (currentIndex >= maxIndex) if (allowEscape && currentIndex !== listRef.current.length) indexRef.current = -1;
+			else {
+				forceSyncFocusRef.current = false;
+				indexRef.current = minIndex;
+			}
+			else indexRef.current = findNonDisabledListIndex(listRef, {
+				startingIndex: currentIndex,
+				disabledIndices
+			});
+			else indexRef.current = Math.min(maxIndex, findNonDisabledListIndex(listRef, {
+				startingIndex: currentIndex,
+				disabledIndices
+			}));
+			else if (loop) if (currentIndex <= minIndex) if (allowEscape && currentIndex !== -1) indexRef.current = listRef.current.length;
+			else {
+				forceSyncFocusRef.current = false;
+				indexRef.current = maxIndex;
+			}
+			else indexRef.current = findNonDisabledListIndex(listRef, {
+				startingIndex: currentIndex,
+				decrement: true,
+				disabledIndices
+			});
+			else indexRef.current = Math.max(minIndex, findNonDisabledListIndex(listRef, {
+				startingIndex: currentIndex,
+				decrement: true,
+				disabledIndices
+			}));
+			if (isIndexOutOfListBounds(listRef, indexRef.current)) indexRef.current = -1;
+			onNavigate(event);
+		}
+	});
+	const ariaActiveDescendantProp = React$1.useMemo(() => {
+		return virtual && open && hasActiveIndex && { "aria-activedescendant": `${id}-${activeIndex}` };
+	}, [
+		virtual,
+		open,
+		hasActiveIndex,
+		id,
+		activeIndex
+	]);
+	const floating = React$1.useMemo(() => {
+		return {
+			"aria-orientation": orientation === "both" ? void 0 : orientation,
+			...!typeableComboboxReference ? ariaActiveDescendantProp : {},
+			onKeyDown(event) {
+				if (event.key === "Tab" && event.shiftKey && open && !virtual) {
+					stopEvent(event);
+					onOpenChange(false, createChangeEventDetails("list-navigation", event.nativeEvent));
+					if (isHTMLElement(elements.domReference)) elements.domReference.focus();
+					return;
+				}
+				commonOnKeyDown(event);
+			},
+			onPointerMove() {
+				isPointerModalityRef.current = true;
+			}
+		};
+	}, [
+		ariaActiveDescendantProp,
+		commonOnKeyDown,
+		orientation,
+		typeableComboboxReference,
+		onOpenChange,
+		open,
+		virtual,
+		elements.domReference
+	]);
+	const reference = React$1.useMemo(() => {
+		function checkVirtualMouse(event) {
+			if (focusItemOnOpen === "auto" && isVirtualClick(event.nativeEvent)) focusItemOnOpenRef.current = !virtual;
+		}
+		function checkVirtualPointer(event) {
+			focusItemOnOpenRef.current = focusItemOnOpen;
+			if (focusItemOnOpen === "auto" && isVirtualPointerEvent(event.nativeEvent)) focusItemOnOpenRef.current = true;
+		}
+		return {
+			...ariaActiveDescendantProp,
+			onKeyDown(event) {
+				isPointerModalityRef.current = false;
+				const isArrowKey = event.key.startsWith("Arrow");
+				const isParentCrossOpenKey = isCrossOrientationOpenKey(event.key, getParentOrientation(), rtl);
+				const isMainKey = isMainOrientationKey(event.key, orientation);
+				const isNavigationKey = (nested ? isParentCrossOpenKey : isMainKey) || event.key === "Enter" || event.key.trim() === "";
+				if (virtual && open) return commonOnKeyDown(event);
+				if (!open && !openOnArrowKeyDown && isArrowKey) return;
+				if (isNavigationKey) {
+					const isParentMainKey = isMainOrientationKey(event.key, getParentOrientation());
+					keyRef.current = nested && isParentMainKey ? null : event.key;
+				}
+				if (nested) {
+					if (isParentCrossOpenKey) {
+						stopEvent(event);
+						if (open) {
+							indexRef.current = getMinListIndex(listRef, disabledIndicesRef.current);
+							onNavigate(event);
+						} else onOpenChange(true, createChangeEventDetails("list-navigation", event.nativeEvent));
+					}
+					return;
+				}
+				if (isMainKey) {
+					if (selectedIndex != null) indexRef.current = selectedIndex;
+					stopEvent(event);
+					if (!open && openOnArrowKeyDown) onOpenChange(true, createChangeEventDetails("list-navigation", event.nativeEvent));
+					else commonOnKeyDown(event);
+					if (open) onNavigate(event);
+				}
+			},
+			onFocus(event) {
+				if (open && !virtual) {
+					indexRef.current = -1;
+					onNavigate(event);
+				}
+			},
+			onPointerDown: checkVirtualPointer,
+			onPointerEnter: checkVirtualPointer,
+			onMouseDown: checkVirtualMouse,
+			onClick: checkVirtualMouse
+		};
+	}, [
+		ariaActiveDescendantProp,
+		commonOnKeyDown,
+		disabledIndicesRef,
+		focusItemOnOpen,
+		listRef,
+		nested,
+		onNavigate,
+		onOpenChange,
+		open,
+		openOnArrowKeyDown,
+		orientation,
+		getParentOrientation,
+		rtl,
+		selectedIndex,
+		virtual
+	]);
+	return React$1.useMemo(() => enabled ? {
+		reference,
+		floating,
+		item
+	} : {}, [
+		enabled,
+		reference,
+		floating,
+		item
+	]);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/hooks/useTypeahead.js
+/**
+* Provides a matching callback that can be used to focus an item as the user
+* types, often used in tandem with `useListNavigation()`.
+* @see https://floating-ui.com/docs/useTypeahead
+*/
+function useTypeahead(context, props) {
+	var _ref;
+	const { open, dataRef } = context;
+	const { listRef, activeIndex, onMatch: onMatchProp, onTypingChange: onTypingChangeProp, enabled = true, findMatch = null, resetMs = 750, ignoreKeys = [], selectedIndex = null } = props;
+	const timeout = useTimeout();
+	const stringRef = React$1.useRef("");
+	const prevIndexRef = React$1.useRef((_ref = selectedIndex !== null && selectedIndex !== void 0 ? selectedIndex : activeIndex) !== null && _ref !== void 0 ? _ref : -1);
+	const matchIndexRef = React$1.useRef(null);
+	const onMatch = useEventCallback(onMatchProp);
+	const onTypingChange = useEventCallback(onTypingChangeProp);
+	const findMatchRef = useLatestRef(findMatch);
+	const ignoreKeysRef = useLatestRef(ignoreKeys);
+	useIsoLayoutEffect(() => {
+		if (open) {
+			timeout.clear();
+			matchIndexRef.current = null;
+			stringRef.current = "";
+		}
+	}, [open, timeout]);
+	useIsoLayoutEffect(() => {
+		if (open && stringRef.current === "") {
+			var _ref2;
+			prevIndexRef.current = (_ref2 = selectedIndex !== null && selectedIndex !== void 0 ? selectedIndex : activeIndex) !== null && _ref2 !== void 0 ? _ref2 : -1;
+		}
+	}, [
+		open,
+		selectedIndex,
+		activeIndex
+	]);
+	const setTypingChange = useEventCallback((value) => {
+		if (value) {
+			if (!dataRef.current.typing) {
+				dataRef.current.typing = value;
+				onTypingChange(value);
+			}
+		} else if (dataRef.current.typing) {
+			dataRef.current.typing = value;
+			onTypingChange(value);
+		}
+	});
+	const onKeyDown = useEventCallback((event) => {
+		function getMatchingIndex(list, orderedList, string) {
+			const str = findMatchRef.current ? findMatchRef.current(orderedList, string) : orderedList.find((text) => (text === null || text === void 0 ? void 0 : text.toLocaleLowerCase().indexOf(string.toLocaleLowerCase())) === 0);
+			return str ? list.indexOf(str) : -1;
+		}
+		const listContent = listRef.current;
+		if (stringRef.current.length > 0 && stringRef.current[0] !== " ") {
+			if (getMatchingIndex(listContent, listContent, stringRef.current) === -1) setTypingChange(false);
+			else if (event.key === " ") stopEvent(event);
+		}
+		if (listContent == null || ignoreKeysRef.current.includes(event.key) || event.key.length !== 1 || event.ctrlKey || event.metaKey || event.altKey) return;
+		if (open && event.key !== " ") {
+			stopEvent(event);
+			setTypingChange(true);
+		}
+		if (listContent.every((text) => {
+			var _text$, _text$2;
+			return text ? ((_text$ = text[0]) === null || _text$ === void 0 ? void 0 : _text$.toLocaleLowerCase()) !== ((_text$2 = text[1]) === null || _text$2 === void 0 ? void 0 : _text$2.toLocaleLowerCase()) : true;
+		}) && stringRef.current === event.key) {
+			stringRef.current = "";
+			prevIndexRef.current = matchIndexRef.current;
+		}
+		stringRef.current += event.key;
+		timeout.start(resetMs, () => {
+			stringRef.current = "";
+			prevIndexRef.current = matchIndexRef.current;
+			setTypingChange(false);
+		});
+		const prevIndex = prevIndexRef.current;
+		const index = getMatchingIndex(listContent, [...listContent.slice((prevIndex || 0) + 1), ...listContent.slice(0, (prevIndex || 0) + 1)], stringRef.current);
+		if (index !== -1) {
+			onMatch(index);
+			matchIndexRef.current = index;
+		} else if (event.key !== " ") {
+			stringRef.current = "";
+			setTypingChange(false);
+		}
+	});
+	const reference = React$1.useMemo(() => ({ onKeyDown }), [onKeyDown]);
+	const floating = React$1.useMemo(() => {
+		return {
+			onKeyDown,
+			onKeyUp(event) {
+				if (event.key === " ") setTypingChange(false);
+			}
+		};
+	}, [onKeyDown, setTypingChange]);
+	return React$1.useMemo(() => enabled ? {
+		reference,
+		floating
+	} : {}, [
+		enabled,
+		reference,
+		floating
+	]);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/safePolygon.js
+function isPointInPolygon(point, polygon) {
+	const [x, y] = point;
+	let isInsideValue = false;
+	const length = polygon.length;
+	for (let i = 0, j = length - 1; i < length; j = i++) {
+		const [xi, yi] = polygon[i] || [0, 0];
+		const [xj, yj] = polygon[j] || [0, 0];
+		if (yi >= y !== yj >= y && x <= (xj - xi) * (y - yi) / (yj - yi) + xi) isInsideValue = !isInsideValue;
+	}
+	return isInsideValue;
+}
+function isInside(point, rect) {
+	return point[0] >= rect.x && point[0] <= rect.x + rect.width && point[1] >= rect.y && point[1] <= rect.y + rect.height;
+}
+/**
+* Generates a safe polygon area that the user can traverse without closing the
+* floating element once leaving the reference element.
+* @see https://floating-ui.com/docs/useHover#safepolygon
+*/
+function safePolygon(options = {}) {
+	const { buffer = .5, blockPointerEvents = false, requireIntent = true } = options;
+	const timeout = new Timeout();
+	let hasLanded = false;
+	let lastX = null;
+	let lastY = null;
+	let lastCursorTime = typeof performance !== "undefined" ? performance.now() : 0;
+	function getCursorSpeed(x, y) {
+		const currentTime = performance.now();
+		const elapsedTime = currentTime - lastCursorTime;
+		if (lastX === null || lastY === null || elapsedTime === 0) {
+			lastX = x;
+			lastY = y;
+			lastCursorTime = currentTime;
+			return null;
+		}
+		const deltaX = x - lastX;
+		const deltaY = y - lastY;
+		const speed = Math.sqrt(deltaX * deltaX + deltaY * deltaY) / elapsedTime;
+		lastX = x;
+		lastY = y;
+		lastCursorTime = currentTime;
+		return speed;
+	}
+	const fn = ({ x, y, placement, elements, onClose, nodeId, tree }) => {
+		return function onMouseMove(event) {
+			function close() {
+				timeout.clear();
+				onClose();
+			}
+			timeout.clear();
+			if (!elements.domReference || !elements.floating || placement == null || x == null || y == null) return;
+			const { clientX, clientY } = event;
+			const clientPoint = [clientX, clientY];
+			const target = getTarget(event);
+			const isLeave = event.type === "mouseleave";
+			const isOverFloatingEl = contains(elements.floating, target);
+			const isOverReferenceEl = contains(elements.domReference, target);
+			const refRect = elements.domReference.getBoundingClientRect();
+			const rect = elements.floating.getBoundingClientRect();
+			const side = placement.split("-")[0];
+			const cursorLeaveFromRight = x > rect.right - rect.width / 2;
+			const cursorLeaveFromBottom = y > rect.bottom - rect.height / 2;
+			const isOverReferenceRect = isInside(clientPoint, refRect);
+			const isFloatingWider = rect.width > refRect.width;
+			const isFloatingTaller = rect.height > refRect.height;
+			const left = (isFloatingWider ? refRect : rect).left;
+			const right = (isFloatingWider ? refRect : rect).right;
+			const top = (isFloatingTaller ? refRect : rect).top;
+			const bottom = (isFloatingTaller ? refRect : rect).bottom;
+			if (isOverFloatingEl) {
+				hasLanded = true;
+				if (!isLeave) return;
+			}
+			if (isOverReferenceEl) hasLanded = false;
+			if (isOverReferenceEl && !isLeave) {
+				hasLanded = true;
+				return;
+			}
+			if (isLeave && isElement(event.relatedTarget) && contains(elements.floating, event.relatedTarget)) return;
+			if (tree && getNodeChildren(tree.nodesRef.current, nodeId).some(({ context }) => context === null || context === void 0 ? void 0 : context.open)) return;
+			if (side === "top" && y >= refRect.bottom - 1 || side === "bottom" && y <= refRect.top + 1 || side === "left" && x >= refRect.right - 1 || side === "right" && x <= refRect.left + 1) return close();
+			let rectPoly = [];
+			switch (side) {
+				case "top":
+					rectPoly = [
+						[left, refRect.top + 1],
+						[left, rect.bottom - 1],
+						[right, rect.bottom - 1],
+						[right, refRect.top + 1]
+					];
+					break;
+				case "bottom":
+					rectPoly = [
+						[left, rect.top + 1],
+						[left, refRect.bottom - 1],
+						[right, refRect.bottom - 1],
+						[right, rect.top + 1]
+					];
+					break;
+				case "left":
+					rectPoly = [
+						[rect.right - 1, bottom],
+						[rect.right - 1, top],
+						[refRect.left + 1, top],
+						[refRect.left + 1, bottom]
+					];
+					break;
+				case "right":
+					rectPoly = [
+						[refRect.right - 1, bottom],
+						[refRect.right - 1, top],
+						[rect.left + 1, top],
+						[rect.left + 1, bottom]
+					];
+					break;
+				default:
+			}
+			function getPolygon([px, py]) {
+				switch (side) {
+					case "top": return [
+						[isFloatingWider ? px + buffer / 2 : cursorLeaveFromRight ? px + buffer * 4 : px - buffer * 4, py + buffer + 1],
+						[isFloatingWider ? px - buffer / 2 : cursorLeaveFromRight ? px + buffer * 4 : px - buffer * 4, py + buffer + 1],
+						...[[rect.left, cursorLeaveFromRight ? rect.bottom - buffer : isFloatingWider ? rect.bottom - buffer : rect.top], [rect.right, cursorLeaveFromRight ? isFloatingWider ? rect.bottom - buffer : rect.top : rect.bottom - buffer]]
+					];
+					case "bottom": return [
+						[isFloatingWider ? px + buffer / 2 : cursorLeaveFromRight ? px + buffer * 4 : px - buffer * 4, py - buffer],
+						[isFloatingWider ? px - buffer / 2 : cursorLeaveFromRight ? px + buffer * 4 : px - buffer * 4, py - buffer],
+						...[[rect.left, cursorLeaveFromRight ? rect.top + buffer : isFloatingWider ? rect.top + buffer : rect.bottom], [rect.right, cursorLeaveFromRight ? isFloatingWider ? rect.top + buffer : rect.bottom : rect.top + buffer]]
+					];
+					case "left": {
+						const cursorPointOne = [px + buffer + 1, isFloatingTaller ? py + buffer / 2 : cursorLeaveFromBottom ? py + buffer * 4 : py - buffer * 4];
+						const cursorPointTwo = [px + buffer + 1, isFloatingTaller ? py - buffer / 2 : cursorLeaveFromBottom ? py + buffer * 4 : py - buffer * 4];
+						return [
+							...[[cursorLeaveFromBottom ? rect.right - buffer : isFloatingTaller ? rect.right - buffer : rect.left, rect.top], [cursorLeaveFromBottom ? isFloatingTaller ? rect.right - buffer : rect.left : rect.right - buffer, rect.bottom]],
+							cursorPointOne,
+							cursorPointTwo
+						];
+					}
+					case "right": return [
+						[px - buffer, isFloatingTaller ? py + buffer / 2 : cursorLeaveFromBottom ? py + buffer * 4 : py - buffer * 4],
+						[px - buffer, isFloatingTaller ? py - buffer / 2 : cursorLeaveFromBottom ? py + buffer * 4 : py - buffer * 4],
+						...[[cursorLeaveFromBottom ? rect.left + buffer : isFloatingTaller ? rect.left + buffer : rect.right, rect.top], [cursorLeaveFromBottom ? isFloatingTaller ? rect.left + buffer : rect.right : rect.left + buffer, rect.bottom]]
+					];
+					default: return [];
+				}
+			}
+			if (isPointInPolygon([clientX, clientY], rectPoly)) return;
+			if (hasLanded && !isOverReferenceRect) return close();
+			if (!isLeave && requireIntent) {
+				const cursorSpeed = getCursorSpeed(event.clientX, event.clientY);
+				if (cursorSpeed !== null && cursorSpeed < .1) return close();
+			}
+			if (!isPointInPolygon([clientX, clientY], getPolygon([x, y]))) close();
+			else if (!hasLanded && requireIntent) timeout.start(40, close);
+		};
+	};
+	fn.__options = { blockPointerEvents };
+	return fn;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/middleware/arrow.js
+/**
+* Fork of the original `arrow` middleware from Floating UI that allows
+* configuring the offset parent.
+*/
+var baseArrow = (options) => ({
+	name: "arrow",
+	options,
+	async fn(state) {
+		var _platform$getOffsetPa, _platform$isElement;
+		const { x, y, placement, rects, platform, elements, middlewareData } = state;
+		const { element, padding = 0, offsetParent = "real" } = evaluate(options, state) || {};
+		if (element == null) return {};
+		const paddingObject = getPaddingObject(padding);
+		const coords = {
+			x,
+			y
+		};
+		const axis = getAlignmentAxis(placement);
+		const length = getAxisLength(axis);
+		const arrowDimensions = await platform.getDimensions(element);
+		const isYAxis = axis === "y";
+		const minProp = isYAxis ? "top" : "left";
+		const maxProp = isYAxis ? "bottom" : "right";
+		const clientProp = isYAxis ? "clientHeight" : "clientWidth";
+		const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
+		const startDiff = coords[axis] - rects.reference[axis];
+		const arrowOffsetParent = offsetParent === "real" ? await ((_platform$getOffsetPa = platform.getOffsetParent) === null || _platform$getOffsetPa === void 0 ? void 0 : _platform$getOffsetPa.call(platform, element)) : elements.floating;
+		let clientSize = elements.floating[clientProp] || rects.floating[length];
+		if (!clientSize || !await ((_platform$isElement = platform.isElement) === null || _platform$isElement === void 0 ? void 0 : _platform$isElement.call(platform, arrowOffsetParent))) clientSize = elements.floating[clientProp] || rects.floating[length];
+		const centerToReference = endDiff / 2 - startDiff / 2;
+		const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
+		const minPadding = Math.min(paddingObject[minProp], largestPossiblePadding);
+		const maxPadding = Math.min(paddingObject[maxProp], largestPossiblePadding);
+		const min = minPadding;
+		const max = clientSize - arrowDimensions[length] - maxPadding;
+		const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+		const offset = clamp(min, center, max);
+		const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+		const alignmentOffset = shouldAddOffset ? center < min ? center - min : center - max : 0;
+		return {
+			[axis]: coords[axis] + alignmentOffset,
+			data: {
+				[axis]: offset,
+				centerOffset: center - offset - alignmentOffset,
+				...shouldAddOffset && { alignmentOffset }
+			},
+			reset: shouldAddOffset
+		};
+	}
+});
+/**
+* Provides data to position an inner element of the floating element so that it
+* appears centered to the reference element.
+* This wraps the core `arrow` middleware to allow React refs as the element.
+* @see https://floating-ui.com/docs/arrow
+*/
+var arrow = (options, deps) => ({
+	...baseArrow(options),
+	options: [options, deps]
+});
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/utils/useAnchorPositioning.js
+function getLogicalSide(sideParam, renderedSide, isRtl) {
+	const isLogicalSideParam = sideParam === "inline-start" || sideParam === "inline-end";
+	return {
+		top: "top",
+		right: isLogicalSideParam ? isRtl ? "inline-start" : "inline-end" : "right",
+		bottom: "bottom",
+		left: isLogicalSideParam ? isRtl ? "inline-end" : "inline-start" : "left"
+	}[renderedSide];
+}
+function getOffsetData(state, sideParam, isRtl) {
+	const { rects, placement } = state;
+	return {
+		side: getLogicalSide(sideParam, getSide(placement), isRtl),
+		align: getAlignment(placement) || "center",
+		anchor: {
+			width: rects.reference.width,
+			height: rects.reference.height
+		},
+		positioner: {
+			width: rects.floating.width,
+			height: rects.floating.height
+		}
+	};
+}
+/**
+* Provides standardized anchor positioning behavior for floating elements. Wraps Floating UI's
+* `useFloating` hook.
+*/
+function useAnchorPositioning(params) {
+	var _middlewareData$hide, _middlewareData$arrow5;
+	const { anchor, positionMethod = "absolute", side: sideParam = "bottom", sideOffset = 0, align = "center", alignOffset = 0, collisionBoundary, collisionPadding: collisionPaddingParam = 5, sticky = false, arrowPadding = 5, trackAnchor = true, keepMounted = false, floatingRootContext, mounted, collisionAvoidance, shiftCrossAxis = false, nodeId, adaptiveOrigin, lazyFlip = false } = params;
+	const [mountSide, setMountSide] = React$1.useState(null);
+	if (!mounted && mountSide !== null) setMountSide(null);
+	const collisionAvoidanceSide = collisionAvoidance.side || "flip";
+	const collisionAvoidanceAlign = collisionAvoidance.align || "flip";
+	const collisionAvoidanceFallbackAxisSide = collisionAvoidance.fallbackAxisSide || "end";
+	const anchorFn = typeof anchor === "function" ? anchor : void 0;
+	const anchorFnCallback = useEventCallback(anchorFn);
+	const anchorDep = anchorFn ? anchorFnCallback : anchor;
+	const anchorValueRef = useLatestRef(anchor);
+	const isRtl = useDirection() === "rtl";
+	const side = mountSide || {
+		top: "top",
+		right: "right",
+		bottom: "bottom",
+		left: "left",
+		"inline-end": isRtl ? "left" : "right",
+		"inline-start": isRtl ? "right" : "left"
+	}[sideParam];
+	const placement = align === "center" ? side : `${side}-${align}`;
+	let collisionPadding = collisionPaddingParam;
+	const bias = 1;
+	const biasTop = sideParam === "bottom" ? bias : 0;
+	const biasBottom = sideParam === "top" ? bias : 0;
+	const biasLeft = sideParam === "right" ? bias : 0;
+	const biasRight = sideParam === "left" ? bias : 0;
+	if (typeof collisionPadding === "number") collisionPadding = {
+		top: collisionPadding + biasTop,
+		right: collisionPadding + biasRight,
+		bottom: collisionPadding + biasBottom,
+		left: collisionPadding + biasLeft
+	};
+	else if (collisionPadding) collisionPadding = {
+		top: (collisionPadding.top || 0) + biasTop,
+		right: (collisionPadding.right || 0) + biasRight,
+		bottom: (collisionPadding.bottom || 0) + biasBottom,
+		left: (collisionPadding.left || 0) + biasLeft
+	};
+	const commonCollisionProps = {
+		boundary: collisionBoundary === "clipping-ancestors" ? "clippingAncestors" : collisionBoundary,
+		padding: collisionPadding
+	};
+	const arrowRef = React$1.useRef(null);
+	const sideOffsetRef = useLatestRef(sideOffset);
+	const alignOffsetRef = useLatestRef(alignOffset);
+	const middleware = [offset((state) => {
+		const data = getOffsetData(state, sideParam, isRtl);
+		const sideAxis = typeof sideOffsetRef.current === "function" ? sideOffsetRef.current(data) : sideOffsetRef.current;
+		const alignAxis = typeof alignOffsetRef.current === "function" ? alignOffsetRef.current(data) : alignOffsetRef.current;
+		return {
+			mainAxis: sideAxis,
+			crossAxis: alignAxis,
+			alignmentAxis: alignAxis
+		};
+	}, [
+		typeof sideOffset !== "function" ? sideOffset : 0,
+		typeof alignOffset !== "function" ? alignOffset : 0,
+		isRtl,
+		sideParam
+	])];
+	const shiftDisabled = collisionAvoidanceAlign === "none" && collisionAvoidanceSide !== "shift";
+	const crossAxisShiftEnabled = !shiftDisabled && (sticky || shiftCrossAxis || collisionAvoidanceSide === "shift");
+	const flipMiddleware = collisionAvoidanceSide === "none" ? null : flip({
+		...commonCollisionProps,
+		padding: {
+			top: collisionPadding.top + bias,
+			right: collisionPadding.right + bias,
+			bottom: collisionPadding.bottom + bias,
+			left: collisionPadding.left + bias
+		},
+		mainAxis: !shiftCrossAxis && collisionAvoidanceSide === "flip",
+		crossAxis: collisionAvoidanceAlign === "flip" ? "alignment" : false,
+		fallbackAxisSideDirection: collisionAvoidanceFallbackAxisSide
+	});
+	const shiftMiddleware = shiftDisabled ? null : shift((data) => {
+		const html = ownerDocument(data.elements.floating).documentElement;
+		return {
+			...commonCollisionProps,
+			rootBoundary: shiftCrossAxis ? {
+				x: 0,
+				y: 0,
+				width: html.clientWidth,
+				height: html.clientHeight
+			} : void 0,
+			mainAxis: collisionAvoidanceAlign !== "none",
+			crossAxis: crossAxisShiftEnabled,
+			limiter: sticky || shiftCrossAxis ? void 0 : limitShift((limitData) => {
+				if (!arrowRef.current) return {};
+				const { width, height } = arrowRef.current.getBoundingClientRect();
+				const sideAxis = getSideAxis(getSide(limitData.placement));
+				const arrowSize = sideAxis === "y" ? width : height;
+				const offsetAmount = sideAxis === "y" ? collisionPadding.left + collisionPadding.right : collisionPadding.top + collisionPadding.bottom;
+				return { offset: arrowSize / 2 + offsetAmount / 2 };
+			})
+		};
+	}, [
+		commonCollisionProps,
+		sticky,
+		shiftCrossAxis,
+		collisionPadding,
+		collisionAvoidanceAlign
+	]);
+	if (collisionAvoidanceSide === "shift" || collisionAvoidanceAlign === "shift" || align === "center") middleware.push(shiftMiddleware, flipMiddleware);
+	else middleware.push(flipMiddleware, shiftMiddleware);
+	middleware.push(size({
+		...commonCollisionProps,
+		apply({ elements: { floating }, rects: { reference }, availableWidth, availableHeight }) {
+			Object.entries({
+				"--available-width": `${availableWidth}px`,
+				"--available-height": `${availableHeight}px`,
+				"--anchor-width": `${reference.width}px`,
+				"--anchor-height": `${reference.height}px`
+			}).forEach(([key, value]) => {
+				floating.style.setProperty(key, value);
+			});
+		}
+	}), arrow(() => ({
+		element: arrowRef.current || document.createElement("div"),
+		padding: arrowPadding,
+		offsetParent: "floating"
+	}), [arrowPadding]), hide(), {
+		name: "transformOrigin",
+		fn(state) {
+			var _middlewareData$arrow, _middlewareData$arrow2, _middlewareData$shift;
+			const { elements, middlewareData, placement: renderedPlacement, rects, y } = state;
+			const currentRenderedSide = getSide(renderedPlacement);
+			const currentRenderedAxis = getSideAxis(currentRenderedSide);
+			const arrowEl = arrowRef.current;
+			const arrowX = ((_middlewareData$arrow = middlewareData.arrow) === null || _middlewareData$arrow === void 0 ? void 0 : _middlewareData$arrow.x) || 0;
+			const arrowY = ((_middlewareData$arrow2 = middlewareData.arrow) === null || _middlewareData$arrow2 === void 0 ? void 0 : _middlewareData$arrow2.y) || 0;
+			const arrowWidth = (arrowEl === null || arrowEl === void 0 ? void 0 : arrowEl.clientWidth) || 0;
+			const arrowHeight = (arrowEl === null || arrowEl === void 0 ? void 0 : arrowEl.clientHeight) || 0;
+			const transformX = arrowX + arrowWidth / 2;
+			const transformY = arrowY + arrowHeight / 2;
+			const shiftY = Math.abs(((_middlewareData$shift = middlewareData.shift) === null || _middlewareData$shift === void 0 ? void 0 : _middlewareData$shift.y) || 0);
+			const halfAnchorHeight = rects.reference.height / 2;
+			const sideOffsetValue = typeof sideOffset === "function" ? sideOffset(getOffsetData(state, sideParam, isRtl)) : sideOffset;
+			const isOverlappingAnchor = shiftY > sideOffsetValue;
+			const adjacentTransformOrigin = {
+				top: `${transformX}px calc(100% + ${sideOffsetValue}px)`,
+				bottom: `${transformX}px ${-sideOffsetValue}px`,
+				left: `calc(100% + ${sideOffsetValue}px) ${transformY}px`,
+				right: `${-sideOffsetValue}px ${transformY}px`
+			}[currentRenderedSide];
+			const overlapTransformOrigin = `${transformX}px ${rects.reference.y + halfAnchorHeight - y}px`;
+			elements.floating.style.setProperty("--transform-origin", crossAxisShiftEnabled && currentRenderedAxis === "y" && isOverlappingAnchor ? overlapTransformOrigin : adjacentTransformOrigin);
+			return {};
+		}
+	}, adaptiveOrigin);
+	let rootContext = floatingRootContext;
+	if (!mounted && floatingRootContext) rootContext = {
+		...floatingRootContext,
+		elements: {
+			reference: null,
+			floating: null,
+			domReference: null
+		}
+	};
+	const autoUpdateOptions = React$1.useMemo(() => ({
+		elementResize: trackAnchor && typeof ResizeObserver !== "undefined",
+		layoutShift: trackAnchor && typeof IntersectionObserver !== "undefined"
+	}), [trackAnchor]);
+	const { refs, elements, x, y, middlewareData, update, placement: renderedPlacement, context, isPositioned, floatingStyles: originalFloatingStyles } = useFloating({
+		rootContext,
+		placement,
+		middleware,
+		strategy: positionMethod,
+		whileElementsMounted: keepMounted ? void 0 : (...args) => autoUpdate(...args, autoUpdateOptions),
+		nodeId
+	});
+	const { sideX, sideY } = middlewareData.adaptiveOrigin || {};
+	const floatingStyles = React$1.useMemo(() => adaptiveOrigin ? {
+		position: positionMethod,
+		[sideX]: `${x}px`,
+		[sideY]: `${y}px`
+	} : originalFloatingStyles, [
+		adaptiveOrigin,
+		sideX,
+		sideY,
+		positionMethod,
+		x,
+		y,
+		originalFloatingStyles
+	]);
+	const registeredPositionReferenceRef = React$1.useRef(null);
+	useIsoLayoutEffect(() => {
+		if (!mounted) return;
+		const anchorValue = anchorValueRef.current;
+		const resolvedAnchor = typeof anchorValue === "function" ? anchorValue() : anchorValue;
+		const finalAnchor = (isRef(resolvedAnchor) ? resolvedAnchor.current : resolvedAnchor) || null;
+		if (finalAnchor !== registeredPositionReferenceRef.current) {
+			refs.setPositionReference(finalAnchor);
+			registeredPositionReferenceRef.current = finalAnchor;
+		}
+	}, [
+		mounted,
+		refs,
+		anchorDep,
+		anchorValueRef
+	]);
+	React$1.useEffect(() => {
+		if (!mounted) return;
+		const anchorValue = anchorValueRef.current;
+		if (typeof anchorValue === "function") return;
+		if (isRef(anchorValue) && anchorValue.current !== registeredPositionReferenceRef.current) {
+			refs.setPositionReference(anchorValue.current);
+			registeredPositionReferenceRef.current = anchorValue.current;
+		}
+	}, [
+		mounted,
+		refs,
+		anchorDep,
+		anchorValueRef
+	]);
+	React$1.useEffect(() => {
+		if (keepMounted && mounted && elements.domReference && elements.floating) return autoUpdate(elements.domReference, elements.floating, update, autoUpdateOptions);
+	}, [
+		keepMounted,
+		mounted,
+		elements,
+		update,
+		autoUpdateOptions
+	]);
+	const renderedSide = getSide(renderedPlacement);
+	const logicalRenderedSide = getLogicalSide(sideParam, renderedSide, isRtl);
+	const renderedAlign = getAlignment(renderedPlacement) || "center";
+	const anchorHidden = Boolean((_middlewareData$hide = middlewareData.hide) === null || _middlewareData$hide === void 0 ? void 0 : _middlewareData$hide.referenceHidden);
+	/**
+	* Locks the flip (makes it "sticky") so it doesn't prefer a given placement
+	* and flips back lazily, not eagerly. Ideal for filtered lists that change
+	* the size of the popup dynamically to avoid unwanted flipping when typing.
+	*/
+	useIsoLayoutEffect(() => {
+		if (lazyFlip && mounted && isPositioned) setMountSide(renderedSide);
+	}, [
+		lazyFlip,
+		mounted,
+		isPositioned,
+		renderedSide
+	]);
+	const arrowStyles = React$1.useMemo(() => {
+		var _middlewareData$arrow3, _middlewareData$arrow4;
+		return {
+			position: "absolute",
+			top: (_middlewareData$arrow3 = middlewareData.arrow) === null || _middlewareData$arrow3 === void 0 ? void 0 : _middlewareData$arrow3.y,
+			left: (_middlewareData$arrow4 = middlewareData.arrow) === null || _middlewareData$arrow4 === void 0 ? void 0 : _middlewareData$arrow4.x
+		};
+	}, [middlewareData.arrow]);
+	const arrowUncentered = ((_middlewareData$arrow5 = middlewareData.arrow) === null || _middlewareData$arrow5 === void 0 ? void 0 : _middlewareData$arrow5.centerOffset) !== 0;
+	return React$1.useMemo(() => ({
+		positionerStyles: floatingStyles,
+		arrowStyles,
+		arrowRef,
+		arrowUncentered,
+		side: logicalRenderedSide,
+		align: renderedAlign,
+		physicalSide: renderedSide,
+		anchorHidden,
+		refs,
+		context,
+		isPositioned,
+		update
+	}), [
+		floatingStyles,
+		arrowStyles,
+		arrowRef,
+		arrowUncentered,
+		logicalRenderedSide,
+		renderedAlign,
+		renderedSide,
+		anchorHidden,
+		refs,
+		context,
+		isPositioned,
+		update
+	]);
+}
+function isRef(param) {
+	return param != null && "current" in param;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/context-menu/root/ContextMenuRootContext.js
+var ContextMenuRootContext = /* @__PURE__ */ React$1.createContext(void 0);
+if (process.env.NODE_ENV !== "production") ContextMenuRootContext.displayName = "ContextMenuRootContext";
+function useContextMenuRootContext(optional = true) {
+	const context = React$1.useContext(ContextMenuRootContext);
+	if (context === void 0 && !optional) throw new Error("Base UI: ContextMenuRootContext is missing. ContextMenu parts must be placed within <ContextMenu.Root>.");
+	return context;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/positioner/MenuPositionerContext.js
+var MenuPositionerContext = /* @__PURE__ */ React$1.createContext(void 0);
+if (process.env.NODE_ENV !== "production") MenuPositionerContext.displayName = "MenuPositionerContext";
+function useMenuPositionerContext(optional) {
+	const context = React$1.useContext(MenuPositionerContext);
+	if (context === void 0 && !optional) throw new Error("Base UI: MenuPositionerContext is missing. MenuPositioner parts must be placed within <Menu.Positioner>.");
+	return context;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/root/MenuRootContext.js
+var MenuRootContext = /* @__PURE__ */ React$1.createContext(void 0);
+if (process.env.NODE_ENV !== "production") MenuRootContext.displayName = "MenuRootContext";
+function useMenuRootContext(optional) {
+	const context = React$1.useContext(MenuRootContext);
+	if (context === void 0 && !optional) throw new Error("Base UI: MenuRootContext is missing. Menu parts must be placed within <Menu.Root>.");
+	return context;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/backdrop/MenuBackdrop.js
+var stateAttributesMapping$1 = {
+	...popupStateMapping,
+	...transitionStatusMapping
+};
+/**
+* An overlay displayed beneath the menu popup.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+*/
+var MenuBackdrop = /* @__PURE__ */ React$1.forwardRef(function MenuBackdrop(componentProps, forwardedRef) {
+	const { className, render, ...elementProps } = componentProps;
+	const { open, mounted, transitionStatus, lastOpenChangeReason } = useMenuRootContext();
+	const contextMenuContext = useContextMenuRootContext();
+	const state = React$1.useMemo(() => ({
+		open,
+		transitionStatus
+	}), [open, transitionStatus]);
+	return useRenderElement("div", componentProps, {
+		ref: (contextMenuContext === null || contextMenuContext === void 0 ? void 0 : contextMenuContext.backdropRef) ? [forwardedRef, contextMenuContext.backdropRef] : forwardedRef,
+		state,
+		stateAttributesMapping: stateAttributesMapping$1,
+		props: [{
+			role: "presentation",
+			hidden: !mounted,
+			style: {
+				pointerEvents: lastOpenChangeReason === "trigger-hover" ? "none" : void 0,
+				userSelect: "none",
+				WebkitUserSelect: "none"
+			}
+		}, elementProps]
+	});
+});
+if (process.env.NODE_ENV !== "production") MenuBackdrop.displayName = "MenuBackdrop";
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/checkbox-item/MenuCheckboxItemContext.js
+var MenuCheckboxItemContext = /* @__PURE__ */ React$1.createContext(void 0);
+if (process.env.NODE_ENV !== "production") MenuCheckboxItemContext.displayName = "MenuCheckboxItemContext";
+function useMenuCheckboxItemContext() {
+	const context = React$1.useContext(MenuCheckboxItemContext);
+	if (context === void 0) throw new Error("Base UI: MenuCheckboxItemContext is missing. MenuCheckboxItem parts must be placed within <Menu.CheckboxItem>.");
+	return context;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/item/useMenuItem.js
+var REGULAR_ITEM = { type: "regular-item" };
+function useMenuItem(params) {
+	const { closeOnClick, disabled = false, highlighted, id, menuEvents, allowMouseUpTriggerRef, typingRef, nativeButton, itemMetadata, nodeId } = params;
+	const itemRef = React$1.useRef(null);
+	const isContextMenu = useContextMenuRootContext(true) !== void 0;
+	const { getButtonProps, buttonRef } = useButton({
+		disabled,
+		focusableWhenDisabled: true,
+		native: nativeButton
+	});
+	const getItemProps = React$1.useCallback((externalProps) => {
+		return mergeProps({
+			id,
+			role: "menuitem",
+			tabIndex: highlighted ? 0 : -1,
+			onMouseMove(event) {
+				if (!nodeId) return;
+				menuEvents.emit("itemhover", {
+					nodeId,
+					target: event.currentTarget
+				});
+			},
+			onMouseEnter() {
+				if (itemMetadata.type !== "submenu-trigger") return;
+				itemMetadata.setActive();
+			},
+			onKeyUp(event) {
+				if (event.key === " " && typingRef.current) event.preventBaseUIHandler();
+			},
+			onClick(event) {
+				if (closeOnClick) menuEvents.emit("close", {
+					domEvent: event,
+					reason: "item-press"
+				});
+			},
+			onMouseUp(event) {
+				if (itemRef.current && allowMouseUpTriggerRef.current && (!isContextMenu || event.button === 2)) {
+					if (itemMetadata.type === "regular-item") itemRef.current.click();
+				}
+			}
+		}, externalProps, getButtonProps);
+	}, [
+		id,
+		highlighted,
+		getButtonProps,
+		typingRef,
+		closeOnClick,
+		menuEvents,
+		allowMouseUpTriggerRef,
+		isContextMenu,
+		itemMetadata,
+		nodeId
+	]);
+	const mergedRef = useMergedRefs(itemRef, buttonRef);
+	return React$1.useMemo(() => ({
+		getItemProps,
+		itemRef: mergedRef
+	}), [getItemProps, mergedRef]);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/checkbox-item/MenuCheckboxItemDataAttributes.js
+var MenuCheckboxItemDataAttributes = /* @__PURE__ */ function(MenuCheckboxItemDataAttributes) {
+	/**
+	* Present when the menu checkbox item is checked.
+	*/
+	MenuCheckboxItemDataAttributes["checked"] = "data-checked";
+	/**
+	* Present when the menu checkbox item is not checked.
+	*/
+	MenuCheckboxItemDataAttributes["unchecked"] = "data-unchecked";
+	/**
+	* Present when the menu checkbox item is disabled.
+	*/
+	MenuCheckboxItemDataAttributes["disabled"] = "data-disabled";
+	/**
+	* Present when the menu checkbox item is highlighted.
+	*/
+	MenuCheckboxItemDataAttributes["highlighted"] = "data-highlighted";
+	return MenuCheckboxItemDataAttributes;
+}({});
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/utils/stateAttributesMapping.js
+var itemMapping = {
+	checked(value) {
+		if (value) return { [MenuCheckboxItemDataAttributes.checked]: "" };
+		return { [MenuCheckboxItemDataAttributes.unchecked]: "" };
+	},
+	...transitionStatusMapping
+};
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/checkbox-item/MenuCheckboxItem.js
+var InnerMenuCheckboxItem = /* @__PURE__ */ React$1.memo(/* @__PURE__ */ React$1.forwardRef(function InnerMenuCheckboxItem(componentProps, forwardedRef) {
+	const { checked: checkedProp, defaultChecked, onCheckedChange, className, closeOnClick, disabled = false, highlighted, id, menuEvents, itemProps, render, allowMouseUpTriggerRef, typingRef, nativeButton, nodeId, ...elementProps } = componentProps;
+	const [checked, setChecked] = useControlled({
+		controlled: checkedProp,
+		default: defaultChecked !== null && defaultChecked !== void 0 ? defaultChecked : false,
+		name: "MenuCheckboxItem",
+		state: "checked"
+	});
+	const { getItemProps, itemRef } = useMenuItem({
+		closeOnClick,
+		disabled,
+		highlighted,
+		id,
+		menuEvents,
+		allowMouseUpTriggerRef,
+		typingRef,
+		nativeButton,
+		nodeId,
+		itemMetadata: REGULAR_ITEM
+	});
+	const state = React$1.useMemo(() => ({
+		disabled,
+		highlighted,
+		checked
+	}), [
+		disabled,
+		highlighted,
+		checked
+	]);
+	const element = useRenderElement("div", componentProps, {
+		state,
+		stateAttributesMapping: itemMapping,
+		props: [
+			itemProps,
+			{
+				role: "menuitemcheckbox",
+				"aria-checked": checked,
+				onClick(event) {
+					const details = createChangeEventDetails("item-press", event.nativeEvent);
+					onCheckedChange === null || onCheckedChange === void 0 || onCheckedChange(!checked, details);
+					if (details.isCanceled) return;
+					setChecked((currentlyChecked) => !currentlyChecked);
+				}
+			},
+			elementProps,
+			getItemProps
+		],
+		ref: [itemRef, forwardedRef]
+	});
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuCheckboxItemContext.Provider, {
+		value: state,
+		children: element
+	});
+}));
+/**
+* A menu item that toggles a setting on or off.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+*/
+if (process.env.NODE_ENV !== "production") InnerMenuCheckboxItem.displayName = "InnerMenuCheckboxItem";
+var MenuCheckboxItem = /* @__PURE__ */ React$1.forwardRef(function MenuCheckboxItem(props, forwardedRef) {
+	const { id: idProp, label, closeOnClick = false, nativeButton = false, ...other } = props;
+	const itemRef = React$1.useRef(null);
+	const listItem = useCompositeListItem({ label });
+	const mergedRef = useMergedRefs(forwardedRef, listItem.ref, itemRef);
+	const { itemProps, activeIndex, allowMouseUpTriggerRef, typingRef } = useMenuRootContext();
+	const menuPositionerContext = useMenuPositionerContext(true);
+	const id = useBaseUiId(idProp);
+	const highlighted = listItem.index === activeIndex;
+	const { events: menuEvents } = useFloatingTree();
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InnerMenuCheckboxItem, {
+		...other,
+		id,
+		ref: mergedRef,
+		highlighted,
+		menuEvents,
+		itemProps,
+		allowMouseUpTriggerRef,
+		typingRef,
+		closeOnClick,
+		nativeButton,
+		nodeId: menuPositionerContext === null || menuPositionerContext === void 0 ? void 0 : menuPositionerContext.floatingContext.nodeId
+	});
+});
+if (process.env.NODE_ENV !== "production") MenuCheckboxItem.displayName = "MenuCheckboxItem";
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/checkbox-item-indicator/MenuCheckboxItemIndicator.js
+/**
+* Indicates whether the checkbox item is ticked.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+*/
+var MenuCheckboxItemIndicator = /* @__PURE__ */ React$1.forwardRef(function MenuCheckboxItemIndicator(componentProps, forwardedRef) {
+	const { render, className, keepMounted = false, ...elementProps } = componentProps;
+	const item = useMenuCheckboxItemContext();
+	const indicatorRef = React$1.useRef(null);
+	const { transitionStatus, setMounted } = useTransitionStatus(item.checked);
+	useOpenChangeComplete({
+		open: item.checked,
+		ref: indicatorRef,
+		onComplete() {
+			if (!item.checked) setMounted(false);
+		}
+	});
+	return useRenderElement("span", componentProps, {
+		state: React$1.useMemo(() => ({
+			checked: item.checked,
+			disabled: item.disabled,
+			highlighted: item.highlighted,
+			transitionStatus
+		}), [
+			item.checked,
+			item.disabled,
+			item.highlighted,
+			transitionStatus
+		]),
+		ref: [forwardedRef, indicatorRef],
+		stateAttributesMapping: itemMapping,
+		props: {
+			"aria-hidden": true,
+			...elementProps
+		},
+		enabled: keepMounted || item.checked
+	});
+});
+if (process.env.NODE_ENV !== "production") MenuCheckboxItemIndicator.displayName = "MenuCheckboxItemIndicator";
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/group/MenuGroupContext.js
+var MenuGroupContext = /* @__PURE__ */ React$1.createContext(void 0);
+if (process.env.NODE_ENV !== "production") MenuGroupContext.displayName = "MenuGroupContext";
+function useMenuGroupRootContext() {
+	const context = React$1.useContext(MenuGroupContext);
+	if (context === void 0) throw new Error("Base UI: MenuGroupRootContext is missing. Menu group parts must be used within <Menu.Group>.");
+	return context;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/group/MenuGroup.js
+/**
+* Groups related menu items with the corresponding label.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+*/
+var MenuGroup = /* @__PURE__ */ React$1.forwardRef(function MenuGroup(componentProps, forwardedRef) {
+	const { render, className, ...elementProps } = componentProps;
+	const [labelId, setLabelId] = React$1.useState(void 0);
+	const context = React$1.useMemo(() => ({ setLabelId }), [setLabelId]);
+	const element = useRenderElement("div", componentProps, {
+		ref: forwardedRef,
+		props: {
+			role: "group",
+			"aria-labelledby": labelId,
+			...elementProps
+		}
+	});
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuGroupContext.Provider, {
+		value: context,
+		children: element
+	});
+});
+if (process.env.NODE_ENV !== "production") MenuGroup.displayName = "MenuGroup";
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/group-label/MenuGroupLabel.js
+/**
+* An accessible label that is automatically associated with its parent group.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+*/
+var MenuGroupLabel = /* @__PURE__ */ React$1.forwardRef(function MenuGroupLabelComponent(componentProps, forwardedRef) {
+	const { className, render, id: idProp, ...elementProps } = componentProps;
+	const id = useBaseUiId(idProp);
+	const { setLabelId } = useMenuGroupRootContext();
+	useIsoLayoutEffect(() => {
+		setLabelId(id);
+		return () => {
+			setLabelId(void 0);
+		};
+	}, [setLabelId, id]);
+	return useRenderElement("div", componentProps, {
+		ref: forwardedRef,
+		props: {
+			id,
+			role: "presentation",
+			...elementProps
+		}
+	});
+});
+if (process.env.NODE_ENV !== "production") MenuGroupLabel.displayName = "MenuGroupLabel";
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/item/MenuItem.js
+var InnerMenuItem = /* @__PURE__ */ React$1.memo(/* @__PURE__ */ React$1.forwardRef(function InnerMenuItem(componentProps, forwardedRef) {
+	const { className, closeOnClick = true, disabled = false, highlighted, id, menuEvents, itemProps, render, allowMouseUpTriggerRef, typingRef, nativeButton, nodeId, ...elementProps } = componentProps;
+	const { getItemProps, itemRef } = useMenuItem({
+		closeOnClick,
+		disabled,
+		highlighted,
+		id,
+		menuEvents,
+		allowMouseUpTriggerRef,
+		typingRef,
+		nativeButton,
+		nodeId,
+		itemMetadata: REGULAR_ITEM
+	});
+	return useRenderElement("div", componentProps, {
+		state: React$1.useMemo(() => ({
+			disabled,
+			highlighted
+		}), [disabled, highlighted]),
+		ref: [itemRef, forwardedRef],
+		props: [
+			itemProps,
+			elementProps,
+			getItemProps
+		]
+	});
+}));
+/**
+* An individual interactive item in the menu.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+*/
+if (process.env.NODE_ENV !== "production") InnerMenuItem.displayName = "InnerMenuItem";
+var MenuItem = /* @__PURE__ */ React$1.forwardRef(function MenuItem(props, forwardedRef) {
+	const { id: idProp, label, nativeButton = false, ...other } = props;
+	const itemRef = React$1.useRef(null);
+	const listItem = useCompositeListItem({ label });
+	const mergedRef = useMergedRefs(forwardedRef, listItem.ref, itemRef);
+	const { itemProps, activeIndex, allowMouseUpTriggerRef, typingRef } = useMenuRootContext();
+	const menuPositionerContext = useMenuPositionerContext(true);
+	const id = useBaseUiId(idProp);
+	const highlighted = listItem.index === activeIndex;
+	const { events: menuEvents } = useFloatingTree();
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InnerMenuItem, {
+		...other,
+		id,
+		ref: mergedRef,
+		highlighted,
+		menuEvents,
+		itemProps,
+		allowMouseUpTriggerRef,
+		typingRef,
+		nativeButton,
+		nodeId: menuPositionerContext === null || menuPositionerContext === void 0 ? void 0 : menuPositionerContext.floatingContext.nodeId
+	});
+});
+if (process.env.NODE_ENV !== "production") MenuItem.displayName = "MenuItem";
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/toolbar/root/ToolbarRootContext.js
+var ToolbarRootContext = /* @__PURE__ */ React$1.createContext(void 0);
+if (process.env.NODE_ENV !== "production") ToolbarRootContext.displayName = "ToolbarRootContext";
+function useToolbarRootContext(optional) {
+	const context = React$1.useContext(ToolbarRootContext);
+	if (context === void 0 && !optional) throw new Error("Base UI: ToolbarRootContext is missing. Toolbar parts must be placed within <Toolbar.Root>.");
+	return context;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/popup/MenuPopup.js
+var stateAttributesMapping = {
+	...popupStateMapping,
+	...transitionStatusMapping
+};
+/**
+* A container for the menu items.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+*/
+var MenuPopup = /* @__PURE__ */ React$1.forwardRef(function MenuPopup(componentProps, forwardedRef) {
+	const { render, className, finalFocus, ...elementProps } = componentProps;
+	const { open, setOpen, popupRef, transitionStatus, popupProps, mounted, instantType, triggerElement, onOpenChangeComplete, parent, lastOpenChangeReason, rootId } = useMenuRootContext();
+	const { side, align, floatingContext } = useMenuPositionerContext();
+	const insideToolbar = useToolbarRootContext(true) != null;
+	useOpenChangeComplete({
+		open,
+		ref: popupRef,
+		onComplete() {
+			if (open) onOpenChangeComplete === null || onOpenChangeComplete === void 0 || onOpenChangeComplete(true);
+		}
+	});
+	const { events: menuEvents } = useFloatingTree();
+	React$1.useEffect(() => {
+		function handleClose(event) {
+			setOpen(false, createChangeEventDetails(event.reason, event.domEvent));
+		}
+		menuEvents.on("close", handleClose);
+		return () => {
+			menuEvents.off("close", handleClose);
+		};
+	}, [menuEvents, setOpen]);
+	const element = useRenderElement("div", componentProps, {
+		state: React$1.useMemo(() => ({
+			transitionStatus,
+			side,
+			align,
+			open,
+			nested: parent.type === "menu",
+			instant: instantType
+		}), [
+			transitionStatus,
+			side,
+			align,
+			open,
+			parent.type,
+			instantType
+		]),
+		ref: [forwardedRef, popupRef],
+		stateAttributesMapping,
+		props: [
+			popupProps,
+			{ onKeyDown(event) {
+				if (insideToolbar && COMPOSITE_KEYS.has(event.key)) event.stopPropagation();
+			} },
+			transitionStatus === "starting" ? DISABLED_TRANSITIONS_STYLE : EMPTY_OBJECT,
+			elementProps,
+			{ "data-rootownerid": rootId }
+		]
+	});
+	let returnFocus = parent.type === void 0 || parent.type === "context-menu";
+	if (triggerElement || parent.type === "menubar" && lastOpenChangeReason !== "outside-press") returnFocus = true;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FloatingFocusManager, {
+		context: floatingContext,
+		modal: false,
+		disabled: !mounted,
+		returnFocus: finalFocus === void 0 ? returnFocus : finalFocus,
+		initialFocus: parent.type !== "menu",
+		restoreFocus: true,
+		children: element
+	});
+});
+if (process.env.NODE_ENV !== "production") MenuPopup.displayName = "MenuPopup";
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/portal/MenuPortalContext.js
+var MenuPortalContext = /* @__PURE__ */ React$1.createContext(void 0);
+if (process.env.NODE_ENV !== "production") MenuPortalContext.displayName = "MenuPortalContext";
+function useMenuPortalContext() {
+	const value = React$1.useContext(MenuPortalContext);
+	if (value === void 0) throw new Error("Base UI: <Menu.Portal> is missing.");
+	return value;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/portal/MenuPortal.js
+/**
+* A portal element that moves the popup to a different part of the DOM.
+* By default, the portal element is appended to `<body>`.
+*
+* Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+*/
+function MenuPortal(props) {
+	const { children, keepMounted = false, container } = props;
+	const { mounted } = useMenuRootContext();
+	if (!(mounted || keepMounted)) return null;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuPortalContext.Provider, {
+		value: keepMounted,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FloatingPortal, {
+			root: container,
+			children
+		})
+	});
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/positioner/MenuPositioner.js
+/**
+* Positions the menu popup against the trigger.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+*/
+var MenuPositioner = /* @__PURE__ */ React$1.forwardRef(function MenuPositioner(componentProps, forwardedRef) {
+	const { anchor: anchorProp, positionMethod: positionMethodProp = "absolute", className, render, side, align: alignProp, sideOffset: sideOffsetProp = 0, alignOffset: alignOffsetProp = 0, collisionBoundary = "clipping-ancestors", collisionPadding = 5, arrowPadding = 5, sticky = false, trackAnchor = true, collisionAvoidance = DROPDOWN_COLLISION_AVOIDANCE, ...elementProps } = componentProps;
+	const { open, setOpen, floatingRootContext, setPositionerElement, itemDomElements, itemLabels, mounted, modal, lastOpenChangeReason, parent, setHoverEnabled, triggerElement } = useMenuRootContext();
+	const keepMounted = useMenuPortalContext();
+	const nodeId = useFloatingNodeId();
+	const parentNodeId = useFloatingParentNodeId();
+	const contextMenuContext = useContextMenuRootContext(true);
+	let anchor = anchorProp;
+	let sideOffset = sideOffsetProp;
+	let alignOffset = alignOffsetProp;
+	let align = alignProp;
+	if (parent.type === "context-menu") {
+		var _parent$context$ancho, _parent$context, _align;
+		anchor = (_parent$context$ancho = (_parent$context = parent.context) === null || _parent$context === void 0 ? void 0 : _parent$context.anchor) !== null && _parent$context$ancho !== void 0 ? _parent$context$ancho : anchorProp;
+		align = (_align = align) !== null && _align !== void 0 ? _align : "start";
+		if (!side && align !== "center") {
+			var _componentProps$align, _componentProps$sideO;
+			alignOffset = (_componentProps$align = componentProps.alignOffset) !== null && _componentProps$align !== void 0 ? _componentProps$align : 2;
+			sideOffset = (_componentProps$sideO = componentProps.sideOffset) !== null && _componentProps$sideO !== void 0 ? _componentProps$sideO : -5;
+		}
+	}
+	let computedSide = side;
+	let computedAlign = align;
+	if (parent.type === "menu") {
+		var _computedSide, _computedAlign;
+		computedSide = (_computedSide = computedSide) !== null && _computedSide !== void 0 ? _computedSide : "inline-end";
+		computedAlign = (_computedAlign = computedAlign) !== null && _computedAlign !== void 0 ? _computedAlign : "start";
+	} else if (parent.type === "menubar") {
+		var _computedSide2, _computedAlign2;
+		computedSide = (_computedSide2 = computedSide) !== null && _computedSide2 !== void 0 ? _computedSide2 : "bottom";
+		computedAlign = (_computedAlign2 = computedAlign) !== null && _computedAlign2 !== void 0 ? _computedAlign2 : "start";
+	}
+	const contextMenu = parent.type === "context-menu";
+	const positioner = useAnchorPositioning({
+		anchor,
+		floatingRootContext,
+		positionMethod: contextMenuContext ? "fixed" : positionMethodProp,
+		mounted,
+		side: computedSide,
+		sideOffset,
+		align: computedAlign,
+		alignOffset,
+		arrowPadding: contextMenu ? 0 : arrowPadding,
+		collisionBoundary,
+		collisionPadding,
+		sticky,
+		nodeId,
+		keepMounted,
+		trackAnchor,
+		collisionAvoidance,
+		shiftCrossAxis: contextMenu
+	});
+	const { events: menuEvents } = useFloatingTree();
+	const positionerProps = React$1.useMemo(() => {
+		const hiddenStyles = {};
+		if (!open) hiddenStyles.pointerEvents = "none";
+		return {
+			role: "presentation",
+			hidden: !mounted,
+			style: {
+				...positioner.positionerStyles,
+				...hiddenStyles
+			}
+		};
+	}, [
+		open,
+		mounted,
+		positioner.positionerStyles
+	]);
+	React$1.useEffect(() => {
+		function onMenuOpenChange(details) {
+			if (details.open) {
+				if (details.parentNodeId === nodeId) setHoverEnabled(false);
+				if (details.nodeId !== nodeId && details.parentNodeId === parentNodeId) setOpen(false, createChangeEventDetails("sibling-open"));
+			} else if (details.parentNodeId === nodeId) {
+				if (details.reason !== "sibling-open") setHoverEnabled(true);
+			}
+		}
+		menuEvents.on("menuopenchange", onMenuOpenChange);
+		return () => {
+			menuEvents.off("menuopenchange", onMenuOpenChange);
+		};
+	}, [
+		menuEvents,
+		nodeId,
+		parentNodeId,
+		setOpen,
+		setHoverEnabled
+	]);
+	React$1.useEffect(() => {
+		if (parentNodeId == null) return;
+		function onParentClose(details) {
+			var _details$reason;
+			if (details.open || details.nodeId !== parentNodeId) return;
+			setOpen(false, createChangeEventDetails((_details$reason = details.reason) !== null && _details$reason !== void 0 ? _details$reason : "sibling-open"));
+		}
+		menuEvents.on("menuopenchange", onParentClose);
+		return () => {
+			menuEvents.off("menuopenchange", onParentClose);
+		};
+	}, [
+		menuEvents,
+		parentNodeId,
+		setOpen
+	]);
+	React$1.useEffect(() => {
+		function onItemHover(event) {
+			if (!open || event.nodeId !== parentNodeId) return;
+			if (triggerElement && event.target && triggerElement !== event.target) setOpen(false, createChangeEventDetails("sibling-open"));
+		}
+		menuEvents.on("itemhover", onItemHover);
+		return () => {
+			menuEvents.off("itemhover", onItemHover);
+		};
+	}, [
+		menuEvents,
+		parentNodeId,
+		triggerElement,
+		open,
+		setOpen
+	]);
+	React$1.useEffect(() => {
+		const eventDetails = {
+			open,
+			nodeId,
+			parentNodeId,
+			reason: lastOpenChangeReason
+		};
+		menuEvents.emit("menuopenchange", eventDetails);
+	}, [
+		menuEvents,
+		open,
+		nodeId,
+		parentNodeId,
+		lastOpenChangeReason
+	]);
+	const state = React$1.useMemo(() => ({
+		open,
+		side: positioner.side,
+		align: positioner.align,
+		anchorHidden: positioner.anchorHidden,
+		nested: parent.type === "menu"
+	}), [
+		open,
+		positioner.side,
+		positioner.align,
+		positioner.anchorHidden,
+		parent.type
+	]);
+	const contextValue = React$1.useMemo(() => ({
+		side: positioner.side,
+		align: positioner.align,
+		arrowRef: positioner.arrowRef,
+		arrowUncentered: positioner.arrowUncentered,
+		arrowStyles: positioner.arrowStyles,
+		floatingContext: positioner.context
+	}), [
+		positioner.side,
+		positioner.align,
+		positioner.arrowRef,
+		positioner.arrowUncentered,
+		positioner.arrowStyles,
+		positioner.context
+	]);
+	const element = useRenderElement("div", componentProps, {
+		state,
+		stateAttributesMapping: popupStateMapping,
+		ref: [forwardedRef, setPositionerElement],
+		props: {
+			...positionerProps,
+			...elementProps
+		}
+	});
+	const shouldRenderBackdrop = mounted && parent.type !== "menu" && (parent.type !== "menubar" && modal && lastOpenChangeReason !== "trigger-hover" || parent.type === "menubar" && parent.context.modal);
+	let backdropCutout = null;
+	if (parent.type === "menubar") backdropCutout = parent.context.contentElement;
+	else if (parent.type === void 0) backdropCutout = triggerElement;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(MenuPositionerContext.Provider, {
+		value: contextValue,
+		children: [shouldRenderBackdrop && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InternalBackdrop, {
+			ref: parent.type === "context-menu" || parent.type === "nested-context-menu" ? parent.context.internalBackdropRef : null,
+			inert: inertValue(!open),
+			cutout: backdropCutout
+		}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FloatingNode, {
+			id: nodeId,
+			children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CompositeList, {
+				elementsRef: itemDomElements,
+				labelsRef: itemLabels,
+				children: element
+			})
+		})]
+	});
+});
+if (process.env.NODE_ENV !== "production") MenuPositioner.displayName = "MenuPositioner";
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/radio-group/MenuRadioGroupContext.js
+var MenuRadioGroupContext = /* @__PURE__ */ React$1.createContext(void 0);
+if (process.env.NODE_ENV !== "production") MenuRadioGroupContext.displayName = "MenuRadioGroupContext";
+function useMenuRadioGroupContext() {
+	const context = React$1.useContext(MenuRadioGroupContext);
+	if (context === void 0) throw new Error("Base UI: MenuRadioGroupContext is missing. MenuRadioGroup parts must be placed within <Menu.RadioGroup>.");
+	return context;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/radio-group/MenuRadioGroup.js
+/**
+* Groups related radio items.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+*/
+var MenuRadioGroup = /* @__PURE__ */ React$1.memo(/* @__PURE__ */ React$1.forwardRef(function MenuRadioGroup(componentProps, forwardedRef) {
+	const { render, className, value: valueProp, defaultValue, onValueChange: onValueChangeProp, disabled = false, ...elementProps } = componentProps;
+	const [value, setValueUnwrapped] = useControlled({
+		controlled: valueProp,
+		default: defaultValue,
+		name: "MenuRadioGroup"
+	});
+	const onValueChange = useEventCallback(onValueChangeProp);
+	const setValue = useEventCallback((newValue, eventDetails) => {
+		onValueChange === null || onValueChange === void 0 || onValueChange(newValue, eventDetails);
+		if (eventDetails.isCanceled) return;
+		setValueUnwrapped(newValue);
+	});
+	const element = useRenderElement("div", componentProps, {
+		state: React$1.useMemo(() => ({ disabled }), [disabled]),
+		ref: forwardedRef,
+		props: {
+			role: "group",
+			"aria-disabled": disabled || void 0,
+			...elementProps
+		}
+	});
+	const context = React$1.useMemo(() => ({
+		value,
+		setValue,
+		disabled
+	}), [
+		value,
+		setValue,
+		disabled
+	]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuRadioGroupContext.Provider, {
+		value: context,
+		children: element
+	});
+}));
+if (process.env.NODE_ENV !== "production") MenuRadioGroup.displayName = "MenuRadioGroup";
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/radio-item/MenuRadioItemContext.js
+var MenuRadioItemContext = /* @__PURE__ */ React$1.createContext(void 0);
+if (process.env.NODE_ENV !== "production") MenuRadioItemContext.displayName = "MenuRadioItemContext";
+function useMenuRadioItemContext() {
+	const context = React$1.useContext(MenuRadioItemContext);
+	if (context === void 0) throw new Error("Base UI: MenuRadioItemContext is missing. MenuRadioItem parts must be placed within <Menu.RadioItem>.");
+	return context;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/radio-item/MenuRadioItem.js
+var InnerMenuRadioItem = /* @__PURE__ */ React$1.memo(/* @__PURE__ */ React$1.forwardRef(function InnerMenuRadioItem(componentProps, forwardedRef) {
+	const { checked, setChecked, className, closeOnClick, disabled = false, highlighted, id, menuEvents, itemProps, render, allowMouseUpTriggerRef, typingRef, nativeButton, nodeId, ...elementProps } = componentProps;
+	const { getItemProps, itemRef } = useMenuItem({
+		closeOnClick,
+		disabled,
+		highlighted,
+		id,
+		menuEvents,
+		allowMouseUpTriggerRef,
+		typingRef,
+		nativeButton,
+		itemMetadata: REGULAR_ITEM,
+		nodeId
+	});
+	return useRenderElement("div", componentProps, {
+		state: React$1.useMemo(() => ({
+			disabled,
+			highlighted,
+			checked
+		}), [
+			disabled,
+			highlighted,
+			checked
+		]),
+		stateAttributesMapping: itemMapping,
+		ref: [itemRef, forwardedRef],
+		props: [
+			itemProps,
+			{
+				role: "menuitemradio",
+				"aria-checked": checked,
+				onClick(event) {
+					setChecked(createChangeEventDetails("item-press", event.nativeEvent));
+				}
+			},
+			elementProps,
+			getItemProps
+		]
+	});
+}));
+/**
+* A menu item that works like a radio button in a given group.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+*/
+if (process.env.NODE_ENV !== "production") InnerMenuRadioItem.displayName = "InnerMenuRadioItem";
+var MenuRadioItem = /* @__PURE__ */ React$1.forwardRef(function MenuRadioItem(props, forwardedRef) {
+	const { id: idProp, value, label, disabled: disabledProp = false, closeOnClick = false, nativeButton = false, ...other } = props;
+	const itemRef = React$1.useRef(null);
+	const listItem = useCompositeListItem({ label });
+	const mergedRef = useMergedRefs(forwardedRef, listItem.ref, itemRef);
+	const { itemProps, activeIndex, allowMouseUpTriggerRef, typingRef } = useMenuRootContext();
+	const menuPositionerContext = useMenuPositionerContext(true);
+	const id = useBaseUiId(idProp);
+	const highlighted = listItem.index === activeIndex;
+	const { events: menuEvents } = useFloatingTree();
+	const { value: selectedValue, setValue: setSelectedValue, disabled: groupDisabled } = useMenuRadioGroupContext();
+	const disabled = groupDisabled || disabledProp;
+	const checked = selectedValue === value;
+	const setChecked = React$1.useCallback((eventDetails) => {
+		setSelectedValue(value, eventDetails);
+	}, [setSelectedValue, value]);
+	const contextValue = React$1.useMemo(() => ({
+		checked,
+		highlighted,
+		disabled
+	}), [
+		checked,
+		highlighted,
+		disabled
+	]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuRadioItemContext.Provider, {
+		value: contextValue,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InnerMenuRadioItem, {
+			...other,
+			id,
+			ref: mergedRef,
+			disabled,
+			highlighted,
+			menuEvents,
+			itemProps,
+			allowMouseUpTriggerRef,
+			checked: selectedValue === value,
+			setChecked,
+			typingRef,
+			closeOnClick,
+			nativeButton,
+			nodeId: menuPositionerContext === null || menuPositionerContext === void 0 ? void 0 : menuPositionerContext.floatingContext.nodeId
+		})
+	});
+});
+if (process.env.NODE_ENV !== "production") MenuRadioItem.displayName = "MenuRadioItem";
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/radio-item-indicator/MenuRadioItemIndicator.js
+/**
+* Indicates whether the radio item is selected.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+*/
+var MenuRadioItemIndicator = /* @__PURE__ */ React$1.forwardRef(function MenuRadioItemIndicator(componentProps, forwardedRef) {
+	const { render, className, keepMounted = false, ...elementProps } = componentProps;
+	const item = useMenuRadioItemContext();
+	const indicatorRef = React$1.useRef(null);
+	const { transitionStatus, setMounted } = useTransitionStatus(item.checked);
+	useOpenChangeComplete({
+		open: item.checked,
+		ref: indicatorRef,
+		onComplete() {
+			if (!item.checked) setMounted(false);
+		}
+	});
+	return useRenderElement("span", componentProps, {
+		state: React$1.useMemo(() => ({
+			checked: item.checked,
+			disabled: item.disabled,
+			highlighted: item.highlighted,
+			transitionStatus
+		}), [
+			item.checked,
+			item.disabled,
+			item.highlighted,
+			transitionStatus
+		]),
+		stateAttributesMapping: itemMapping,
+		ref: [forwardedRef, indicatorRef],
+		props: {
+			"aria-hidden": true,
+			...elementProps
+		},
+		enabled: keepMounted || item.checked
+	});
+});
+if (process.env.NODE_ENV !== "production") MenuRadioItemIndicator.displayName = "MenuRadioItemIndicator";
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menubar/MenubarContext.js
+var MenubarContext = /* @__PURE__ */ React$1.createContext(null);
+if (process.env.NODE_ENV !== "production") MenubarContext.displayName = "MenubarContext";
+function useMenubarContext(optional) {
+	const context = React$1.useContext(MenubarContext);
+	if (context === null && !optional) throw new Error("Base UI: MenubarContext is missing. Menubar parts must be placed within <Menubar>.");
+	return context;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/submenu-root/MenuSubmenuRootContext.js
+var MenuSubmenuRootContext = /* @__PURE__ */ React$1.createContext(false);
+if (process.env.NODE_ENV !== "production") MenuSubmenuRootContext.displayName = "MenuSubmenuRootContext";
+function useMenuSubmenuRootContext() {
+	return React$1.useContext(MenuSubmenuRootContext);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/utils/useMixedToggleClickHander.js
+/**
+* Returns `click` and `mousedown` handlers that fix the behavior of triggers of popups that are toggled by different events.
+* For example, a button that opens a popup on mousedown and closes it on click.
+* This hook prevents the popup from closing immediately after the mouse button is released.
+*/
+function useMixedToggleClickHandler(params) {
+	const { enabled = true, mouseDownAction, open } = params;
+	const ignoreClickRef = React$1.useRef(false);
+	return React$1.useMemo(() => {
+		if (!enabled) return EMPTY_OBJECT;
+		return {
+			onMouseDown: (event) => {
+				if (mouseDownAction === "open" && !open || mouseDownAction === "close" && open) {
+					ignoreClickRef.current = true;
+					ownerDocument(event.currentTarget).addEventListener("click", () => {
+						ignoreClickRef.current = false;
+					}, { once: true });
+				}
+			},
+			onClick: (event) => {
+				if (ignoreClickRef.current) {
+					ignoreClickRef.current = false;
+					event.preventBaseUIHandler();
+				}
+			}
+		};
+	}, [
+		enabled,
+		mouseDownAction,
+		open
+	]);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/root/MenuRoot.js
+var EMPTY_ARRAY = [];
+var EMPTY_REF = { current: false };
+/**
+* Groups all parts of the menu.
+* Doesn’t render its own HTML element.
+*
+* Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+*/
+var MenuRoot = function MenuRoot(props) {
+	const { children, open: openProp, onOpenChange, onOpenChangeComplete, defaultOpen = false, disabled: disabledProp = false, modal: modalProp, loop = true, orientation = "vertical", actionsRef, openOnHover: openOnHoverProp, delay = 100, closeDelay = 0, closeParentOnEsc = true } = props;
+	const [triggerElement, setTriggerElement] = React$1.useState(null);
+	const [positionerElement, setPositionerElementUnwrapped] = React$1.useState(null);
+	const [instantType, setInstantType] = React$1.useState();
+	const [hoverEnabled, setHoverEnabled] = React$1.useState(true);
+	const [activeIndex, setActiveIndex] = React$1.useState(null);
+	const [lastOpenChangeReason, setLastOpenChangeReason] = React$1.useState(null);
+	const [stickIfOpen, setStickIfOpen] = React$1.useState(true);
+	const [allowMouseEnterState, setAllowMouseEnterState] = React$1.useState(false);
+	const openEventRef = React$1.useRef(null);
+	const popupRef = React$1.useRef(null);
+	const positionerRef = React$1.useRef(null);
+	const itemDomElements = React$1.useRef([]);
+	const itemLabels = React$1.useRef([]);
+	const stickIfOpenTimeout = useTimeout();
+	const contextMenuContext = useContextMenuRootContext(true);
+	const isSubmenu = useMenuSubmenuRootContext();
+	const nested = useFloatingParentNodeId() != null;
+	let floatingEvents;
+	let parent;
+	{
+		const parentContext = useMenuRootContext(true);
+		const menubarContext = useMenubarContext(true);
+		if (isSubmenu && parentContext) parent = {
+			type: "menu",
+			context: parentContext
+		};
+		else if (menubarContext) parent = {
+			type: "menubar",
+			context: menubarContext
+		};
+		else if (contextMenuContext && !parentContext) parent = {
+			type: "context-menu",
+			context: contextMenuContext
+		};
+		else parent = { type: void 0 };
+	}
+	let rootId = useId$1();
+	if (parent.type !== void 0) rootId = parent.context.rootId;
+	const modal = (parent.type === void 0 || parent.type === "context-menu") && (modalProp !== null && modalProp !== void 0 ? modalProp : true);
+	const disabled = disabledProp || parent.type === "menubar" && parent.context.disabled || false;
+	const allowMouseEnter = parent.type === "menu" ? parent.context.allowMouseEnter : allowMouseEnterState;
+	const setAllowMouseEnter = parent.type === "menu" ? parent.context.setAllowMouseEnter : setAllowMouseEnterState;
+	if (process.env.NODE_ENV !== "production") {
+		if (parent.type !== void 0 && modalProp !== void 0) console.warn("Base UI: The `modal` prop is not supported on nested menus. It will be ignored.");
+	}
+	const openOnHover = openOnHoverProp !== null && openOnHoverProp !== void 0 ? openOnHoverProp : parent.type === "menu" || parent.type === "menubar" && parent.context.hasSubmenuOpen;
+	const [open, setOpenUnwrapped] = useControlled({
+		controlled: openProp,
+		default: defaultOpen,
+		name: "MenuRoot",
+		state: "open"
+	});
+	const allowOutsidePressDismissalRef = React$1.useRef(parent.type !== "context-menu");
+	const allowOutsidePressDismissalTimeout = useTimeout();
+	React$1.useEffect(() => {
+		if (!open) openEventRef.current = null;
+		if (parent.type !== "context-menu") return;
+		if (!open) {
+			allowOutsidePressDismissalTimeout.clear();
+			allowOutsidePressDismissalRef.current = false;
+			return;
+		}
+		allowOutsidePressDismissalTimeout.start(500, () => {
+			allowOutsidePressDismissalRef.current = true;
+		});
+	}, [
+		allowOutsidePressDismissalTimeout,
+		open,
+		parent.type
+	]);
+	const setPositionerElement = React$1.useCallback((value) => {
+		positionerRef.current = value;
+		setPositionerElementUnwrapped(value);
+	}, []);
+	const { mounted, setMounted, transitionStatus } = useTransitionStatus(open);
+	const { openMethod, triggerProps: interactionTypeProps, reset: resetOpenInteractionType } = useOpenInteractionType(open);
+	useScrollLock({
+		enabled: open && modal && lastOpenChangeReason !== "trigger-hover" && openMethod !== "touch",
+		mounted,
+		open,
+		referenceElement: positionerElement
+	});
+	if (!open && !hoverEnabled) setHoverEnabled(true);
+	const handleUnmount = useEventCallback(() => {
+		setMounted(false);
+		setStickIfOpen(true);
+		setAllowMouseEnter(false);
+		onOpenChangeComplete === null || onOpenChangeComplete === void 0 || onOpenChangeComplete(false);
+		resetOpenInteractionType();
+	});
+	useOpenChangeComplete({
+		enabled: !actionsRef,
+		open,
+		ref: popupRef,
+		onComplete() {
+			if (!open) handleUnmount();
+		}
+	});
+	const allowTouchToCloseRef = React$1.useRef(true);
+	const allowTouchToCloseTimeout = useTimeout();
+	const setOpen = useEventCallback((nextOpen, eventDetails) => {
+		const reason = eventDetails.reason;
+		if (open === nextOpen) return;
+		onOpenChange === null || onOpenChange === void 0 || onOpenChange(nextOpen, eventDetails);
+		if (eventDetails.isCanceled) return;
+		const details = {
+			open: nextOpen,
+			nativeEvent: eventDetails.event,
+			reason: eventDetails.reason,
+			nested
+		};
+		floatingEvents === null || floatingEvents === void 0 || floatingEvents.emit("openchange", details);
+		const nativeEvent = eventDetails.event;
+		if (nextOpen === false && (nativeEvent === null || nativeEvent === void 0 ? void 0 : nativeEvent.type) === "click" && nativeEvent.pointerType === "touch" && !allowTouchToCloseRef.current) return;
+		if (!nextOpen && activeIndex !== null) {
+			const activeOption = itemDomElements.current[activeIndex];
+			queueMicrotask(() => {
+				activeOption === null || activeOption === void 0 || activeOption.setAttribute("tabindex", "-1");
+			});
+		}
+		if (nextOpen && reason === "trigger-focus") {
+			allowTouchToCloseRef.current = false;
+			allowTouchToCloseTimeout.start(300, () => {
+				allowTouchToCloseRef.current = true;
+			});
+		} else {
+			allowTouchToCloseRef.current = true;
+			allowTouchToCloseTimeout.clear();
+		}
+		const isKeyboardClick = (reason === "trigger-press" || reason === "item-press") && nativeEvent.detail === 0 && (nativeEvent === null || nativeEvent === void 0 ? void 0 : nativeEvent.isTrusted);
+		const isDismissClose = !nextOpen && (reason === "escape-key" || reason == null);
+		function changeState() {
+			var _eventDetails$event;
+			setOpenUnwrapped(nextOpen);
+			setLastOpenChangeReason(reason !== null && reason !== void 0 ? reason : null);
+			openEventRef.current = (_eventDetails$event = eventDetails.event) !== null && _eventDetails$event !== void 0 ? _eventDetails$event : null;
+		}
+		if (reason === "trigger-hover") {
+			setStickIfOpen(true);
+			stickIfOpenTimeout.start(500, () => {
+				setStickIfOpen(false);
+			});
+			ReactDOM$1.flushSync(changeState);
+		} else changeState();
+		if (parent.type === "menubar" && (reason === "trigger-focus" || reason === "focus-out" || reason === "trigger-hover" || reason === "list-navigation" || reason === "sibling-open")) setInstantType("group");
+		else if (isKeyboardClick || isDismissClose) setInstantType(isKeyboardClick ? "click" : "dismiss");
+		else setInstantType(void 0);
+	});
+	React$1.useImperativeHandle(actionsRef, () => ({ unmount: handleUnmount }), [handleUnmount]);
+	let ctx;
+	if (parent.type === "context-menu") ctx = parent.context;
+	React$1.useImperativeHandle(ctx === null || ctx === void 0 ? void 0 : ctx.positionerRef, () => positionerElement, [positionerElement]);
+	React$1.useImperativeHandle(ctx === null || ctx === void 0 ? void 0 : ctx.actionsRef, () => ({ setOpen }), [setOpen]);
+	React$1.useEffect(() => {
+		if (!open) stickIfOpenTimeout.clear();
+	}, [stickIfOpenTimeout, open]);
+	const floatingRootContext = useFloatingRootContext({
+		elements: {
+			reference: triggerElement,
+			floating: positionerElement
+		},
+		open,
+		onOpenChange: setOpen
+	});
+	floatingEvents = floatingRootContext.events;
+	const hover = useHover(floatingRootContext, {
+		enabled: hoverEnabled && openOnHover && !disabled && parent.type !== "context-menu" && (parent.type !== "menubar" || parent.context.hasSubmenuOpen && !open),
+		handleClose: safePolygon({ blockPointerEvents: true }),
+		mouseOnly: true,
+		move: parent.type === "menu",
+		restMs: parent.type === void 0 || parent.type === "menu" && allowMouseEnter ? delay : void 0,
+		delay: parent.type === "menu" ? {
+			open: allowMouseEnter ? delay : 10 ** 10,
+			close: closeDelay
+		} : { close: closeDelay }
+	});
+	const focus = useFocus(floatingRootContext, { enabled: !disabled && !open && parent.type === "menubar" && parent.context.hasSubmenuOpen && !contextMenuContext });
+	const click = useClick(floatingRootContext, {
+		enabled: !disabled && parent.type !== "context-menu",
+		event: open && parent.type === "menubar" ? "click" : "mousedown",
+		toggle: !openOnHover || parent.type !== "menu",
+		ignoreMouse: openOnHover && parent.type === "menu",
+		stickIfOpen: parent.type === void 0 ? stickIfOpen : false
+	});
+	const dismiss = useDismiss(floatingRootContext, {
+		enabled: !disabled,
+		bubbles: closeParentOnEsc && parent.type === "menu",
+		outsidePress() {
+			var _openEventRef$current;
+			if (parent.type !== "context-menu" || ((_openEventRef$current = openEventRef.current) === null || _openEventRef$current === void 0 ? void 0 : _openEventRef$current.type) === "contextmenu") return true;
+			return allowOutsidePressDismissalRef.current;
+		}
+	});
+	const role = useRole(floatingRootContext, { role: "menu" });
+	const direction = useDirection();
+	const listNavigation = useListNavigation(floatingRootContext, {
+		enabled: !disabled,
+		listRef: itemDomElements,
+		activeIndex,
+		nested: parent.type !== void 0,
+		loop,
+		orientation,
+		parentOrientation: parent.type === "menubar" ? parent.context.orientation : void 0,
+		rtl: direction === "rtl",
+		disabledIndices: EMPTY_ARRAY,
+		onNavigate: setActiveIndex,
+		openOnArrowKeyDown: parent.type !== "context-menu"
+	});
+	const typingRef = React$1.useRef(false);
+	const { getReferenceProps, getFloatingProps, getItemProps } = useInteractions([
+		hover,
+		click,
+		dismiss,
+		focus,
+		role,
+		listNavigation,
+		useTypeahead(floatingRootContext, {
+			listRef: itemLabels,
+			activeIndex,
+			resetMs: 500,
+			onMatch: (index) => {
+				if (open && index !== activeIndex) setActiveIndex(index);
+			},
+			onTypingChange: React$1.useCallback((nextTyping) => {
+				typingRef.current = nextTyping;
+			}, [])
+		})
+	]);
+	const mixedToggleHandlers = useMixedToggleClickHandler({
+		open,
+		enabled: parent.type === "menubar",
+		mouseDownAction: "open"
+	});
+	const triggerProps = React$1.useMemo(() => {
+		const referenceProps = mergeProps(getReferenceProps(), {
+			onMouseEnter() {
+				setHoverEnabled(true);
+			},
+			onMouseMove() {
+				setAllowMouseEnter(true);
+			}
+		}, interactionTypeProps, mixedToggleHandlers);
+		delete referenceProps.role;
+		return referenceProps;
+	}, [
+		getReferenceProps,
+		mixedToggleHandlers,
+		setAllowMouseEnter,
+		interactionTypeProps
+	]);
+	const popupProps = React$1.useMemo(() => getFloatingProps({
+		onMouseEnter() {
+			if (!openOnHover || parent.type === "menu") setHoverEnabled(false);
+		},
+		onMouseMove() {
+			setAllowMouseEnter(true);
+		},
+		onClick() {
+			if (openOnHover) setHoverEnabled(false);
+		}
+	}), [
+		getFloatingProps,
+		openOnHover,
+		parent.type,
+		setAllowMouseEnter
+	]);
+	const itemProps = React$1.useMemo(() => getItemProps(), [getItemProps]);
+	const context = React$1.useMemo(() => ({
+		activeIndex,
+		setActiveIndex,
+		allowMouseUpTriggerRef: parent.type ? parent.context.allowMouseUpTriggerRef : EMPTY_REF,
+		floatingRootContext,
+		itemProps,
+		popupProps,
+		triggerProps,
+		itemDomElements,
+		itemLabels,
+		mounted,
+		open,
+		popupRef,
+		positionerRef,
+		setOpen,
+		setPositionerElement,
+		triggerElement,
+		setTriggerElement,
+		transitionStatus,
+		lastOpenChangeReason,
+		instantType,
+		onOpenChangeComplete,
+		setHoverEnabled,
+		typingRef,
+		modal,
+		disabled,
+		parent,
+		rootId,
+		allowMouseEnter,
+		setAllowMouseEnter
+	}), [
+		activeIndex,
+		floatingRootContext,
+		itemProps,
+		popupProps,
+		triggerProps,
+		itemDomElements,
+		itemLabels,
+		mounted,
+		open,
+		positionerRef,
+		setOpen,
+		transitionStatus,
+		triggerElement,
+		setPositionerElement,
+		lastOpenChangeReason,
+		instantType,
+		onOpenChangeComplete,
+		modal,
+		disabled,
+		parent,
+		rootId,
+		allowMouseEnter,
+		setAllowMouseEnter
+	]);
+	const content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuRootContext.Provider, {
+		value: context,
+		children
+	});
+	if (parent.type === void 0 || parent.type === "context-menu") return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FloatingTree, { children: content });
+	return content;
+};
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/submenu-root/MenuSubmenuRoot.js
+/**
+* Groups all parts of a submenu.
+* Doesn’t render its own HTML element.
+*
+* Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+*/
+function MenuSubmenuRoot(props) {
+	const { closeParentOnEsc = false } = props;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuSubmenuRootContext.Provider, {
+		value: true,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuRoot, {
+			closeParentOnEsc,
+			...props
+		})
+	});
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/utils/getPseudoElementBounds.js
+function getPseudoElementBounds(element) {
+	const elementRect = element.getBoundingClientRect();
+	if (process.env.NODE_ENV === "test") return elementRect;
+	const beforeStyles = window.getComputedStyle(element, "::before");
+	const afterStyles = window.getComputedStyle(element, "::after");
+	if (!(beforeStyles.content !== "none" || afterStyles.content !== "none")) return elementRect;
+	const beforeWidth = parseFloat(beforeStyles.width) || 0;
+	const beforeHeight = parseFloat(beforeStyles.height) || 0;
+	const afterWidth = parseFloat(afterStyles.width) || 0;
+	const afterHeight = parseFloat(afterStyles.height) || 0;
+	const totalWidth = Math.max(elementRect.width, beforeWidth, afterWidth);
+	const totalHeight = Math.max(elementRect.height, beforeHeight, afterHeight);
+	const widthDiff = totalWidth - elementRect.width;
+	const heightDiff = totalHeight - elementRect.height;
+	return {
+		left: elementRect.left - widthDiff / 2,
+		right: elementRect.right + widthDiff / 2,
+		top: elementRect.top - heightDiff / 2,
+		bottom: elementRect.bottom + heightDiff / 2
+	};
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/composite/item/useCompositeItem.js
+function useCompositeItem(params = {}) {
+	const { highlightItemOnHover, highlightedIndex, onHighlightedIndexChange } = useCompositeRootContext();
+	const { ref, index } = useCompositeListItem(params);
+	const isHighlighted = highlightedIndex === index;
+	const itemRef = React$1.useRef(null);
+	const mergedRef = useMergedRefs(ref, itemRef);
+	return {
+		compositeProps: React$1.useMemo(() => ({
+			tabIndex: isHighlighted ? 0 : -1,
+			onFocus() {
+				onHighlightedIndexChange(index);
+			},
+			onMouseMove() {
+				const item = itemRef.current;
+				if (!highlightItemOnHover || !item) return;
+				const disabled = item.hasAttribute("disabled") || item.ariaDisabled === "true";
+				if (!isHighlighted && !disabled) item.focus();
+			}
+		}), [
+			isHighlighted,
+			onHighlightedIndexChange,
+			index,
+			highlightItemOnHover
+		]),
+		compositeRef: mergedRef,
+		index
+	};
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/composite/item/CompositeItem.js
+/**
+* @internal
+*/
+function CompositeItem(componentProps) {
+	const { render, className, state = EMPTY_OBJECT, props = EMPTY_ARRAY$1, refs = EMPTY_ARRAY$1, metadata, stateAttributesMapping, tag = "div", ...elementProps } = componentProps;
+	const { compositeProps, compositeRef } = useCompositeItem({ metadata });
+	return useRenderElement(tag, componentProps, {
+		state,
+		ref: [...refs, compositeRef],
+		props: [
+			compositeProps,
+			...props,
+			elementProps
+		],
+		stateAttributesMapping
+	});
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/utils/findRootOwnerId.js
+function findRootOwnerId(node) {
+	if (isHTMLElement(node) && node.hasAttribute("data-rootownerid")) {
+		var _node$getAttribute;
+		return (_node$getAttribute = node.getAttribute("data-rootownerid")) !== null && _node$getAttribute !== void 0 ? _node$getAttribute : void 0;
+	}
+	if (isLastTraversableNode(node)) return;
+	return findRootOwnerId(getParentNode(node));
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/trigger/MenuTrigger.js
+var BOUNDARY_OFFSET = 2;
+/**
+* A button that opens the menu.
+* Renders a `<button>` element.
+*
+* Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+*/
+var MenuTrigger = /* @__PURE__ */ React$1.forwardRef(function MenuTrigger(componentProps, forwardedRef) {
+	const { render, className, disabled: disabledProp = false, nativeButton = true, ...elementProps } = componentProps;
+	const { triggerProps: rootTriggerProps, disabled: menuDisabled, setTriggerElement, open, allowMouseUpTriggerRef, positionerRef, parent, lastOpenChangeReason, rootId } = useMenuRootContext();
+	const disabled = disabledProp || menuDisabled;
+	const triggerRef = React$1.useRef(null);
+	const allowMouseUpTriggerTimeout = useTimeout();
+	const { getButtonProps, buttonRef } = useButton({
+		disabled,
+		native: nativeButton
+	});
+	const handleRef = useMergedRefs(buttonRef, setTriggerElement);
+	const { events: menuEvents } = useFloatingTree();
+	React$1.useEffect(() => {
+		if (!open && parent.type === void 0) allowMouseUpTriggerRef.current = false;
+	}, [
+		allowMouseUpTriggerRef,
+		open,
+		parent.type
+	]);
+	const handleDocumentMouseUp = useEventCallback((mouseEvent) => {
+		if (!triggerRef.current) return;
+		allowMouseUpTriggerTimeout.clear();
+		allowMouseUpTriggerRef.current = false;
+		const mouseUpTarget = mouseEvent.target;
+		if (contains(triggerRef.current, mouseUpTarget) || contains(positionerRef.current, mouseUpTarget) || mouseUpTarget === triggerRef.current) return;
+		if (mouseUpTarget != null && findRootOwnerId(mouseUpTarget) === rootId) return;
+		const bounds = getPseudoElementBounds(triggerRef.current);
+		if (mouseEvent.clientX >= bounds.left - BOUNDARY_OFFSET && mouseEvent.clientX <= bounds.right + BOUNDARY_OFFSET && mouseEvent.clientY >= bounds.top - BOUNDARY_OFFSET && mouseEvent.clientY <= bounds.bottom + BOUNDARY_OFFSET) return;
+		menuEvents.emit("close", {
+			domEvent: mouseEvent,
+			reason: "cancel-open"
+		});
+	});
+	React$1.useEffect(() => {
+		if (open && lastOpenChangeReason === "trigger-hover") ownerDocument(triggerRef.current).addEventListener("mouseup", handleDocumentMouseUp, { once: true });
+	}, [
+		open,
+		handleDocumentMouseUp,
+		lastOpenChangeReason
+	]);
+	const isMenubar = parent.type === "menubar";
+	const getTriggerProps = React$1.useCallback((externalProps) => {
+		return mergeProps(isMenubar ? { role: "menuitem" } : {}, {
+			"aria-haspopup": "menu",
+			ref: handleRef,
+			onMouseDown: (event) => {
+				if (open) return;
+				allowMouseUpTriggerTimeout.start(200, () => {
+					allowMouseUpTriggerRef.current = true;
+				});
+				ownerDocument(event.currentTarget).addEventListener("mouseup", handleDocumentMouseUp, { once: true });
+			}
+		}, externalProps, getButtonProps);
+	}, [
+		getButtonProps,
+		handleRef,
+		open,
+		allowMouseUpTriggerRef,
+		allowMouseUpTriggerTimeout,
+		handleDocumentMouseUp,
+		isMenubar
+	]);
+	const state = React$1.useMemo(() => ({
+		disabled,
+		open
+	}), [disabled, open]);
+	const ref = [
+		triggerRef,
+		forwardedRef,
+		buttonRef
+	];
+	const props = [
+		rootTriggerProps,
+		elementProps,
+		getTriggerProps
+	];
+	const element = useRenderElement("button", componentProps, {
+		enabled: !isMenubar,
+		stateAttributesMapping: pressableTriggerOpenStateMapping,
+		state,
+		ref,
+		props
+	});
+	if (isMenubar) return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CompositeItem, {
+		tag: "button",
+		render,
+		className,
+		state,
+		refs: ref,
+		props,
+		stateAttributesMapping: pressableTriggerOpenStateMapping
+	});
+	return element;
+});
+if (process.env.NODE_ENV !== "production") MenuTrigger.displayName = "MenuTrigger";
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/menu/submenu-trigger/MenuSubmenuTrigger.js
+/**
+* A menu item that opens a submenu.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+*/
+var MenuSubmenuTrigger = /* @__PURE__ */ React$1.forwardRef(function SubmenuTriggerComponent(componentProps, forwardedRef) {
+	const { render, className, label, id: idProp, nativeButton = false, ...elementProps } = componentProps;
+	const id = useBaseUiId(idProp);
+	const { triggerProps: rootTriggerProps, parent, setTriggerElement, open, typingRef, disabled, allowMouseUpTriggerRef } = useMenuRootContext();
+	const menuPositionerContext = useMenuPositionerContext();
+	if (parent.type !== "menu") throw new Error("Base UI: <Menu.SubmenuTrigger> must be placed in <Menu.SubmenuRoot>.");
+	const parentMenuContext = parent.context;
+	const { activeIndex, itemProps, setActiveIndex } = parentMenuContext;
+	const item = useCompositeListItem();
+	const highlighted = activeIndex === item.index;
+	const { events: menuEvents } = useFloatingTree();
+	const { getItemProps, itemRef } = useMenuItem({
+		closeOnClick: false,
+		disabled,
+		highlighted,
+		id,
+		menuEvents,
+		allowMouseUpTriggerRef,
+		typingRef,
+		nativeButton,
+		itemMetadata: React$1.useMemo(() => ({
+			type: "submenu-trigger",
+			setActive: () => setActiveIndex(item.index),
+			allowMouseEnterEnabled: parentMenuContext.allowMouseEnter
+		}), [
+			setActiveIndex,
+			item.index,
+			parentMenuContext.allowMouseEnter
+		]),
+		nodeId: menuPositionerContext === null || menuPositionerContext === void 0 ? void 0 : menuPositionerContext.floatingContext.nodeId
+	});
+	return useRenderElement("div", componentProps, {
+		state: React$1.useMemo(() => ({
+			disabled,
+			highlighted,
+			open
+		}), [
+			disabled,
+			highlighted,
+			open
+		]),
+		ref: [
+			forwardedRef,
+			item.ref,
+			itemRef,
+			setTriggerElement
+		],
+		stateAttributesMapping: triggerOpenStateMapping,
+		props: [
+			rootTriggerProps,
+			itemProps,
+			elementProps,
+			getItemProps,
+			{
+				tabIndex: open || highlighted ? 0 : -1,
+				onBlur() {
+					if (highlighted) setActiveIndex(null);
+				}
+			}
+		]
+	});
+});
+if (process.env.NODE_ENV !== "production") MenuSubmenuTrigger.displayName = "MenuSubmenuTrigger";
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/use-render/useRender.js
+/**
+* Renders a Base UI element.
+*
+* @public
+*/
+function useRender(params) {
+	var _params$defaultTagNam;
+	return useRenderElement((_params$defaultTagNam = params.defaultTagName) !== null && _params$defaultTagNam !== void 0 ? _params$defaultTagNam : "div", params, params);
+}
+//#endregion
+//#region src/components/DropdownMenu/style/DropdownMenu.module.less
+var positioner = "positioner__eWf4l";
+var fixedPositioner = "fixedPositioner__ASeFt";
+var popup = "popup__UucRm";
+var backdrop = "backdrop__bBmVf";
+var item = "item__5a484";
+var itemLabel = "itemLabel__z75Xr";
+var itemDescription = "itemDescription__oxy7a";
+var itemValue = "itemValue__VOv0R";
+var itemLeadingElements = "itemLeadingElements__5ARFl";
+var itemTrailingElements = "itemTrailingElements__rx0FW";
+var group = "group__-plPv";
+var groupLabel = "groupLabel__OisFc";
+var radioGroup = "radioGroup__cjmci";
+var checkboxItemIndicator = "checkboxItemIndicator__6wmLt";
+var DropdownMenu_module_default = {
+	positioner,
+	fixedPositioner,
+	popup,
+	backdrop,
+	"slide-in": "slide-in__GPz7e",
+	"slide-out": "slide-out__02zSh",
+	"opacity-in": "opacity-in__056Lb",
+	"opacity-out": "opacity-out__COIpb",
+	item,
+	itemLabel,
+	itemDescription,
+	itemValue,
+	itemLeadingElements,
+	itemTrailingElements,
+	group,
+	groupLabel,
+	radioGroup,
+	checkboxItemIndicator
+};
+//#endregion
+//#region src/components/DropdownMenu/primitives/DropdownMenu.primitives.tsx
+/**
+* Set of styled and extended primitives for the DropdownMenu component.
+* Follows radix/base-ui philosophy of having a single element per component.
+*/
+/**
+* Anatomy:
+*
+* <Root>
+*   <Trigger />
+*
+*   <Portal>
+*     <Backdrop />
+*
+*     <Positioner>
+*       <Popup>
+*         <Item>
+*           <ItemContainer>
+*             <ItemLeadingElements />
+*             <ItemLabel />
+*             <ItemDescription />
+*             <ItemTrailingElements>
+*               <ItemValue />
+*               <ItemSubmenuIcon />
+*             </ItemTrailingElements>
+*           </ItemContainer>
+*         </Item>
+*
+*         <Group>
+*           <GroupLabel />
+*           <Item />
+*         </Group>
+*
+*         <SubmenuRoot>
+*           <SubmenuTrigger>
+*             <ItemContainer />
+*           </SubmenuTrigger>
+*           <Portal>
+*             <Backdrop />
+*             <Positioner>
+*               <Popup />
+*             </Positioner>
+*           </Portal>
+*         </SubmenuRoot>
+*       </Popup>
+*     </Positioner>
+*   </Portal>
+* </Root>
+*/
+var Root = MenuRoot;
+/**
+* Extends base-ui Menu.Trigger component to use children as the trigger element by default.
+*/
+var Trigger = forwardRef(function Trigger({ children, ...props }, ref) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuTrigger, {
+		render: children,
+		ref,
+		...props
+	});
+});
+/**
+* Extends base-ui Menu.Portal component to use our portals slot.
+*/
+function Portal(props) {
+	const portalElement = usePortalElement();
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuPortal, {
+		container: portalElement,
+		...props
+	});
+}
+/**
+* Context for whether the positioner is inside a submenu.
+*/
+var submenuContext = createContext(false);
+/**
+* Styled base-ui Menu.Backdrop
+*/
+function Backdrop(props) {
+	const isSubmenu = useContext(submenuContext);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuBackdrop, {
+		className: DropdownMenu_module_default.backdrop,
+		"data-backdrop": isSubmenu ? "submenu" : "root",
+		...props
+	});
+}
+var FixedPositioner = forwardRef(function StaticPositioner(props, ref) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		ref,
+		className: DropdownMenu_module_default.fixedPositioner,
+		...props,
+		style: void 0
+	});
+});
+/**
+* Extends base-ui Menu.Positioner component to use bottom sheet on mobile.
+*/
+function Positioner(props) {
+	const shouldRenderBottomSheet = !useBreakpointMatch("medium-s");
+	const isSubmenu = useContext(submenuContext);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuPositioner, {
+		render: shouldRenderBottomSheet ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FixedPositioner, {}) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: DropdownMenu_module_default.positioner }),
+		collisionAvoidance: {
+			side: "shift",
+			align: "shift"
+		},
+		collisionPadding: 24,
+		sideOffset: isSubmenu ? 12 : void 0,
+		...props
+	});
+}
+/**
+* Styled base-ui Menu.Popup
+*/
+function Popup({ dataset, preplyDsComponent, ...props }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuPopup, {
+		className: DropdownMenu_module_default.popup,
+		tabIndex: 0,
+		...getDatasetProps(dataset, { preplyDsComponent }),
+		...props
+	});
+}
+var itemDescriptionIdCtx = createContext("");
+/**
+* Item container.
+* By default will render a div, but can be modified via `render` prop,
+* see https://base-ui.com/react/utils/use-render
+*
+* @example
+* <ItemContainer>
+*   Will render div
+* </ItemContainer>
+*
+* @example
+* <ItemContainer render={<a href="#" />}>
+*   Will render anchor
+* </ItemContainer>
+*
+* @example
+* <ItemContainer as={<Link to="/" />}>
+*   Will render custom element
+* </ItemContainer>
+*/
+var ItemContainer = forwardRef(function ItemContainer({ dataset, render, ...props }, ref) {
+	const descriptionId = useId();
+	const element = useRender({
+		render,
+		ref,
+		defaultTagName: "div",
+		props: {
+			className: DropdownMenu_module_default.item,
+			"aria-describedby": descriptionId,
+			...getDatasetProps(dataset),
+			...props
+		}
+	});
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(itemDescriptionIdCtx.Provider, {
+		value: descriptionId,
+		children: element
+	});
+});
+/**
+* Extends base-ui Menu.Item component to use children as the item element by default.
+*/
+function Item({ children, ...props }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuItem, {
+		render: children,
+		...props
+	});
+}
+/**
+* Container for leading elements, such as an icon, image or avatar.
+*/
+function ItemLeadingElements(props) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		className: DropdownMenu_module_default.itemLeadingElements,
+		...props
+	});
+}
+/**
+* Container for trailing elements, such as a value or a submenu icon.
+*/
+function ItemTrailingElements(props) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		className: DropdownMenu_module_default.itemTrailingElements,
+		...props
+	});
+}
+/**
+* Item label
+*/
+function ItemLabel(props) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
+		className: DropdownMenu_module_default.itemLabel,
+		...props
+	});
+}
+/**
+* Item description
+*/
+function ItemDescription(props) {
+	const descriptionId = useContext(itemDescriptionIdCtx);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
+		className: DropdownMenu_module_default.itemDescription,
+		id: descriptionId,
+		"aria-hidden": true,
+		...props
+	});
+}
+/**
+* Item value
+*/
+var ItemValue = forwardRef(function ItemValue(props, ref) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
+		className: DropdownMenu_module_default.itemValue,
+		...props,
+		ref
+	});
+});
+/**
+* Item submenu icon
+*/
+function ItemSubmenuIcon(props) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Icon, {
+		svg: TokyoUIChevronRight,
+		size: "16",
+		accent: "tertiary",
+		...props
+	});
+}
+/**
+* Styled base-ui Menu.Group
+*/
+var Group = forwardRef(function Group({ dataset, ...props }, ref) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuGroup, {
+		className: DropdownMenu_module_default.group,
+		...getDatasetProps(dataset),
+		ref,
+		...props
+	});
+});
+/**
+* Styled base-ui Menu.GroupLabel
+*/
+function GroupLabel(props) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuGroupLabel, {
+		className: DropdownMenu_module_default.groupLabel,
+		...props
+	});
+}
+/**
+* Extends base-ui Menu.SubmenuRoot to not open on hover on mobile.
+*/
+function SubmenuRoot(props) {
+	const shouldRenderBottomSheet = !useBreakpointMatch("medium-s");
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(submenuContext.Provider, {
+		value: true,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuSubmenuRoot, {
+			openOnHover: !shouldRenderBottomSheet,
+			...props
+		})
+	});
+}
+/**
+* Extends base-ui Menu.SubmenuTrigger to use children as the trigger element by default.
+*/
+function SubmenuTrigger({ children, ...props }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuSubmenuTrigger, {
+		render: children,
+		...props
+	});
+}
+var RadioGroup = forwardRef(function RadioGroup(props, ref) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuRadioGroup, {
+		className: DropdownMenu_module_default.radioGroup,
+		ref,
+		...props
+	});
+});
+function RadioItem({ children, ...props }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuRadioItem, {
+		render: children,
+		...props
+	});
+}
+function RadioItemIndicator(props) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuRadioItemIndicator, {
+		render: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Icon, {
+			svg: TokyoUICheck,
+			size: "24"
+		}),
+		...props
+	});
+}
+function CheckboxItem({ children, ...props }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuCheckboxItem, {
+		render: children,
+		...props
+	});
+}
+function CheckboxItemIndicator(props) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenuCheckboxItemIndicator, {
+		className: DropdownMenu_module_default.checkboxItemIndicator,
+		keepMounted: true,
+		...props
+	});
+}
+//#endregion
+export { Trigger as C, SubmenuTrigger as S, RadioGroup as _, GroupLabel as a, Root as b, ItemDescription as c, ItemSubmenuIcon as d, ItemTrailingElements as f, Positioner as g, Portal as h, Group as i, ItemLabel as l, Popup as m, CheckboxItem as n, Item as o, ItemValue as p, CheckboxItemIndicator as r, ItemContainer as s, Backdrop as t, ItemLeadingElements as u, RadioItem as v, MenuRadioItemIndicator as w, SubmenuRoot as x, RadioItemIndicator as y };