@preply/ds-web-lib 11.0.0 → 11.1.0

package/dist/useOpenInteractionType-D8vA_ZKI.js

@@ -0,0 +1,4104 @@
+"use client";
+import { t as require_jsx_runtime } from "./jsx-runtime-i4KUlhDu.js";
+import { a as useMergedRefs, d as NOOP, f as useRefWithInit, i as isReactVersionAtLeast, u as EMPTY_OBJECT } from "./useRenderElement-ZBds6eRN.js";
+import { S as useEventCallback, _ as isTableElement, a as getNodeName, b as createChangeEventDetails, c as getParentNode, d as isElement, f as isHTMLElement, g as isShadowRoot, h as isOverflowElement, i as getFrameElement, l as getWindow, m as isNode, n as getContainingBlock, o as getNodeScroll, p as isLastTraversableNode, r as getDocumentElement, s as getOverflowAncestors, t as getComputedStyle$1, u as isContainingBlock, v as isTopLayer, x as useIsoLayoutEffect, y as isWebKit$1 } from "./floating-ui.utils.dom-CoeTbDZx.js";
+import { t as useId$1 } from "./useId-CJsH-2wV.js";
+import * as React$1 from "react";
+import { useLayoutEffect } from "react";
+import * as ReactDOM$1 from "react-dom";
+//#region ../../node_modules/@base-ui-components/utils/esm/useOnMount.js
+var EMPTY$2 = [];
+/**
+* A React.useEffect equivalent that runs once, when the component is mounted.
+*/
+function useOnMount(fn) {
+	React$1.useEffect(fn, EMPTY$2);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/utils/esm/useAnimationFrame.js
+/** Unlike `setTimeout`, rAF doesn't guarantee a positive integer return value, so we can't have
+* a monomorphic `uint` type with `0` meaning empty.
+* See warning note at:
+* https://developer.mozilla.org/en-US/docs/Web/API/Window/requestAnimationFrame#return_value */
+var EMPTY$1 = null;
+var LAST_RAF = globalThis.requestAnimationFrame;
+var Scheduler = class {
+	constructor() {
+		_defineProperty(this, "callbacks", []);
+		_defineProperty(this, "callbacksCount", 0);
+		_defineProperty(this, "nextId", 1);
+		_defineProperty(this, "startId", 1);
+		_defineProperty(this, "isScheduled", false);
+		_defineProperty(this, "tick", (timestamp) => {
+			this.isScheduled = false;
+			const currentCallbacks = this.callbacks;
+			const currentCallbacksCount = this.callbacksCount;
+			this.callbacks = [];
+			this.callbacksCount = 0;
+			this.startId = this.nextId;
+			if (currentCallbacksCount > 0) for (let i = 0; i < currentCallbacks.length; i += 1) {
+				var _currentCallbacks$i;
+				(_currentCallbacks$i = currentCallbacks[i]) === null || _currentCallbacks$i === void 0 || _currentCallbacks$i.call(currentCallbacks, timestamp);
+			}
+		});
+	}
+	request(fn) {
+		const id = this.nextId;
+		this.nextId += 1;
+		this.callbacks.push(fn);
+		this.callbacksCount += 1;
+		const didRAFChange = process.env.NODE_ENV === "test" && LAST_RAF !== requestAnimationFrame && (LAST_RAF = requestAnimationFrame, true);
+		if (!this.isScheduled || didRAFChange) {
+			requestAnimationFrame(this.tick);
+			this.isScheduled = true;
+		}
+		return id;
+	}
+	cancel(id) {
+		const index = id - this.startId;
+		if (index < 0 || index >= this.callbacks.length) return;
+		this.callbacks[index] = null;
+		this.callbacksCount -= 1;
+	}
+};
+var scheduler = new Scheduler();
+var AnimationFrame = class AnimationFrame {
+	constructor() {
+		_defineProperty(this, "currentId", EMPTY$1);
+		_defineProperty(this, "cancel", () => {
+			if (this.currentId !== EMPTY$1) {
+				scheduler.cancel(this.currentId);
+				this.currentId = EMPTY$1;
+			}
+		});
+		_defineProperty(this, "disposeEffect", () => {
+			return this.cancel;
+		});
+	}
+	static create() {
+		return new AnimationFrame();
+	}
+	static request(fn) {
+		return scheduler.request(fn);
+	}
+	static cancel(id) {
+		return scheduler.cancel(id);
+	}
+	/**
+	* Executes `fn` after `delay`, clearing any previously scheduled call.
+	*/
+	request(fn) {
+		this.cancel();
+		this.currentId = scheduler.request(() => {
+			this.currentId = EMPTY$1;
+			fn();
+		});
+	}
+};
+/**
+* A `requestAnimationFrame` with automatic cleanup and guard.
+*/
+function useAnimationFrame() {
+	const timeout = useRefWithInit(AnimationFrame.create).current;
+	useOnMount(timeout.disposeEffect);
+	return timeout;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/utils/useAnimationsFinished.js
+/**
+* Executes a function once all animations have finished on the provided element.
+* @param elementOrRef - The element to watch for animations.
+* @param waitForNextTick - Whether to wait for the next tick before checking for animations.
+*/
+function useAnimationsFinished(elementOrRef, waitForNextTick = false) {
+	const frame = useAnimationFrame();
+	return useEventCallback((fnToExecute, signal = null) => {
+		frame.cancel();
+		if (elementOrRef == null) return;
+		let element;
+		if ("current" in elementOrRef) {
+			if (elementOrRef.current == null) return;
+			element = elementOrRef.current;
+		} else element = elementOrRef;
+		if (typeof element.getAnimations !== "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED) fnToExecute();
+		else frame.request(() => {
+			function exec() {
+				if (!element) return;
+				Promise.allSettled(element.getAnimations().map((anim) => anim.finished)).then(() => {
+					if (signal != null && signal.aborted) return;
+					ReactDOM$1.flushSync(fnToExecute);
+				});
+			}
+			if (waitForNextTick) frame.request(exec);
+			else exec();
+		});
+	});
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/utils/useTransitionStatus.js
+/**
+* Provides a status string for CSS animations.
+* @param open - a boolean that determines if the element is open.
+* @param enableIdleState - a boolean that enables the `'idle'` state between `'starting'` and `'ending'`
+*/
+function useTransitionStatus(open, enableIdleState = false, deferEndingState = false) {
+	const [transitionStatus, setTransitionStatus] = React$1.useState(open && enableIdleState ? "idle" : void 0);
+	const [mounted, setMounted] = React$1.useState(open);
+	if (open && !mounted) {
+		setMounted(true);
+		setTransitionStatus("starting");
+	}
+	if (!open && mounted && transitionStatus !== "ending" && !deferEndingState) setTransitionStatus("ending");
+	if (!open && !mounted && transitionStatus === "ending") setTransitionStatus(void 0);
+	useIsoLayoutEffect(() => {
+		if (!open && mounted && transitionStatus !== "ending" && deferEndingState) {
+			const frame = AnimationFrame.request(() => {
+				setTransitionStatus("ending");
+			});
+			return () => {
+				AnimationFrame.cancel(frame);
+			};
+		}
+	}, [
+		open,
+		mounted,
+		transitionStatus,
+		deferEndingState
+	]);
+	useIsoLayoutEffect(() => {
+		if (!open || enableIdleState) return;
+		const frame = AnimationFrame.request(() => {
+			ReactDOM$1.flushSync(() => {
+				setTransitionStatus(void 0);
+			});
+		});
+		return () => {
+			AnimationFrame.cancel(frame);
+		};
+	}, [enableIdleState, open]);
+	useIsoLayoutEffect(() => {
+		if (!open || !enableIdleState) return;
+		if (open && mounted && transitionStatus !== "idle") setTransitionStatus("starting");
+		const frame = AnimationFrame.request(() => {
+			setTransitionStatus("idle");
+		});
+		return () => {
+			AnimationFrame.cancel(frame);
+		};
+	}, [
+		enableIdleState,
+		open,
+		mounted,
+		setTransitionStatus,
+		transitionStatus
+	]);
+	return React$1.useMemo(() => ({
+		mounted,
+		setMounted,
+		transitionStatus
+	}), [mounted, transitionStatus]);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/utils/stateAttributesMapping.js
+var TransitionStatusDataAttributes = /* @__PURE__ */ function(TransitionStatusDataAttributes) {
+	/**
+	* Present when the component is animating in.
+	*/
+	TransitionStatusDataAttributes["startingStyle"] = "data-starting-style";
+	/**
+	* Present when the component is animating out.
+	*/
+	TransitionStatusDataAttributes["endingStyle"] = "data-ending-style";
+	return TransitionStatusDataAttributes;
+}({});
+var STARTING_HOOK = { [TransitionStatusDataAttributes.startingStyle]: "" };
+var ENDING_HOOK = { [TransitionStatusDataAttributes.endingStyle]: "" };
+var transitionStatusMapping = { transitionStatus(value) {
+	if (value === "starting") return STARTING_HOOK;
+	if (value === "ending") return ENDING_HOOK;
+	return null;
+} };
+//#endregion
+//#region ../../node_modules/@base-ui-components/utils/esm/detectBrowser.js
+var hasNavigator = typeof navigator !== "undefined";
+var nav = getNavigatorData();
+var platform$1 = getPlatform();
+var userAgent = getUserAgent();
+var isWebKit = typeof CSS === "undefined" || !CSS.supports ? false : CSS.supports("-webkit-backdrop-filter:none");
+var isIOS = nav.platform === "MacIntel" && nav.maxTouchPoints > 1 ? true : /iP(hone|ad|od)|iOS/.test(nav.platform);
+hasNavigator && /firefox/i.test(userAgent);
+var isSafari = hasNavigator && /apple/i.test(navigator.vendor);
+var isAndroid = hasNavigator && /android/i.test(platform$1) || /android/i.test(userAgent);
+var isMac = hasNavigator && platform$1.toLowerCase().startsWith("mac") && !navigator.maxTouchPoints;
+var isJSDOM = userAgent.includes("jsdom/");
+function getNavigatorData() {
+	var _navigator$platform, _navigator$maxTouchPo;
+	if (!hasNavigator) return {
+		platform: "",
+		maxTouchPoints: -1
+	};
+	const uaData = navigator.userAgentData;
+	if (uaData === null || uaData === void 0 ? void 0 : uaData.platform) return {
+		platform: uaData.platform,
+		maxTouchPoints: navigator.maxTouchPoints
+	};
+	return {
+		platform: (_navigator$platform = navigator.platform) !== null && _navigator$platform !== void 0 ? _navigator$platform : "",
+		maxTouchPoints: (_navigator$maxTouchPo = navigator.maxTouchPoints) !== null && _navigator$maxTouchPo !== void 0 ? _navigator$maxTouchPo : -1
+	};
+}
+function getUserAgent() {
+	if (!hasNavigator) return "";
+	const uaData = navigator.userAgentData;
+	if (uaData && Array.isArray(uaData.brands)) return uaData.brands.map(({ brand, version }) => `${brand}/${version}`).join(" ");
+	return navigator.userAgent;
+}
+function getPlatform() {
+	var _navigator$platform2;
+	if (!hasNavigator) return "";
+	const uaData = navigator.userAgentData;
+	if (uaData === null || uaData === void 0 ? void 0 : uaData.platform) return uaData.platform;
+	return (_navigator$platform2 = navigator.platform) !== null && _navigator$platform2 !== void 0 ? _navigator$platform2 : "";
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/utils/constants.js
+var FOCUSABLE_ATTRIBUTE = "data-base-ui-focusable";
+var ARROW_LEFT$1 = "ArrowLeft";
+var ARROW_RIGHT$1 = "ArrowRight";
+var ARROW_UP$1 = "ArrowUp";
+var ARROW_DOWN$1 = "ArrowDown";
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/utils/element.js
+function activeElement(doc) {
+	var _element$shadowRoot;
+	let element = doc.activeElement;
+	while ((element === null || element === void 0 || (_element$shadowRoot = element.shadowRoot) === null || _element$shadowRoot === void 0 ? void 0 : _element$shadowRoot.activeElement) != null) element = element.shadowRoot.activeElement;
+	return element;
+}
+function contains(parent, child) {
+	var _child$getRootNode;
+	if (!parent || !child) return false;
+	const rootNode = (_child$getRootNode = child.getRootNode) === null || _child$getRootNode === void 0 ? void 0 : _child$getRootNode.call(child);
+	if (parent.contains(child)) return true;
+	if (rootNode && isShadowRoot(rootNode)) {
+		let next = child;
+		while (next) {
+			if (parent === next) return true;
+			next = next.parentNode || next.host;
+		}
+	}
+	return false;
+}
+function getTarget(event) {
+	if ("composedPath" in event) return event.composedPath()[0];
+	return event.target;
+}
+function isEventTargetWithin(event, node) {
+	if (node == null) return false;
+	if ("composedPath" in event) return event.composedPath().includes(node);
+	const eventAgain = event;
+	return eventAgain.target != null && node.contains(eventAgain.target);
+}
+function isRootElement(element) {
+	return element.matches("html,body");
+}
+function getDocument(node) {
+	return (node === null || node === void 0 ? void 0 : node.ownerDocument) || document;
+}
+function isTypeableElement(element) {
+	return isHTMLElement(element) && element.matches("input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])");
+}
+function isTypeableCombobox(element) {
+	if (!element) return false;
+	return element.getAttribute("role") === "combobox" && isTypeableElement(element);
+}
+function matchesFocusVisible(element) {
+	if (!element || isJSDOM) return true;
+	try {
+		return element.matches(":focus-visible");
+	} catch (_e) {
+		return true;
+	}
+}
+function getFloatingFocusElement(floatingElement) {
+	if (!floatingElement) return null;
+	return floatingElement.hasAttribute("data-base-ui-focusable") ? floatingElement : floatingElement.querySelector(`[data-base-ui-focusable]`) || floatingElement;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/utils/nodes.js
+function getNodeChildren(nodes, id, onlyOpenChildren = true) {
+	return nodes.filter((node) => {
+		var _node$context;
+		return node.parentId === id && (!onlyOpenChildren || ((_node$context = node.context) === null || _node$context === void 0 ? void 0 : _node$context.open));
+	}).flatMap((child) => [child, ...getNodeChildren(nodes, child.id, onlyOpenChildren)]);
+}
+function getNodeAncestors(nodes, id) {
+	var _nodes$find;
+	let allAncestors = [];
+	let currentParentId = (_nodes$find = nodes.find((node) => node.id === id)) === null || _nodes$find === void 0 ? void 0 : _nodes$find.parentId;
+	while (currentParentId) {
+		const currentNode = nodes.find((node) => node.id === currentParentId);
+		currentParentId = currentNode === null || currentNode === void 0 ? void 0 : currentNode.parentId;
+		if (currentNode) allAncestors = allAncestors.concat(currentNode);
+	}
+	return allAncestors;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/utils/event.js
+function stopEvent(event) {
+	event.preventDefault();
+	event.stopPropagation();
+}
+function isReactEvent(event) {
+	return "nativeEvent" in event;
+}
+function isVirtualClick(event) {
+	if (event.mozInputSource === 0 && event.isTrusted) return true;
+	if (isAndroid && event.pointerType) return event.type === "click" && event.buttons === 1;
+	return event.detail === 0 && !event.pointerType;
+}
+function isVirtualPointerEvent(event) {
+	if (isJSDOM) return false;
+	return !isAndroid && event.width === 0 && event.height === 0 || isAndroid && event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "mouse" || event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "touch";
+}
+function isMouseLikePointerType(pointerType, strict) {
+	const values = ["mouse", "pen"];
+	if (!strict) values.push("", void 0);
+	return values.includes(pointerType);
+}
+//#endregion
+//#region ../../node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
+/**
+* Custom positioning reference element.
+* @see https://floating-ui.com/docs/virtual-elements
+*/
+var sides = [
+	"top",
+	"right",
+	"bottom",
+	"left"
+];
+var min = Math.min;
+var max = Math.max;
+var round = Math.round;
+var floor = Math.floor;
+var createCoords = (v) => ({
+	x: v,
+	y: v
+});
+var oppositeSideMap = {
+	left: "right",
+	right: "left",
+	bottom: "top",
+	top: "bottom"
+};
+var oppositeAlignmentMap = {
+	start: "end",
+	end: "start"
+};
+function clamp(start, value, end) {
+	return max(start, min(value, end));
+}
+function evaluate(value, param) {
+	return typeof value === "function" ? value(param) : value;
+}
+function getSide(placement) {
+	return placement.split("-")[0];
+}
+function getAlignment(placement) {
+	return placement.split("-")[1];
+}
+function getOppositeAxis(axis) {
+	return axis === "x" ? "y" : "x";
+}
+function getAxisLength(axis) {
+	return axis === "y" ? "height" : "width";
+}
+var yAxisSides = /* @__PURE__ */ new Set(["top", "bottom"]);
+function getSideAxis(placement) {
+	return yAxisSides.has(getSide(placement)) ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+	return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+	if (rtl === void 0) rtl = false;
+	const alignment = getAlignment(placement);
+	const alignmentAxis = getAlignmentAxis(placement);
+	const length = getAxisLength(alignmentAxis);
+	let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
+	if (rects.reference[length] > rects.floating[length]) mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+	return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+	const oppositePlacement = getOppositePlacement(placement);
+	return [
+		getOppositeAlignmentPlacement(placement),
+		oppositePlacement,
+		getOppositeAlignmentPlacement(oppositePlacement)
+	];
+}
+function getOppositeAlignmentPlacement(placement) {
+	return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
+}
+var lrPlacement = ["left", "right"];
+var rlPlacement = ["right", "left"];
+var tbPlacement = ["top", "bottom"];
+var btPlacement = ["bottom", "top"];
+function getSideList(side, isStart, rtl) {
+	switch (side) {
+		case "top":
+		case "bottom":
+			if (rtl) return isStart ? rlPlacement : lrPlacement;
+			return isStart ? lrPlacement : rlPlacement;
+		case "left":
+		case "right": return isStart ? tbPlacement : btPlacement;
+		default: return [];
+	}
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+	const alignment = getAlignment(placement);
+	let list = getSideList(getSide(placement), direction === "start", rtl);
+	if (alignment) {
+		list = list.map((side) => side + "-" + alignment);
+		if (flipAlignment) list = list.concat(list.map(getOppositeAlignmentPlacement));
+	}
+	return list;
+}
+function getOppositePlacement(placement) {
+	return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
+}
+function expandPaddingObject(padding) {
+	return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0,
+		...padding
+	};
+}
+function getPaddingObject(padding) {
+	return typeof padding !== "number" ? expandPaddingObject(padding) : {
+		top: padding,
+		right: padding,
+		bottom: padding,
+		left: padding
+	};
+}
+function rectToClientRect(rect) {
+	const { x, y, width, height } = rect;
+	return {
+		width,
+		height,
+		top: y,
+		left: x,
+		right: x + width,
+		bottom: y + height,
+		x,
+		y
+	};
+}
+var candidateSelector = /* @__PURE__ */ [
+	"input:not([inert])",
+	"select:not([inert])",
+	"textarea:not([inert])",
+	"a[href]:not([inert])",
+	"button:not([inert])",
+	"[tabindex]:not(slot):not([inert])",
+	"audio[controls]:not([inert])",
+	"video[controls]:not([inert])",
+	"[contenteditable]:not([contenteditable=\"false\"]):not([inert])",
+	"details>summary:first-of-type:not([inert])",
+	"details:not([inert])"
+].join(",");
+var NoElement = typeof Element === "undefined";
+var matches = NoElement ? function() {} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
+var getRootNode = !NoElement && Element.prototype.getRootNode ? function(element) {
+	var _element$getRootNode;
+	return element === null || element === void 0 ? void 0 : (_element$getRootNode = element.getRootNode) === null || _element$getRootNode === void 0 ? void 0 : _element$getRootNode.call(element);
+} : function(element) {
+	return element === null || element === void 0 ? void 0 : element.ownerDocument;
+};
+/**
+* Determines if a node is inert or in an inert ancestor.
+* @param {Element} [node]
+* @param {boolean} [lookUp] If true and `node` is not inert, looks up at ancestors to
+*  see if any of them are inert. If false, only `node` itself is considered.
+* @returns {boolean} True if inert itself or by way of being in an inert ancestor.
+*  False if `node` is falsy.
+*/
+var isInert = function isInert(node, lookUp) {
+	var _node$getAttribute;
+	if (lookUp === void 0) lookUp = true;
+	var inertAtt = node === null || node === void 0 ? void 0 : (_node$getAttribute = node.getAttribute) === null || _node$getAttribute === void 0 ? void 0 : _node$getAttribute.call(node, "inert");
+	return inertAtt === "" || inertAtt === "true" || lookUp && node && isInert(node.parentNode);
+};
+/**
+* Determines if a node's content is editable.
+* @param {Element} [node]
+* @returns True if it's content-editable; false if it's not or `node` is falsy.
+*/
+var isContentEditable = function isContentEditable(node) {
+	var _node$getAttribute2;
+	var attValue = node === null || node === void 0 ? void 0 : (_node$getAttribute2 = node.getAttribute) === null || _node$getAttribute2 === void 0 ? void 0 : _node$getAttribute2.call(node, "contenteditable");
+	return attValue === "" || attValue === "true";
+};
+/**
+* @param {Element} el container to check in
+* @param {boolean} includeContainer add container to check
+* @param {(node: Element) => boolean} filter filter candidates
+* @returns {Element[]}
+*/
+var getCandidates = function getCandidates(el, includeContainer, filter) {
+	if (isInert(el)) return [];
+	var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
+	if (includeContainer && matches.call(el, candidateSelector)) candidates.unshift(el);
+	candidates = candidates.filter(filter);
+	return candidates;
+};
+/**
+* @callback GetShadowRoot
+* @param {Element} element to check for shadow root
+* @returns {ShadowRoot|boolean} ShadowRoot if available or boolean indicating if a shadowRoot is attached but not available.
+*/
+/**
+* @callback ShadowRootFilter
+* @param {Element} shadowHostNode the element which contains shadow content
+* @returns {boolean} true if a shadow root could potentially contain valid candidates.
+*/
+/**
+* @typedef {Object} CandidateScope
+* @property {Element} scopeParent contains inner candidates
+* @property {Element[]} candidates list of candidates found in the scope parent
+*/
+/**
+* @typedef {Object} IterativeOptions
+* @property {GetShadowRoot|boolean} getShadowRoot true if shadow support is enabled; falsy if not;
+*  if a function, implies shadow support is enabled and either returns the shadow root of an element
+*  or a boolean stating if it has an undisclosed shadow root
+* @property {(node: Element) => boolean} filter filter candidates
+* @property {boolean} flatten if true then result will flatten any CandidateScope into the returned list
+* @property {ShadowRootFilter} shadowRootFilter filter shadow roots;
+*/
+/**
+* @param {Element[]} elements list of element containers to match candidates from
+* @param {boolean} includeContainer add container list to check
+* @param {IterativeOptions} options
+* @returns {Array.<Element|CandidateScope>}
+*/
+var getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {
+	var candidates = [];
+	var elementsToCheck = Array.from(elements);
+	while (elementsToCheck.length) {
+		var element = elementsToCheck.shift();
+		if (isInert(element, false)) continue;
+		if (element.tagName === "SLOT") {
+			var assigned = element.assignedElements();
+			var nestedCandidates = getCandidatesIteratively(assigned.length ? assigned : element.children, true, options);
+			if (options.flatten) candidates.push.apply(candidates, nestedCandidates);
+			else candidates.push({
+				scopeParent: element,
+				candidates: nestedCandidates
+			});
+		} else {
+			if (matches.call(element, candidateSelector) && options.filter(element) && (includeContainer || !elements.includes(element))) candidates.push(element);
+			var shadowRoot = element.shadowRoot || typeof options.getShadowRoot === "function" && options.getShadowRoot(element);
+			var validShadowRoot = !isInert(shadowRoot, false) && (!options.shadowRootFilter || options.shadowRootFilter(element));
+			if (shadowRoot && validShadowRoot) {
+				var _nestedCandidates = getCandidatesIteratively(shadowRoot === true ? element.children : shadowRoot.children, true, options);
+				if (options.flatten) candidates.push.apply(candidates, _nestedCandidates);
+				else candidates.push({
+					scopeParent: element,
+					candidates: _nestedCandidates
+				});
+			} else elementsToCheck.unshift.apply(elementsToCheck, element.children);
+		}
+	}
+	return candidates;
+};
+/**
+* @private
+* Determines if the node has an explicitly specified `tabindex` attribute.
+* @param {HTMLElement} node
+* @returns {boolean} True if so; false if not.
+*/
+var hasTabIndex = function hasTabIndex(node) {
+	return !isNaN(parseInt(node.getAttribute("tabindex"), 10));
+};
+/**
+* Determine the tab index of a given node.
+* @param {HTMLElement} node
+* @returns {number} Tab order (negative, 0, or positive number).
+* @throws {Error} If `node` is falsy.
+*/
+var getTabIndex = function getTabIndex(node) {
+	if (!node) throw new Error("No node provided");
+	if (node.tabIndex < 0) {
+		if ((/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || isContentEditable(node)) && !hasTabIndex(node)) return 0;
+	}
+	return node.tabIndex;
+};
+/**
+* Determine the tab index of a given node __for sort order purposes__.
+* @param {HTMLElement} node
+* @param {boolean} [isScope] True for a custom element with shadow root or slot that, by default,
+*  has tabIndex -1, but needs to be sorted by document order in order for its content to be
+*  inserted into the correct sort position.
+* @returns {number} Tab order (negative, 0, or positive number).
+*/
+var getSortOrderTabIndex = function getSortOrderTabIndex(node, isScope) {
+	var tabIndex = getTabIndex(node);
+	if (tabIndex < 0 && isScope && !hasTabIndex(node)) return 0;
+	return tabIndex;
+};
+var sortOrderedTabbables = function sortOrderedTabbables(a, b) {
+	return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
+};
+var isInput = function isInput(node) {
+	return node.tagName === "INPUT";
+};
+var isHiddenInput = function isHiddenInput(node) {
+	return isInput(node) && node.type === "hidden";
+};
+var isDetailsWithSummary = function isDetailsWithSummary(node) {
+	return node.tagName === "DETAILS" && Array.prototype.slice.apply(node.children).some(function(child) {
+		return child.tagName === "SUMMARY";
+	});
+};
+var getCheckedRadio = function getCheckedRadio(nodes, form) {
+	for (var i = 0; i < nodes.length; i++) if (nodes[i].checked && nodes[i].form === form) return nodes[i];
+};
+var isTabbableRadio = function isTabbableRadio(node) {
+	if (!node.name) return true;
+	var radioScope = node.form || getRootNode(node);
+	var queryRadios = function queryRadios(name) {
+		return radioScope.querySelectorAll("input[type=\"radio\"][name=\"" + name + "\"]");
+	};
+	var radioSet;
+	if (typeof window !== "undefined" && typeof window.CSS !== "undefined" && typeof window.CSS.escape === "function") radioSet = queryRadios(window.CSS.escape(node.name));
+	else try {
+		radioSet = queryRadios(node.name);
+	} catch (err) {
+		console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", err.message);
+		return false;
+	}
+	var checked = getCheckedRadio(radioSet, node.form);
+	return !checked || checked === node;
+};
+var isRadio = function isRadio(node) {
+	return isInput(node) && node.type === "radio";
+};
+var isNonTabbableRadio = function isNonTabbableRadio(node) {
+	return isRadio(node) && !isTabbableRadio(node);
+};
+var isNodeAttached = function isNodeAttached(node) {
+	var _nodeRoot;
+	var nodeRoot = node && getRootNode(node);
+	var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;
+	var attached = false;
+	if (nodeRoot && nodeRoot !== node) {
+		var _nodeRootHost, _nodeRootHost$ownerDo, _node$ownerDocument;
+		attached = !!((_nodeRootHost = nodeRootHost) !== null && _nodeRootHost !== void 0 && (_nodeRootHost$ownerDo = _nodeRootHost.ownerDocument) !== null && _nodeRootHost$ownerDo !== void 0 && _nodeRootHost$ownerDo.contains(nodeRootHost) || node !== null && node !== void 0 && (_node$ownerDocument = node.ownerDocument) !== null && _node$ownerDocument !== void 0 && _node$ownerDocument.contains(node));
+		while (!attached && nodeRootHost) {
+			var _nodeRoot2, _nodeRootHost2, _nodeRootHost2$ownerD;
+			nodeRoot = getRootNode(nodeRootHost);
+			nodeRootHost = (_nodeRoot2 = nodeRoot) === null || _nodeRoot2 === void 0 ? void 0 : _nodeRoot2.host;
+			attached = !!((_nodeRootHost2 = nodeRootHost) !== null && _nodeRootHost2 !== void 0 && (_nodeRootHost2$ownerD = _nodeRootHost2.ownerDocument) !== null && _nodeRootHost2$ownerD !== void 0 && _nodeRootHost2$ownerD.contains(nodeRootHost));
+		}
+	}
+	return attached;
+};
+var isZeroArea = function isZeroArea(node) {
+	var _node$getBoundingClie = node.getBoundingClientRect(), width = _node$getBoundingClie.width, height = _node$getBoundingClie.height;
+	return width === 0 && height === 0;
+};
+var isHidden = function isHidden(node, _ref) {
+	var displayCheck = _ref.displayCheck, getShadowRoot = _ref.getShadowRoot;
+	if (getComputedStyle(node).visibility === "hidden") return true;
+	var nodeUnderDetails = matches.call(node, "details>summary:first-of-type") ? node.parentElement : node;
+	if (matches.call(nodeUnderDetails, "details:not([open]) *")) return true;
+	if (!displayCheck || displayCheck === "full" || displayCheck === "legacy-full") {
+		if (typeof getShadowRoot === "function") {
+			var originalNode = node;
+			while (node) {
+				var parentElement = node.parentElement;
+				var rootNode = getRootNode(node);
+				if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true) return isZeroArea(node);
+				else if (node.assignedSlot) node = node.assignedSlot;
+				else if (!parentElement && rootNode !== node.ownerDocument) node = rootNode.host;
+				else node = parentElement;
+			}
+			node = originalNode;
+		}
+		if (isNodeAttached(node)) return !node.getClientRects().length;
+		if (displayCheck !== "legacy-full") return true;
+	} else if (displayCheck === "non-zero-area") return isZeroArea(node);
+	return false;
+};
+var isDisabledFromFieldset = function isDisabledFromFieldset(node) {
+	if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {
+		var parentNode = node.parentElement;
+		while (parentNode) {
+			if (parentNode.tagName === "FIELDSET" && parentNode.disabled) {
+				for (var i = 0; i < parentNode.children.length; i++) {
+					var child = parentNode.children.item(i);
+					if (child.tagName === "LEGEND") return matches.call(parentNode, "fieldset[disabled] *") ? true : !child.contains(node);
+				}
+				return true;
+			}
+			parentNode = parentNode.parentElement;
+		}
+	}
+	return false;
+};
+var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable(options, node) {
+	if (node.disabled || isInert(node) || isHiddenInput(node) || isHidden(node, options) || isDetailsWithSummary(node) || isDisabledFromFieldset(node)) return false;
+	return true;
+};
+var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable(options, node) {
+	if (isNonTabbableRadio(node) || getTabIndex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) return false;
+	return true;
+};
+var isValidShadowRootTabbable = function isValidShadowRootTabbable(shadowHostNode) {
+	var tabIndex = parseInt(shadowHostNode.getAttribute("tabindex"), 10);
+	if (isNaN(tabIndex) || tabIndex >= 0) return true;
+	return false;
+};
+/**
+* @param {Array.<Element|CandidateScope>} candidates
+* @returns Element[]
+*/
+var sortByOrder = function sortByOrder(candidates) {
+	var regularTabbables = [];
+	var orderedTabbables = [];
+	candidates.forEach(function(item, i) {
+		var isScope = !!item.scopeParent;
+		var element = isScope ? item.scopeParent : item;
+		var candidateTabindex = getSortOrderTabIndex(element, isScope);
+		var elements = isScope ? sortByOrder(item.candidates) : element;
+		if (candidateTabindex === 0) isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);
+		else orderedTabbables.push({
+			documentOrder: i,
+			tabIndex: candidateTabindex,
+			item,
+			isScope,
+			content: elements
+		});
+	});
+	return orderedTabbables.sort(sortOrderedTabbables).reduce(function(acc, sortable) {
+		sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);
+		return acc;
+	}, []).concat(regularTabbables);
+};
+var tabbable = function tabbable(container, options) {
+	options = options || {};
+	var candidates;
+	if (options.getShadowRoot) candidates = getCandidatesIteratively([container], options.includeContainer, {
+		filter: isNodeMatchingSelectorTabbable.bind(null, options),
+		flatten: false,
+		getShadowRoot: options.getShadowRoot,
+		shadowRootFilter: isValidShadowRootTabbable
+	});
+	else candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
+	return sortByOrder(candidates);
+};
+var focusable = function focusable(container, options) {
+	options = options || {};
+	var candidates;
+	if (options.getShadowRoot) candidates = getCandidatesIteratively([container], options.includeContainer, {
+		filter: isNodeMatchingSelectorFocusable.bind(null, options),
+		flatten: true,
+		getShadowRoot: options.getShadowRoot
+	});
+	else candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));
+	return candidates;
+};
+var isTabbable = function isTabbable(node, options) {
+	options = options || {};
+	if (!node) throw new Error("No node provided");
+	if (matches.call(node, candidateSelector) === false) return false;
+	return isNodeMatchingSelectorTabbable(options, node);
+};
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/utils/tabbable.js
+var getTabbableOptions = () => ({
+	getShadowRoot: true,
+	displayCheck: typeof ResizeObserver === "function" && ResizeObserver.toString().includes("[native code]") ? "full" : "none"
+});
+function getTabbableIn(container, dir) {
+	const list = tabbable(container, getTabbableOptions());
+	const len = list.length;
+	if (len === 0) return;
+	const active = activeElement(getDocument(container));
+	const index = list.indexOf(active);
+	return list[index === -1 ? dir === 1 ? 0 : len - 1 : index + dir];
+}
+function getNextTabbable(referenceElement) {
+	return getTabbableIn(getDocument(referenceElement).body, 1) || referenceElement;
+}
+function getPreviousTabbable(referenceElement) {
+	return getTabbableIn(getDocument(referenceElement).body, -1) || referenceElement;
+}
+function isOutsideEvent(event, container) {
+	const containerElement = container || event.currentTarget;
+	const relatedTarget = event.relatedTarget;
+	return !relatedTarget || !contains(containerElement, relatedTarget);
+}
+function disableFocusInside(container) {
+	tabbable(container, getTabbableOptions()).forEach((element) => {
+		element.dataset.tabindex = element.getAttribute("tabindex") || "";
+		element.setAttribute("tabindex", "-1");
+	});
+}
+function enableFocusInside(container) {
+	container.querySelectorAll("[data-tabindex]").forEach((element) => {
+		const tabindex = element.dataset.tabindex;
+		delete element.dataset.tabindex;
+		if (tabindex) element.setAttribute("tabindex", tabindex);
+		else element.removeAttribute("tabindex");
+	});
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/composite/composite.js
+var ARROW_UP = "ArrowUp";
+var ARROW_DOWN = "ArrowDown";
+var ARROW_LEFT = "ArrowLeft";
+var ARROW_RIGHT = "ArrowRight";
+var HOME = "Home";
+var HORIZONTAL_KEYS = new Set([ARROW_LEFT, ARROW_RIGHT]);
+var VERTICAL_KEYS = new Set([ARROW_UP, ARROW_DOWN]);
+var ARROW_KEYS = new Set([...HORIZONTAL_KEYS, ...VERTICAL_KEYS]);
+new Set([
+	...ARROW_KEYS,
+	HOME,
+	"End"
+]);
+var COMPOSITE_KEYS = new Set([
+	ARROW_UP,
+	ARROW_DOWN,
+	ARROW_LEFT,
+	ARROW_RIGHT,
+	HOME,
+	"End"
+]);
+//#endregion
+//#region ../../node_modules/@base-ui-components/utils/esm/useLatestRef.js
+function useLatestRef$1(value) {
+	const latest = useRefWithInit(createLatestRef, value).current;
+	latest.next = value;
+	useIsoLayoutEffect(latest.effect);
+	return latest;
+}
+function createLatestRef(value) {
+	const latest = {
+		current: value,
+		next: value,
+		effect: () => {
+			latest.current = latest.next;
+		}
+	};
+	return latest;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/utils/useOpenChangeComplete.js
+/**
+* Calls the provided function when the CSS open/close animation or transition completes.
+*/
+function useOpenChangeComplete(parameters) {
+	const { enabled = true, open, ref, onComplete: onCompleteParam } = parameters;
+	const openRef = useLatestRef$1(open);
+	const onComplete = useEventCallback(onCompleteParam);
+	const runOnceAnimationsFinish = useAnimationsFinished(ref, open);
+	React$1.useEffect(() => {
+		if (!enabled) return;
+		runOnceAnimationsFinish(() => {
+			if (open === openRef.current) onComplete();
+		});
+	}, [
+		enabled,
+		open,
+		onComplete,
+		runOnceAnimationsFinish,
+		openRef
+	]);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/utils/popupStateMapping.js
+var CommonPopupDataAttributes = function(CommonPopupDataAttributes) {
+	/**
+	* Present when the popup is open.
+	*/
+	CommonPopupDataAttributes["open"] = "data-open";
+	/**
+	* Present when the popup is closed.
+	*/
+	CommonPopupDataAttributes["closed"] = "data-closed";
+	/**
+	* Present when the popup is animating in.
+	*/
+	CommonPopupDataAttributes[CommonPopupDataAttributes["startingStyle"] = TransitionStatusDataAttributes.startingStyle] = "startingStyle";
+	/**
+	* Present when the popup is animating out.
+	*/
+	CommonPopupDataAttributes[CommonPopupDataAttributes["endingStyle"] = TransitionStatusDataAttributes.endingStyle] = "endingStyle";
+	/**
+	* Present when the anchor is hidden.
+	*/
+	CommonPopupDataAttributes["anchorHidden"] = "data-anchor-hidden";
+	return CommonPopupDataAttributes;
+}({});
+var CommonTriggerDataAttributes = /* @__PURE__ */ function(CommonTriggerDataAttributes) {
+	/**
+	* Present when the popup is open.
+	*/
+	CommonTriggerDataAttributes["popupOpen"] = "data-popup-open";
+	/**
+	* Present when a pressable trigger is pressed.
+	*/
+	CommonTriggerDataAttributes["pressed"] = "data-pressed";
+	return CommonTriggerDataAttributes;
+}({});
+var TRIGGER_HOOK = { [CommonTriggerDataAttributes.popupOpen]: "" };
+var PRESSABLE_TRIGGER_HOOK = {
+	[CommonTriggerDataAttributes.popupOpen]: "",
+	[CommonTriggerDataAttributes.pressed]: ""
+};
+var POPUP_OPEN_HOOK = { [CommonPopupDataAttributes.open]: "" };
+var POPUP_CLOSED_HOOK = { [CommonPopupDataAttributes.closed]: "" };
+var ANCHOR_HIDDEN_HOOK = { [CommonPopupDataAttributes.anchorHidden]: "" };
+var triggerOpenStateMapping = { open(value) {
+	if (value) return TRIGGER_HOOK;
+	return null;
+} };
+var pressableTriggerOpenStateMapping = { open(value) {
+	if (value) return PRESSABLE_TRIGGER_HOOK;
+	return null;
+} };
+var popupStateMapping = {
+	open(value) {
+		if (value) return POPUP_OPEN_HOOK;
+		return POPUP_CLOSED_HOOK;
+	},
+	anchorHidden(value) {
+		if (value) return ANCHOR_HIDDEN_HOOK;
+		return null;
+	}
+};
+//#endregion
+//#region ../../node_modules/@base-ui-components/utils/esm/inertValue.js
+function inertValue(value) {
+	if (isReactVersionAtLeast(19)) return value;
+	return value ? "true" : void 0;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/utils/esm/useTimeout.js
+var EMPTY = 0;
+var Timeout = class Timeout {
+	constructor() {
+		_defineProperty(this, "currentId", EMPTY);
+		_defineProperty(this, "clear", () => {
+			if (this.currentId !== EMPTY) {
+				clearTimeout(this.currentId);
+				this.currentId = EMPTY;
+			}
+		});
+		_defineProperty(this, "disposeEffect", () => {
+			return this.clear;
+		});
+	}
+	static create() {
+		return new Timeout();
+	}
+	/**
+	* Executes `fn` after `delay`, clearing any previously scheduled call.
+	*/
+	start(delay, fn) {
+		this.clear();
+		this.currentId = setTimeout(() => {
+			this.currentId = EMPTY;
+			fn();
+		}, delay);
+	}
+	isStarted() {
+		return this.currentId !== EMPTY;
+	}
+};
+/**
+* A `setTimeout` with automatic cleanup and guard.
+*/
+function useTimeout() {
+	const timeout = useRefWithInit(Timeout.create).current;
+	useOnMount(timeout.disposeEffect);
+	return timeout;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/utils/createEventEmitter.js
+function createEventEmitter() {
+	const map = /* @__PURE__ */ new Map();
+	return {
+		emit(event, data) {
+			var _map$get;
+			(_map$get = map.get(event)) === null || _map$get === void 0 || _map$get.forEach((listener) => listener(data));
+		},
+		on(event, listener) {
+			if (!map.has(event)) map.set(event, /* @__PURE__ */ new Set());
+			map.get(event).add(listener);
+		},
+		off(event, listener) {
+			var _map$get2;
+			(_map$get2 = map.get(event)) === null || _map$get2 === void 0 || _map$get2.delete(listener);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/components/FloatingTree.js
+var import_jsx_runtime = require_jsx_runtime();
+var FloatingNodeContext = /* @__PURE__ */ React$1.createContext(null);
+if (process.env.NODE_ENV !== "production") FloatingNodeContext.displayName = "FloatingNodeContext";
+var FloatingTreeContext = /* @__PURE__ */ React$1.createContext(null);
+/**
+* Returns the parent node id for nested floating elements, if available.
+* Returns `null` for top-level floating elements.
+*/
+if (process.env.NODE_ENV !== "production") FloatingTreeContext.displayName = "FloatingTreeContext";
+var useFloatingParentNodeId = () => {
+	var _React$useContext;
+	return ((_React$useContext = React$1.useContext(FloatingNodeContext)) === null || _React$useContext === void 0 ? void 0 : _React$useContext.id) || null;
+};
+/**
+* Returns the nearest floating tree context, if available.
+*/
+var useFloatingTree = () => React$1.useContext(FloatingTreeContext);
+/**
+* Registers a node into the `FloatingTree`, returning its id.
+* @see https://floating-ui.com/docs/FloatingTree
+*/
+function useFloatingNodeId(customParentId) {
+	const id = useId$1();
+	const tree = useFloatingTree();
+	const reactParentId = useFloatingParentNodeId();
+	const parentId = customParentId || reactParentId;
+	useIsoLayoutEffect(() => {
+		if (!id) return;
+		const node = {
+			id,
+			parentId
+		};
+		tree === null || tree === void 0 || tree.addNode(node);
+		return () => {
+			tree === null || tree === void 0 || tree.removeNode(node);
+		};
+	}, [
+		tree,
+		id,
+		parentId
+	]);
+	return id;
+}
+/**
+* Provides parent node context for nested floating elements.
+* @see https://floating-ui.com/docs/FloatingTree
+* @internal
+*/
+function FloatingNode(props) {
+	const { children, id } = props;
+	const parentId = useFloatingParentNodeId();
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FloatingNodeContext.Provider, {
+		value: React$1.useMemo(() => ({
+			id,
+			parentId
+		}), [id, parentId]),
+		children
+	});
+}
+/**
+* Provides context for nested floating elements when they are not children of
+* each other on the DOM.
+* This is not necessary in all cases, except when there must be explicit communication between parent and child floating elements. It is necessary for:
+* - The `bubbles` option in the `useDismiss()` Hook
+* - Nested virtual list navigation
+* - Nested floating elements that each open on hover
+* - Custom communication between parent and child floating elements
+* @see https://floating-ui.com/docs/FloatingTree
+* @internal
+*/
+function FloatingTree(props) {
+	const { children } = props;
+	const nodesRef = React$1.useRef([]);
+	const addNode = React$1.useCallback((node) => {
+		nodesRef.current = [...nodesRef.current, node];
+	}, []);
+	const removeNode = React$1.useCallback((node) => {
+		nodesRef.current = nodesRef.current.filter((n) => n !== node);
+	}, []);
+	const [events] = React$1.useState(() => createEventEmitter());
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FloatingTreeContext.Provider, {
+		value: React$1.useMemo(() => ({
+			nodesRef,
+			addNode,
+			removeNode,
+			events
+		}), [
+			addNode,
+			removeNode,
+			events
+		]),
+		children
+	});
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/utils/createAttribute.js
+function createAttribute(name) {
+	return `data-base-ui-${name}`;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/utils/esm/visuallyHidden.js
+var visuallyHidden = {
+	clip: "rect(0 0 0 0)",
+	overflow: "hidden",
+	whiteSpace: "nowrap",
+	position: "fixed",
+	top: 0,
+	left: 0,
+	border: 0,
+	padding: 0,
+	width: 1,
+	height: 1,
+	margin: -1
+};
+//#endregion
+//#region ../../node_modules/@base-ui-components/utils/esm/owner.js
+function ownerDocument(node) {
+	return (node === null || node === void 0 ? void 0 : node.ownerDocument) || document;
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/utils/FocusGuard.js
+/**
+* @internal
+*/
+var FocusGuard = /* @__PURE__ */ React$1.forwardRef(function FocusGuard(props, ref) {
+	const [role, setRole] = React$1.useState();
+	useIsoLayoutEffect(() => {
+		if (isSafari) setRole("button");
+	}, []);
+	const restProps = {
+		tabIndex: 0,
+		role
+	};
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
+		...props,
+		ref,
+		style: visuallyHidden,
+		"aria-hidden": role ? void 0 : true,
+		...restProps,
+		"data-base-ui-focus-guard": ""
+	});
+});
+if (process.env.NODE_ENV !== "production") FocusGuard.displayName = "FocusGuard";
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/utils/enqueueFocus.js
+var rafId = 0;
+function enqueueFocus(el, options = {}) {
+	const { preventScroll = false, cancelPrevious = true, sync = false } = options;
+	if (cancelPrevious) cancelAnimationFrame(rafId);
+	const exec = () => el === null || el === void 0 ? void 0 : el.focus({ preventScroll });
+	if (sync) exec();
+	else rafId = requestAnimationFrame(exec);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/utils/markOthers.js
+var counters = {
+	inert: /* @__PURE__ */ new WeakMap(),
+	"aria-hidden": /* @__PURE__ */ new WeakMap(),
+	none: /* @__PURE__ */ new WeakMap()
+};
+function getCounterMap(control) {
+	if (control === "inert") return counters.inert;
+	if (control === "aria-hidden") return counters["aria-hidden"];
+	return counters.none;
+}
+var uncontrolledElementsSet = /* @__PURE__ */ new WeakSet();
+var markerMap = {};
+var lockCount = 0;
+var unwrapHost = (node) => node && (node.host || unwrapHost(node.parentNode));
+var correctElements = (parent, targets) => targets.map((target) => {
+	if (parent.contains(target)) return target;
+	const correctedTarget = unwrapHost(target);
+	if (parent.contains(correctedTarget)) return correctedTarget;
+	return null;
+}).filter((x) => x != null);
+function applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, inert) {
+	const markerName = "data-base-ui-inert";
+	const controlAttribute = inert ? "inert" : ariaHidden ? "aria-hidden" : null;
+	const avoidElements = correctElements(body, uncorrectedAvoidElements);
+	const elementsToKeep = /* @__PURE__ */ new Set();
+	const elementsToStop = new Set(avoidElements);
+	const hiddenElements = [];
+	if (!markerMap[markerName]) markerMap[markerName] = /* @__PURE__ */ new WeakMap();
+	const markerCounter = markerMap[markerName];
+	avoidElements.forEach(keep);
+	deep(body);
+	elementsToKeep.clear();
+	function keep(el) {
+		if (!el || elementsToKeep.has(el)) return;
+		elementsToKeep.add(el);
+		if (el.parentNode) keep(el.parentNode);
+	}
+	function deep(parent) {
+		if (!parent || elementsToStop.has(parent)) return;
+		[].forEach.call(parent.children, (node) => {
+			if (getNodeName(node) === "script") return;
+			if (elementsToKeep.has(node)) deep(node);
+			else {
+				const attr = controlAttribute ? node.getAttribute(controlAttribute) : null;
+				const alreadyHidden = attr !== null && attr !== "false";
+				const counterMap = getCounterMap(controlAttribute);
+				const counterValue = (counterMap.get(node) || 0) + 1;
+				const markerValue = (markerCounter.get(node) || 0) + 1;
+				counterMap.set(node, counterValue);
+				markerCounter.set(node, markerValue);
+				hiddenElements.push(node);
+				if (counterValue === 1 && alreadyHidden) uncontrolledElementsSet.add(node);
+				if (markerValue === 1) node.setAttribute(markerName, "");
+				if (!alreadyHidden && controlAttribute) node.setAttribute(controlAttribute, controlAttribute === "inert" ? "" : "true");
+			}
+		});
+	}
+	lockCount += 1;
+	return () => {
+		hiddenElements.forEach((element) => {
+			const counterMap = getCounterMap(controlAttribute);
+			const counterValue = (counterMap.get(element) || 0) - 1;
+			const markerValue = (markerCounter.get(element) || 0) - 1;
+			counterMap.set(element, counterValue);
+			markerCounter.set(element, markerValue);
+			if (!counterValue) {
+				if (!uncontrolledElementsSet.has(element) && controlAttribute) element.removeAttribute(controlAttribute);
+				uncontrolledElementsSet.delete(element);
+			}
+			if (!markerValue) element.removeAttribute(markerName);
+		});
+		lockCount -= 1;
+		if (!lockCount) {
+			counters.inert = /* @__PURE__ */ new WeakMap();
+			counters["aria-hidden"] = /* @__PURE__ */ new WeakMap();
+			counters.none = /* @__PURE__ */ new WeakMap();
+			uncontrolledElementsSet = /* @__PURE__ */ new WeakSet();
+			markerMap = {};
+		}
+	};
+}
+function markOthers(avoidElements, ariaHidden = false, inert = false) {
+	const body = getDocument(avoidElements[0]).body;
+	return applyAttributeToOthers(avoidElements.concat(Array.from(body.querySelectorAll("[aria-live]"))), body, ariaHidden, inert);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/components/FloatingPortal.js
+var PortalContext = /* @__PURE__ */ React$1.createContext(null);
+if (process.env.NODE_ENV !== "production") PortalContext.displayName = "PortalContext";
+var usePortalContext = () => React$1.useContext(PortalContext);
+var attr = createAttribute("portal");
+/**
+* @see https://floating-ui.com/docs/FloatingPortal#usefloatingportalnode
+*/
+function useFloatingPortalNode(props = {}) {
+	const { id, root } = props;
+	const uniqueId = useId$1();
+	const portalContext = usePortalContext();
+	const [portalNode, setPortalNode] = React$1.useState(null);
+	const portalNodeRef = React$1.useRef(null);
+	useIsoLayoutEffect(() => {
+		return () => {
+			portalNode === null || portalNode === void 0 || portalNode.remove();
+			queueMicrotask(() => {
+				portalNodeRef.current = null;
+			});
+		};
+	}, [portalNode]);
+	useIsoLayoutEffect(() => {
+		if (!uniqueId) return;
+		if (portalNodeRef.current) return;
+		const existingIdRoot = id ? document.getElementById(id) : null;
+		if (!existingIdRoot) return;
+		const subRoot = document.createElement("div");
+		subRoot.id = uniqueId;
+		subRoot.setAttribute(attr, "");
+		existingIdRoot.appendChild(subRoot);
+		portalNodeRef.current = subRoot;
+		setPortalNode(subRoot);
+	}, [id, uniqueId]);
+	useIsoLayoutEffect(() => {
+		if (root === null) return;
+		if (!uniqueId) return;
+		if (portalNodeRef.current) return;
+		let container = root || (portalContext === null || portalContext === void 0 ? void 0 : portalContext.portalNode);
+		if (container && !isNode(container)) container = container.current;
+		container = container || document.body;
+		let idWrapper = null;
+		if (id) {
+			idWrapper = document.createElement("div");
+			idWrapper.id = id;
+			container.appendChild(idWrapper);
+		}
+		const subRoot = document.createElement("div");
+		subRoot.id = uniqueId;
+		subRoot.setAttribute(attr, "");
+		container = idWrapper || container;
+		container.appendChild(subRoot);
+		portalNodeRef.current = subRoot;
+		setPortalNode(subRoot);
+	}, [
+		id,
+		root,
+		uniqueId,
+		portalContext
+	]);
+	return portalNode;
+}
+/**
+* Portals the floating element into a given container element — by default,
+* outside of the app root and into the body.
+* This is necessary to ensure the floating element can appear outside any
+* potential parent containers that cause clipping (such as `overflow: hidden`),
+* while retaining its location in the React tree.
+* @see https://floating-ui.com/docs/FloatingPortal
+* @internal
+*/
+function FloatingPortal(props) {
+	const { children, id, root, preserveTabOrder = true } = props;
+	const portalNode = useFloatingPortalNode({
+		id,
+		root
+	});
+	const [focusManagerState, setFocusManagerState] = React$1.useState(null);
+	const beforeOutsideRef = React$1.useRef(null);
+	const afterOutsideRef = React$1.useRef(null);
+	const beforeInsideRef = React$1.useRef(null);
+	const afterInsideRef = React$1.useRef(null);
+	const modal = focusManagerState === null || focusManagerState === void 0 ? void 0 : focusManagerState.modal;
+	const open = focusManagerState === null || focusManagerState === void 0 ? void 0 : focusManagerState.open;
+	const shouldRenderGuards = !!focusManagerState && !focusManagerState.modal && focusManagerState.open && preserveTabOrder && !!(root || portalNode);
+	React$1.useEffect(() => {
+		if (!portalNode || !preserveTabOrder || modal) return;
+		function onFocus(event) {
+			if (portalNode && isOutsideEvent(event)) (event.type === "focusin" ? enableFocusInside : disableFocusInside)(portalNode);
+		}
+		portalNode.addEventListener("focusin", onFocus, true);
+		portalNode.addEventListener("focusout", onFocus, true);
+		return () => {
+			portalNode.removeEventListener("focusin", onFocus, true);
+			portalNode.removeEventListener("focusout", onFocus, true);
+		};
+	}, [
+		portalNode,
+		preserveTabOrder,
+		modal
+	]);
+	React$1.useEffect(() => {
+		if (!portalNode) return;
+		if (open) return;
+		enableFocusInside(portalNode);
+	}, [open, portalNode]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(PortalContext.Provider, {
+		value: React$1.useMemo(() => ({
+			preserveTabOrder,
+			beforeOutsideRef,
+			afterOutsideRef,
+			beforeInsideRef,
+			afterInsideRef,
+			portalNode,
+			setFocusManagerState
+		}), [preserveTabOrder, portalNode]),
+		children: [
+			shouldRenderGuards && portalNode && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FocusGuard, {
+				"data-type": "outside",
+				ref: beforeOutsideRef,
+				onFocus: (event) => {
+					if (isOutsideEvent(event, portalNode)) {
+						var _beforeInsideRef$curr;
+						(_beforeInsideRef$curr = beforeInsideRef.current) === null || _beforeInsideRef$curr === void 0 || _beforeInsideRef$curr.focus();
+					} else {
+						const prevTabbable = getPreviousTabbable(focusManagerState ? focusManagerState.domReference : null);
+						prevTabbable === null || prevTabbable === void 0 || prevTabbable.focus();
+					}
+				}
+			}),
+			shouldRenderGuards && portalNode && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
+				"aria-owns": portalNode.id,
+				style: visuallyHidden
+			}),
+			portalNode && /* @__PURE__ */ ReactDOM$1.createPortal(children, portalNode),
+			shouldRenderGuards && portalNode && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FocusGuard, {
+				"data-type": "outside",
+				ref: afterOutsideRef,
+				onFocus: (event) => {
+					if (isOutsideEvent(event, portalNode)) {
+						var _afterInsideRef$curre;
+						(_afterInsideRef$curre = afterInsideRef.current) === null || _afterInsideRef$curre === void 0 || _afterInsideRef$curre.focus();
+					} else {
+						const nextTabbable = getNextTabbable(focusManagerState ? focusManagerState.domReference : null);
+						nextTabbable === null || nextTabbable === void 0 || nextTabbable.focus();
+						if (focusManagerState === null || focusManagerState === void 0 ? void 0 : focusManagerState.closeOnFocusOut) focusManagerState === null || focusManagerState === void 0 || focusManagerState.onOpenChange(false, createChangeEventDetails("focus-out", event.nativeEvent));
+					}
+				}
+			})
+		]
+	});
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/components/FloatingFocusManager.js
+function getEventType(event, lastInteractionType) {
+	const win = getWindow(event.target);
+	if (event instanceof win.KeyboardEvent) return "keyboard";
+	if (event instanceof win.FocusEvent) return lastInteractionType || "keyboard";
+	if ("pointerType" in event) return event.pointerType || "keyboard";
+	if ("touches" in event) return "touch";
+	if (event instanceof win.MouseEvent) return lastInteractionType || (event.detail === 0 ? "keyboard" : "mouse");
+	return "";
+}
+var LIST_LIMIT = 20;
+var previouslyFocusedElements = [];
+function clearDisconnectedPreviouslyFocusedElements() {
+	previouslyFocusedElements = previouslyFocusedElements.filter((el) => el.isConnected);
+}
+function addPreviouslyFocusedElement(element) {
+	clearDisconnectedPreviouslyFocusedElements();
+	if (element && getNodeName(element) !== "body") {
+		previouslyFocusedElements.push(element);
+		if (previouslyFocusedElements.length > LIST_LIMIT) previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);
+	}
+}
+function getPreviouslyFocusedElement() {
+	clearDisconnectedPreviouslyFocusedElements();
+	return previouslyFocusedElements[previouslyFocusedElements.length - 1];
+}
+function getFirstTabbableElement(container) {
+	if (!container) return null;
+	const tabbableOptions = getTabbableOptions();
+	if (isTabbable(container, tabbableOptions)) return container;
+	return tabbable(container, tabbableOptions)[0] || container;
+}
+function handleTabIndex(floatingFocusElement, orderRef) {
+	var _floatingFocusElement;
+	if (!orderRef.current.includes("floating") && !((_floatingFocusElement = floatingFocusElement.getAttribute("role")) === null || _floatingFocusElement === void 0 ? void 0 : _floatingFocusElement.includes("dialog"))) return;
+	const options = getTabbableOptions();
+	const tabbableContent = focusable(floatingFocusElement, options).filter((element) => {
+		const dataTabIndex = element.getAttribute("data-tabindex") || "";
+		return isTabbable(element, options) || element.hasAttribute("data-tabindex") && !dataTabIndex.startsWith("-");
+	});
+	const tabIndex = floatingFocusElement.getAttribute("tabindex");
+	if (orderRef.current.includes("floating") || tabbableContent.length === 0) {
+		if (tabIndex !== "0") floatingFocusElement.setAttribute("tabindex", "0");
+	} else if (tabIndex !== "-1" || floatingFocusElement.hasAttribute("data-tabindex") && floatingFocusElement.getAttribute("data-tabindex") !== "-1") {
+		floatingFocusElement.setAttribute("tabindex", "-1");
+		floatingFocusElement.setAttribute("data-tabindex", "-1");
+	}
+}
+/**
+* Provides focus management for the floating element.
+* @see https://floating-ui.com/docs/FloatingFocusManager
+* @internal
+*/
+function FloatingFocusManager(props) {
+	const { context, children, disabled = false, order = ["content"], initialFocus = true, returnFocus = true, restoreFocus = false, modal = true, closeOnFocusOut = true, openInteractionType = "", getInsideElements: getInsideElementsProp = () => [] } = props;
+	const { open, onOpenChange, events, dataRef, elements: { domReference, floating } } = context;
+	const getNodeId = useEventCallback(() => {
+		var _dataRef$current$floa;
+		return (_dataRef$current$floa = dataRef.current.floatingContext) === null || _dataRef$current$floa === void 0 ? void 0 : _dataRef$current$floa.nodeId;
+	});
+	const getInsideElements = useEventCallback(getInsideElementsProp);
+	const ignoreInitialFocus = initialFocus === false;
+	const isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;
+	const orderRef = useLatestRef$1(order);
+	const initialFocusRef = useLatestRef$1(initialFocus);
+	const returnFocusRef = useLatestRef$1(returnFocus);
+	const openInteractionTypeRef = useLatestRef$1(openInteractionType);
+	const tree = useFloatingTree();
+	const portalContext = usePortalContext();
+	const startDismissButtonRef = React$1.useRef(null);
+	const endDismissButtonRef = React$1.useRef(null);
+	const preventReturnFocusRef = React$1.useRef(false);
+	const isPointerDownRef = React$1.useRef(false);
+	const tabbableIndexRef = React$1.useRef(-1);
+	const closeTypeRef = React$1.useRef("");
+	const lastInteractionTypeRef = React$1.useRef("");
+	const blurTimeout = useTimeout();
+	const pointerDownTimeout = useTimeout();
+	const restoreFocusFrame = useAnimationFrame();
+	const isInsidePortal = portalContext != null;
+	const floatingFocusElement = getFloatingFocusElement(floating);
+	const getTabbableContent = useEventCallback((container = floatingFocusElement) => {
+		return container ? tabbable(container, getTabbableOptions()) : [];
+	});
+	const getTabbableElements = useEventCallback((container) => {
+		const content = getTabbableContent(container);
+		return orderRef.current.map(() => content).filter(Boolean).flat();
+	});
+	React$1.useEffect(() => {
+		if (disabled) return;
+		if (!modal) return;
+		function onKeyDown(event) {
+			if (event.key === "Tab") {
+				if (contains(floatingFocusElement, activeElement(getDocument(floatingFocusElement))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) stopEvent(event);
+			}
+		}
+		const doc = getDocument(floatingFocusElement);
+		doc.addEventListener("keydown", onKeyDown);
+		return () => {
+			doc.removeEventListener("keydown", onKeyDown);
+		};
+	}, [
+		disabled,
+		domReference,
+		floatingFocusElement,
+		modal,
+		orderRef,
+		isUntrappedTypeableCombobox,
+		getTabbableContent,
+		getTabbableElements
+	]);
+	React$1.useEffect(() => {
+		if (disabled) return;
+		if (!floating) return;
+		function handleFocusIn(event) {
+			const target = getTarget(event);
+			const tabbableIndex = getTabbableContent().indexOf(target);
+			if (tabbableIndex !== -1) tabbableIndexRef.current = tabbableIndex;
+		}
+		floating.addEventListener("focusin", handleFocusIn);
+		return () => {
+			floating.removeEventListener("focusin", handleFocusIn);
+		};
+	}, [
+		disabled,
+		floating,
+		getTabbableContent
+	]);
+	React$1.useEffect(() => {
+		if (disabled || !open) return;
+		const doc = getDocument(floatingFocusElement);
+		function onPointerDown(event) {
+			lastInteractionTypeRef.current = event.pointerType || "keyboard";
+		}
+		function onKeyDown() {
+			lastInteractionTypeRef.current = "keyboard";
+		}
+		doc.addEventListener("pointerdown", onPointerDown, true);
+		doc.addEventListener("keydown", onKeyDown, true);
+		return () => {
+			doc.removeEventListener("pointerdown", onPointerDown, true);
+			doc.removeEventListener("keydown", onKeyDown, true);
+		};
+	}, [
+		disabled,
+		floating,
+		domReference,
+		floatingFocusElement,
+		open
+	]);
+	React$1.useEffect(() => {
+		if (disabled) return;
+		if (!closeOnFocusOut) return;
+		function handlePointerDown() {
+			isPointerDownRef.current = true;
+			pointerDownTimeout.start(0, () => {
+				isPointerDownRef.current = false;
+			});
+		}
+		function handleFocusOutside(event) {
+			const relatedTarget = event.relatedTarget;
+			const currentTarget = event.currentTarget;
+			const target = getTarget(event);
+			queueMicrotask(() => {
+				const nodeId = getNodeId();
+				const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext === null || portalContext === void 0 ? void 0 : portalContext.portalNode, relatedTarget) || (relatedTarget === null || relatedTarget === void 0 ? void 0 : relatedTarget.hasAttribute(createAttribute("focus-guard"))) || tree && (getNodeChildren(tree.nodesRef.current, nodeId).find((node) => {
+					var _node$context, _node$context2;
+					return contains((_node$context = node.context) === null || _node$context === void 0 ? void 0 : _node$context.elements.floating, relatedTarget) || contains((_node$context2 = node.context) === null || _node$context2 === void 0 ? void 0 : _node$context2.elements.domReference, relatedTarget);
+				}) || getNodeAncestors(tree.nodesRef.current, nodeId).find((node) => {
+					var _node$context3, _node$context4, _node$context5;
+					return [(_node$context3 = node.context) === null || _node$context3 === void 0 ? void 0 : _node$context3.elements.floating, getFloatingFocusElement((_node$context4 = node.context) === null || _node$context4 === void 0 ? void 0 : _node$context4.elements.floating)].includes(relatedTarget) || ((_node$context5 = node.context) === null || _node$context5 === void 0 ? void 0 : _node$context5.elements.domReference) === relatedTarget;
+				})));
+				if (currentTarget === domReference && floatingFocusElement) handleTabIndex(floatingFocusElement, orderRef);
+				if (restoreFocus && currentTarget !== domReference && !(target === null || target === void 0 ? void 0 : target.isConnected) && activeElement(getDocument(floatingFocusElement)) === getDocument(floatingFocusElement).body) {
+					if (isHTMLElement(floatingFocusElement)) {
+						floatingFocusElement.focus();
+						if (restoreFocus === "popup") {
+							restoreFocusFrame.request(() => {
+								floatingFocusElement.focus();
+							});
+							return;
+						}
+					}
+					const prevTabbableIndex = tabbableIndexRef.current;
+					const tabbableContent = getTabbableContent();
+					const nodeToFocus = tabbableContent[prevTabbableIndex] || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;
+					if (isHTMLElement(nodeToFocus)) nodeToFocus.focus();
+				}
+				if (dataRef.current.insideReactTree) {
+					dataRef.current.insideReactTree = false;
+					return;
+				}
+				if ((isUntrappedTypeableCombobox ? true : !modal) && relatedTarget && movedToUnrelatedNode && (isUntrappedTypeableCombobox || relatedTarget !== getPreviouslyFocusedElement())) {
+					preventReturnFocusRef.current = true;
+					onOpenChange(false, createChangeEventDetails("focus-out", event));
+				}
+			});
+		}
+		function markInsideReactTree() {
+			dataRef.current.insideReactTree = true;
+			blurTimeout.start(0, () => {
+				dataRef.current.insideReactTree = false;
+			});
+		}
+		if (floating && isHTMLElement(domReference)) {
+			domReference.addEventListener("focusout", handleFocusOutside);
+			domReference.addEventListener("pointerdown", handlePointerDown);
+			floating.addEventListener("focusout", handleFocusOutside);
+			if (portalContext) floating.addEventListener("focusout", markInsideReactTree, true);
+			return () => {
+				domReference.removeEventListener("focusout", handleFocusOutside);
+				domReference.removeEventListener("pointerdown", handlePointerDown);
+				floating.removeEventListener("focusout", handleFocusOutside);
+				if (portalContext) floating.removeEventListener("focusout", markInsideReactTree, true);
+			};
+		}
+	}, [
+		disabled,
+		domReference,
+		floating,
+		floatingFocusElement,
+		modal,
+		tree,
+		portalContext,
+		onOpenChange,
+		closeOnFocusOut,
+		restoreFocus,
+		getTabbableContent,
+		isUntrappedTypeableCombobox,
+		getNodeId,
+		orderRef,
+		dataRef,
+		blurTimeout,
+		pointerDownTimeout,
+		restoreFocusFrame
+	]);
+	const beforeGuardRef = React$1.useRef(null);
+	const afterGuardRef = React$1.useRef(null);
+	const mergedBeforeGuardRef = useMergedRefs(beforeGuardRef, portalContext === null || portalContext === void 0 ? void 0 : portalContext.beforeInsideRef);
+	const mergedAfterGuardRef = useMergedRefs(afterGuardRef, portalContext === null || portalContext === void 0 ? void 0 : portalContext.afterInsideRef);
+	React$1.useEffect(() => {
+		var _portalContext$portal, _ancestors$find;
+		if (disabled || !floating || !open) return;
+		const portalNodes = Array.from((portalContext === null || portalContext === void 0 || (_portalContext$portal = portalContext.portalNode) === null || _portalContext$portal === void 0 ? void 0 : _portalContext$portal.querySelectorAll(`[${createAttribute("portal")}]`)) || []);
+		const cleanup = markOthers([
+			floating,
+			(_ancestors$find = (tree ? getNodeAncestors(tree.nodesRef.current, getNodeId()) : []).find((node) => {
+				var _node$context6;
+				return isTypeableCombobox(((_node$context6 = node.context) === null || _node$context6 === void 0 ? void 0 : _node$context6.elements.domReference) || null);
+			})) === null || _ancestors$find === void 0 || (_ancestors$find = _ancestors$find.context) === null || _ancestors$find === void 0 ? void 0 : _ancestors$find.elements.domReference,
+			...portalNodes,
+			...getInsideElements(),
+			startDismissButtonRef.current,
+			endDismissButtonRef.current,
+			beforeGuardRef.current,
+			afterGuardRef.current,
+			portalContext === null || portalContext === void 0 ? void 0 : portalContext.beforeOutsideRef.current,
+			portalContext === null || portalContext === void 0 ? void 0 : portalContext.afterOutsideRef.current,
+			isUntrappedTypeableCombobox ? domReference : null
+		].filter((x) => x != null), modal || isUntrappedTypeableCombobox);
+		return () => {
+			cleanup();
+		};
+	}, [
+		open,
+		disabled,
+		domReference,
+		floating,
+		modal,
+		orderRef,
+		portalContext,
+		isUntrappedTypeableCombobox,
+		tree,
+		getNodeId,
+		getInsideElements
+	]);
+	useIsoLayoutEffect(() => {
+		if (disabled || !isHTMLElement(floatingFocusElement)) return;
+		const previouslyFocusedElement = activeElement(getDocument(floatingFocusElement));
+		queueMicrotask(() => {
+			const focusableElements = getTabbableElements(floatingFocusElement);
+			const initialFocusValueOrFn = initialFocusRef.current;
+			const resolvedInitialFocus = typeof initialFocusValueOrFn === "function" ? initialFocusValueOrFn(openInteractionTypeRef.current || "") : initialFocusValueOrFn;
+			if (resolvedInitialFocus === void 0 || resolvedInitialFocus === false) return;
+			let elToFocus;
+			if (resolvedInitialFocus === true || resolvedInitialFocus === null) elToFocus = focusableElements[0] || floatingFocusElement;
+			else if ("current" in resolvedInitialFocus) elToFocus = resolvedInitialFocus.current;
+			else elToFocus = resolvedInitialFocus;
+			elToFocus = elToFocus || focusableElements[0] || floatingFocusElement;
+			if (!contains(floatingFocusElement, previouslyFocusedElement) && open) enqueueFocus(elToFocus, { preventScroll: elToFocus === floatingFocusElement });
+		});
+	}, [
+		disabled,
+		open,
+		floatingFocusElement,
+		ignoreInitialFocus,
+		getTabbableElements,
+		initialFocusRef,
+		openInteractionTypeRef
+	]);
+	useIsoLayoutEffect(() => {
+		if (disabled || !floatingFocusElement) return;
+		const doc = getDocument(floatingFocusElement);
+		addPreviouslyFocusedElement(activeElement(doc));
+		function onOpenChangeLocal(details) {
+			if (!details.open) closeTypeRef.current = getEventType(details.nativeEvent, lastInteractionTypeRef.current);
+			if (details.reason === "trigger-hover" && details.nativeEvent.type === "mouseleave") preventReturnFocusRef.current = true;
+			if (details.reason !== "outside-press") return;
+			if (details.nested) preventReturnFocusRef.current = false;
+			else if (isVirtualClick(details.nativeEvent) || isVirtualPointerEvent(details.nativeEvent)) preventReturnFocusRef.current = false;
+			else {
+				let isPreventScrollSupported = false;
+				document.createElement("div").focus({ get preventScroll() {
+					isPreventScrollSupported = true;
+					return false;
+				} });
+				if (isPreventScrollSupported) preventReturnFocusRef.current = false;
+				else preventReturnFocusRef.current = true;
+			}
+		}
+		events.on("openchange", onOpenChangeLocal);
+		const fallbackEl = doc.createElement("span");
+		fallbackEl.setAttribute("tabindex", "-1");
+		fallbackEl.setAttribute("aria-hidden", "true");
+		Object.assign(fallbackEl.style, visuallyHidden);
+		if (isInsidePortal && domReference) domReference.insertAdjacentElement("afterend", fallbackEl);
+		function getReturnElement() {
+			const returnFocusValueOrFn = returnFocusRef.current;
+			let resolvedReturnFocusValue = typeof returnFocusValueOrFn === "function" ? returnFocusValueOrFn(closeTypeRef.current) : returnFocusValueOrFn;
+			if (resolvedReturnFocusValue === void 0 || resolvedReturnFocusValue === false) return null;
+			if (resolvedReturnFocusValue === null) resolvedReturnFocusValue = true;
+			if (typeof resolvedReturnFocusValue === "boolean") {
+				const el = domReference || getPreviouslyFocusedElement();
+				return el && el.isConnected ? el : fallbackEl;
+			}
+			const fallback = domReference || getPreviouslyFocusedElement() || fallbackEl;
+			if ("current" in resolvedReturnFocusValue) return resolvedReturnFocusValue.current || fallback;
+			return resolvedReturnFocusValue || fallback;
+		}
+		return () => {
+			events.off("openchange", onOpenChangeLocal);
+			const activeEl = activeElement(doc);
+			const isFocusInsideFloatingTree = contains(floating, activeEl) || tree && getNodeChildren(tree.nodesRef.current, getNodeId(), false).some((node) => {
+				var _node$context7;
+				return contains((_node$context7 = node.context) === null || _node$context7 === void 0 ? void 0 : _node$context7.elements.floating, activeEl);
+			});
+			const returnElement = getReturnElement();
+			queueMicrotask(() => {
+				const tabbableReturnElement = getFirstTabbableElement(returnElement);
+				const hasExplicitReturnFocus = typeof returnFocusRef.current !== "boolean";
+				if (returnFocusRef.current && !preventReturnFocusRef.current && isHTMLElement(tabbableReturnElement) && (!hasExplicitReturnFocus && tabbableReturnElement !== activeEl && activeEl !== doc.body ? isFocusInsideFloatingTree : true)) tabbableReturnElement.focus({ preventScroll: true });
+				fallbackEl.remove();
+			});
+		};
+	}, [
+		disabled,
+		floating,
+		floatingFocusElement,
+		returnFocusRef,
+		dataRef,
+		events,
+		tree,
+		isInsidePortal,
+		domReference,
+		getNodeId
+	]);
+	React$1.useEffect(() => {
+		queueMicrotask(() => {
+			preventReturnFocusRef.current = false;
+		});
+	}, [disabled]);
+	React$1.useEffect(() => {
+		if (disabled || !open) return;
+		function handlePointerDown(event) {
+			const target = getTarget(event);
+			if (target === null || target === void 0 ? void 0 : target.closest(`[data-base-ui-click-trigger]`)) isPointerDownRef.current = true;
+		}
+		const doc = getDocument(floatingFocusElement);
+		doc.addEventListener("pointerdown", handlePointerDown, true);
+		return () => {
+			doc.removeEventListener("pointerdown", handlePointerDown, true);
+		};
+	}, [
+		disabled,
+		open,
+		floatingFocusElement
+	]);
+	useIsoLayoutEffect(() => {
+		if (disabled) return;
+		if (!portalContext) return;
+		portalContext.setFocusManagerState({
+			modal,
+			closeOnFocusOut,
+			open,
+			onOpenChange,
+			domReference
+		});
+		return () => {
+			portalContext.setFocusManagerState(null);
+		};
+	}, [
+		disabled,
+		portalContext,
+		modal,
+		open,
+		onOpenChange,
+		closeOnFocusOut,
+		domReference
+	]);
+	useIsoLayoutEffect(() => {
+		if (disabled || !floatingFocusElement) return;
+		handleTabIndex(floatingFocusElement, orderRef);
+		return () => {
+			queueMicrotask(clearDisconnectedPreviouslyFocusedElements);
+		};
+	}, [
+		disabled,
+		floatingFocusElement,
+		orderRef
+	]);
+	const shouldRenderGuards = !disabled && (modal ? !isUntrappedTypeableCombobox : true) && (isInsidePortal || modal);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(React$1.Fragment, { children: [
+		shouldRenderGuards && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FocusGuard, {
+			"data-type": "inside",
+			ref: mergedBeforeGuardRef,
+			onFocus: (event) => {
+				if (modal) {
+					const els = getTabbableElements();
+					enqueueFocus(els[els.length - 1]);
+				} else if ((portalContext === null || portalContext === void 0 ? void 0 : portalContext.preserveTabOrder) && portalContext.portalNode) {
+					preventReturnFocusRef.current = false;
+					if (isOutsideEvent(event, portalContext.portalNode)) {
+						const nextTabbable = getNextTabbable(domReference);
+						nextTabbable === null || nextTabbable === void 0 || nextTabbable.focus();
+					} else {
+						var _portalContext$before;
+						(_portalContext$before = portalContext.beforeOutsideRef.current) === null || _portalContext$before === void 0 || _portalContext$before.focus();
+					}
+				}
+			}
+		}),
+		children,
+		shouldRenderGuards && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FocusGuard, {
+			"data-type": "inside",
+			ref: mergedAfterGuardRef,
+			onFocus: (event) => {
+				if (modal) enqueueFocus(getTabbableElements()[0]);
+				else if ((portalContext === null || portalContext === void 0 ? void 0 : portalContext.preserveTabOrder) && portalContext.portalNode) {
+					if (closeOnFocusOut) preventReturnFocusRef.current = true;
+					if (isOutsideEvent(event, portalContext.portalNode)) {
+						const prevTabbable = getPreviousTabbable(domReference);
+						prevTabbable === null || prevTabbable === void 0 || prevTabbable.focus();
+					} else {
+						var _portalContext$afterO;
+						(_portalContext$afterO = portalContext.afterOutsideRef.current) === null || _portalContext$afterO === void 0 || _portalContext$afterO.focus();
+					}
+				}
+			}
+		})
+	] });
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/hooks/useClick.js
+/**
+* Opens or closes the floating element when clicking the reference element.
+* @see https://floating-ui.com/docs/useClick
+*/
+function useClick(context, props = {}) {
+	const { open, onOpenChange, dataRef } = context;
+	const { enabled = true, event: eventOption = "click", toggle = true, ignoreMouse = false, stickIfOpen = true, touchOpenDelay = 0 } = props;
+	const pointerTypeRef = React$1.useRef(void 0);
+	const frame = useAnimationFrame();
+	const touchOpenTimeout = useTimeout();
+	const reference = React$1.useMemo(() => ({
+		onPointerDown(event) {
+			pointerTypeRef.current = event.pointerType;
+		},
+		onMouseDown(event) {
+			const pointerType = pointerTypeRef.current;
+			const nativeEvent = event.nativeEvent;
+			if (event.button !== 0 || eventOption === "click" || isMouseLikePointerType(pointerType, true) && ignoreMouse) return;
+			const openEvent = dataRef.current.openEvent;
+			const openEventType = openEvent === null || openEvent === void 0 ? void 0 : openEvent.type;
+			const nextOpen = !(open && toggle && (openEvent && stickIfOpen ? openEventType === "click" || openEventType === "mousedown" : true));
+			if (isTypeableElement(nativeEvent.target)) {
+				const details = createChangeEventDetails("trigger-press", nativeEvent);
+				if (nextOpen && pointerType === "touch" && touchOpenDelay > 0) touchOpenTimeout.start(touchOpenDelay, () => {
+					onOpenChange(true, details);
+				});
+				else onOpenChange(nextOpen, details);
+				return;
+			}
+			frame.request(() => {
+				const details = createChangeEventDetails("trigger-press", nativeEvent);
+				if (nextOpen && pointerType === "touch" && touchOpenDelay > 0) touchOpenTimeout.start(touchOpenDelay, () => {
+					onOpenChange(true, details);
+				});
+				else onOpenChange(nextOpen, details);
+			});
+		},
+		onClick(event) {
+			if (eventOption === "mousedown-only") return;
+			const pointerType = pointerTypeRef.current;
+			if (eventOption === "mousedown" && pointerType) {
+				pointerTypeRef.current = void 0;
+				return;
+			}
+			if (isMouseLikePointerType(pointerType, true) && ignoreMouse) return;
+			const openEvent = dataRef.current.openEvent;
+			const openEventType = openEvent === null || openEvent === void 0 ? void 0 : openEvent.type;
+			const nextOpen = !(open && toggle && (openEvent && stickIfOpen ? openEventType === "click" || openEventType === "mousedown" || openEventType === "keydown" || openEventType === "keyup" : true));
+			const details = createChangeEventDetails("trigger-press", event.nativeEvent);
+			if (nextOpen && pointerType === "touch" && touchOpenDelay > 0) touchOpenTimeout.start(touchOpenDelay, () => {
+				onOpenChange(true, details);
+			});
+			else onOpenChange(nextOpen, details);
+		},
+		onKeyDown() {
+			pointerTypeRef.current = void 0;
+		}
+	}), [
+		dataRef,
+		eventOption,
+		ignoreMouse,
+		onOpenChange,
+		open,
+		stickIfOpen,
+		toggle,
+		frame,
+		touchOpenTimeout,
+		touchOpenDelay
+	]);
+	return React$1.useMemo(() => enabled ? { reference } : EMPTY_OBJECT, [enabled, reference]);
+}
+//#endregion
+//#region ../../node_modules/@floating-ui/core/dist/floating-ui.core.mjs
+function computeCoordsFromPlacement(_ref, placement, rtl) {
+	let { reference, floating } = _ref;
+	const sideAxis = getSideAxis(placement);
+	const alignmentAxis = getAlignmentAxis(placement);
+	const alignLength = getAxisLength(alignmentAxis);
+	const side = getSide(placement);
+	const isVertical = sideAxis === "y";
+	const commonX = reference.x + reference.width / 2 - floating.width / 2;
+	const commonY = reference.y + reference.height / 2 - floating.height / 2;
+	const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+	let coords;
+	switch (side) {
+		case "top":
+			coords = {
+				x: commonX,
+				y: reference.y - floating.height
+			};
+			break;
+		case "bottom":
+			coords = {
+				x: commonX,
+				y: reference.y + reference.height
+			};
+			break;
+		case "right":
+			coords = {
+				x: reference.x + reference.width,
+				y: commonY
+			};
+			break;
+		case "left":
+			coords = {
+				x: reference.x - floating.width,
+				y: commonY
+			};
+			break;
+		default: coords = {
+			x: reference.x,
+			y: reference.y
+		};
+	}
+	switch (getAlignment(placement)) {
+		case "start":
+			coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+			break;
+		case "end":
+			coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+			break;
+	}
+	return coords;
+}
+/**
+* Computes the `x` and `y` coordinates that will place the floating element
+* next to a given reference element.
+*
+* This export does not have any `platform` interface logic. You will need to
+* write one for the platform you are using Floating UI with.
+*/
+var computePosition$1 = async (reference, floating, config) => {
+	const { placement = "bottom", strategy = "absolute", middleware = [], platform } = config;
+	const validMiddleware = middleware.filter(Boolean);
+	const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
+	let rects = await platform.getElementRects({
+		reference,
+		floating,
+		strategy
+	});
+	let { x, y } = computeCoordsFromPlacement(rects, placement, rtl);
+	let statefulPlacement = placement;
+	let middlewareData = {};
+	let resetCount = 0;
+	for (let i = 0; i < validMiddleware.length; i++) {
+		const { name, fn } = validMiddleware[i];
+		const { x: nextX, y: nextY, data, reset } = await fn({
+			x,
+			y,
+			initialPlacement: placement,
+			placement: statefulPlacement,
+			strategy,
+			middlewareData,
+			rects,
+			platform,
+			elements: {
+				reference,
+				floating
+			}
+		});
+		x = nextX != null ? nextX : x;
+		y = nextY != null ? nextY : y;
+		middlewareData = {
+			...middlewareData,
+			[name]: {
+				...middlewareData[name],
+				...data
+			}
+		};
+		if (reset && resetCount <= 50) {
+			resetCount++;
+			if (typeof reset === "object") {
+				if (reset.placement) statefulPlacement = reset.placement;
+				if (reset.rects) rects = reset.rects === true ? await platform.getElementRects({
+					reference,
+					floating,
+					strategy
+				}) : reset.rects;
+				({x, y} = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+			}
+			i = -1;
+		}
+	}
+	return {
+		x,
+		y,
+		placement: statefulPlacement,
+		strategy,
+		middlewareData
+	};
+};
+/**
+* Resolves with an object of overflow side offsets that determine how much the
+* element is overflowing a given clipping boundary on each side.
+* - positive = overflowing the boundary by that number of pixels
+* - negative = how many pixels left before it will overflow
+* - 0 = lies flush with the boundary
+* @see https://floating-ui.com/docs/detectOverflow
+*/
+async function detectOverflow(state, options) {
+	var _await$platform$isEle;
+	if (options === void 0) options = {};
+	const { x, y, platform, rects, elements, strategy } = state;
+	const { boundary = "clippingAncestors", rootBoundary = "viewport", elementContext = "floating", altBoundary = false, padding = 0 } = evaluate(options, state);
+	const paddingObject = getPaddingObject(padding);
+	const element = elements[altBoundary ? elementContext === "floating" ? "reference" : "floating" : elementContext];
+	const clippingClientRect = rectToClientRect(await platform.getClippingRect({
+		element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating)),
+		boundary,
+		rootBoundary,
+		strategy
+	}));
+	const rect = elementContext === "floating" ? {
+		x,
+		y,
+		width: rects.floating.width,
+		height: rects.floating.height
+	} : rects.reference;
+	const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
+	const offsetScale = await (platform.isElement == null ? void 0 : platform.isElement(offsetParent)) ? await (platform.getScale == null ? void 0 : platform.getScale(offsetParent)) || {
+		x: 1,
+		y: 1
+	} : {
+		x: 1,
+		y: 1
+	};
+	const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+		elements,
+		rect,
+		offsetParent,
+		strategy
+	}) : rect);
+	return {
+		top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+		bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+		left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+		right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
+	};
+}
+/**
+* Optimizes the visibility of the floating element by flipping the `placement`
+* in order to keep it in view when the preferred placement(s) will overflow the
+* clipping boundary. Alternative to `autoPlacement`.
+* @see https://floating-ui.com/docs/flip
+*/
+var flip$2 = function(options) {
+	if (options === void 0) options = {};
+	return {
+		name: "flip",
+		options,
+		async fn(state) {
+			var _middlewareData$arrow, _middlewareData$flip;
+			const { placement, middlewareData, rects, initialPlacement, platform, elements } = state;
+			const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true, fallbackPlacements: specifiedFallbackPlacements, fallbackStrategy = "bestFit", fallbackAxisSideDirection = "none", flipAlignment = true, ...detectOverflowOptions } = evaluate(options, state);
+			if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) return {};
+			const side = getSide(placement);
+			const initialSideAxis = getSideAxis(initialPlacement);
+			const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+			const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+			const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+			const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
+			if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+			const placements = [initialPlacement, ...fallbackPlacements];
+			const overflow = await detectOverflow(state, detectOverflowOptions);
+			const overflows = [];
+			let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+			if (checkMainAxis) overflows.push(overflow[side]);
+			if (checkCrossAxis) {
+				const sides = getAlignmentSides(placement, rects, rtl);
+				overflows.push(overflow[sides[0]], overflow[sides[1]]);
+			}
+			overflowsData = [...overflowsData, {
+				placement,
+				overflows
+			}];
+			if (!overflows.every((side) => side <= 0)) {
+				var _middlewareData$flip2, _overflowsData$filter;
+				const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+				const nextPlacement = placements[nextIndex];
+				if (nextPlacement) {
+					if (!(checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false) || overflowsData.every((d) => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) return {
+						data: {
+							index: nextIndex,
+							overflows: overflowsData
+						},
+						reset: { placement: nextPlacement }
+					};
+				}
+				let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
+				if (!resetPlacement) switch (fallbackStrategy) {
+					case "bestFit": {
+						var _overflowsData$filter2;
+						const placement = (_overflowsData$filter2 = overflowsData.filter((d) => {
+							if (hasFallbackAxisSideDirection) {
+								const currentSideAxis = getSideAxis(d.placement);
+								return currentSideAxis === initialSideAxis || currentSideAxis === "y";
+							}
+							return true;
+						}).map((d) => [d.placement, d.overflows.filter((overflow) => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
+						if (placement) resetPlacement = placement;
+						break;
+					}
+					case "initialPlacement":
+						resetPlacement = initialPlacement;
+						break;
+				}
+				if (placement !== resetPlacement) return { reset: { placement: resetPlacement } };
+			}
+			return {};
+		}
+	};
+};
+function getSideOffsets(overflow, rect) {
+	return {
+		top: overflow.top - rect.height,
+		right: overflow.right - rect.width,
+		bottom: overflow.bottom - rect.height,
+		left: overflow.left - rect.width
+	};
+}
+function isAnySideFullyClipped(overflow) {
+	return sides.some((side) => overflow[side] >= 0);
+}
+/**
+* Provides data to hide the floating element in applicable situations, such as
+* when it is not in the same clipping context as the reference element.
+* @see https://floating-ui.com/docs/hide
+*/
+var hide$2 = function(options) {
+	if (options === void 0) options = {};
+	return {
+		name: "hide",
+		options,
+		async fn(state) {
+			const { rects } = state;
+			const { strategy = "referenceHidden", ...detectOverflowOptions } = evaluate(options, state);
+			switch (strategy) {
+				case "referenceHidden": {
+					const offsets = getSideOffsets(await detectOverflow(state, {
+						...detectOverflowOptions,
+						elementContext: "reference"
+					}), rects.reference);
+					return { data: {
+						referenceHiddenOffsets: offsets,
+						referenceHidden: isAnySideFullyClipped(offsets)
+					} };
+				}
+				case "escaped": {
+					const offsets = getSideOffsets(await detectOverflow(state, {
+						...detectOverflowOptions,
+						altBoundary: true
+					}), rects.floating);
+					return { data: {
+						escapedOffsets: offsets,
+						escaped: isAnySideFullyClipped(offsets)
+					} };
+				}
+				default: return {};
+			}
+		}
+	};
+};
+var originSides = /* @__PURE__ */ new Set(["left", "top"]);
+async function convertValueToCoords(state, options) {
+	const { placement, platform, elements } = state;
+	const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+	const side = getSide(placement);
+	const alignment = getAlignment(placement);
+	const isVertical = getSideAxis(placement) === "y";
+	const mainAxisMulti = originSides.has(side) ? -1 : 1;
+	const crossAxisMulti = rtl && isVertical ? -1 : 1;
+	const rawValue = evaluate(options, state);
+	let { mainAxis, crossAxis, alignmentAxis } = typeof rawValue === "number" ? {
+		mainAxis: rawValue,
+		crossAxis: 0,
+		alignmentAxis: null
+	} : {
+		mainAxis: rawValue.mainAxis || 0,
+		crossAxis: rawValue.crossAxis || 0,
+		alignmentAxis: rawValue.alignmentAxis
+	};
+	if (alignment && typeof alignmentAxis === "number") crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
+	return isVertical ? {
+		x: crossAxis * crossAxisMulti,
+		y: mainAxis * mainAxisMulti
+	} : {
+		x: mainAxis * mainAxisMulti,
+		y: crossAxis * crossAxisMulti
+	};
+}
+/**
+* Modifies the placement by translating the floating element along the
+* specified axes.
+* A number (shorthand for `mainAxis` or distance), or an axes configuration
+* object may be passed.
+* @see https://floating-ui.com/docs/offset
+*/
+var offset$2 = function(options) {
+	if (options === void 0) options = 0;
+	return {
+		name: "offset",
+		options,
+		async fn(state) {
+			var _middlewareData$offse, _middlewareData$arrow;
+			const { x, y, placement, middlewareData } = state;
+			const diffCoords = await convertValueToCoords(state, options);
+			if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) return {};
+			return {
+				x: x + diffCoords.x,
+				y: y + diffCoords.y,
+				data: {
+					...diffCoords,
+					placement
+				}
+			};
+		}
+	};
+};
+/**
+* Optimizes the visibility of the floating element by shifting it in order to
+* keep it in view when it will overflow the clipping boundary.
+* @see https://floating-ui.com/docs/shift
+*/
+var shift$2 = function(options) {
+	if (options === void 0) options = {};
+	return {
+		name: "shift",
+		options,
+		async fn(state) {
+			const { x, y, placement } = state;
+			const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = false, limiter = { fn: (_ref) => {
+				let { x, y } = _ref;
+				return {
+					x,
+					y
+				};
+			} }, ...detectOverflowOptions } = evaluate(options, state);
+			const coords = {
+				x,
+				y
+			};
+			const overflow = await detectOverflow(state, detectOverflowOptions);
+			const crossAxis = getSideAxis(getSide(placement));
+			const mainAxis = getOppositeAxis(crossAxis);
+			let mainAxisCoord = coords[mainAxis];
+			let crossAxisCoord = coords[crossAxis];
+			if (checkMainAxis) {
+				const minSide = mainAxis === "y" ? "top" : "left";
+				const maxSide = mainAxis === "y" ? "bottom" : "right";
+				const min = mainAxisCoord + overflow[minSide];
+				const max = mainAxisCoord - overflow[maxSide];
+				mainAxisCoord = clamp(min, mainAxisCoord, max);
+			}
+			if (checkCrossAxis) {
+				const minSide = crossAxis === "y" ? "top" : "left";
+				const maxSide = crossAxis === "y" ? "bottom" : "right";
+				const min = crossAxisCoord + overflow[minSide];
+				const max = crossAxisCoord - overflow[maxSide];
+				crossAxisCoord = clamp(min, crossAxisCoord, max);
+			}
+			const limitedCoords = limiter.fn({
+				...state,
+				[mainAxis]: mainAxisCoord,
+				[crossAxis]: crossAxisCoord
+			});
+			return {
+				...limitedCoords,
+				data: {
+					x: limitedCoords.x - x,
+					y: limitedCoords.y - y,
+					enabled: {
+						[mainAxis]: checkMainAxis,
+						[crossAxis]: checkCrossAxis
+					}
+				}
+			};
+		}
+	};
+};
+/**
+* Built-in `limiter` that will stop `shift()` at a certain point.
+*/
+var limitShift$2 = function(options) {
+	if (options === void 0) options = {};
+	return {
+		options,
+		fn(state) {
+			const { x, y, placement, rects, middlewareData } = state;
+			const { offset = 0, mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true } = evaluate(options, state);
+			const coords = {
+				x,
+				y
+			};
+			const crossAxis = getSideAxis(placement);
+			const mainAxis = getOppositeAxis(crossAxis);
+			let mainAxisCoord = coords[mainAxis];
+			let crossAxisCoord = coords[crossAxis];
+			const rawOffset = evaluate(offset, state);
+			const computedOffset = typeof rawOffset === "number" ? {
+				mainAxis: rawOffset,
+				crossAxis: 0
+			} : {
+				mainAxis: 0,
+				crossAxis: 0,
+				...rawOffset
+			};
+			if (checkMainAxis) {
+				const len = mainAxis === "y" ? "height" : "width";
+				const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
+				const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
+				if (mainAxisCoord < limitMin) mainAxisCoord = limitMin;
+				else if (mainAxisCoord > limitMax) mainAxisCoord = limitMax;
+			}
+			if (checkCrossAxis) {
+				var _middlewareData$offse, _middlewareData$offse2;
+				const len = mainAxis === "y" ? "width" : "height";
+				const isOriginSide = originSides.has(getSide(placement));
+				const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
+				const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
+				if (crossAxisCoord < limitMin) crossAxisCoord = limitMin;
+				else if (crossAxisCoord > limitMax) crossAxisCoord = limitMax;
+			}
+			return {
+				[mainAxis]: mainAxisCoord,
+				[crossAxis]: crossAxisCoord
+			};
+		}
+	};
+};
+/**
+* Provides data that allows you to change the size of the floating element —
+* for instance, prevent it from overflowing the clipping boundary or match the
+* width of the reference element.
+* @see https://floating-ui.com/docs/size
+*/
+var size$2 = function(options) {
+	if (options === void 0) options = {};
+	return {
+		name: "size",
+		options,
+		async fn(state) {
+			var _state$middlewareData, _state$middlewareData2;
+			const { placement, rects, platform, elements } = state;
+			const { apply = () => {}, ...detectOverflowOptions } = evaluate(options, state);
+			const overflow = await detectOverflow(state, detectOverflowOptions);
+			const side = getSide(placement);
+			const alignment = getAlignment(placement);
+			const isYAxis = getSideAxis(placement) === "y";
+			const { width, height } = rects.floating;
+			let heightSide;
+			let widthSide;
+			if (side === "top" || side === "bottom") {
+				heightSide = side;
+				widthSide = alignment === (await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right";
+			} else {
+				widthSide = side;
+				heightSide = alignment === "end" ? "top" : "bottom";
+			}
+			const maximumClippingHeight = height - overflow.top - overflow.bottom;
+			const maximumClippingWidth = width - overflow.left - overflow.right;
+			const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);
+			const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);
+			const noShift = !state.middlewareData.shift;
+			let availableHeight = overflowAvailableHeight;
+			let availableWidth = overflowAvailableWidth;
+			if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) availableWidth = maximumClippingWidth;
+			if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) availableHeight = maximumClippingHeight;
+			if (noShift && !alignment) {
+				const xMin = max(overflow.left, 0);
+				const xMax = max(overflow.right, 0);
+				const yMin = max(overflow.top, 0);
+				const yMax = max(overflow.bottom, 0);
+				if (isYAxis) availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
+				else availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
+			}
+			await apply({
+				...state,
+				availableWidth,
+				availableHeight
+			});
+			const nextDimensions = await platform.getDimensions(elements.floating);
+			if (width !== nextDimensions.width || height !== nextDimensions.height) return { reset: { rects: true } };
+			return {};
+		}
+	};
+};
+//#endregion
+//#region ../../node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
+function getCssDimensions(element) {
+	const css = getComputedStyle$1(element);
+	let width = parseFloat(css.width) || 0;
+	let height = parseFloat(css.height) || 0;
+	const hasOffset = isHTMLElement(element);
+	const offsetWidth = hasOffset ? element.offsetWidth : width;
+	const offsetHeight = hasOffset ? element.offsetHeight : height;
+	const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+	if (shouldFallback) {
+		width = offsetWidth;
+		height = offsetHeight;
+	}
+	return {
+		width,
+		height,
+		$: shouldFallback
+	};
+}
+function unwrapElement(element) {
+	return !isElement(element) ? element.contextElement : element;
+}
+function getScale(element) {
+	const domElement = unwrapElement(element);
+	if (!isHTMLElement(domElement)) return createCoords(1);
+	const rect = domElement.getBoundingClientRect();
+	const { width, height, $ } = getCssDimensions(domElement);
+	let x = ($ ? round(rect.width) : rect.width) / width;
+	let y = ($ ? round(rect.height) : rect.height) / height;
+	if (!x || !Number.isFinite(x)) x = 1;
+	if (!y || !Number.isFinite(y)) y = 1;
+	return {
+		x,
+		y
+	};
+}
+var noOffsets = /* @__PURE__ */ createCoords(0);
+function getVisualOffsets(element) {
+	const win = getWindow(element);
+	if (!isWebKit$1() || !win.visualViewport) return noOffsets;
+	return {
+		x: win.visualViewport.offsetLeft,
+		y: win.visualViewport.offsetTop
+	};
+}
+function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+	if (isFixed === void 0) isFixed = false;
+	if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) return false;
+	return isFixed;
+}
+function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+	if (includeScale === void 0) includeScale = false;
+	if (isFixedStrategy === void 0) isFixedStrategy = false;
+	const clientRect = element.getBoundingClientRect();
+	const domElement = unwrapElement(element);
+	let scale = createCoords(1);
+	if (includeScale) if (offsetParent) {
+		if (isElement(offsetParent)) scale = getScale(offsetParent);
+	} else scale = getScale(element);
+	const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+	let x = (clientRect.left + visualOffsets.x) / scale.x;
+	let y = (clientRect.top + visualOffsets.y) / scale.y;
+	let width = clientRect.width / scale.x;
+	let height = clientRect.height / scale.y;
+	if (domElement) {
+		const win = getWindow(domElement);
+		const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+		let currentWin = win;
+		let currentIFrame = getFrameElement(currentWin);
+		while (currentIFrame && offsetParent && offsetWin !== currentWin) {
+			const iframeScale = getScale(currentIFrame);
+			const iframeRect = currentIFrame.getBoundingClientRect();
+			const css = getComputedStyle$1(currentIFrame);
+			const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+			const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+			x *= iframeScale.x;
+			y *= iframeScale.y;
+			width *= iframeScale.x;
+			height *= iframeScale.y;
+			x += left;
+			y += top;
+			currentWin = getWindow(currentIFrame);
+			currentIFrame = getFrameElement(currentWin);
+		}
+	}
+	return rectToClientRect({
+		width,
+		height,
+		x,
+		y
+	});
+}
+function getWindowScrollBarX(element, rect) {
+	const leftScroll = getNodeScroll(element).scrollLeft;
+	if (!rect) return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+	return rect.left + leftScroll;
+}
+function getHTMLOffset(documentElement, scroll) {
+	const htmlRect = documentElement.getBoundingClientRect();
+	return {
+		x: htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect),
+		y: htmlRect.top + scroll.scrollTop
+	};
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+	let { elements, rect, offsetParent, strategy } = _ref;
+	const isFixed = strategy === "fixed";
+	const documentElement = getDocumentElement(offsetParent);
+	const topLayer = elements ? isTopLayer(elements.floating) : false;
+	if (offsetParent === documentElement || topLayer && isFixed) return rect;
+	let scroll = {
+		scrollLeft: 0,
+		scrollTop: 0
+	};
+	let scale = createCoords(1);
+	const offsets = createCoords(0);
+	const isOffsetParentAnElement = isHTMLElement(offsetParent);
+	if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+		if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) scroll = getNodeScroll(offsetParent);
+		if (isHTMLElement(offsetParent)) {
+			const offsetRect = getBoundingClientRect(offsetParent);
+			scale = getScale(offsetParent);
+			offsets.x = offsetRect.x + offsetParent.clientLeft;
+			offsets.y = offsetRect.y + offsetParent.clientTop;
+		}
+	}
+	const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+	return {
+		width: rect.width * scale.x,
+		height: rect.height * scale.y,
+		x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
+		y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
+	};
+}
+function getClientRects(element) {
+	return Array.from(element.getClientRects());
+}
+function getDocumentRect(element) {
+	const html = getDocumentElement(element);
+	const scroll = getNodeScroll(element);
+	const body = element.ownerDocument.body;
+	const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+	const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+	let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+	const y = -scroll.scrollTop;
+	if (getComputedStyle$1(body).direction === "rtl") x += max(html.clientWidth, body.clientWidth) - width;
+	return {
+		width,
+		height,
+		x,
+		y
+	};
+}
+var SCROLLBAR_MAX = 25;
+function getViewportRect(element, strategy) {
+	const win = getWindow(element);
+	const html = getDocumentElement(element);
+	const visualViewport = win.visualViewport;
+	let width = html.clientWidth;
+	let height = html.clientHeight;
+	let x = 0;
+	let y = 0;
+	if (visualViewport) {
+		width = visualViewport.width;
+		height = visualViewport.height;
+		const visualViewportBased = isWebKit$1();
+		if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
+			x = visualViewport.offsetLeft;
+			y = visualViewport.offsetTop;
+		}
+	}
+	const windowScrollbarX = getWindowScrollBarX(html);
+	if (windowScrollbarX <= 0) {
+		const doc = html.ownerDocument;
+		const body = doc.body;
+		const bodyStyles = getComputedStyle(body);
+		const bodyMarginInline = doc.compatMode === "CSS1Compat" ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
+		const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
+		if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) width -= clippingStableScrollbarWidth;
+	} else if (windowScrollbarX <= SCROLLBAR_MAX) width += windowScrollbarX;
+	return {
+		width,
+		height,
+		x,
+		y
+	};
+}
+var absoluteOrFixed = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function getInnerBoundingClientRect(element, strategy) {
+	const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
+	const top = clientRect.top + element.clientTop;
+	const left = clientRect.left + element.clientLeft;
+	const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+	return {
+		width: element.clientWidth * scale.x,
+		height: element.clientHeight * scale.y,
+		x: left * scale.x,
+		y: top * scale.y
+	};
+}
+function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+	let rect;
+	if (clippingAncestor === "viewport") rect = getViewportRect(element, strategy);
+	else if (clippingAncestor === "document") rect = getDocumentRect(getDocumentElement(element));
+	else if (isElement(clippingAncestor)) rect = getInnerBoundingClientRect(clippingAncestor, strategy);
+	else {
+		const visualOffsets = getVisualOffsets(element);
+		rect = {
+			x: clippingAncestor.x - visualOffsets.x,
+			y: clippingAncestor.y - visualOffsets.y,
+			width: clippingAncestor.width,
+			height: clippingAncestor.height
+		};
+	}
+	return rectToClientRect(rect);
+}
+function hasFixedPositionAncestor(element, stopNode) {
+	const parentNode = getParentNode(element);
+	if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) return false;
+	return getComputedStyle$1(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
+}
+function getClippingElementAncestors(element, cache) {
+	const cachedResult = cache.get(element);
+	if (cachedResult) return cachedResult;
+	let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
+	let currentContainingBlockComputedStyle = null;
+	const elementIsFixed = getComputedStyle$1(element).position === "fixed";
+	let currentNode = elementIsFixed ? getParentNode(element) : element;
+	while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
+		const computedStyle = getComputedStyle$1(currentNode);
+		const currentNodeIsContaining = isContainingBlock(currentNode);
+		if (!currentNodeIsContaining && computedStyle.position === "fixed") currentContainingBlockComputedStyle = null;
+		if (elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && absoluteOrFixed.has(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode)) result = result.filter((ancestor) => ancestor !== currentNode);
+		else currentContainingBlockComputedStyle = computedStyle;
+		currentNode = getParentNode(currentNode);
+	}
+	cache.set(element, result);
+	return result;
+}
+function getClippingRect(_ref) {
+	let { element, boundary, rootBoundary, strategy } = _ref;
+	const clippingAncestors = [...boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary), rootBoundary];
+	const firstClippingAncestor = clippingAncestors[0];
+	const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
+		const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
+		accRect.top = max(rect.top, accRect.top);
+		accRect.right = min(rect.right, accRect.right);
+		accRect.bottom = min(rect.bottom, accRect.bottom);
+		accRect.left = max(rect.left, accRect.left);
+		return accRect;
+	}, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+	return {
+		width: clippingRect.right - clippingRect.left,
+		height: clippingRect.bottom - clippingRect.top,
+		x: clippingRect.left,
+		y: clippingRect.top
+	};
+}
+function getDimensions(element) {
+	const { width, height } = getCssDimensions(element);
+	return {
+		width,
+		height
+	};
+}
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+	const isOffsetParentAnElement = isHTMLElement(offsetParent);
+	const documentElement = getDocumentElement(offsetParent);
+	const isFixed = strategy === "fixed";
+	const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
+	let scroll = {
+		scrollLeft: 0,
+		scrollTop: 0
+	};
+	const offsets = createCoords(0);
+	function setLeftRTLScrollbarOffset() {
+		offsets.x = getWindowScrollBarX(documentElement);
+	}
+	if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+		if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) scroll = getNodeScroll(offsetParent);
+		if (isOffsetParentAnElement) {
+			const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
+			offsets.x = offsetRect.x + offsetParent.clientLeft;
+			offsets.y = offsetRect.y + offsetParent.clientTop;
+		} else if (documentElement) setLeftRTLScrollbarOffset();
+	}
+	if (isFixed && !isOffsetParentAnElement && documentElement) setLeftRTLScrollbarOffset();
+	const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+	return {
+		x: rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x,
+		y: rect.top + scroll.scrollTop - offsets.y - htmlOffset.y,
+		width: rect.width,
+		height: rect.height
+	};
+}
+function isStaticPositioned(element) {
+	return getComputedStyle$1(element).position === "static";
+}
+function getTrueOffsetParent(element, polyfill) {
+	if (!isHTMLElement(element) || getComputedStyle$1(element).position === "fixed") return null;
+	if (polyfill) return polyfill(element);
+	let rawOffsetParent = element.offsetParent;
+	if (getDocumentElement(element) === rawOffsetParent) rawOffsetParent = rawOffsetParent.ownerDocument.body;
+	return rawOffsetParent;
+}
+function getOffsetParent(element, polyfill) {
+	const win = getWindow(element);
+	if (isTopLayer(element)) return win;
+	if (!isHTMLElement(element)) {
+		let svgOffsetParent = getParentNode(element);
+		while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
+			if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) return svgOffsetParent;
+			svgOffsetParent = getParentNode(svgOffsetParent);
+		}
+		return win;
+	}
+	let offsetParent = getTrueOffsetParent(element, polyfill);
+	while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+	if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) return win;
+	return offsetParent || getContainingBlock(element) || win;
+}
+var getElementRects = async function(data) {
+	const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+	const getDimensionsFn = this.getDimensions;
+	const floatingDimensions = await getDimensionsFn(data.floating);
+	return {
+		reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
+		floating: {
+			x: 0,
+			y: 0,
+			width: floatingDimensions.width,
+			height: floatingDimensions.height
+		}
+	};
+};
+function isRTL(element) {
+	return getComputedStyle$1(element).direction === "rtl";
+}
+var platform = {
+	convertOffsetParentRelativeRectToViewportRelativeRect,
+	getDocumentElement,
+	getClippingRect,
+	getOffsetParent,
+	getElementRects,
+	getClientRects,
+	getDimensions,
+	getScale,
+	isElement,
+	isRTL
+};
+function rectsAreEqual(a, b) {
+	return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+function observeMove(element, onMove) {
+	let io = null;
+	let timeoutId;
+	const root = getDocumentElement(element);
+	function cleanup() {
+		var _io;
+		clearTimeout(timeoutId);
+		(_io = io) == null || _io.disconnect();
+		io = null;
+	}
+	function refresh(skip, threshold) {
+		if (skip === void 0) skip = false;
+		if (threshold === void 0) threshold = 1;
+		cleanup();
+		const elementRectForRootMargin = element.getBoundingClientRect();
+		const { left, top, width, height } = elementRectForRootMargin;
+		if (!skip) onMove();
+		if (!width || !height) return;
+		const insetTop = floor(top);
+		const insetRight = floor(root.clientWidth - (left + width));
+		const insetBottom = floor(root.clientHeight - (top + height));
+		const insetLeft = floor(left);
+		const options = {
+			rootMargin: -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px",
+			threshold: max(0, min(1, threshold)) || 1
+		};
+		let isFirstUpdate = true;
+		function handleObserve(entries) {
+			const ratio = entries[0].intersectionRatio;
+			if (ratio !== threshold) {
+				if (!isFirstUpdate) return refresh();
+				if (!ratio) timeoutId = setTimeout(() => {
+					refresh(false, 1e-7);
+				}, 1e3);
+				else refresh(false, ratio);
+			}
+			if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) refresh();
+			isFirstUpdate = false;
+		}
+		try {
+			io = new IntersectionObserver(handleObserve, {
+				...options,
+				root: root.ownerDocument
+			});
+		} catch (_e) {
+			io = new IntersectionObserver(handleObserve, options);
+		}
+		io.observe(element);
+	}
+	refresh(true);
+	return cleanup;
+}
+/**
+* Automatically updates the position of the floating element when necessary.
+* Should only be called when the floating element is mounted on the DOM or
+* visible on the screen.
+* @returns cleanup function that should be invoked when the floating element is
+* removed from the DOM or hidden from the screen.
+* @see https://floating-ui.com/docs/autoUpdate
+*/
+function autoUpdate(reference, floating, update, options) {
+	if (options === void 0) options = {};
+	const { ancestorScroll = true, ancestorResize = true, elementResize = typeof ResizeObserver === "function", layoutShift = typeof IntersectionObserver === "function", animationFrame = false } = options;
+	const referenceEl = unwrapElement(reference);
+	const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
+	ancestors.forEach((ancestor) => {
+		ancestorScroll && ancestor.addEventListener("scroll", update, { passive: true });
+		ancestorResize && ancestor.addEventListener("resize", update);
+	});
+	const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+	let reobserveFrame = -1;
+	let resizeObserver = null;
+	if (elementResize) {
+		resizeObserver = new ResizeObserver((_ref) => {
+			let [firstEntry] = _ref;
+			if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
+				resizeObserver.unobserve(floating);
+				cancelAnimationFrame(reobserveFrame);
+				reobserveFrame = requestAnimationFrame(() => {
+					var _resizeObserver;
+					(_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
+				});
+			}
+			update();
+		});
+		if (referenceEl && !animationFrame) resizeObserver.observe(referenceEl);
+		resizeObserver.observe(floating);
+	}
+	let frameId;
+	let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+	if (animationFrame) frameLoop();
+	function frameLoop() {
+		const nextRefRect = getBoundingClientRect(reference);
+		if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) update();
+		prevRefRect = nextRefRect;
+		frameId = requestAnimationFrame(frameLoop);
+	}
+	update();
+	return () => {
+		var _resizeObserver2;
+		ancestors.forEach((ancestor) => {
+			ancestorScroll && ancestor.removeEventListener("scroll", update);
+			ancestorResize && ancestor.removeEventListener("resize", update);
+		});
+		cleanupIo == null || cleanupIo();
+		(_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
+		resizeObserver = null;
+		if (animationFrame) cancelAnimationFrame(frameId);
+	};
+}
+/**
+* Modifies the placement by translating the floating element along the
+* specified axes.
+* A number (shorthand for `mainAxis` or distance), or an axes configuration
+* object may be passed.
+* @see https://floating-ui.com/docs/offset
+*/
+var offset$1 = offset$2;
+/**
+* Optimizes the visibility of the floating element by shifting it in order to
+* keep it in view when it will overflow the clipping boundary.
+* @see https://floating-ui.com/docs/shift
+*/
+var shift$1 = shift$2;
+/**
+* Optimizes the visibility of the floating element by flipping the `placement`
+* in order to keep it in view when the preferred placement(s) will overflow the
+* clipping boundary. Alternative to `autoPlacement`.
+* @see https://floating-ui.com/docs/flip
+*/
+var flip$1 = flip$2;
+/**
+* Provides data that allows you to change the size of the floating element —
+* for instance, prevent it from overflowing the clipping boundary or match the
+* width of the reference element.
+* @see https://floating-ui.com/docs/size
+*/
+var size$1 = size$2;
+/**
+* Provides data to hide the floating element in applicable situations, such as
+* when it is not in the same clipping context as the reference element.
+* @see https://floating-ui.com/docs/hide
+*/
+var hide$1 = hide$2;
+/**
+* Built-in `limiter` that will stop `shift()` at a certain point.
+*/
+var limitShift$1 = limitShift$2;
+/**
+* Computes the `x` and `y` coordinates that will place the floating element
+* next to a given reference element.
+*/
+var computePosition = (reference, floating, options) => {
+	const cache = /* @__PURE__ */ new Map();
+	const mergedOptions = {
+		platform,
+		...options
+	};
+	const platformWithCache = {
+		...mergedOptions.platform,
+		_c: cache
+	};
+	return computePosition$1(reference, floating, {
+		...mergedOptions,
+		platform: platformWithCache
+	});
+};
+//#endregion
+//#region ../../node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs
+var index = typeof document !== "undefined" ? useLayoutEffect : function noop() {};
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (typeof a === "function" && a.toString() === b.toString()) return true;
+	let length;
+	let i;
+	let keys;
+	if (a && b && typeof a === "object") {
+		if (Array.isArray(a)) {
+			length = a.length;
+			if (length !== b.length) return false;
+			for (i = length; i-- !== 0;) if (!deepEqual(a[i], b[i])) return false;
+			return true;
+		}
+		keys = Object.keys(a);
+		length = keys.length;
+		if (length !== Object.keys(b).length) return false;
+		for (i = length; i-- !== 0;) if (!{}.hasOwnProperty.call(b, keys[i])) return false;
+		for (i = length; i-- !== 0;) {
+			const key = keys[i];
+			if (key === "_owner" && a.$$typeof) continue;
+			if (!deepEqual(a[key], b[key])) return false;
+		}
+		return true;
+	}
+	return a !== a && b !== b;
+}
+function getDPR(element) {
+	if (typeof window === "undefined") return 1;
+	return (element.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function roundByDPR(element, value) {
+	const dpr = getDPR(element);
+	return Math.round(value * dpr) / dpr;
+}
+function useLatestRef(value) {
+	const ref = React$1.useRef(value);
+	index(() => {
+		ref.current = value;
+	});
+	return ref;
+}
+/**
+* Provides data to position a floating element.
+* @see https://floating-ui.com/docs/useFloating
+*/
+function useFloating(options) {
+	if (options === void 0) options = {};
+	const { placement = "bottom", strategy = "absolute", middleware = [], platform, elements: { reference: externalReference, floating: externalFloating } = {}, transform = true, whileElementsMounted, open } = options;
+	const [data, setData] = React$1.useState({
+		x: 0,
+		y: 0,
+		strategy,
+		placement,
+		middlewareData: {},
+		isPositioned: false
+	});
+	const [latestMiddleware, setLatestMiddleware] = React$1.useState(middleware);
+	if (!deepEqual(latestMiddleware, middleware)) setLatestMiddleware(middleware);
+	const [_reference, _setReference] = React$1.useState(null);
+	const [_floating, _setFloating] = React$1.useState(null);
+	const setReference = React$1.useCallback((node) => {
+		if (node !== referenceRef.current) {
+			referenceRef.current = node;
+			_setReference(node);
+		}
+	}, []);
+	const setFloating = React$1.useCallback((node) => {
+		if (node !== floatingRef.current) {
+			floatingRef.current = node;
+			_setFloating(node);
+		}
+	}, []);
+	const referenceEl = externalReference || _reference;
+	const floatingEl = externalFloating || _floating;
+	const referenceRef = React$1.useRef(null);
+	const floatingRef = React$1.useRef(null);
+	const dataRef = React$1.useRef(data);
+	const hasWhileElementsMounted = whileElementsMounted != null;
+	const whileElementsMountedRef = useLatestRef(whileElementsMounted);
+	const platformRef = useLatestRef(platform);
+	const openRef = useLatestRef(open);
+	const update = React$1.useCallback(() => {
+		if (!referenceRef.current || !floatingRef.current) return;
+		const config = {
+			placement,
+			strategy,
+			middleware: latestMiddleware
+		};
+		if (platformRef.current) config.platform = platformRef.current;
+		computePosition(referenceRef.current, floatingRef.current, config).then((data) => {
+			const fullData = {
+				...data,
+				isPositioned: openRef.current !== false
+			};
+			if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
+				dataRef.current = fullData;
+				ReactDOM$1.flushSync(() => {
+					setData(fullData);
+				});
+			}
+		});
+	}, [
+		latestMiddleware,
+		placement,
+		strategy,
+		platformRef,
+		openRef
+	]);
+	index(() => {
+		if (open === false && dataRef.current.isPositioned) {
+			dataRef.current.isPositioned = false;
+			setData((data) => ({
+				...data,
+				isPositioned: false
+			}));
+		}
+	}, [open]);
+	const isMountedRef = React$1.useRef(false);
+	index(() => {
+		isMountedRef.current = true;
+		return () => {
+			isMountedRef.current = false;
+		};
+	}, []);
+	index(() => {
+		if (referenceEl) referenceRef.current = referenceEl;
+		if (floatingEl) floatingRef.current = floatingEl;
+		if (referenceEl && floatingEl) {
+			if (whileElementsMountedRef.current) return whileElementsMountedRef.current(referenceEl, floatingEl, update);
+			update();
+		}
+	}, [
+		referenceEl,
+		floatingEl,
+		update,
+		whileElementsMountedRef,
+		hasWhileElementsMounted
+	]);
+	const refs = React$1.useMemo(() => ({
+		reference: referenceRef,
+		floating: floatingRef,
+		setReference,
+		setFloating
+	}), [setReference, setFloating]);
+	const elements = React$1.useMemo(() => ({
+		reference: referenceEl,
+		floating: floatingEl
+	}), [referenceEl, floatingEl]);
+	const floatingStyles = React$1.useMemo(() => {
+		const initialStyles = {
+			position: strategy,
+			left: 0,
+			top: 0
+		};
+		if (!elements.floating) return initialStyles;
+		const x = roundByDPR(elements.floating, data.x);
+		const y = roundByDPR(elements.floating, data.y);
+		if (transform) return {
+			...initialStyles,
+			transform: "translate(" + x + "px, " + y + "px)",
+			...getDPR(elements.floating) >= 1.5 && { willChange: "transform" }
+		};
+		return {
+			position: strategy,
+			left: x,
+			top: y
+		};
+	}, [
+		strategy,
+		transform,
+		elements.floating,
+		data.x,
+		data.y
+	]);
+	return React$1.useMemo(() => ({
+		...data,
+		update,
+		refs,
+		elements,
+		floatingStyles
+	}), [
+		data,
+		update,
+		refs,
+		elements,
+		floatingStyles
+	]);
+}
+/**
+* Modifies the placement by translating the floating element along the
+* specified axes.
+* A number (shorthand for `mainAxis` or distance), or an axes configuration
+* object may be passed.
+* @see https://floating-ui.com/docs/offset
+*/
+var offset = (options, deps) => ({
+	...offset$1(options),
+	options: [options, deps]
+});
+/**
+* Optimizes the visibility of the floating element by shifting it in order to
+* keep it in view when it will overflow the clipping boundary.
+* @see https://floating-ui.com/docs/shift
+*/
+var shift = (options, deps) => ({
+	...shift$1(options),
+	options: [options, deps]
+});
+/**
+* Built-in `limiter` that will stop `shift()` at a certain point.
+*/
+var limitShift = (options, deps) => ({
+	...limitShift$1(options),
+	options: [options, deps]
+});
+/**
+* Optimizes the visibility of the floating element by flipping the `placement`
+* in order to keep it in view when the preferred placement(s) will overflow the
+* clipping boundary. Alternative to `autoPlacement`.
+* @see https://floating-ui.com/docs/flip
+*/
+var flip = (options, deps) => ({
+	...flip$1(options),
+	options: [options, deps]
+});
+/**
+* Provides data that allows you to change the size of the floating element —
+* for instance, prevent it from overflowing the clipping boundary or match the
+* width of the reference element.
+* @see https://floating-ui.com/docs/size
+*/
+var size = (options, deps) => ({
+	...size$1(options),
+	options: [options, deps]
+});
+/**
+* Provides data to hide the floating element in applicable situations, such as
+* when it is not in the same clipping context as the reference element.
+* @see https://floating-ui.com/docs/hide
+*/
+var hide = (options, deps) => ({
+	...hide$1(options),
+	options: [options, deps]
+});
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/hooks/useDismiss.js
+var bubbleHandlerKeys = {
+	intentional: "onClick",
+	sloppy: "onPointerDown"
+};
+function normalizeProp(normalizable) {
+	var _normalizable$escapeK, _normalizable$outside;
+	return {
+		escapeKey: typeof normalizable === "boolean" ? normalizable : (_normalizable$escapeK = normalizable === null || normalizable === void 0 ? void 0 : normalizable.escapeKey) !== null && _normalizable$escapeK !== void 0 ? _normalizable$escapeK : false,
+		outsidePress: typeof normalizable === "boolean" ? normalizable : (_normalizable$outside = normalizable === null || normalizable === void 0 ? void 0 : normalizable.outsidePress) !== null && _normalizable$outside !== void 0 ? _normalizable$outside : true
+	};
+}
+/**
+* Closes the floating element when a dismissal is requested — by default, when
+* the user presses the `escape` key or outside of the floating element.
+* @see https://floating-ui.com/docs/useDismiss
+*/
+function useDismiss(context, props = {}) {
+	const { open, onOpenChange, elements, dataRef } = context;
+	const { enabled = true, escapeKey = true, outsidePress: outsidePressProp = true, outsidePressEvent = "sloppy", referencePress = false, referencePressEvent = "sloppy", ancestorScroll = false, bubbles, capture } = props;
+	const tree = useFloatingTree();
+	const outsidePressFn = useEventCallback(typeof outsidePressProp === "function" ? outsidePressProp : () => false);
+	const outsidePress = typeof outsidePressProp === "function" ? outsidePressFn : outsidePressProp;
+	const endedOrStartedInsideRef = React$1.useRef(false);
+	const { escapeKey: escapeKeyBubbles, outsidePress: outsidePressBubbles } = normalizeProp(bubbles);
+	const { escapeKey: escapeKeyCapture, outsidePress: outsidePressCapture } = normalizeProp(capture);
+	const touchStateRef = React$1.useRef(null);
+	const cancelDismissOnEndTimeout = useTimeout();
+	const insideReactTreeTimeout = useTimeout();
+	const isComposingRef = React$1.useRef(false);
+	const currentPointerTypeRef = React$1.useRef("");
+	const trackPointerType = useEventCallback((event) => {
+		currentPointerTypeRef.current = event.pointerType;
+	});
+	const getOutsidePressEvent = useEventCallback(() => {
+		const type = currentPointerTypeRef.current;
+		const computedType = type === "pen" || !type ? "mouse" : type;
+		const resolved = typeof outsidePressEvent === "function" ? outsidePressEvent() : outsidePressEvent;
+		if (typeof resolved === "string") return resolved;
+		return resolved[computedType];
+	});
+	const closeOnEscapeKeyDown = useEventCallback((event) => {
+		var _dataRef$current$floa;
+		if (!open || !enabled || !escapeKey || event.key !== "Escape") return;
+		if (isComposingRef.current) return;
+		const nodeId = (_dataRef$current$floa = dataRef.current.floatingContext) === null || _dataRef$current$floa === void 0 ? void 0 : _dataRef$current$floa.nodeId;
+		const children = tree ? getNodeChildren(tree.nodesRef.current, nodeId) : [];
+		if (!escapeKeyBubbles) {
+			if (children.length > 0) {
+				let shouldDismiss = true;
+				children.forEach((child) => {
+					var _child$context;
+					if (((_child$context = child.context) === null || _child$context === void 0 ? void 0 : _child$context.open) && !child.context.dataRef.current.__escapeKeyBubbles) shouldDismiss = false;
+				});
+				if (!shouldDismiss) return;
+			}
+		}
+		const eventDetails = createChangeEventDetails("escape-key", isReactEvent(event) ? event.nativeEvent : event);
+		onOpenChange(false, eventDetails);
+		if (!escapeKeyBubbles && !eventDetails.isPropagationAllowed) event.stopPropagation();
+	});
+	const shouldIgnoreEvent = useEventCallback((event) => {
+		const computedOutsidePressEvent = getOutsidePressEvent();
+		return computedOutsidePressEvent === "intentional" && event.type !== "click" || computedOutsidePressEvent === "sloppy" && event.type === "click";
+	});
+	const closeOnEscapeKeyDownCapture = useEventCallback((event) => {
+		var _getTarget2;
+		const callback = () => {
+			var _getTarget;
+			closeOnEscapeKeyDown(event);
+			(_getTarget = getTarget(event)) === null || _getTarget === void 0 || _getTarget.removeEventListener("keydown", callback);
+		};
+		(_getTarget2 = getTarget(event)) === null || _getTarget2 === void 0 || _getTarget2.addEventListener("keydown", callback);
+	});
+	const closeOnPressOutside = useEventCallback((event, endedOrStartedInside = false) => {
+		var _dataRef$current$floa2;
+		if (shouldIgnoreEvent(event)) return;
+		const insideReactTree = dataRef.current.insideReactTree;
+		dataRef.current.insideReactTree = false;
+		if (getOutsidePressEvent() === "intentional" && endedOrStartedInside) return;
+		if (insideReactTree) return;
+		if (typeof outsidePress === "function" && !outsidePress(event)) return;
+		const target = getTarget(event);
+		const inertSelector = `[${createAttribute("inert")}]`;
+		const markers = getDocument(elements.floating).querySelectorAll(inertSelector);
+		let targetRootAncestor = isElement(target) ? target : null;
+		while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {
+			const nextParent = getParentNode(targetRootAncestor);
+			if (isLastTraversableNode(nextParent) || !isElement(nextParent)) break;
+			targetRootAncestor = nextParent;
+		}
+		if (markers.length && isElement(target) && !isRootElement(target) && !contains(target, elements.floating) && Array.from(markers).every((marker) => !contains(targetRootAncestor, marker))) return;
+		if (isHTMLElement(target)) {
+			const lastTraversableNode = isLastTraversableNode(target);
+			const style = getComputedStyle$1(target);
+			const scrollRe = /auto|scroll/;
+			const isScrollableX = lastTraversableNode || scrollRe.test(style.overflowX);
+			const isScrollableY = lastTraversableNode || scrollRe.test(style.overflowY);
+			const canScrollX = isScrollableX && target.clientWidth > 0 && target.scrollWidth > target.clientWidth;
+			const canScrollY = isScrollableY && target.clientHeight > 0 && target.scrollHeight > target.clientHeight;
+			const isRTL = style.direction === "rtl";
+			const pressedVerticalScrollbar = canScrollY && (isRTL ? event.offsetX <= target.offsetWidth - target.clientWidth : event.offsetX > target.clientWidth);
+			const pressedHorizontalScrollbar = canScrollX && event.offsetY > target.clientHeight;
+			if (pressedVerticalScrollbar || pressedHorizontalScrollbar) return;
+		}
+		const nodeId = (_dataRef$current$floa2 = dataRef.current.floatingContext) === null || _dataRef$current$floa2 === void 0 ? void 0 : _dataRef$current$floa2.nodeId;
+		const targetIsInsideChildren = tree && getNodeChildren(tree.nodesRef.current, nodeId).some((node) => {
+			var _node$context;
+			return isEventTargetWithin(event, (_node$context = node.context) === null || _node$context === void 0 ? void 0 : _node$context.elements.floating);
+		});
+		if (isEventTargetWithin(event, elements.floating) || isEventTargetWithin(event, elements.domReference) || targetIsInsideChildren) return;
+		const children = tree ? getNodeChildren(tree.nodesRef.current, nodeId) : [];
+		if (children.length > 0) {
+			let shouldDismiss = true;
+			children.forEach((child) => {
+				var _child$context2;
+				if (((_child$context2 = child.context) === null || _child$context2 === void 0 ? void 0 : _child$context2.open) && !child.context.dataRef.current.__outsidePressBubbles) shouldDismiss = false;
+			});
+			if (!shouldDismiss) return;
+		}
+		onOpenChange(false, createChangeEventDetails("outside-press", event));
+	});
+	const handlePointerDown = useEventCallback((event) => {
+		if (getOutsidePressEvent() !== "sloppy" || !open || !enabled || isEventTargetWithin(event, elements.floating) || isEventTargetWithin(event, elements.domReference)) return;
+		if (event.pointerType === "touch") {
+			touchStateRef.current = {
+				startTime: Date.now(),
+				startX: event.clientX,
+				startY: event.clientY,
+				dismissOnPointerUp: false,
+				dismissOnMouseDown: true
+			};
+			cancelDismissOnEndTimeout.start(1e3, () => {
+				if (touchStateRef.current) {
+					touchStateRef.current.dismissOnPointerUp = false;
+					touchStateRef.current.dismissOnMouseDown = false;
+				}
+			});
+			return;
+		}
+		closeOnPressOutside(event);
+	});
+	const closeOnPressOutsideCapture = useEventCallback((event) => {
+		var _getTarget4;
+		const endedOrStartedInside = endedOrStartedInsideRef.current;
+		endedOrStartedInsideRef.current = false;
+		if (shouldIgnoreEvent(event)) return;
+		cancelDismissOnEndTimeout.clear();
+		if (event.type === "mousedown" && touchStateRef.current && !touchStateRef.current.dismissOnMouseDown) return;
+		const callback = () => {
+			var _getTarget3;
+			if (event.type === "pointerdown") handlePointerDown(event);
+			else closeOnPressOutside(event, endedOrStartedInside);
+			(_getTarget3 = getTarget(event)) === null || _getTarget3 === void 0 || _getTarget3.removeEventListener(event.type, callback);
+		};
+		(_getTarget4 = getTarget(event)) === null || _getTarget4 === void 0 || _getTarget4.addEventListener(event.type, callback);
+	});
+	const handlePointerMove = useEventCallback((event) => {
+		if (getOutsidePressEvent() !== "sloppy" || event.pointerType !== "touch" || !touchStateRef.current || isEventTargetWithin(event, elements.floating) || isEventTargetWithin(event, elements.domReference)) return;
+		const deltaX = Math.abs(event.clientX - touchStateRef.current.startX);
+		const deltaY = Math.abs(event.clientY - touchStateRef.current.startY);
+		const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+		if (distance > 5) touchStateRef.current.dismissOnPointerUp = true;
+		if (distance > 10) {
+			closeOnPressOutside(event);
+			cancelDismissOnEndTimeout.clear();
+			touchStateRef.current = null;
+		}
+	});
+	const handlePointerUp = useEventCallback((event) => {
+		if (getOutsidePressEvent() !== "sloppy" || event.pointerType !== "touch" || !touchStateRef.current || isEventTargetWithin(event, elements.floating) || isEventTargetWithin(event, elements.domReference)) return;
+		if (touchStateRef.current.dismissOnPointerUp) closeOnPressOutside(event);
+		cancelDismissOnEndTimeout.clear();
+		touchStateRef.current = null;
+	});
+	React$1.useEffect(() => {
+		if (!open || !enabled) return;
+		dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
+		dataRef.current.__outsidePressBubbles = outsidePressBubbles;
+		const compositionTimeout = new Timeout();
+		function onScroll(event) {
+			onOpenChange(false, createChangeEventDetails("none", event));
+		}
+		function handleCompositionStart() {
+			compositionTimeout.clear();
+			isComposingRef.current = true;
+		}
+		function handleCompositionEnd() {
+			compositionTimeout.start(isWebKit$1() ? 5 : 0, () => {
+				isComposingRef.current = false;
+			});
+		}
+		const doc = getDocument(elements.floating);
+		doc.addEventListener("pointerdown", trackPointerType, true);
+		if (escapeKey) {
+			doc.addEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
+			doc.addEventListener("compositionstart", handleCompositionStart);
+			doc.addEventListener("compositionend", handleCompositionEnd);
+		}
+		if (outsidePress) {
+			doc.addEventListener("click", outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
+			doc.addEventListener("pointerdown", outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
+			doc.addEventListener("pointermove", handlePointerMove, outsidePressCapture);
+			doc.addEventListener("pointerup", handlePointerUp, outsidePressCapture);
+			doc.addEventListener("mousedown", closeOnPressOutsideCapture, outsidePressCapture);
+		}
+		let ancestors = [];
+		if (ancestorScroll) {
+			if (isElement(elements.domReference)) ancestors = getOverflowAncestors(elements.domReference);
+			if (isElement(elements.floating)) ancestors = ancestors.concat(getOverflowAncestors(elements.floating));
+			if (!isElement(elements.reference) && elements.reference && elements.reference.contextElement) ancestors = ancestors.concat(getOverflowAncestors(elements.reference.contextElement));
+		}
+		ancestors = ancestors.filter((ancestor) => {
+			var _doc$defaultView;
+			return ancestor !== ((_doc$defaultView = doc.defaultView) === null || _doc$defaultView === void 0 ? void 0 : _doc$defaultView.visualViewport);
+		});
+		ancestors.forEach((ancestor) => {
+			ancestor.addEventListener("scroll", onScroll, { passive: true });
+		});
+		return () => {
+			doc.removeEventListener("pointerdown", trackPointerType, true);
+			if (escapeKey) {
+				doc.removeEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
+				doc.removeEventListener("compositionstart", handleCompositionStart);
+				doc.removeEventListener("compositionend", handleCompositionEnd);
+			}
+			if (outsidePress) {
+				doc.removeEventListener("click", outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
+				doc.removeEventListener("pointerdown", outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
+				doc.removeEventListener("pointermove", handlePointerMove, outsidePressCapture);
+				doc.removeEventListener("pointerup", handlePointerUp, outsidePressCapture);
+				doc.removeEventListener("mousedown", closeOnPressOutsideCapture, outsidePressCapture);
+			}
+			ancestors.forEach((ancestor) => {
+				ancestor.removeEventListener("scroll", onScroll);
+			});
+			compositionTimeout.clear();
+		};
+	}, [
+		dataRef,
+		elements,
+		escapeKey,
+		outsidePress,
+		open,
+		onOpenChange,
+		ancestorScroll,
+		enabled,
+		escapeKeyBubbles,
+		outsidePressBubbles,
+		closeOnEscapeKeyDown,
+		escapeKeyCapture,
+		closeOnEscapeKeyDownCapture,
+		closeOnPressOutside,
+		outsidePressCapture,
+		closeOnPressOutsideCapture,
+		handlePointerDown,
+		handlePointerMove,
+		handlePointerUp,
+		trackPointerType
+	]);
+	React$1.useEffect(() => {
+		dataRef.current.insideReactTree = false;
+	}, [dataRef, outsidePress]);
+	const reference = React$1.useMemo(() => ({
+		onKeyDown: closeOnEscapeKeyDown,
+		...referencePress && {
+			[bubbleHandlerKeys[referencePressEvent]]: (event) => {
+				onOpenChange(false, createChangeEventDetails("trigger-press", event.nativeEvent));
+			},
+			...referencePressEvent !== "intentional" && { onClick(event) {
+				onOpenChange(false, createChangeEventDetails("trigger-press", event.nativeEvent));
+			} }
+		}
+	}), [
+		closeOnEscapeKeyDown,
+		onOpenChange,
+		referencePress,
+		referencePressEvent
+	]);
+	const handlePressedInside = useEventCallback((event) => {
+		const target = getTarget(event.nativeEvent);
+		if (!contains(elements.floating, target) || event.button !== 0) return;
+		endedOrStartedInsideRef.current = true;
+	});
+	const handleCaptureInside = useEventCallback(() => {
+		dataRef.current.insideReactTree = true;
+		insideReactTreeTimeout.start(0, () => {
+			dataRef.current.insideReactTree = false;
+		});
+	});
+	const floating = React$1.useMemo(() => ({
+		onKeyDown: closeOnEscapeKeyDown,
+		onMouseDown: handlePressedInside,
+		onMouseUp: handlePressedInside,
+		onPointerDownCapture: handleCaptureInside,
+		onMouseDownCapture: handleCaptureInside,
+		onClickCapture: handleCaptureInside,
+		onMouseUpCapture: handleCaptureInside
+	}), [
+		closeOnEscapeKeyDown,
+		handlePressedInside,
+		handleCaptureInside
+	]);
+	return React$1.useMemo(() => enabled ? {
+		reference,
+		floating
+	} : {}, [
+		enabled,
+		reference,
+		floating
+	]);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/hooks/useFloatingRootContext.js
+function useFloatingRootContext(options) {
+	const { open = false, onOpenChange: onOpenChangeProp, elements: elementsProp } = options;
+	const floatingId = useId$1();
+	const dataRef = React$1.useRef({});
+	const [events] = React$1.useState(() => createEventEmitter());
+	const nested = useFloatingParentNodeId() != null;
+	if (process.env.NODE_ENV !== "production") {
+		const optionDomReference = elementsProp.reference;
+		if (optionDomReference && !isElement(optionDomReference)) console.error("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `refs.setPositionReference()`", "instead.");
+	}
+	const [positionReference, setPositionReference] = React$1.useState(elementsProp.reference);
+	const onOpenChange = useEventCallback((newOpen, eventDetails) => {
+		dataRef.current.openEvent = newOpen ? eventDetails.event : void 0;
+		if (!options.noEmit) {
+			const details = {
+				open: newOpen,
+				reason: eventDetails.reason,
+				nativeEvent: eventDetails.event,
+				nested
+			};
+			events.emit("openchange", details);
+		}
+		onOpenChangeProp === null || onOpenChangeProp === void 0 || onOpenChangeProp(newOpen, eventDetails);
+	});
+	const refs = React$1.useMemo(() => ({ setPositionReference }), []);
+	const elements = React$1.useMemo(() => ({
+		reference: positionReference || elementsProp.reference || null,
+		floating: elementsProp.floating || null,
+		domReference: elementsProp.reference
+	}), [
+		positionReference,
+		elementsProp.reference,
+		elementsProp.floating
+	]);
+	return React$1.useMemo(() => ({
+		dataRef,
+		open,
+		onOpenChange,
+		elements,
+		events,
+		floatingId,
+		refs
+	}), [
+		open,
+		onOpenChange,
+		elements,
+		events,
+		floatingId,
+		refs
+	]);
+}
+function getEmptyContext() {
+	return {
+		open: false,
+		onOpenChange: () => {},
+		dataRef: { current: {} },
+		elements: {
+			floating: null,
+			reference: null,
+			domReference: null
+		},
+		events: {
+			on: () => {},
+			off: () => {},
+			emit: () => {}
+		},
+		floatingId: "",
+		refs: { setPositionReference: () => {} }
+	};
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/hooks/useInteractions.js
+/**
+* Merges an array of interaction hooks' props into prop getters, allowing
+* event handler functions to be composed together without overwriting one
+* another.
+* @see https://floating-ui.com/docs/useInteractions
+*/
+function useInteractions(propsList = []) {
+	const referenceDeps = propsList.map((key) => key === null || key === void 0 ? void 0 : key.reference);
+	const floatingDeps = propsList.map((key) => key === null || key === void 0 ? void 0 : key.floating);
+	const itemDeps = propsList.map((key) => key === null || key === void 0 ? void 0 : key.item);
+	const getReferenceProps = React$1.useCallback((userProps) => mergeProps(userProps, propsList, "reference"), referenceDeps);
+	const getFloatingProps = React$1.useCallback((userProps) => mergeProps(userProps, propsList, "floating"), floatingDeps);
+	const getItemProps = React$1.useCallback((userProps) => mergeProps(userProps, propsList, "item"), itemDeps);
+	return React$1.useMemo(() => ({
+		getReferenceProps,
+		getFloatingProps,
+		getItemProps
+	}), [
+		getReferenceProps,
+		getFloatingProps,
+		getItemProps
+	]);
+}
+function mergeProps(userProps, propsList, elementKey) {
+	const eventHandlers = /* @__PURE__ */ new Map();
+	const isItem = elementKey === "item";
+	const outputProps = {};
+	if (elementKey === "floating") {
+		outputProps.tabIndex = -1;
+		outputProps[FOCUSABLE_ATTRIBUTE] = "";
+	}
+	for (const key in userProps) {
+		if (isItem && userProps) {
+			if (key === "active" || key === "selected") continue;
+		}
+		outputProps[key] = userProps[key];
+	}
+	for (let i = 0; i < propsList.length; i += 1) {
+		var _propsList$i;
+		let props;
+		const propsOrGetProps = (_propsList$i = propsList[i]) === null || _propsList$i === void 0 ? void 0 : _propsList$i[elementKey];
+		if (typeof propsOrGetProps === "function") props = userProps ? propsOrGetProps(userProps) : null;
+		else props = propsOrGetProps;
+		if (!props) continue;
+		mutablyMergeProps(outputProps, props, isItem, eventHandlers);
+	}
+	mutablyMergeProps(outputProps, userProps, isItem, eventHandlers);
+	return outputProps;
+}
+function mutablyMergeProps(outputProps, props, isItem, eventHandlers) {
+	for (const key in props) {
+		const value = props[key];
+		if (isItem && (key === "active" || key === "selected")) continue;
+		if (!key.startsWith("on")) outputProps[key] = value;
+		else {
+			if (!eventHandlers.has(key)) eventHandlers.set(key, []);
+			if (typeof value === "function") {
+				var _eventHandlers$get;
+				(_eventHandlers$get = eventHandlers.get(key)) === null || _eventHandlers$get === void 0 || _eventHandlers$get.push(value);
+				outputProps[key] = (...args) => {
+					var _eventHandlers$get2;
+					return (_eventHandlers$get2 = eventHandlers.get(key)) === null || _eventHandlers$get2 === void 0 ? void 0 : _eventHandlers$get2.map((fn) => fn(...args)).find((val) => val !== void 0);
+				};
+			}
+		}
+	}
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/floating-ui-react/hooks/useRole.js
+var componentRoleToAriaRoleMap = new Map([
+	["select", "listbox"],
+	["combobox", "listbox"],
+	["label", false]
+]);
+/**
+* Adds base screen reader props to the reference and floating elements for a
+* given floating element `role`.
+* @see https://floating-ui.com/docs/useRole
+*/
+function useRole(context, props = {}) {
+	var _elements$domReferenc, _componentRoleToAriaR;
+	const { open, elements, floatingId: defaultFloatingId } = context;
+	const { enabled = true, role = "dialog" } = props;
+	const defaultReferenceId = useId$1();
+	const referenceId = ((_elements$domReferenc = elements.domReference) === null || _elements$domReferenc === void 0 ? void 0 : _elements$domReferenc.id) || defaultReferenceId;
+	const floatingId = React$1.useMemo(() => {
+		var _getFloatingFocusElem;
+		return ((_getFloatingFocusElem = getFloatingFocusElement(elements.floating)) === null || _getFloatingFocusElem === void 0 ? void 0 : _getFloatingFocusElem.id) || defaultFloatingId;
+	}, [elements.floating, defaultFloatingId]);
+	const ariaRole = (_componentRoleToAriaR = componentRoleToAriaRoleMap.get(role)) !== null && _componentRoleToAriaR !== void 0 ? _componentRoleToAriaR : role;
+	const isNested = useFloatingParentNodeId() != null;
+	const reference = React$1.useMemo(() => {
+		if (ariaRole === "tooltip" || role === "label") return { [`aria-${role === "label" ? "labelledby" : "describedby"}`]: open ? floatingId : void 0 };
+		return {
+			"aria-expanded": open ? "true" : "false",
+			"aria-haspopup": ariaRole === "alertdialog" ? "dialog" : ariaRole,
+			"aria-controls": open ? floatingId : void 0,
+			...ariaRole === "listbox" && { role: "combobox" },
+			...ariaRole === "menu" && { id: referenceId },
+			...ariaRole === "menu" && isNested && { role: "menuitem" },
+			...role === "select" && { "aria-autocomplete": "none" },
+			...role === "combobox" && { "aria-autocomplete": "list" }
+		};
+	}, [
+		ariaRole,
+		floatingId,
+		isNested,
+		open,
+		referenceId,
+		role
+	]);
+	const floating = React$1.useMemo(() => {
+		const floatingProps = {
+			id: floatingId,
+			...ariaRole && { role: ariaRole }
+		};
+		if (ariaRole === "tooltip" || role === "label") return floatingProps;
+		return {
+			...floatingProps,
+			...ariaRole === "menu" && { "aria-labelledby": referenceId }
+		};
+	}, [
+		ariaRole,
+		floatingId,
+		referenceId,
+		role
+	]);
+	const item = React$1.useCallback(({ active, selected }) => {
+		const commonProps = {
+			role: "option",
+			...active && { id: `${floatingId}-fui-option` }
+		};
+		switch (role) {
+			case "select":
+			case "combobox": return {
+				...commonProps,
+				"aria-selected": selected
+			};
+			default:
+		}
+		return {};
+	}, [floatingId, role]);
+	return React$1.useMemo(() => enabled ? {
+		reference,
+		floating,
+		item
+	} : {}, [
+		enabled,
+		reference,
+		floating,
+		item
+	]);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/utils/InternalBackdrop.js
+/**
+* @internal
+*/
+var InternalBackdrop = /* @__PURE__ */ React$1.forwardRef(function InternalBackdrop(props, ref) {
+	const { cutout, ...otherProps } = props;
+	let clipPath;
+	if (cutout) {
+		const rect = cutout === null || cutout === void 0 ? void 0 : cutout.getBoundingClientRect();
+		clipPath = `polygon(
+      0% 0%,
+      100% 0%,
+      100% 100%,
+      0% 100%,
+      0% 0%,
+      ${rect.left}px ${rect.top}px,
+      ${rect.left}px ${rect.bottom}px,
+      ${rect.right}px ${rect.bottom}px,
+      ${rect.right}px ${rect.top}px,
+      ${rect.left}px ${rect.top}px
+    )`;
+	}
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		ref,
+		role: "presentation",
+		"data-base-ui-inert": "",
+		...otherProps,
+		style: {
+			position: "fixed",
+			inset: 0,
+			userSelect: "none",
+			WebkitUserSelect: "none",
+			clipPath
+		}
+	});
+});
+if (process.env.NODE_ENV !== "production") InternalBackdrop.displayName = "InternalBackdrop";
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/utils/useScrollLock.js
+var originalHtmlStyles = {};
+var originalBodyStyles = {};
+var originalHtmlScrollBehavior = "";
+function hasInsetScrollbars(referenceElement) {
+	if (typeof document === "undefined") return false;
+	const doc = ownerDocument(referenceElement);
+	return getWindow(doc).innerWidth - doc.documentElement.clientWidth > 0;
+}
+function preventScrollBasic(referenceElement) {
+	const html = ownerDocument(referenceElement).documentElement;
+	const originalOverflow = html.style.overflow;
+	html.style.overflow = "hidden";
+	return () => {
+		html.style.overflow = originalOverflow;
+	};
+}
+function preventScrollStandard(referenceElement) {
+	var _win$visualViewport$s, _win$visualViewport;
+	const doc = ownerDocument(referenceElement);
+	const html = doc.documentElement;
+	const body = doc.body;
+	const win = getWindow(html);
+	let scrollTop = 0;
+	let scrollLeft = 0;
+	const resizeFrame = AnimationFrame.create();
+	if (isWebKit && ((_win$visualViewport$s = (_win$visualViewport = win.visualViewport) === null || _win$visualViewport === void 0 ? void 0 : _win$visualViewport.scale) !== null && _win$visualViewport$s !== void 0 ? _win$visualViewport$s : 1) !== 1) return () => {};
+	function lockScroll() {
+		var _CSS$supports, _CSS;
+		const htmlStyles = win.getComputedStyle(html);
+		const bodyStyles = win.getComputedStyle(body);
+		scrollTop = html.scrollTop;
+		scrollLeft = html.scrollLeft;
+		originalHtmlStyles = {
+			scrollbarGutter: html.style.scrollbarGutter,
+			overflowY: html.style.overflowY,
+			overflowX: html.style.overflowX
+		};
+		originalHtmlScrollBehavior = html.style.scrollBehavior;
+		originalBodyStyles = {
+			position: body.style.position,
+			height: body.style.height,
+			width: body.style.width,
+			boxSizing: body.style.boxSizing,
+			overflowY: body.style.overflowY,
+			overflowX: body.style.overflowX,
+			scrollBehavior: body.style.scrollBehavior
+		};
+		const supportsStableScrollbarGutter = typeof CSS !== "undefined" && ((_CSS$supports = (_CSS = CSS).supports) === null || _CSS$supports === void 0 ? void 0 : _CSS$supports.call(_CSS, "scrollbar-gutter", "stable"));
+		const isScrollableY = html.scrollHeight > html.clientHeight;
+		const isScrollableX = html.scrollWidth > html.clientWidth;
+		const hasConstantOverflowY = htmlStyles.overflowY === "scroll" || bodyStyles.overflowY === "scroll";
+		const hasConstantOverflowX = htmlStyles.overflowX === "scroll" || bodyStyles.overflowX === "scroll";
+		const scrollbarWidth = Math.max(0, win.innerWidth - html.clientWidth);
+		const scrollbarHeight = Math.max(0, win.innerHeight - html.clientHeight);
+		const marginY = parseFloat(bodyStyles.marginTop) + parseFloat(bodyStyles.marginBottom);
+		const marginX = parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight);
+		Object.assign(html.style, {
+			scrollbarGutter: "stable",
+			overflowY: !supportsStableScrollbarGutter && (isScrollableY || hasConstantOverflowY) ? "scroll" : "hidden",
+			overflowX: !supportsStableScrollbarGutter && (isScrollableX || hasConstantOverflowX) ? "scroll" : "hidden"
+		});
+		Object.assign(body.style, {
+			position: "relative",
+			height: marginY || scrollbarHeight ? `calc(100dvh - ${marginY + scrollbarHeight}px)` : "100dvh",
+			width: marginX || scrollbarWidth ? `calc(100vw - ${marginX + scrollbarWidth}px)` : "100vw",
+			boxSizing: "border-box",
+			overflow: "hidden",
+			scrollBehavior: "unset"
+		});
+		body.scrollTop = scrollTop;
+		body.scrollLeft = scrollLeft;
+		html.setAttribute("data-base-ui-scroll-locked", "");
+		html.style.scrollBehavior = "unset";
+	}
+	function cleanup() {
+		Object.assign(html.style, originalHtmlStyles);
+		Object.assign(body.style, originalBodyStyles);
+		html.scrollTop = scrollTop;
+		html.scrollLeft = scrollLeft;
+		html.removeAttribute("data-base-ui-scroll-locked");
+		html.style.scrollBehavior = originalHtmlScrollBehavior;
+	}
+	function handleResize() {
+		cleanup();
+		resizeFrame.request(lockScroll);
+	}
+	lockScroll();
+	win.addEventListener("resize", handleResize);
+	return () => {
+		resizeFrame.cancel();
+		cleanup();
+		win.removeEventListener("resize", handleResize);
+	};
+}
+var ScrollLocker = class {
+	constructor() {
+		_defineProperty(this, "lockCount", 0);
+		_defineProperty(this, "restore", null);
+		_defineProperty(this, "timeoutLock", Timeout.create());
+		_defineProperty(this, "timeoutUnlock", Timeout.create());
+		_defineProperty(this, "release", () => {
+			this.lockCount -= 1;
+			if (this.lockCount === 0 && this.restore) this.timeoutUnlock.start(0, this.unlock);
+		});
+		_defineProperty(this, "unlock", () => {
+			if (this.lockCount === 0 && this.restore) {
+				var _this$restore;
+				(_this$restore = this.restore) === null || _this$restore === void 0 || _this$restore.call(this);
+				this.restore = null;
+			}
+		});
+	}
+	acquire(referenceElement) {
+		this.lockCount += 1;
+		if (this.lockCount === 1 && this.restore === null) this.timeoutLock.start(0, () => this.lock(referenceElement));
+		return this.release;
+	}
+	lock(referenceElement) {
+		if (this.lockCount === 0 || this.restore !== null) return;
+		const html = ownerDocument(referenceElement).documentElement;
+		const htmlOverflowY = getWindow(html).getComputedStyle(html).overflowY;
+		if (htmlOverflowY === "hidden" || htmlOverflowY === "clip") {
+			this.restore = NOOP;
+			return;
+		}
+		this.restore = isIOS || !hasInsetScrollbars(referenceElement) ? preventScrollBasic(referenceElement) : preventScrollStandard(referenceElement);
+	}
+};
+var SCROLL_LOCKER = new ScrollLocker();
+/**
+* Locks the scroll of the document when enabled.
+*
+* @param enabled - Whether to enable the scroll lock.
+*/
+function useScrollLock(params) {
+	const { enabled = true, mounted, open, referenceElement = null } = params;
+	useIsoLayoutEffect(() => {
+		if (enabled && isWebKit && mounted && !open) {
+			const doc = ownerDocument(referenceElement);
+			const originalUserSelect = doc.body.style.userSelect;
+			const originalWebkitUserSelect = doc.body.style.webkitUserSelect;
+			doc.body.style.userSelect = "none";
+			doc.body.style.webkitUserSelect = "none";
+			return () => {
+				doc.body.style.userSelect = originalUserSelect;
+				doc.body.style.webkitUserSelect = originalWebkitUserSelect;
+			};
+		}
+	}, [
+		enabled,
+		mounted,
+		open,
+		referenceElement
+	]);
+	useIsoLayoutEffect(() => {
+		if (!enabled) return;
+		return SCROLL_LOCKER.acquire(referenceElement);
+	}, [enabled, referenceElement]);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/utils/esm/useEnhancedClickHandler.js
+/**
+* Provides a cross-browser way to determine the type of the pointer used to click.
+* Safari and Firefox do not provide the PointerEvent to the click handler (they use MouseEvent) yet.
+* Additionally, this implementation detects if the click was triggered by the keyboard.
+*
+* @param handler The function to be called when the button is clicked. The first parameter is the original event and the second parameter is the pointer type.
+*/
+function useEnhancedClickHandler(handler) {
+	const lastClickInteractionTypeRef = React$1.useRef("");
+	const handlePointerDown = React$1.useCallback((event) => {
+		if (event.defaultPrevented) return;
+		lastClickInteractionTypeRef.current = event.pointerType;
+		handler(event, event.pointerType);
+	}, [handler]);
+	return {
+		onClick: React$1.useCallback((event) => {
+			if (event.detail === 0) {
+				handler(event, "keyboard");
+				return;
+			}
+			if ("pointerType" in event) handler(event, event.pointerType);
+			handler(event, lastClickInteractionTypeRef.current);
+			lastClickInteractionTypeRef.current = "";
+		}, [handler]),
+		onPointerDown: handlePointerDown
+	};
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/utils/useOpenInteractionType.js
+/**
+* Determines the interaction type (keyboard, mouse, touch, etc.) that opened the component.
+*
+* @param open The open state of the component.
+*/
+function useOpenInteractionType(open) {
+	const [openMethod, setOpenMethod] = React$1.useState(null);
+	const handleTriggerClick = useEventCallback((_, interactionType) => {
+		if (!open) setOpenMethod(interactionType);
+	});
+	const reset = useEventCallback(() => {
+		setOpenMethod(null);
+	});
+	const { onClick, onPointerDown } = useEnhancedClickHandler(handleTriggerClick);
+	return React$1.useMemo(() => ({
+		openMethod,
+		reset,
+		triggerProps: {
+			onClick,
+			onPointerDown
+		}
+	}), [
+		openMethod,
+		reset,
+		onClick,
+		onPointerDown
+	]);
+}
+//#endregion
+export { contains as $, inertValue as A, floor as B, FloatingNode as C, useFloatingTree as D, useFloatingParentNodeId as E, useOpenChangeComplete as F, getSide as G, getAlignmentAxis as H, useLatestRef$1 as I, isVirtualClick as J, getSideAxis as K, COMPOSITE_KEYS as L, popupStateMapping as M, pressableTriggerOpenStateMapping as N, Timeout as O, triggerOpenStateMapping as P, activeElement as Q, clamp as R, createAttribute as S, useFloatingNodeId as T, getAxisLength as U, getAlignment as V, getPaddingObject as W, stopEvent as X, isVirtualPointerEvent as Y, getNodeChildren as Z, useClick as _, useInteractions as a, matchesFocusVisible as at, enqueueFocus as b, useDismiss as c, ARROW_RIGHT$1 as ct, limitShift as d, isSafari as dt, getDocument as et, offset as f, transitionStatusMapping as ft, autoUpdate as g, useFloating as h, useRole as i, isTypeableElement as it, CommonPopupDataAttributes as j, useTimeout as k, flip as l, ARROW_UP$1 as lt, size as m, _defineProperty as mt, useScrollLock as n, getTarget as nt, getEmptyContext as o, ARROW_DOWN$1 as ot, shift as p, useTransitionStatus as pt, isMouseLikePointerType as q, InternalBackdrop as r, isTypeableCombobox as rt, useFloatingRootContext as s, ARROW_LEFT$1 as st, useOpenInteractionType as t, getFloatingFocusElement as tt, hide as u, isMac as ut, FloatingFocusManager as v, FloatingTree as w, ownerDocument as x, FloatingPortal as y, evaluate as z };