@helsenorge/designsystem-react 13.0.0-beta.2 → 13.0.0-beta.5

package/lib/floating-ui.react.js

@@ -0,0 +1,3550 @@
+import * as React$1 from "react";
+import { useLayoutEffect } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import * as ReactDOM from "react-dom";
+function hasWindow() {
+	return typeof window !== "undefined";
+}
+function getNodeName(node) {
+	if (isNode(node)) return (node.nodeName || "").toLowerCase();
+	return "#document";
+}
+function getWindow(node) {
+	var _node$ownerDocument;
+	return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+	var _ref;
+	return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+	if (!hasWindow()) return false;
+	return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+	if (!hasWindow()) return false;
+	return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+	if (!hasWindow()) return false;
+	return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+	if (!hasWindow() || typeof ShadowRoot === "undefined") return false;
+	return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+var invalidOverflowDisplayValues = /* @__PURE__ */ new Set(["inline", "contents"]);
+function isOverflowElement(element) {
+	const { overflow, overflowX, overflowY, display } = getComputedStyle$1(element);
+	return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !invalidOverflowDisplayValues.has(display);
+}
+var tableElements = /* @__PURE__ */ new Set([
+	"table",
+	"td",
+	"th"
+]);
+function isTableElement(element) {
+	return tableElements.has(getNodeName(element));
+}
+var topLayerSelectors = [":popover-open", ":modal"];
+function isTopLayer(element) {
+	return topLayerSelectors.some((selector) => {
+		try {
+			return element.matches(selector);
+		} catch (_e) {
+			return false;
+		}
+	});
+}
+var transformProperties = [
+	"transform",
+	"translate",
+	"scale",
+	"rotate",
+	"perspective"
+];
+var willChangeValues = [
+	"transform",
+	"translate",
+	"scale",
+	"rotate",
+	"perspective",
+	"filter"
+];
+var containValues = [
+	"paint",
+	"layout",
+	"strict",
+	"content"
+];
+function isContainingBlock(elementOrCss) {
+	const webkit = isWebKit();
+	const css = isElement(elementOrCss) ? getComputedStyle$1(elementOrCss) : elementOrCss;
+	return transformProperties.some((value) => css[value] ? css[value] !== "none" : false) || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || willChangeValues.some((value) => (css.willChange || "").includes(value)) || containValues.some((value) => (css.contain || "").includes(value));
+}
+function getContainingBlock(element) {
+	let currentNode = getParentNode(element);
+	while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+		if (isContainingBlock(currentNode)) return currentNode;
+		else if (isTopLayer(currentNode)) return null;
+		currentNode = getParentNode(currentNode);
+	}
+	return null;
+}
+function isWebKit() {
+	if (typeof CSS === "undefined" || !CSS.supports) return false;
+	return CSS.supports("-webkit-backdrop-filter", "none");
+}
+var lastTraversableNodeNames = /* @__PURE__ */ new Set([
+	"html",
+	"body",
+	"#document"
+]);
+function isLastTraversableNode(node) {
+	return lastTraversableNodeNames.has(getNodeName(node));
+}
+function getComputedStyle$1(element) {
+	return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+	if (isElement(element)) return {
+		scrollLeft: element.scrollLeft,
+		scrollTop: element.scrollTop
+	};
+	return {
+		scrollLeft: element.scrollX,
+		scrollTop: element.scrollY
+	};
+}
+function getParentNode(node) {
+	if (getNodeName(node) === "html") return node;
+	const result = node.assignedSlot || node.parentNode || isShadowRoot(node) && node.host || getDocumentElement(node);
+	return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+	const parentNode = getParentNode(node);
+	if (isLastTraversableNode(parentNode)) return node.ownerDocument ? node.ownerDocument.body : node.body;
+	if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) return parentNode;
+	return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+	var _node$ownerDocument2;
+	if (list === void 0) list = [];
+	if (traverseIframes === void 0) traverseIframes = true;
+	const scrollableAncestor = getNearestOverflowAncestor(node);
+	const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+	const win = getWindow(scrollableAncestor);
+	if (isBody) {
+		const frameElement = getFrameElement(win);
+		return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+	}
+	return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win) {
+	return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+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;
+};
+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);
+};
+var isContentEditable = function isContentEditable$1(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";
+};
+var getCandidates = function getCandidates$1(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;
+};
+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;
+};
+var hasTabIndex = function hasTabIndex$1(node) {
+	return !isNaN(parseInt(node.getAttribute("tabindex"), 10));
+};
+var getTabIndex = function getTabIndex$1(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;
+};
+var getSortOrderTabIndex = function getSortOrderTabIndex$1(node, isScope) {
+	var tabIndex = getTabIndex(node);
+	if (tabIndex < 0 && isScope && !hasTabIndex(node)) return 0;
+	return tabIndex;
+};
+var sortOrderedTabbables = function sortOrderedTabbables$1(a, b) {
+	return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
+};
+var isInput = function isInput$1(node) {
+	return node.tagName === "INPUT";
+};
+var isHiddenInput = function isHiddenInput$1(node) {
+	return isInput(node) && node.type === "hidden";
+};
+var isDetailsWithSummary = function isDetailsWithSummary$1(node) {
+	return node.tagName === "DETAILS" && Array.prototype.slice.apply(node.children).some(function(child) {
+		return child.tagName === "SUMMARY";
+	});
+};
+var getCheckedRadio = function getCheckedRadio$1(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$1(node) {
+	if (!node.name) return true;
+	var radioScope = node.form || getRootNode(node);
+	var queryRadios = function queryRadios$1(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$1(node) {
+	return isInput(node) && node.type === "radio";
+};
+var isNonTabbableRadio = function isNonTabbableRadio$1(node) {
+	return isRadio(node) && !isTabbableRadio(node);
+};
+var isNodeAttached = function isNodeAttached$1(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$1(node) {
+	var _node$getBoundingClie = node.getBoundingClientRect(), width = _node$getBoundingClie.width, height = _node$getBoundingClie.height;
+	return width === 0 && height === 0;
+};
+var isHidden = function isHidden$1(node, _ref) {
+	var displayCheck = _ref.displayCheck, getShadowRoot = _ref.getShadowRoot;
+	if (displayCheck === "full-native") {
+		if ("checkVisibility" in node) return !node.checkVisibility({
+			checkOpacity: false,
+			opacityProperty: false,
+			contentVisibilityAuto: true,
+			visibilityProperty: true,
+			checkVisibilityCSS: true
+		});
+	}
+	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 === "full-native" || 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$1(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$1(options, node) {
+	if (node.disabled || _isInert(node) || isHiddenInput(node) || isHidden(node, options) || isDetailsWithSummary(node) || isDisabledFromFieldset(node)) return false;
+	return true;
+};
+var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable$1(options, node) {
+	if (isNonTabbableRadio(node) || getTabIndex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) return false;
+	return true;
+};
+var isShadowRootTabbable = function isShadowRootTabbable$1(shadowHostNode) {
+	var tabIndex = parseInt(shadowHostNode.getAttribute("tabindex"), 10);
+	if (isNaN(tabIndex) || tabIndex >= 0) return true;
+	return false;
+};
+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$1(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: isShadowRootTabbable
+	});
+	else candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
+	return _sortByOrder(candidates);
+};
+var focusable = function focusable$1(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$1(node, options) {
+	options = options || {};
+	if (!node) throw new Error("No node provided");
+	if (matches.call(node, candidateSelector) === false) return false;
+	return isNodeMatchingSelectorTabbable(options, node);
+};
+function getPlatform() {
+	const uaData = navigator.userAgentData;
+	if (uaData != null && uaData.platform) return uaData.platform;
+	return navigator.platform;
+}
+function getUserAgent() {
+	const uaData = navigator.userAgentData;
+	if (uaData && Array.isArray(uaData.brands)) return uaData.brands.map((_ref) => {
+		let { brand, version } = _ref;
+		return brand + "/" + version;
+	}).join(" ");
+	return navigator.userAgent;
+}
+function isSafari() {
+	return /apple/i.test(navigator.vendor);
+}
+function isAndroid() {
+	const re = /android/i;
+	return re.test(getPlatform()) || re.test(getUserAgent());
+}
+function isMac() {
+	return getPlatform().toLowerCase().startsWith("mac") && !navigator.maxTouchPoints;
+}
+function isJSDOM() {
+	return getUserAgent().includes("jsdom/");
+}
+var FOCUSABLE_ATTRIBUTE$1 = "data-floating-ui-focusable";
+var TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+function activeElement(doc) {
+	let activeElement$1 = doc.activeElement;
+	while (((_activeElement = activeElement$1) == null || (_activeElement = _activeElement.shadowRoot) == null ? void 0 : _activeElement.activeElement) != null) {
+		var _activeElement;
+		activeElement$1 = activeElement$1.shadowRoot.activeElement;
+	}
+	return activeElement$1;
+}
+function contains(parent, child) {
+	if (!parent || !child) return false;
+	const rootNode = child.getRootNode == null ? void 0 : child.getRootNode();
+	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 e = event;
+	return e.target != null && node.contains(e.target);
+}
+function isRootElement(element) {
+	return element.matches("html,body");
+}
+function getDocument(node) {
+	return (node == null ? void 0 : node.ownerDocument) || document;
+}
+function isTypeableElement(element) {
+	return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
+}
+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(FOCUSABLE_ATTRIBUTE$1) ? floatingElement : floatingElement.querySelector("[" + FOCUSABLE_ATTRIBUTE$1 + "]") || floatingElement;
+}
+function getNodeChildren(nodes, id, onlyOpenChildren) {
+	if (onlyOpenChildren === void 0) onlyOpenChildren = true;
+	return nodes.filter((node) => {
+		var _node$context;
+		return node.parentId === id && (!onlyOpenChildren || ((_node$context = node.context) == null ? 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 ? void 0 : _nodes$find.parentId;
+	while (currentParentId) {
+		const currentNode = nodes.find((node) => node.id === currentParentId);
+		currentParentId = currentNode == null ? void 0 : currentNode.parentId;
+		if (currentNode) allAncestors = allAncestors.concat(currentNode);
+	}
+	return allAncestors;
+}
+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);
+}
+var index = typeof document !== "undefined" ? useLayoutEffect : function noop() {};
+var SafeReact$1 = { ...React$1 };
+function useLatestRef(value) {
+	const ref = React$1.useRef(value);
+	index(() => {
+		ref.current = value;
+	});
+	return ref;
+}
+var useSafeInsertionEffect = SafeReact$1.useInsertionEffect || ((fn) => fn());
+function useEffectEvent(callback) {
+	const ref = React$1.useRef(() => {
+		if (process.env.NODE_ENV !== "production") throw new Error("Cannot call an event handler while rendering.");
+	});
+	useSafeInsertionEffect(() => {
+		ref.current = callback;
+	});
+	return React$1.useCallback(function() {
+		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+		return ref.current == null ? void 0 : ref.current(...args);
+	}, []);
+}
+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$2 = list.indexOf(active);
+	return list[index$2 === -1 ? dir === 1 ? 0 : len - 1 : index$2 + 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 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;
+}
+var computePosition$1 = async (reference, floating, config) => {
+	const { placement = "bottom", strategy = "absolute", middleware = [], platform: platform$1 } = config;
+	const validMiddleware = middleware.filter(Boolean);
+	const rtl = await (platform$1.isRTL == null ? void 0 : platform$1.isRTL(floating));
+	let rects = await platform$1.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: platform$1,
+			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$1.getElementRects({
+					reference,
+					floating,
+					strategy
+				}) : reset.rects;
+				({x, y} = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+			}
+			i = -1;
+		}
+	}
+	return {
+		x,
+		y,
+		placement: statefulPlacement,
+		strategy,
+		middlewareData
+	};
+};
+async function detectOverflow$1(state, options) {
+	var _await$platform$isEle;
+	if (options === void 0) options = {};
+	const { x, y, platform: platform$1, 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$1.getClippingRect({
+		element: ((_await$platform$isEle = await (platform$1.isElement == null ? void 0 : platform$1.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform$1.getDocumentElement == null ? void 0 : platform$1.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$1.getOffsetParent == null ? void 0 : platform$1.getOffsetParent(elements.floating));
+	const offsetScale = await (platform$1.isElement == null ? void 0 : platform$1.isElement(offsetParent)) ? await (platform$1.getScale == null ? void 0 : platform$1.getScale(offsetParent)) || {
+		x: 1,
+		y: 1
+	} : {
+		x: 1,
+		y: 1
+	};
+	const elementClientRect = rectToClientRect(platform$1.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform$1.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
+	};
+}
+var arrow$2 = (options) => ({
+	name: "arrow",
+	options,
+	async fn(state) {
+		const { x, y, placement, rects, platform: platform$1, elements, middlewareData } = state;
+		const { element, padding = 0 } = evaluate(options, state) || {};
+		if (element == null) return {};
+		const paddingObject = getPaddingObject(padding);
+		const coords = {
+			x,
+			y
+		};
+		const axis = getAlignmentAxis(placement);
+		const length = getAxisLength(axis);
+		const arrowDimensions = await platform$1.getDimensions(element);
+		const isYAxis = axis === "y";
+		const minProp = isYAxis ? "top" : "left";
+		const maxProp = isYAxis ? "bottom" : "right";
+		const clientProp = isYAxis ? "clientHeight" : "clientWidth";
+		const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
+		const startDiff = coords[axis] - rects.reference[axis];
+		const arrowOffsetParent = await (platform$1.getOffsetParent == null ? void 0 : platform$1.getOffsetParent(element));
+		let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
+		if (!clientSize || !await (platform$1.isElement == null ? void 0 : platform$1.isElement(arrowOffsetParent))) clientSize = elements.floating[clientProp] || rects.floating[length];
+		const centerToReference = endDiff / 2 - startDiff / 2;
+		const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
+		const minPadding = min(paddingObject[minProp], largestPossiblePadding);
+		const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
+		const min$1 = minPadding;
+		const max$1 = clientSize - arrowDimensions[length] - maxPadding;
+		const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+		const offset$3 = clamp(min$1, center, max$1);
+		const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset$3 && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+		const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max$1 : 0;
+		return {
+			[axis]: coords[axis] + alignmentOffset,
+			data: {
+				[axis]: offset$3,
+				centerOffset: center - offset$3 - alignmentOffset,
+				...shouldAddOffset && { alignmentOffset }
+			},
+			reset: shouldAddOffset
+		};
+	}
+});
+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: platform$1, 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$1.isRTL == null ? void 0 : platform$1.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$1 = [initialPlacement, ...fallbackPlacements];
+			const overflow = await detectOverflow$1(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$1 = getAlignmentSides(placement, rects, rtl);
+				overflows.push(overflow[sides$1[0]], overflow[sides$1[1]]);
+			}
+			overflowsData = [...overflowsData, {
+				placement,
+				overflows
+			}];
+			if (!overflows.every((side$1) => side$1 <= 0)) {
+				var _middlewareData$flip2, _overflowsData$filter;
+				const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+				const nextPlacement = placements$1[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$1 = (_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$1) => overflow$1 > 0).reduce((acc, overflow$1) => acc + overflow$1, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
+						if (placement$1) resetPlacement = placement$1;
+						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);
+}
+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$1(state, {
+						...detectOverflowOptions,
+						elementContext: "reference"
+					}), rects.reference);
+					return { data: {
+						referenceHiddenOffsets: offsets,
+						referenceHidden: isAnySideFullyClipped(offsets)
+					} };
+				}
+				case "escaped": {
+					const offsets = getSideOffsets(await detectOverflow$1(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: platform$1, elements } = state;
+	const rtl = await (platform$1.isRTL == null ? void 0 : platform$1.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
+	};
+}
+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
+				}
+			};
+		}
+	};
+};
+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: x$1, y: y$1 } = _ref;
+				return {
+					x: x$1,
+					y: y$1
+				};
+			} }, ...detectOverflowOptions } = evaluate(options, state);
+			const coords = {
+				x,
+				y
+			};
+			const overflow = await detectOverflow$1(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$1 = mainAxisCoord + overflow[minSide];
+				const max$1 = mainAxisCoord - overflow[maxSide];
+				mainAxisCoord = clamp(min$1, mainAxisCoord, max$1);
+			}
+			if (checkCrossAxis) {
+				const minSide = crossAxis === "y" ? "top" : "left";
+				const maxSide = crossAxis === "y" ? "bottom" : "right";
+				const min$1 = crossAxisCoord + overflow[minSide];
+				const max$1 = crossAxisCoord - overflow[maxSide];
+				crossAxisCoord = clamp(min$1, crossAxisCoord, max$1);
+			}
+			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
+					}
+				}
+			};
+		}
+	};
+};
+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: platform$1, elements } = state;
+			const { apply = () => {}, ...detectOverflowOptions } = evaluate(options, state);
+			const overflow = await detectOverflow$1(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$1.isRTL == null ? void 0 : platform$1.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$1.getDimensions(elements.floating);
+			if (width !== nextDimensions.width || height !== nextDimensions.height) return { reset: { rects: true } };
+			return {};
+		}
+	};
+};
+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() || !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();
+		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;
+}
+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?.();
+		(_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
+		resizeObserver = null;
+		if (animationFrame) cancelAnimationFrame(frameId);
+	};
+}
+var offset$1 = offset$2;
+var shift$1 = shift$2;
+var flip$1 = flip$2;
+var size$1 = size$2;
+var hide$1 = hide$2;
+var arrow$1 = arrow$2;
+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
+	});
+};
+var index$1 = 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$1(value) {
+	const ref = React$1.useRef(value);
+	index$1(() => {
+		ref.current = value;
+	});
+	return ref;
+}
+function useFloating(options) {
+	if (options === void 0) options = {};
+	const { placement = "bottom", strategy = "absolute", middleware = [], platform: platform$1, 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$1(whileElementsMounted);
+	const platformRef = useLatestRef$1(platform$1);
+	const openRef = useLatestRef$1(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$1) => {
+			const fullData = {
+				...data$1,
+				isPositioned: openRef.current !== false
+			};
+			if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
+				dataRef.current = fullData;
+				ReactDOM.flushSync(() => {
+					setData(fullData);
+				});
+			}
+		});
+	}, [
+		latestMiddleware,
+		placement,
+		strategy,
+		platformRef,
+		openRef
+	]);
+	index$1(() => {
+		if (open === false && dataRef.current.isPositioned) {
+			dataRef.current.isPositioned = false;
+			setData((data$1) => ({
+				...data$1,
+				isPositioned: false
+			}));
+		}
+	}, [open]);
+	const isMountedRef = React$1.useRef(false);
+	index$1(() => {
+		isMountedRef.current = true;
+		return () => {
+			isMountedRef.current = false;
+		};
+	}, []);
+	index$1(() => {
+		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
+	]);
+}
+var arrow$1$1 = (options) => {
+	function isRef(value) {
+		return {}.hasOwnProperty.call(value, "current");
+	}
+	return {
+		name: "arrow",
+		options,
+		fn(state) {
+			const { element, padding } = typeof options === "function" ? options(state) : options;
+			if (element && isRef(element)) {
+				if (element.current != null) return arrow$1({
+					element: element.current,
+					padding
+				}).fn(state);
+				return {};
+			}
+			if (element) return arrow$1({
+				element,
+				padding
+			}).fn(state);
+			return {};
+		}
+	};
+};
+var offset = (options, deps) => ({
+	...offset$1(options),
+	options: [options, deps]
+});
+var shift = (options, deps) => ({
+	...shift$1(options),
+	options: [options, deps]
+});
+var flip = (options, deps) => ({
+	...flip$1(options),
+	options: [options, deps]
+});
+var size = (options, deps) => ({
+	...size$1(options),
+	options: [options, deps]
+});
+var hide = (options, deps) => ({
+	...hide$1(options),
+	options: [options, deps]
+});
+var arrow = (options, deps) => ({
+	...arrow$1$1(options),
+	options: [options, deps]
+});
+function useMergeRefs(refs) {
+	const cleanupRef = React$1.useRef(void 0);
+	const refEffect = React$1.useCallback((instance) => {
+		const cleanups = refs.map((ref) => {
+			if (ref == null) return;
+			if (typeof ref === "function") {
+				const refCallback = ref;
+				const refCleanup = refCallback(instance);
+				return typeof refCleanup === "function" ? refCleanup : () => {
+					refCallback(null);
+				};
+			}
+			ref.current = instance;
+			return () => {
+				ref.current = null;
+			};
+		});
+		return () => {
+			cleanups.forEach((refCleanup) => refCleanup == null ? void 0 : refCleanup());
+		};
+	}, refs);
+	return React$1.useMemo(() => {
+		if (refs.every((ref) => ref == null)) return null;
+		return (value) => {
+			if (cleanupRef.current) {
+				cleanupRef.current();
+				cleanupRef.current = void 0;
+			}
+			if (value != null) cleanupRef.current = refEffect(value);
+		};
+	}, refs);
+}
+var FOCUSABLE_ATTRIBUTE = "data-floating-ui-focusable";
+var ACTIVE_KEY = "active";
+var SELECTED_KEY = "selected";
+var ARROW_LEFT = "ArrowLeft";
+var ARROW_RIGHT = "ArrowRight";
+var ARROW_UP = "ArrowUp";
+var ARROW_DOWN = "ArrowDown";
+var horizontalKeys = [ARROW_LEFT, ARROW_RIGHT];
+var verticalKeys = [ARROW_UP, ARROW_DOWN];
+[...horizontalKeys, ...verticalKeys];
+var SafeReact = { ...React$1 };
+var serverHandoffComplete = false;
+var count = 0;
+var genId = () => "floating-ui-" + Math.random().toString(36).slice(2, 6) + count++;
+function useFloatingId() {
+	const [id, setId] = React$1.useState(() => serverHandoffComplete ? genId() : void 0);
+	index(() => {
+		if (id == null) setId(genId());
+	}, []);
+	React$1.useEffect(() => {
+		serverHandoffComplete = true;
+	}, []);
+	return id;
+}
+var useId$1 = SafeReact.useId || useFloatingId;
+var devMessageSet;
+if (process.env.NODE_ENV !== "production") devMessageSet = /* @__PURE__ */ new Set();
+function warn() {
+	var _devMessageSet;
+	for (var _len = arguments.length, messages = new Array(_len), _key = 0; _key < _len; _key++) messages[_key] = arguments[_key];
+	const message = "Floating UI: " + messages.join(" ");
+	if (!((_devMessageSet = devMessageSet) != null && _devMessageSet.has(message))) {
+		var _devMessageSet2;
+		(_devMessageSet2 = devMessageSet) == null || _devMessageSet2.add(message);
+		console.warn(message);
+	}
+}
+function error() {
+	var _devMessageSet3;
+	for (var _len2 = arguments.length, messages = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) messages[_key2] = arguments[_key2];
+	const message = "Floating UI: " + messages.join(" ");
+	if (!((_devMessageSet3 = devMessageSet) != null && _devMessageSet3.has(message))) {
+		var _devMessageSet4;
+		(_devMessageSet4 = devMessageSet) == null || _devMessageSet4.add(message);
+		console.error(message);
+	}
+}
+var FloatingArrow = /* @__PURE__ */ React$1.forwardRef(function FloatingArrow$1(props, ref) {
+	const { context: { placement, elements: { floating }, middlewareData: { arrow: arrow$3, shift: shift$3 } }, width = 14, height = 7, tipRadius = 0, strokeWidth = 0, staticOffset, stroke, d, style: { transform, ...restStyle } = {}, ...rest } = props;
+	if (process.env.NODE_ENV !== "production") {
+		if (!ref) warn("The `ref` prop is required for `FloatingArrow`.");
+	}
+	const clipPathId = useId$1();
+	const [isRTL$1, setIsRTL] = React$1.useState(false);
+	index(() => {
+		if (!floating) return;
+		if (getComputedStyle$1(floating).direction === "rtl") setIsRTL(true);
+	}, [floating]);
+	if (!floating) return null;
+	const [side, alignment] = placement.split("-");
+	const isVerticalSide = side === "top" || side === "bottom";
+	let computedStaticOffset = staticOffset;
+	if (isVerticalSide && shift$3 != null && shift$3.x || !isVerticalSide && shift$3 != null && shift$3.y) computedStaticOffset = null;
+	const computedStrokeWidth = strokeWidth * 2;
+	const halfStrokeWidth = computedStrokeWidth / 2;
+	const svgX = width / 2 * (tipRadius / -8 + 1);
+	const svgY = height / 2 * tipRadius / 4;
+	const isCustomShape = !!d;
+	const yOffsetProp = computedStaticOffset && alignment === "end" ? "bottom" : "top";
+	let xOffsetProp = computedStaticOffset && alignment === "end" ? "right" : "left";
+	if (computedStaticOffset && isRTL$1) xOffsetProp = alignment === "end" ? "left" : "right";
+	const arrowX = (arrow$3 == null ? void 0 : arrow$3.x) != null ? computedStaticOffset || arrow$3.x : "";
+	const arrowY = (arrow$3 == null ? void 0 : arrow$3.y) != null ? computedStaticOffset || arrow$3.y : "";
+	const dValue = d || "M0,0" + (" H" + width) + (" L" + (width - svgX) + "," + (height - svgY)) + (" Q" + width / 2 + "," + height + " " + svgX + "," + (height - svgY)) + " Z";
+	const rotation = {
+		top: isCustomShape ? "rotate(180deg)" : "",
+		left: isCustomShape ? "rotate(90deg)" : "rotate(-90deg)",
+		bottom: isCustomShape ? "" : "rotate(180deg)",
+		right: isCustomShape ? "rotate(-90deg)" : "rotate(90deg)"
+	}[side];
+	return /* @__PURE__ */ jsxs("svg", {
+		...rest,
+		"aria-hidden": true,
+		ref,
+		width: isCustomShape ? width : width + computedStrokeWidth,
+		height: width,
+		viewBox: "0 0 " + width + " " + (height > width ? height : width),
+		style: {
+			position: "absolute",
+			pointerEvents: "none",
+			[xOffsetProp]: arrowX,
+			[yOffsetProp]: arrowY,
+			[side]: isVerticalSide || isCustomShape ? "100%" : "calc(100% - " + computedStrokeWidth / 2 + "px)",
+			transform: [rotation, transform].filter((t) => !!t).join(" "),
+			...restStyle
+		},
+		children: [
+			computedStrokeWidth > 0 && /* @__PURE__ */ jsx("path", {
+				clipPath: "url(#" + clipPathId + ")",
+				fill: "none",
+				stroke,
+				strokeWidth: computedStrokeWidth + (d ? 0 : 1),
+				d: dValue
+			}),
+			/* @__PURE__ */ jsx("path", {
+				stroke: computedStrokeWidth && !d ? rest.fill : "none",
+				d: dValue
+			}),
+			/* @__PURE__ */ jsx("clipPath", {
+				id: clipPathId,
+				children: /* @__PURE__ */ jsx("rect", {
+					x: -halfStrokeWidth,
+					y: halfStrokeWidth * (isCustomShape ? -1 : 1),
+					width: width + computedStrokeWidth,
+					height: width
+				})
+			})
+		]
+	});
+});
+function createEventEmitter() {
+	const map = /* @__PURE__ */ new Map();
+	return {
+		emit(event, data) {
+			var _map$get;
+			(_map$get = map.get(event)) == null || _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.delete(listener);
+		}
+	};
+}
+var FloatingNodeContext = /* @__PURE__ */ React$1.createContext(null);
+var FloatingTreeContext = /* @__PURE__ */ React$1.createContext(null);
+var useFloatingParentNodeId = () => {
+	var _React$useContext;
+	return ((_React$useContext = React$1.useContext(FloatingNodeContext)) == null ? void 0 : _React$useContext.id) || null;
+};
+var useFloatingTree = () => React$1.useContext(FloatingTreeContext);
+function createAttribute(name) {
+	return "data-floating-ui-" + name;
+}
+function clearTimeoutIfSet(timeoutRef) {
+	if (timeoutRef.current !== -1) {
+		clearTimeout(timeoutRef.current);
+		timeoutRef.current = -1;
+	}
+}
+var safePolygonIdentifier = /* @__PURE__ */ createAttribute("safe-polygon");
+function getDelay(value, prop, pointerType) {
+	if (pointerType && !isMouseLikePointerType(pointerType)) return 0;
+	if (typeof value === "number") return value;
+	if (typeof value === "function") {
+		const result = value();
+		if (typeof result === "number") return result;
+		return result == null ? void 0 : result[prop];
+	}
+	return value == null ? void 0 : value[prop];
+}
+function getRestMs(value) {
+	if (typeof value === "function") return value();
+	return value;
+}
+function useHover(context, props) {
+	if (props === void 0) props = {};
+	const { open, onOpenChange, dataRef, events, elements } = context;
+	const { enabled = true, delay = 0, handleClose = null, mouseOnly = false, restMs = 0, move = true } = props;
+	const tree = useFloatingTree();
+	const parentId = useFloatingParentNodeId();
+	const handleCloseRef = useLatestRef(handleClose);
+	const delayRef = useLatestRef(delay);
+	const openRef = useLatestRef(open);
+	const restMsRef = useLatestRef(restMs);
+	const pointerTypeRef = React$1.useRef();
+	const timeoutRef = React$1.useRef(-1);
+	const handlerRef = React$1.useRef();
+	const restTimeoutRef = React$1.useRef(-1);
+	const blockMouseMoveRef = React$1.useRef(true);
+	const performedPointerEventsMutationRef = React$1.useRef(false);
+	const unbindMouseMoveRef = React$1.useRef(() => {});
+	const restTimeoutPendingRef = React$1.useRef(false);
+	const isHoverOpen = useEffectEvent(() => {
+		var _dataRef$current$open;
+		const type = (_dataRef$current$open = dataRef.current.openEvent) == null ? void 0 : _dataRef$current$open.type;
+		return (type == null ? void 0 : type.includes("mouse")) && type !== "mousedown";
+	});
+	React$1.useEffect(() => {
+		if (!enabled) return;
+		function onOpenChange$1(_ref) {
+			let { open: open$1 } = _ref;
+			if (!open$1) {
+				clearTimeoutIfSet(timeoutRef);
+				clearTimeoutIfSet(restTimeoutRef);
+				blockMouseMoveRef.current = true;
+				restTimeoutPendingRef.current = false;
+			}
+		}
+		events.on("openchange", onOpenChange$1);
+		return () => {
+			events.off("openchange", onOpenChange$1);
+		};
+	}, [enabled, events]);
+	React$1.useEffect(() => {
+		if (!enabled) return;
+		if (!handleCloseRef.current) return;
+		if (!open) return;
+		function onLeave(event) {
+			if (isHoverOpen()) onOpenChange(false, event, "hover");
+		}
+		const html = getDocument(elements.floating).documentElement;
+		html.addEventListener("mouseleave", onLeave);
+		return () => {
+			html.removeEventListener("mouseleave", onLeave);
+		};
+	}, [
+		elements.floating,
+		open,
+		onOpenChange,
+		enabled,
+		handleCloseRef,
+		isHoverOpen
+	]);
+	const closeWithDelay = React$1.useCallback(function(event, runElseBranch, reason) {
+		if (runElseBranch === void 0) runElseBranch = true;
+		if (reason === void 0) reason = "hover";
+		const closeDelay = getDelay(delayRef.current, "close", pointerTypeRef.current);
+		if (closeDelay && !handlerRef.current) {
+			clearTimeoutIfSet(timeoutRef);
+			timeoutRef.current = window.setTimeout(() => onOpenChange(false, event, reason), closeDelay);
+		} else if (runElseBranch) {
+			clearTimeoutIfSet(timeoutRef);
+			onOpenChange(false, event, reason);
+		}
+	}, [delayRef, onOpenChange]);
+	const cleanupMouseMoveHandler = useEffectEvent(() => {
+		unbindMouseMoveRef.current();
+		handlerRef.current = void 0;
+	});
+	const clearPointerEvents = useEffectEvent(() => {
+		if (performedPointerEventsMutationRef.current) {
+			const body = getDocument(elements.floating).body;
+			body.style.pointerEvents = "";
+			body.removeAttribute(safePolygonIdentifier);
+			performedPointerEventsMutationRef.current = false;
+		}
+	});
+	const isClickLikeOpenEvent = useEffectEvent(() => {
+		return dataRef.current.openEvent ? ["click", "mousedown"].includes(dataRef.current.openEvent.type) : false;
+	});
+	React$1.useEffect(() => {
+		if (!enabled) return;
+		function onReferenceMouseEnter(event) {
+			clearTimeoutIfSet(timeoutRef);
+			blockMouseMoveRef.current = false;
+			if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current) || getRestMs(restMsRef.current) > 0 && !getDelay(delayRef.current, "open")) return;
+			const openDelay = getDelay(delayRef.current, "open", pointerTypeRef.current);
+			if (openDelay) timeoutRef.current = window.setTimeout(() => {
+				if (!openRef.current) onOpenChange(true, event, "hover");
+			}, openDelay);
+			else if (!open) onOpenChange(true, event, "hover");
+		}
+		function onReferenceMouseLeave(event) {
+			if (isClickLikeOpenEvent()) {
+				clearPointerEvents();
+				return;
+			}
+			unbindMouseMoveRef.current();
+			const doc = getDocument(elements.floating);
+			clearTimeoutIfSet(restTimeoutRef);
+			restTimeoutPendingRef.current = false;
+			if (handleCloseRef.current && dataRef.current.floatingContext) {
+				if (!open) clearTimeoutIfSet(timeoutRef);
+				handlerRef.current = handleCloseRef.current({
+					...dataRef.current.floatingContext,
+					tree,
+					x: event.clientX,
+					y: event.clientY,
+					onClose() {
+						clearPointerEvents();
+						cleanupMouseMoveHandler();
+						if (!isClickLikeOpenEvent()) closeWithDelay(event, true, "safe-polygon");
+					}
+				});
+				const handler = handlerRef.current;
+				doc.addEventListener("mousemove", handler);
+				unbindMouseMoveRef.current = () => {
+					doc.removeEventListener("mousemove", handler);
+				};
+				return;
+			}
+			if (pointerTypeRef.current === "touch" ? !contains(elements.floating, event.relatedTarget) : true) closeWithDelay(event);
+		}
+		function onScrollMouseLeave(event) {
+			if (isClickLikeOpenEvent()) return;
+			if (!dataRef.current.floatingContext) return;
+			handleCloseRef.current == null || handleCloseRef.current({
+				...dataRef.current.floatingContext,
+				tree,
+				x: event.clientX,
+				y: event.clientY,
+				onClose() {
+					clearPointerEvents();
+					cleanupMouseMoveHandler();
+					if (!isClickLikeOpenEvent()) closeWithDelay(event);
+				}
+			})(event);
+		}
+		function onFloatingMouseEnter() {
+			clearTimeoutIfSet(timeoutRef);
+		}
+		function onFloatingMouseLeave(event) {
+			if (!isClickLikeOpenEvent()) closeWithDelay(event, false);
+		}
+		if (isElement(elements.domReference)) {
+			const reference$1 = elements.domReference;
+			const floating = elements.floating;
+			if (open) reference$1.addEventListener("mouseleave", onScrollMouseLeave);
+			if (move) reference$1.addEventListener("mousemove", onReferenceMouseEnter, { once: true });
+			reference$1.addEventListener("mouseenter", onReferenceMouseEnter);
+			reference$1.addEventListener("mouseleave", onReferenceMouseLeave);
+			if (floating) {
+				floating.addEventListener("mouseleave", onScrollMouseLeave);
+				floating.addEventListener("mouseenter", onFloatingMouseEnter);
+				floating.addEventListener("mouseleave", onFloatingMouseLeave);
+			}
+			return () => {
+				if (open) reference$1.removeEventListener("mouseleave", onScrollMouseLeave);
+				if (move) reference$1.removeEventListener("mousemove", onReferenceMouseEnter);
+				reference$1.removeEventListener("mouseenter", onReferenceMouseEnter);
+				reference$1.removeEventListener("mouseleave", onReferenceMouseLeave);
+				if (floating) {
+					floating.removeEventListener("mouseleave", onScrollMouseLeave);
+					floating.removeEventListener("mouseenter", onFloatingMouseEnter);
+					floating.removeEventListener("mouseleave", onFloatingMouseLeave);
+				}
+			};
+		}
+	}, [
+		elements,
+		enabled,
+		context,
+		mouseOnly,
+		move,
+		closeWithDelay,
+		cleanupMouseMoveHandler,
+		clearPointerEvents,
+		onOpenChange,
+		open,
+		openRef,
+		tree,
+		delayRef,
+		handleCloseRef,
+		dataRef,
+		isClickLikeOpenEvent,
+		restMsRef
+	]);
+	index(() => {
+		var _handleCloseRef$curre;
+		if (!enabled) return;
+		if (open && (_handleCloseRef$curre = handleCloseRef.current) != null && (_handleCloseRef$curre = _handleCloseRef$curre.__options) != null && _handleCloseRef$curre.blockPointerEvents && isHoverOpen()) {
+			performedPointerEventsMutationRef.current = true;
+			const floatingEl = elements.floating;
+			if (isElement(elements.domReference) && floatingEl) {
+				var _tree$nodesRef$curren;
+				const body = getDocument(elements.floating).body;
+				body.setAttribute(safePolygonIdentifier, "");
+				const ref = elements.domReference;
+				const parentFloating = tree == null || (_tree$nodesRef$curren = tree.nodesRef.current.find((node) => node.id === parentId)) == null || (_tree$nodesRef$curren = _tree$nodesRef$curren.context) == null ? void 0 : _tree$nodesRef$curren.elements.floating;
+				if (parentFloating) parentFloating.style.pointerEvents = "";
+				body.style.pointerEvents = "none";
+				ref.style.pointerEvents = "auto";
+				floatingEl.style.pointerEvents = "auto";
+				return () => {
+					body.style.pointerEvents = "";
+					ref.style.pointerEvents = "";
+					floatingEl.style.pointerEvents = "";
+				};
+			}
+		}
+	}, [
+		enabled,
+		open,
+		parentId,
+		elements,
+		tree,
+		handleCloseRef,
+		isHoverOpen
+	]);
+	index(() => {
+		if (!open) {
+			pointerTypeRef.current = void 0;
+			restTimeoutPendingRef.current = false;
+			cleanupMouseMoveHandler();
+			clearPointerEvents();
+		}
+	}, [
+		open,
+		cleanupMouseMoveHandler,
+		clearPointerEvents
+	]);
+	React$1.useEffect(() => {
+		return () => {
+			cleanupMouseMoveHandler();
+			clearTimeoutIfSet(timeoutRef);
+			clearTimeoutIfSet(restTimeoutRef);
+			clearPointerEvents();
+		};
+	}, [
+		enabled,
+		elements.domReference,
+		cleanupMouseMoveHandler,
+		clearPointerEvents
+	]);
+	const reference = React$1.useMemo(() => {
+		function setPointerRef(event) {
+			pointerTypeRef.current = event.pointerType;
+		}
+		return {
+			onPointerDown: setPointerRef,
+			onPointerEnter: setPointerRef,
+			onMouseMove(event) {
+				const { nativeEvent } = event;
+				function handleMouseMove() {
+					if (!blockMouseMoveRef.current && !openRef.current) onOpenChange(true, nativeEvent, "hover");
+				}
+				if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current)) return;
+				if (open || getRestMs(restMsRef.current) === 0) return;
+				if (restTimeoutPendingRef.current && event.movementX ** 2 + event.movementY ** 2 < 2) return;
+				clearTimeoutIfSet(restTimeoutRef);
+				if (pointerTypeRef.current === "touch") handleMouseMove();
+				else {
+					restTimeoutPendingRef.current = true;
+					restTimeoutRef.current = window.setTimeout(handleMouseMove, getRestMs(restMsRef.current));
+				}
+			}
+		};
+	}, [
+		mouseOnly,
+		onOpenChange,
+		open,
+		openRef,
+		restMsRef
+	]);
+	return React$1.useMemo(() => enabled ? { reference } : {}, [enabled, reference]);
+}
+var NOOP = () => {};
+var FloatingDelayGroupContext = /* @__PURE__ */ React$1.createContext({
+	delay: 0,
+	initialDelay: 0,
+	timeoutMs: 0,
+	currentId: null,
+	setCurrentId: NOOP,
+	setState: NOOP,
+	isInstantPhase: false
+});
+function FloatingDelayGroup(props) {
+	const { children, delay, timeoutMs = 0 } = props;
+	const [state, setState] = React$1.useReducer((prev, next) => ({
+		...prev,
+		...next
+	}), {
+		delay,
+		timeoutMs,
+		initialDelay: delay,
+		currentId: null,
+		isInstantPhase: false
+	});
+	const initialCurrentIdRef = React$1.useRef(null);
+	const setCurrentId = React$1.useCallback((currentId) => {
+		setState({ currentId });
+	}, []);
+	index(() => {
+		if (state.currentId) {
+			if (initialCurrentIdRef.current === null) initialCurrentIdRef.current = state.currentId;
+			else if (!state.isInstantPhase) setState({ isInstantPhase: true });
+		} else {
+			if (state.isInstantPhase) setState({ isInstantPhase: false });
+			initialCurrentIdRef.current = null;
+		}
+	}, [state.currentId, state.isInstantPhase]);
+	return /* @__PURE__ */ jsx(FloatingDelayGroupContext.Provider, {
+		value: React$1.useMemo(() => ({
+			...state,
+			setState,
+			setCurrentId
+		}), [state, setCurrentId]),
+		children
+	});
+}
+var rafId = 0;
+function enqueueFocus(el, options) {
+	if (options === void 0) options = {};
+	const { preventScroll = false, cancelPrevious = true, sync = false } = options;
+	cancelPrevious && cancelAnimationFrame(rafId);
+	const exec = () => el == null ? void 0 : el.focus({ preventScroll });
+	if (sync) exec();
+	else rafId = requestAnimationFrame(exec);
+}
+function getDocument$1(node) {
+	return (node == null ? void 0 : node.ownerDocument) || document;
+}
+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$1 = 0;
+var supportsInert = () => typeof HTMLElement !== "undefined" && "inert" in HTMLElement.prototype;
+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-floating-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);
+		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$1) {
+			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, inert) {
+	if (ariaHidden === void 0) ariaHidden = false;
+	if (inert === void 0) inert = false;
+	const body = getDocument$1(avoidElements[0]).body;
+	return applyAttributeToOthers(avoidElements.concat(Array.from(body.querySelectorAll("[aria-live],[role=\"status\"],output"))), body, ariaHidden, inert);
+}
+var HIDDEN_STYLES = {
+	border: 0,
+	clip: "rect(0 0 0 0)",
+	height: "1px",
+	margin: "-1px",
+	overflow: "hidden",
+	padding: 0,
+	position: "fixed",
+	whiteSpace: "nowrap",
+	width: "1px",
+	top: 0,
+	left: 0
+};
+var FocusGuard = /* @__PURE__ */ React$1.forwardRef(function FocusGuard$1(props, ref) {
+	const [role, setRole] = React$1.useState();
+	index(() => {
+		if (isSafari()) setRole("button");
+	}, []);
+	const restProps = {
+		ref,
+		tabIndex: 0,
+		role,
+		"aria-hidden": role ? void 0 : true,
+		[createAttribute("focus-guard")]: "",
+		style: HIDDEN_STYLES
+	};
+	return /* @__PURE__ */ jsx("span", {
+		...props,
+		...restProps
+	});
+});
+var PortalContext = /* @__PURE__ */ React$1.createContext(null);
+var usePortalContext = () => React$1.useContext(PortalContext);
+function useLiteMergeRefs(refs) {
+	return React$1.useMemo(() => {
+		return (value) => {
+			refs.forEach((ref) => {
+				if (ref) ref.current = value;
+			});
+		};
+	}, refs);
+}
+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(-20);
+	}
+}
+function getPreviouslyFocusedElement() {
+	clearDisconnectedPreviouslyFocusedElements();
+	return previouslyFocusedElements[previouslyFocusedElements.length - 1];
+}
+function getFirstTabbableElement(container) {
+	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.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");
+	}
+}
+var VisuallyHiddenDismiss = /* @__PURE__ */ React$1.forwardRef(function VisuallyHiddenDismiss$1(props, ref) {
+	return /* @__PURE__ */ jsx("button", {
+		...props,
+		type: "button",
+		ref,
+		tabIndex: -1,
+		style: HIDDEN_STYLES
+	});
+});
+function FloatingFocusManager(props) {
+	const { context, children, disabled = false, order = ["content"], guards: _guards = true, initialFocus = 0, returnFocus = true, restoreFocus = false, modal = true, visuallyHiddenDismiss = false, closeOnFocusOut = true, outsideElementsInert = false, getInsideElements: _getInsideElements = () => [] } = props;
+	const { open, onOpenChange, events, dataRef, elements: { domReference, floating } } = context;
+	const getNodeId = useEffectEvent(() => {
+		var _dataRef$current$floa;
+		return (_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.nodeId;
+	});
+	const getInsideElements = useEffectEvent(_getInsideElements);
+	const ignoreInitialFocus = typeof initialFocus === "number" && initialFocus < 0;
+	const isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;
+	const inertSupported = supportsInert();
+	const guards = inertSupported ? _guards : true;
+	const useInert = !guards || inertSupported && outsideElementsInert;
+	const orderRef = useLatestRef(order);
+	const initialFocusRef = useLatestRef(initialFocus);
+	const returnFocusRef = useLatestRef(returnFocus);
+	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 blurTimeoutRef = React$1.useRef(-1);
+	const isInsidePortal = portalContext != null;
+	const floatingFocusElement = getFloatingFocusElement(floating);
+	const getTabbableContent = useEffectEvent(function(container) {
+		if (container === void 0) container = floatingFocusElement;
+		return container ? tabbable(container, getTabbableOptions()) : [];
+	});
+	const getTabbableElements = useEffectEvent((container) => {
+		const content = getTabbableContent(container);
+		return orderRef.current.map((type) => {
+			if (domReference && type === "reference") return domReference;
+			if (floatingFocusElement && type === "floating") return floatingFocusElement;
+			return 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 els = getTabbableElements();
+				const target = getTarget(event);
+				if (orderRef.current[0] === "reference" && target === domReference) {
+					stopEvent(event);
+					if (event.shiftKey) enqueueFocus(els[els.length - 1]);
+					else enqueueFocus(els[1]);
+				}
+				if (orderRef.current[1] === "floating" && target === floatingFocusElement && event.shiftKey) {
+					stopEvent(event);
+					enqueueFocus(els[0]);
+				}
+			}
+		}
+		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) return;
+		if (!closeOnFocusOut) return;
+		function handlePointerDown() {
+			isPointerDownRef.current = true;
+			setTimeout(() => {
+				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 ? void 0 : portalContext.portalNode, relatedTarget) || relatedTarget != null && 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 ? void 0 : _node$context.elements.floating, relatedTarget) || contains((_node$context2 = node.context) == null ? 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 ? void 0 : _node$context3.elements.floating, getFloatingFocusElement((_node$context4 = node.context) == null ? void 0 : _node$context4.elements.floating)].includes(relatedTarget) || ((_node$context5 = node.context) == null ? void 0 : _node$context5.elements.domReference) === relatedTarget;
+				})));
+				if (currentTarget === domReference && floatingFocusElement) handleTabIndex(floatingFocusElement, orderRef);
+				if (restoreFocus && currentTarget !== domReference && !(target != null && target.isConnected) && activeElement(getDocument(floatingFocusElement)) === getDocument(floatingFocusElement).body) {
+					if (isHTMLElement(floatingFocusElement)) floatingFocusElement.focus();
+					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 && !isPointerDownRef.current && relatedTarget !== getPreviouslyFocusedElement()) {
+					preventReturnFocusRef.current = true;
+					onOpenChange(false, event, "focus-out");
+				}
+			});
+		}
+		const shouldHandleBlurCapture = Boolean(!tree && portalContext);
+		function markInsideReactTree() {
+			clearTimeoutIfSet(blurTimeoutRef);
+			dataRef.current.insideReactTree = true;
+			blurTimeoutRef.current = window.setTimeout(() => {
+				dataRef.current.insideReactTree = false;
+			});
+		}
+		if (floating && isHTMLElement(domReference)) {
+			domReference.addEventListener("focusout", handleFocusOutside);
+			domReference.addEventListener("pointerdown", handlePointerDown);
+			floating.addEventListener("focusout", handleFocusOutside);
+			if (shouldHandleBlurCapture) floating.addEventListener("focusout", markInsideReactTree, true);
+			return () => {
+				domReference.removeEventListener("focusout", handleFocusOutside);
+				domReference.removeEventListener("pointerdown", handlePointerDown);
+				floating.removeEventListener("focusout", handleFocusOutside);
+				if (shouldHandleBlurCapture) floating.removeEventListener("focusout", markInsideReactTree, true);
+			};
+		}
+	}, [
+		disabled,
+		domReference,
+		floating,
+		floatingFocusElement,
+		modal,
+		tree,
+		portalContext,
+		onOpenChange,
+		closeOnFocusOut,
+		restoreFocus,
+		getTabbableContent,
+		isUntrappedTypeableCombobox,
+		getNodeId,
+		orderRef,
+		dataRef
+	]);
+	const beforeGuardRef = React$1.useRef(null);
+	const afterGuardRef = React$1.useRef(null);
+	const mergedBeforeGuardRef = useLiteMergeRefs([beforeGuardRef, portalContext == null ? void 0 : portalContext.beforeInsideRef]);
+	const mergedAfterGuardRef = useLiteMergeRefs([afterGuardRef, portalContext == null ? void 0 : portalContext.afterInsideRef]);
+	React$1.useEffect(() => {
+		var _portalContext$portal, _ancestors$find;
+		if (disabled) return;
+		if (!floating) return;
+		const portalNodes = Array.from((portalContext == null || (_portalContext$portal = portalContext.portalNode) == null ? void 0 : _portalContext$portal.querySelectorAll("[" + createAttribute("portal") + "]")) || []);
+		const insideElements = [
+			floating,
+			(_ancestors$find = (tree ? getNodeAncestors(tree.nodesRef.current, getNodeId()) : []).find((node) => {
+				var _node$context6;
+				return isTypeableCombobox(((_node$context6 = node.context) == null ? void 0 : _node$context6.elements.domReference) || null);
+			})) == null || (_ancestors$find = _ancestors$find.context) == null ? void 0 : _ancestors$find.elements.domReference,
+			...portalNodes,
+			...getInsideElements(),
+			startDismissButtonRef.current,
+			endDismissButtonRef.current,
+			beforeGuardRef.current,
+			afterGuardRef.current,
+			portalContext == null ? void 0 : portalContext.beforeOutsideRef.current,
+			portalContext == null ? void 0 : portalContext.afterOutsideRef.current,
+			orderRef.current.includes("reference") || isUntrappedTypeableCombobox ? domReference : null
+		].filter((x) => x != null);
+		const cleanup = modal || isUntrappedTypeableCombobox ? markOthers(insideElements, !useInert, useInert) : markOthers(insideElements);
+		return () => {
+			cleanup();
+		};
+	}, [
+		disabled,
+		domReference,
+		floating,
+		modal,
+		orderRef,
+		portalContext,
+		isUntrappedTypeableCombobox,
+		guards,
+		useInert,
+		tree,
+		getNodeId,
+		getInsideElements
+	]);
+	index(() => {
+		if (disabled || !isHTMLElement(floatingFocusElement)) return;
+		const previouslyFocusedElement = activeElement(getDocument(floatingFocusElement));
+		queueMicrotask(() => {
+			const focusableElements = getTabbableElements(floatingFocusElement);
+			const initialFocusValue = initialFocusRef.current;
+			const elToFocus = (typeof initialFocusValue === "number" ? focusableElements[initialFocusValue] : initialFocusValue.current) || floatingFocusElement;
+			const focusAlreadyInsideFloatingEl = contains(floatingFocusElement, previouslyFocusedElement);
+			if (!ignoreInitialFocus && !focusAlreadyInsideFloatingEl && open) enqueueFocus(elToFocus, { preventScroll: elToFocus === floatingFocusElement });
+		});
+	}, [
+		disabled,
+		open,
+		floatingFocusElement,
+		ignoreInitialFocus,
+		getTabbableElements,
+		initialFocusRef
+	]);
+	index(() => {
+		if (disabled || !floatingFocusElement) return;
+		const doc = getDocument(floatingFocusElement);
+		addPreviouslyFocusedElement(activeElement(doc));
+		function onOpenChange$1(_ref) {
+			let { reason, event, nested } = _ref;
+			if (["hover", "safe-polygon"].includes(reason) && event.type === "mouseleave") preventReturnFocusRef.current = true;
+			if (reason !== "outside-press") return;
+			if (nested) preventReturnFocusRef.current = false;
+			else if (isVirtualClick(event) || isVirtualPointerEvent(event)) 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", onOpenChange$1);
+		const fallbackEl = doc.createElement("span");
+		fallbackEl.setAttribute("tabindex", "-1");
+		fallbackEl.setAttribute("aria-hidden", "true");
+		Object.assign(fallbackEl.style, HIDDEN_STYLES);
+		if (isInsidePortal && domReference) domReference.insertAdjacentElement("afterend", fallbackEl);
+		function getReturnElement() {
+			if (typeof returnFocusRef.current === "boolean") {
+				const el = domReference || getPreviouslyFocusedElement();
+				return el && el.isConnected ? el : fallbackEl;
+			}
+			return returnFocusRef.current.current || fallbackEl;
+		}
+		return () => {
+			events.off("openchange", onOpenChange$1);
+			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 ? void 0 : _node$context7.elements.floating, activeEl);
+			});
+			const returnElement = getReturnElement();
+			queueMicrotask(() => {
+				const tabbableReturnElement = getFirstTabbableElement(returnElement);
+				if (returnFocusRef.current && !preventReturnFocusRef.current && isHTMLElement(tabbableReturnElement) && (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;
+		});
+		return () => {
+			queueMicrotask(clearDisconnectedPreviouslyFocusedElements);
+		};
+	}, [disabled]);
+	index(() => {
+		if (disabled) return;
+		if (!portalContext) return;
+		portalContext.setFocusManagerState({
+			modal,
+			closeOnFocusOut,
+			open,
+			onOpenChange,
+			domReference
+		});
+		return () => {
+			portalContext.setFocusManagerState(null);
+		};
+	}, [
+		disabled,
+		portalContext,
+		modal,
+		open,
+		onOpenChange,
+		closeOnFocusOut,
+		domReference
+	]);
+	index(() => {
+		if (disabled) return;
+		if (!floatingFocusElement) return;
+		handleTabIndex(floatingFocusElement, orderRef);
+	}, [
+		disabled,
+		floatingFocusElement,
+		orderRef
+	]);
+	function renderDismissButton(location) {
+		if (disabled || !visuallyHiddenDismiss || !modal) return null;
+		return /* @__PURE__ */ jsx(VisuallyHiddenDismiss, {
+			ref: location === "start" ? startDismissButtonRef : endDismissButtonRef,
+			onClick: (event) => onOpenChange(false, event.nativeEvent),
+			children: typeof visuallyHiddenDismiss === "string" ? visuallyHiddenDismiss : "Dismiss"
+		});
+	}
+	const shouldRenderGuards = !disabled && guards && (modal ? !isUntrappedTypeableCombobox : true) && (isInsidePortal || modal);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		shouldRenderGuards && /* @__PURE__ */ jsx(FocusGuard, {
+			"data-type": "inside",
+			ref: mergedBeforeGuardRef,
+			onFocus: (event) => {
+				if (modal) {
+					const els = getTabbableElements();
+					enqueueFocus(order[0] === "reference" ? els[0] : els[els.length - 1]);
+				} else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {
+					preventReturnFocusRef.current = false;
+					if (isOutsideEvent(event, portalContext.portalNode)) getNextTabbable(domReference)?.focus();
+					else {
+						var _portalContext$before;
+						(_portalContext$before = portalContext.beforeOutsideRef.current) == null || _portalContext$before.focus();
+					}
+				}
+			}
+		}),
+		!isUntrappedTypeableCombobox && renderDismissButton("start"),
+		children,
+		renderDismissButton("end"),
+		shouldRenderGuards && /* @__PURE__ */ jsx(FocusGuard, {
+			"data-type": "inside",
+			ref: mergedAfterGuardRef,
+			onFocus: (event) => {
+				if (modal) enqueueFocus(getTabbableElements()[0]);
+				else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {
+					if (closeOnFocusOut) preventReturnFocusRef.current = true;
+					if (isOutsideEvent(event, portalContext.portalNode)) getPreviousTabbable(domReference)?.focus();
+					else {
+						var _portalContext$afterO;
+						(_portalContext$afterO = portalContext.afterOutsideRef.current) == null || _portalContext$afterO.focus();
+					}
+				}
+			}
+		})
+	] });
+}
+function isButtonTarget(event) {
+	return isHTMLElement(event.target) && event.target.tagName === "BUTTON";
+}
+function isAnchorTarget(event) {
+	return isHTMLElement(event.target) && event.target.tagName === "A";
+}
+function isSpaceIgnored(element) {
+	return isTypeableElement(element);
+}
+function useClick(context, props) {
+	if (props === void 0) props = {};
+	const { open, onOpenChange, dataRef, elements: { domReference } } = context;
+	const { enabled = true, event: eventOption = "click", toggle = true, ignoreMouse = false, keyboardHandlers = true, stickIfOpen = true } = props;
+	const pointerTypeRef = React$1.useRef();
+	const didKeyDownRef = React$1.useRef(false);
+	const reference = React$1.useMemo(() => ({
+		onPointerDown(event) {
+			pointerTypeRef.current = event.pointerType;
+		},
+		onMouseDown(event) {
+			const pointerType = pointerTypeRef.current;
+			if (event.button !== 0) return;
+			if (eventOption === "click") return;
+			if (isMouseLikePointerType(pointerType, true) && ignoreMouse) return;
+			if (open && toggle && (dataRef.current.openEvent && stickIfOpen ? dataRef.current.openEvent.type === "mousedown" : true)) onOpenChange(false, event.nativeEvent, "click");
+			else {
+				event.preventDefault();
+				onOpenChange(true, event.nativeEvent, "click");
+			}
+		},
+		onClick(event) {
+			const pointerType = pointerTypeRef.current;
+			if (eventOption === "mousedown" && pointerTypeRef.current) {
+				pointerTypeRef.current = void 0;
+				return;
+			}
+			if (isMouseLikePointerType(pointerType, true) && ignoreMouse) return;
+			if (open && toggle && (dataRef.current.openEvent && stickIfOpen ? dataRef.current.openEvent.type === "click" : true)) onOpenChange(false, event.nativeEvent, "click");
+			else onOpenChange(true, event.nativeEvent, "click");
+		},
+		onKeyDown(event) {
+			pointerTypeRef.current = void 0;
+			if (event.defaultPrevented || !keyboardHandlers || isButtonTarget(event)) return;
+			if (event.key === " " && !isSpaceIgnored(domReference)) {
+				event.preventDefault();
+				didKeyDownRef.current = true;
+			}
+			if (isAnchorTarget(event)) return;
+			if (event.key === "Enter") if (open && toggle) onOpenChange(false, event.nativeEvent, "click");
+			else onOpenChange(true, event.nativeEvent, "click");
+		},
+		onKeyUp(event) {
+			if (event.defaultPrevented || !keyboardHandlers || isButtonTarget(event) || isSpaceIgnored(domReference)) return;
+			if (event.key === " " && didKeyDownRef.current) {
+				didKeyDownRef.current = false;
+				if (open && toggle) onOpenChange(false, event.nativeEvent, "click");
+				else onOpenChange(true, event.nativeEvent, "click");
+			}
+		}
+	}), [
+		dataRef,
+		domReference,
+		eventOption,
+		ignoreMouse,
+		keyboardHandlers,
+		onOpenChange,
+		open,
+		stickIfOpen,
+		toggle
+	]);
+	return React$1.useMemo(() => enabled ? { reference } : {}, [enabled, reference]);
+}
+var bubbleHandlerKeys = {
+	pointerdown: "onPointerDown",
+	mousedown: "onMouseDown",
+	click: "onClick"
+};
+var captureHandlerKeys = {
+	pointerdown: "onPointerDownCapture",
+	mousedown: "onMouseDownCapture",
+	click: "onClickCapture"
+};
+var normalizeProp = (normalizable) => {
+	var _normalizable$escapeK, _normalizable$outside;
+	return {
+		escapeKey: typeof normalizable === "boolean" ? normalizable : (_normalizable$escapeK = normalizable == null ? void 0 : normalizable.escapeKey) != null ? _normalizable$escapeK : false,
+		outsidePress: typeof normalizable === "boolean" ? normalizable : (_normalizable$outside = normalizable == null ? void 0 : normalizable.outsidePress) != null ? _normalizable$outside : true
+	};
+};
+function useDismiss(context, props) {
+	if (props === void 0) props = {};
+	const { open, onOpenChange, elements, dataRef } = context;
+	const { enabled = true, escapeKey = true, outsidePress: unstable_outsidePress = true, outsidePressEvent = "pointerdown", referencePress = false, referencePressEvent = "pointerdown", ancestorScroll = false, bubbles, capture } = props;
+	const tree = useFloatingTree();
+	const outsidePressFn = useEffectEvent(typeof unstable_outsidePress === "function" ? unstable_outsidePress : () => false);
+	const outsidePress = typeof unstable_outsidePress === "function" ? outsidePressFn : unstable_outsidePress;
+	const endedOrStartedInsideRef = React$1.useRef(false);
+	const { escapeKey: escapeKeyBubbles, outsidePress: outsidePressBubbles } = normalizeProp(bubbles);
+	const { escapeKey: escapeKeyCapture, outsidePress: outsidePressCapture } = normalizeProp(capture);
+	const isComposingRef = React$1.useRef(false);
+	const closeOnEscapeKeyDown = useEffectEvent((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 ? void 0 : _dataRef$current$floa.nodeId;
+		const children = tree ? getNodeChildren(tree.nodesRef.current, nodeId) : [];
+		if (!escapeKeyBubbles) {
+			event.stopPropagation();
+			if (children.length > 0) {
+				let shouldDismiss = true;
+				children.forEach((child) => {
+					var _child$context;
+					if ((_child$context = child.context) != null && _child$context.open && !child.context.dataRef.current.__escapeKeyBubbles) {
+						shouldDismiss = false;
+						return;
+					}
+				});
+				if (!shouldDismiss) return;
+			}
+		}
+		onOpenChange(false, isReactEvent(event) ? event.nativeEvent : event, "escape-key");
+	});
+	const closeOnEscapeKeyDownCapture = useEffectEvent((event) => {
+		var _getTarget2;
+		const callback = () => {
+			var _getTarget;
+			closeOnEscapeKeyDown(event);
+			(_getTarget = getTarget(event)) == null || _getTarget.removeEventListener("keydown", callback);
+		};
+		(_getTarget2 = getTarget(event)) == null || _getTarget2.addEventListener("keydown", callback);
+	});
+	const closeOnPressOutside = useEffectEvent((event) => {
+		var _dataRef$current$floa2;
+		const insideReactTree = dataRef.current.insideReactTree;
+		dataRef.current.insideReactTree = false;
+		const endedOrStartedInside = endedOrStartedInsideRef.current;
+		endedOrStartedInsideRef.current = false;
+		if (outsidePressEvent === "click" && 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) && floating) {
+			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$1 = style.direction === "rtl";
+			const pressedVerticalScrollbar = canScrollY && (isRTL$1 ? 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 ? 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 ? 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.open && !child.context.dataRef.current.__outsidePressBubbles) {
+					shouldDismiss = false;
+					return;
+				}
+			});
+			if (!shouldDismiss) return;
+		}
+		onOpenChange(false, event, "outside-press");
+	});
+	const closeOnPressOutsideCapture = useEffectEvent((event) => {
+		var _getTarget4;
+		const callback = () => {
+			var _getTarget3;
+			closeOnPressOutside(event);
+			(_getTarget3 = getTarget(event)) == null || _getTarget3.removeEventListener(outsidePressEvent, callback);
+		};
+		(_getTarget4 = getTarget(event)) == null || _getTarget4.addEventListener(outsidePressEvent, callback);
+	});
+	React$1.useEffect(() => {
+		if (!open || !enabled) return;
+		dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
+		dataRef.current.__outsidePressBubbles = outsidePressBubbles;
+		let compositionTimeout = -1;
+		function onScroll(event) {
+			onOpenChange(false, event, "ancestor-scroll");
+		}
+		function handleCompositionStart() {
+			window.clearTimeout(compositionTimeout);
+			isComposingRef.current = true;
+		}
+		function handleCompositionEnd() {
+			compositionTimeout = window.setTimeout(() => {
+				isComposingRef.current = false;
+			}, isWebKit() ? 5 : 0);
+		}
+		const doc = getDocument(elements.floating);
+		if (escapeKey) {
+			doc.addEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
+			doc.addEventListener("compositionstart", handleCompositionStart);
+			doc.addEventListener("compositionend", handleCompositionEnd);
+		}
+		outsidePress && doc.addEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, 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 ? void 0 : _doc$defaultView.visualViewport);
+		});
+		ancestors.forEach((ancestor) => {
+			ancestor.addEventListener("scroll", onScroll, { passive: true });
+		});
+		return () => {
+			if (escapeKey) {
+				doc.removeEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
+				doc.removeEventListener("compositionstart", handleCompositionStart);
+				doc.removeEventListener("compositionend", handleCompositionEnd);
+			}
+			outsidePress && doc.removeEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
+			ancestors.forEach((ancestor) => {
+				ancestor.removeEventListener("scroll", onScroll);
+			});
+			window.clearTimeout(compositionTimeout);
+		};
+	}, [
+		dataRef,
+		elements,
+		escapeKey,
+		outsidePress,
+		outsidePressEvent,
+		open,
+		onOpenChange,
+		ancestorScroll,
+		enabled,
+		escapeKeyBubbles,
+		outsidePressBubbles,
+		closeOnEscapeKeyDown,
+		escapeKeyCapture,
+		closeOnEscapeKeyDownCapture,
+		closeOnPressOutside,
+		outsidePressCapture,
+		closeOnPressOutsideCapture
+	]);
+	React$1.useEffect(() => {
+		dataRef.current.insideReactTree = false;
+	}, [
+		dataRef,
+		outsidePress,
+		outsidePressEvent
+	]);
+	const reference = React$1.useMemo(() => ({
+		onKeyDown: closeOnEscapeKeyDown,
+		...referencePress && {
+			[bubbleHandlerKeys[referencePressEvent]]: (event) => {
+				onOpenChange(false, event.nativeEvent, "reference-press");
+			},
+			...referencePressEvent !== "click" && { onClick(event) {
+				onOpenChange(false, event.nativeEvent, "reference-press");
+			} }
+		}
+	}), [
+		closeOnEscapeKeyDown,
+		onOpenChange,
+		referencePress,
+		referencePressEvent
+	]);
+	const floating = React$1.useMemo(() => ({
+		onKeyDown: closeOnEscapeKeyDown,
+		onMouseDown() {
+			endedOrStartedInsideRef.current = true;
+		},
+		onMouseUp() {
+			endedOrStartedInsideRef.current = true;
+		},
+		[captureHandlerKeys[outsidePressEvent]]: () => {
+			dataRef.current.insideReactTree = true;
+		}
+	}), [
+		closeOnEscapeKeyDown,
+		outsidePressEvent,
+		dataRef
+	]);
+	return React$1.useMemo(() => enabled ? {
+		reference,
+		floating
+	} : {}, [
+		enabled,
+		reference,
+		floating
+	]);
+}
+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)) 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 = useEffectEvent((open$1, event, reason) => {
+		dataRef.current.openEvent = open$1 ? event : void 0;
+		events.emit("openchange", {
+			open: open$1,
+			event,
+			reason,
+			nested
+		});
+		onOpenChangeProp?.(open$1, event, reason);
+	});
+	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 useFloating$1(options) {
+	if (options === void 0) options = {};
+	const { nodeId } = options;
+	const internalRootContext = useFloatingRootContext({
+		...options,
+		elements: {
+			reference: null,
+			floating: null,
+			...options.elements
+		}
+	});
+	const rootContext = options.rootContext || internalRootContext;
+	const computedElements = rootContext.elements;
+	const [_domReference, setDomReference] = React$1.useState(null);
+	const [positionReference, _setPositionReference] = React$1.useState(null);
+	const domReference = (computedElements == null ? void 0 : computedElements.domReference) || _domReference;
+	const domReferenceRef = React$1.useRef(null);
+	const tree = useFloatingTree();
+	index(() => {
+		if (domReference) domReferenceRef.current = domReference;
+	}, [domReference]);
+	const position = useFloating({
+		...options,
+		elements: {
+			...computedElements,
+			...positionReference && { reference: positionReference }
+		}
+	});
+	const setPositionReference = React$1.useCallback((node) => {
+		const computedPositionReference = isElement(node) ? {
+			getBoundingClientRect: () => node.getBoundingClientRect(),
+			getClientRects: () => node.getClientRects(),
+			contextElement: node
+		} : node;
+		_setPositionReference(computedPositionReference);
+		position.refs.setReference(computedPositionReference);
+	}, [position.refs]);
+	const setReference = React$1.useCallback((node) => {
+		if (isElement(node) || node === null) {
+			domReferenceRef.current = node;
+			setDomReference(node);
+		}
+		if (isElement(position.refs.reference.current) || position.refs.reference.current === null || node !== null && !isElement(node)) position.refs.setReference(node);
+	}, [position.refs]);
+	const refs = React$1.useMemo(() => ({
+		...position.refs,
+		setReference,
+		setPositionReference,
+		domReference: domReferenceRef
+	}), [
+		position.refs,
+		setReference,
+		setPositionReference
+	]);
+	const elements = React$1.useMemo(() => ({
+		...position.elements,
+		domReference
+	}), [position.elements, domReference]);
+	const context = React$1.useMemo(() => ({
+		...position,
+		...rootContext,
+		refs,
+		elements,
+		nodeId
+	}), [
+		position,
+		refs,
+		elements,
+		nodeId,
+		rootContext
+	]);
+	index(() => {
+		rootContext.dataRef.current.floatingContext = context;
+		const node = tree == null ? void 0 : tree.nodesRef.current.find((node$1) => node$1.id === nodeId);
+		if (node) node.context = context;
+	});
+	return React$1.useMemo(() => ({
+		...position,
+		context,
+		refs,
+		elements
+	}), [
+		position,
+		refs,
+		elements,
+		context
+	]);
+}
+function isMacSafari() {
+	return isMac() && isSafari();
+}
+function useFocus(context, props) {
+	if (props === void 0) props = {};
+	const { open, onOpenChange, events, dataRef, elements } = context;
+	const { enabled = true, visibleOnly = true } = props;
+	const blockFocusRef = React$1.useRef(false);
+	const timeoutRef = React$1.useRef(-1);
+	const keyboardModalityRef = React$1.useRef(true);
+	React$1.useEffect(() => {
+		if (!enabled) return;
+		const win = getWindow(elements.domReference);
+		function onBlur() {
+			if (!open && isHTMLElement(elements.domReference) && elements.domReference === activeElement(getDocument(elements.domReference))) blockFocusRef.current = true;
+		}
+		function onKeyDown() {
+			keyboardModalityRef.current = true;
+		}
+		function onPointerDown() {
+			keyboardModalityRef.current = false;
+		}
+		win.addEventListener("blur", onBlur);
+		if (isMacSafari()) {
+			win.addEventListener("keydown", onKeyDown, true);
+			win.addEventListener("pointerdown", onPointerDown, true);
+		}
+		return () => {
+			win.removeEventListener("blur", onBlur);
+			if (isMacSafari()) {
+				win.removeEventListener("keydown", onKeyDown, true);
+				win.removeEventListener("pointerdown", onPointerDown, true);
+			}
+		};
+	}, [
+		elements.domReference,
+		open,
+		enabled
+	]);
+	React$1.useEffect(() => {
+		if (!enabled) return;
+		function onOpenChange$1(_ref) {
+			let { reason } = _ref;
+			if (reason === "reference-press" || reason === "escape-key") blockFocusRef.current = true;
+		}
+		events.on("openchange", onOpenChange$1);
+		return () => {
+			events.off("openchange", onOpenChange$1);
+		};
+	}, [events, enabled]);
+	React$1.useEffect(() => {
+		return () => {
+			clearTimeoutIfSet(timeoutRef);
+		};
+	}, []);
+	const reference = React$1.useMemo(() => ({
+		onMouseLeave() {
+			blockFocusRef.current = false;
+		},
+		onFocus(event) {
+			if (blockFocusRef.current) return;
+			const target = getTarget(event.nativeEvent);
+			if (visibleOnly && isElement(target)) {
+				if (isMacSafari() && !event.relatedTarget) {
+					if (!keyboardModalityRef.current && !isTypeableElement(target)) return;
+				} else if (!matchesFocusVisible(target)) return;
+			}
+			onOpenChange(true, event.nativeEvent, "focus");
+		},
+		onBlur(event) {
+			blockFocusRef.current = false;
+			const relatedTarget = event.relatedTarget;
+			const nativeEvent = event.nativeEvent;
+			const movedToFocusGuard = isElement(relatedTarget) && relatedTarget.hasAttribute(createAttribute("focus-guard")) && relatedTarget.getAttribute("data-type") === "outside";
+			timeoutRef.current = window.setTimeout(() => {
+				var _dataRef$current$floa;
+				const activeEl = activeElement(elements.domReference ? elements.domReference.ownerDocument : document);
+				if (!relatedTarget && activeEl === elements.domReference) return;
+				if (contains((_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.refs.floating.current, activeEl) || contains(elements.domReference, activeEl) || movedToFocusGuard) return;
+				onOpenChange(false, nativeEvent, "focus");
+			});
+		}
+	}), [
+		dataRef,
+		elements.domReference,
+		onOpenChange,
+		visibleOnly
+	]);
+	return React$1.useMemo(() => enabled ? { reference } : {}, [enabled, reference]);
+}
+function mergeProps(userProps, propsList, elementKey) {
+	const map = /* @__PURE__ */ new Map();
+	const isItem = elementKey === "item";
+	let domUserProps = userProps;
+	if (isItem && userProps) {
+		const { [ACTIVE_KEY]: _, [SELECTED_KEY]: __, ...validProps } = userProps;
+		domUserProps = validProps;
+	}
+	return {
+		...elementKey === "floating" && {
+			tabIndex: -1,
+			[FOCUSABLE_ATTRIBUTE]: ""
+		},
+		...domUserProps,
+		...propsList.map((value) => {
+			const propsOrGetProps = value ? value[elementKey] : null;
+			if (typeof propsOrGetProps === "function") return userProps ? propsOrGetProps(userProps) : null;
+			return propsOrGetProps;
+		}).concat(userProps).reduce((acc, props) => {
+			if (!props) return acc;
+			Object.entries(props).forEach((_ref) => {
+				let [key, value] = _ref;
+				if (isItem && [ACTIVE_KEY, SELECTED_KEY].includes(key)) return;
+				if (key.indexOf("on") === 0) {
+					if (!map.has(key)) map.set(key, []);
+					if (typeof value === "function") {
+						var _map$get;
+						(_map$get = map.get(key)) == null || _map$get.push(value);
+						acc[key] = function() {
+							var _map$get2;
+							for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+							return (_map$get2 = map.get(key)) == null ? void 0 : _map$get2.map((fn) => fn(...args)).find((val) => val !== void 0);
+						};
+					}
+				} else acc[key] = value;
+			});
+			return acc;
+		}, {})
+	};
+}
+function useInteractions(propsList) {
+	if (propsList === void 0) propsList = [];
+	const referenceDeps = propsList.map((key) => key == null ? void 0 : key.reference);
+	const floatingDeps = propsList.map((key) => key == null ? void 0 : key.floating);
+	const itemDeps = propsList.map((key) => key == null ? 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
+	]);
+}
+export { autoUpdate as _, useDismiss as a, useHover as c, arrow as d, flip as f, size as g, shift as h, useClick as i, useInteractions as l, offset as m, FloatingDelayGroup as n, useFloating$1 as o, hide as p, FloatingFocusManager as r, useFocus as s, FloatingArrow as t, useMergeRefs as u };
+
+//# sourceMappingURL=floating-ui.react.js.map