@helsenorge/designsystem-react 14.9.2 → 15.0.0-beta.1

package/lib/floating-ui.react.js

@@ -2,6 +2,7 @@ import * as React$1 from "react";
 import { useLayoutEffect } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import * as ReactDOM from "react-dom";
+//#region ../../node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
 function hasWindow() {
 	return typeof window !== "undefined";
 }
@@ -113,6 +114,12 @@ function getOverflowAncestors(node, list, traverseIframes) {
 function getFrameElement(win) {
 	return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
 }
+//#endregion
+//#region ../../node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
+/**
+* Custom positioning reference element.
+* @see https://floating-ui.com/docs/virtual-elements
+*/
 var sides = [
 	"top",
 	"right",
@@ -236,6 +243,10 @@ function rectToClientRect(rect) {
 		y
 	};
 }
+/*!
+* tabbable 6.4.0
+* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
+*/
 var candidateSelector = /* @__PURE__ */ [
 	"input:not([inert]):not([inert] *)",
 	"select:not([inert]):not([inert] *)",
@@ -257,24 +268,73 @@ var getRootNode = !NoElement && Element.prototype.getRootNode ? function(element
 } : function(element) {
 	return element === null || element === void 0 ? void 0 : element.ownerDocument;
 };
+/**
+* Determines if a node is inert or in an inert ancestor.
+* @param {Node} [node]
+* @param {boolean} [lookUp] If true and `node` is not inert, looks up at ancestors to
+*  see if any of them are inert. If false, only `node` itself is considered.
+* @returns {boolean} True if inert itself or by way of being in an inert ancestor.
+*  False if `node` is falsy.
+*/
 var _isInert = function isInert(node, lookUp) {
 	var _node$getAttribute;
 	if (lookUp === void 0) lookUp = true;
 	var inertAtt = node === null || node === void 0 ? void 0 : (_node$getAttribute = node.getAttribute) === null || _node$getAttribute === void 0 ? void 0 : _node$getAttribute.call(node, "inert");
 	return inertAtt === "" || inertAtt === "true" || lookUp && node && (typeof node.closest === "function" ? node.closest("[inert]") : _isInert(node.parentNode));
 };
-var isContentEditable = function isContentEditable$1(node) {
+/**
+* Determines if a node's content is editable.
+* @param {Element} [node]
+* @returns True if it's content-editable; false if it's not or `node` is falsy.
+*/
+var isContentEditable = function isContentEditable(node) {
 	var _node$getAttribute2;
 	var attValue = node === null || node === void 0 ? void 0 : (_node$getAttribute2 = node.getAttribute) === null || _node$getAttribute2 === void 0 ? void 0 : _node$getAttribute2.call(node, "contenteditable");
 	return attValue === "" || attValue === "true";
 };
-var getCandidates = function getCandidates$1(el, includeContainer, filter) {
+/**
+* @param {Element} el container to check in
+* @param {boolean} includeContainer add container to check
+* @param {(node: Element) => boolean} filter filter candidates
+* @returns {Element[]}
+*/
+var getCandidates = function getCandidates(el, includeContainer, filter) {
 	if (_isInert(el)) return [];
 	var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
 	if (includeContainer && matches.call(el, candidateSelector)) candidates.unshift(el);
 	candidates = candidates.filter(filter);
 	return candidates;
 };
+/**
+* @callback GetShadowRoot
+* @param {Element} element to check for shadow root
+* @returns {ShadowRoot|boolean} ShadowRoot if available or boolean indicating if a shadowRoot is attached but not available.
+*/
+/**
+* @callback ShadowRootFilter
+* @param {Element} shadowHostNode the element which contains shadow content
+* @returns {boolean} true if a shadow root could potentially contain valid candidates.
+*/
+/**
+* @typedef {Object} CandidateScope
+* @property {Element} scopeParent contains inner candidates
+* @property {Element[]} candidates list of candidates found in the scope parent
+*/
+/**
+* @typedef {Object} IterativeOptions
+* @property {GetShadowRoot|boolean} getShadowRoot true if shadow support is enabled; falsy if not;
+*  if a function, implies shadow support is enabled and either returns the shadow root of an element
+*  or a boolean stating if it has an undisclosed shadow root
+* @property {(node: Element) => boolean} filter filter candidates
+* @property {boolean} flatten if true then result will flatten any CandidateScope into the returned list
+* @property {ShadowRootFilter} shadowRootFilter filter shadow roots;
+*/
+/**
+* @param {Element[]} elements list of element containers to match candidates from
+* @param {boolean} includeContainer add container list to check
+* @param {IterativeOptions} options
+* @returns {Array.<Element|CandidateScope>}
+*/
 var _getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {
 	var candidates = [];
 	var elementsToCheck = Array.from(elements);
@@ -305,42 +365,62 @@ var _getCandidatesIteratively = function getCandidatesIteratively(elements, incl
 	}
 	return candidates;
 };
-var hasTabIndex = function hasTabIndex$1(node) {
+/**
+* @private
+* Determines if the node has an explicitly specified `tabindex` attribute.
+* @param {HTMLElement} node
+* @returns {boolean} True if so; false if not.
+*/
+var hasTabIndex = function hasTabIndex(node) {
 	return !isNaN(parseInt(node.getAttribute("tabindex"), 10));
 };
-var getTabIndex = function getTabIndex$1(node) {
+/**
+* Determine the tab index of a given node.
+* @param {HTMLElement} node
+* @returns {number} Tab order (negative, 0, or positive number).
+* @throws {Error} If `node` is falsy.
+*/
+var getTabIndex = function getTabIndex(node) {
 	if (!node) throw new Error("No node provided");
 	if (node.tabIndex < 0) {
 		if ((/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || isContentEditable(node)) && !hasTabIndex(node)) return 0;
 	}
 	return node.tabIndex;
 };
-var getSortOrderTabIndex = function getSortOrderTabIndex$1(node, isScope) {
+/**
+* Determine the tab index of a given node __for sort order purposes__.
+* @param {HTMLElement} node
+* @param {boolean} [isScope] True for a custom element with shadow root or slot that, by default,
+*  has tabIndex -1, but needs to be sorted by document order in order for its content to be
+*  inserted into the correct sort position.
+* @returns {number} Tab order (negative, 0, or positive number).
+*/
+var getSortOrderTabIndex = function getSortOrderTabIndex(node, isScope) {
 	var tabIndex = getTabIndex(node);
 	if (tabIndex < 0 && isScope && !hasTabIndex(node)) return 0;
 	return tabIndex;
 };
-var sortOrderedTabbables = function sortOrderedTabbables$1(a, b) {
+var sortOrderedTabbables = function sortOrderedTabbables(a, b) {
 	return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
 };
-var isInput = function isInput$1(node) {
+var isInput = function isInput(node) {
 	return node.tagName === "INPUT";
 };
-var isHiddenInput = function isHiddenInput$1(node) {
+var isHiddenInput = function isHiddenInput(node) {
 	return isInput(node) && node.type === "hidden";
 };
-var isDetailsWithSummary = function isDetailsWithSummary$1(node) {
+var isDetailsWithSummary = function isDetailsWithSummary(node) {
 	return node.tagName === "DETAILS" && Array.prototype.slice.apply(node.children).some(function(child) {
 		return child.tagName === "SUMMARY";
 	});
 };
-var getCheckedRadio = function getCheckedRadio$1(nodes, form) {
+var getCheckedRadio = function getCheckedRadio(nodes, form) {
 	for (var i = 0; i < nodes.length; i++) if (nodes[i].checked && nodes[i].form === form) return nodes[i];
 };
-var isTabbableRadio = function isTabbableRadio$1(node) {
+var isTabbableRadio = function isTabbableRadio(node) {
 	if (!node.name) return true;
 	var radioScope = node.form || getRootNode(node);
-	var queryRadios = function queryRadios$1(name) {
+	var queryRadios = function queryRadios(name) {
 		return radioScope.querySelectorAll("input[type=\"radio\"][name=\"" + name + "\"]");
 	};
 	var radioSet;
@@ -354,13 +434,13 @@ var isTabbableRadio = function isTabbableRadio$1(node) {
 	var checked = getCheckedRadio(radioSet, node.form);
 	return !checked || checked === node;
 };
-var isRadio = function isRadio$1(node) {
+var isRadio = function isRadio(node) {
 	return isInput(node) && node.type === "radio";
 };
-var isNonTabbableRadio = function isNonTabbableRadio$1(node) {
+var isNonTabbableRadio = function isNonTabbableRadio(node) {
 	return isRadio(node) && !isTabbableRadio(node);
 };
-var isNodeAttached = function isNodeAttached$1(node) {
+var isNodeAttached = function isNodeAttached(node) {
 	var _nodeRoot;
 	var nodeRoot = node && getRootNode(node);
 	var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;
@@ -377,11 +457,11 @@ var isNodeAttached = function isNodeAttached$1(node) {
 	}
 	return attached;
 };
-var isZeroArea = function isZeroArea$1(node) {
+var isZeroArea = function isZeroArea(node) {
 	var _node$getBoundingClie = node.getBoundingClientRect(), width = _node$getBoundingClie.width, height = _node$getBoundingClie.height;
 	return width === 0 && height === 0;
 };
-var isHidden = function isHidden$1(node, _ref) {
+var isHidden = function isHidden(node, _ref) {
 	var displayCheck = _ref.displayCheck, getShadowRoot = _ref.getShadowRoot;
 	if (displayCheck === "full-native") {
 		if ("checkVisibility" in node) return !node.checkVisibility({
@@ -413,7 +493,7 @@ var isHidden = function isHidden$1(node, _ref) {
 	} else if (displayCheck === "non-zero-area") return isZeroArea(node);
 	return false;
 };
-var isDisabledFromFieldset = function isDisabledFromFieldset$1(node) {
+var isDisabledFromFieldset = function isDisabledFromFieldset(node) {
 	if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {
 		var parentNode = node.parentElement;
 		while (parentNode) {
@@ -429,19 +509,23 @@ var isDisabledFromFieldset = function isDisabledFromFieldset$1(node) {
 	}
 	return false;
 };
-var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable$1(options, node) {
+var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable(options, node) {
 	if (node.disabled || isHiddenInput(node) || isHidden(node, options) || isDetailsWithSummary(node) || isDisabledFromFieldset(node)) return false;
 	return true;
 };
-var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable$1(options, node) {
+var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable(options, node) {
 	if (isNonTabbableRadio(node) || getTabIndex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) return false;
 	return true;
 };
-var isShadowRootTabbable = function isShadowRootTabbable$1(shadowHostNode) {
+var isShadowRootTabbable = function isShadowRootTabbable(shadowHostNode) {
 	var tabIndex = parseInt(shadowHostNode.getAttribute("tabindex"), 10);
 	if (isNaN(tabIndex) || tabIndex >= 0) return true;
 	return false;
 };
+/**
+* @param {Array.<Element|CandidateScope>} candidates
+* @returns Element[]
+*/
 var _sortByOrder = function sortByOrder(candidates) {
 	var regularTabbables = [];
 	var orderedTabbables = [];
@@ -464,7 +548,7 @@ var _sortByOrder = function sortByOrder(candidates) {
 		return acc;
 	}, []).concat(regularTabbables);
 };
-var tabbable = function tabbable$1(container, options) {
+var tabbable = function tabbable(container, options) {
 	options = options || {};
 	var candidates;
 	if (options.getShadowRoot) candidates = _getCandidatesIteratively([container], options.includeContainer, {
@@ -476,7 +560,7 @@ var tabbable = function tabbable$1(container, options) {
 	else candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
 	return _sortByOrder(candidates);
 };
-var focusable = function focusable$1(container, options) {
+var focusable = function focusable(container, options) {
 	options = options || {};
 	var candidates;
 	if (options.getShadowRoot) candidates = _getCandidatesIteratively([container], options.includeContainer, {
@@ -487,12 +571,14 @@ var focusable = function focusable$1(container, options) {
 	else candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));
 	return candidates;
 };
-var isTabbable = function isTabbable$1(node, options) {
+var isTabbable = function isTabbable(node, options) {
 	options = options || {};
 	if (!node) throw new Error("No node provided");
 	if (matches.call(node, candidateSelector) === false) return false;
 	return isNodeMatchingSelectorTabbable(options, node);
 };
+//#endregion
+//#region ../../node_modules/@floating-ui/react/dist/floating-ui.react.utils.mjs
 function getPlatform() {
 	const uaData = navigator.userAgentData;
 	if (uaData != null && uaData.platform) return uaData.platform;
@@ -522,12 +608,12 @@ function isJSDOM() {
 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) {
+	let activeElement = doc.activeElement;
+	while (((_activeElement = activeElement) == null || (_activeElement = _activeElement.shadowRoot) == null ? void 0 : _activeElement.activeElement) != null) {
 		var _activeElement;
-		activeElement$1 = activeElement$1.shadowRoot.activeElement;
+		activeElement = activeElement.shadowRoot.activeElement;
 	}
-	return activeElement$1;
+	return activeElement;
 }
 function contains(parent, child) {
 	if (!parent || !child) return false;
@@ -555,7 +641,7 @@ function isEventTargetWithin(event, node) {
 function isRootElement(element) {
 	return element.matches("html,body");
 }
-function getDocument(node) {
+function getDocument$1(node) {
 	return (node == null ? void 0 : node.ownerDocument) || document;
 }
 function isTypeableElement(element) {
@@ -616,11 +702,11 @@ function isMouseLikePointerType(pointerType, strict) {
 	if (!strict) values.push("", void 0);
 	return values.includes(pointerType);
 }
-var index = typeof document !== "undefined" ? useLayoutEffect : function noop() {};
+var index$1 = typeof document !== "undefined" ? useLayoutEffect : function noop() {};
 var SafeReact$1 = { ...React$1 };
-function useLatestRef(value) {
+function useLatestRef$1(value) {
 	const ref = React$1.useRef(value);
-	index(() => {
+	index$1(() => {
 		ref.current = value;
 	});
 	return ref;
@@ -646,21 +732,23 @@ 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];
+	const active = activeElement(getDocument$1(container));
+	const index = list.indexOf(active);
+	return list[index === -1 ? dir === 1 ? 0 : len - 1 : index + dir];
 }
 function getNextTabbable(referenceElement) {
-	return getTabbableIn(getDocument(referenceElement).body, 1) || referenceElement;
+	return getTabbableIn(getDocument$1(referenceElement).body, 1) || referenceElement;
 }
 function getPreviousTabbable(referenceElement) {
-	return getTabbableIn(getDocument(referenceElement).body, -1) || referenceElement;
+	return getTabbableIn(getDocument$1(referenceElement).body, -1) || referenceElement;
 }
 function isOutsideEvent(event, container) {
 	const containerElement = container || event.currentTarget;
 	const relatedTarget = event.relatedTarget;
 	return !relatedTarget || !contains(containerElement, relatedTarget);
 }
+//#endregion
+//#region ../../node_modules/@floating-ui/core/dist/floating-ui.core.mjs
 function computeCoordsFromPlacement(_ref, placement, rtl) {
 	let { reference, floating } = _ref;
 	const sideAxis = getSideAxis(placement);
@@ -712,15 +800,23 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
 	}
 	return coords;
 }
-async function detectOverflow$1(state, options) {
+/**
+* Resolves with an object of overflow side offsets that determine how much the
+* element is overflowing a given clipping boundary on each side.
+* - positive = overflowing the boundary by that number of pixels
+* - negative = how many pixels left before it will overflow
+* - 0 = lies flush with the boundary
+* @see https://floating-ui.com/docs/detectOverflow
+*/
+async function detectOverflow(state, options) {
 	var _await$platform$isEle;
 	if (options === void 0) options = {};
-	const { x, y, platform: platform$1, rects, elements, strategy } = state;
+	const { x, y, platform, rects, elements, strategy } = state;
 	const { boundary = "clippingAncestors", rootBoundary = "viewport", elementContext = "floating", altBoundary = false, padding = 0 } = evaluate(options, state);
 	const paddingObject = getPaddingObject(padding);
 	const element = elements[altBoundary ? elementContext === "floating" ? "reference" : "floating" : elementContext];
-	const clippingClientRect = rectToClientRect(await platform$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)),
+	const clippingClientRect = rectToClientRect(await platform.getClippingRect({
+		element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating)),
 		boundary,
 		rootBoundary,
 		strategy
@@ -731,15 +827,15 @@ async function detectOverflow$1(state, options) {
 		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)) || {
+	const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
+	const offsetScale = await (platform.isElement == null ? void 0 : platform.isElement(offsetParent)) ? await (platform.getScale == null ? void 0 : platform.getScale(offsetParent)) || {
 		x: 1,
 		y: 1
 	} : {
 		x: 1,
 		y: 1
 	};
-	const elementClientRect = rectToClientRect(platform$1.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform$1.convertOffsetParentRelativeRectToViewportRelativeRect({
+	const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
 		elements,
 		rect,
 		offsetParent,
@@ -753,14 +849,21 @@ async function detectOverflow$1(state, options) {
 	};
 }
 var MAX_RESET_COUNT = 50;
+/**
+* Computes the `x` and `y` coordinates that will place the floating element
+* next to a given reference element.
+*
+* This export does not have any `platform` interface logic. You will need to
+* write one for the platform you are using Floating UI with.
+*/
 var computePosition$1 = async (reference, floating, config) => {
-	const { placement = "bottom", strategy = "absolute", middleware = [], platform: platform$1 } = config;
-	const platformWithDetectOverflow = platform$1.detectOverflow ? platform$1 : {
-		...platform$1,
-		detectOverflow: detectOverflow$1
+	const { placement = "bottom", strategy = "absolute", middleware = [], platform } = config;
+	const platformWithDetectOverflow = platform.detectOverflow ? platform : {
+		...platform,
+		detectOverflow
 	};
-	const rtl = await (platform$1.isRTL == null ? void 0 : platform$1.isRTL(floating));
-	let rects = await platform$1.getElementRects({
+	const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
+	let rects = await platform.getElementRects({
 		reference,
 		floating,
 		strategy
@@ -797,7 +900,7 @@ var computePosition$1 = async (reference, floating, config) => {
 			resetCount++;
 			if (typeof reset === "object") {
 				if (reset.placement) statefulPlacement = reset.placement;
-				if (reset.rects) rects = reset.rects === true ? await platform$1.getElementRects({
+				if (reset.rects) rects = reset.rects === true ? await platform.getElementRects({
 					reference,
 					floating,
 					strategy
@@ -815,11 +918,16 @@ var computePosition$1 = async (reference, floating, config) => {
 		middlewareData
 	};
 };
-var arrow$2 = (options) => ({
+/**
+* Provides data to position an inner element of the floating element so that it
+* appears centered to the reference element.
+* @see https://floating-ui.com/docs/arrow
+*/
+var arrow$3 = (options) => ({
 	name: "arrow",
 	options,
 	async fn(state) {
-		const { x, y, placement, rects, platform: platform$1, elements, middlewareData } = state;
+		const { x, y, placement, rects, platform, elements, middlewareData } = state;
 		const { element, padding = 0 } = evaluate(options, state) || {};
 		if (element == null) return {};
 		const paddingObject = getPaddingObject(padding);
@@ -829,37 +937,43 @@ var arrow$2 = (options) => ({
 		};
 		const axis = getAlignmentAxis(placement);
 		const length = getAxisLength(axis);
-		const arrowDimensions = await platform$1.getDimensions(element);
+		const arrowDimensions = await platform.getDimensions(element);
 		const isYAxis = axis === "y";
 		const minProp = isYAxis ? "top" : "left";
 		const maxProp = isYAxis ? "bottom" : "right";
 		const clientProp = isYAxis ? "clientHeight" : "clientWidth";
 		const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
 		const startDiff = coords[axis] - rects.reference[axis];
-		const arrowOffsetParent = await (platform$1.getOffsetParent == null ? void 0 : platform$1.getOffsetParent(element));
+		const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.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];
+		if (!clientSize || !await (platform.isElement == null ? void 0 : platform.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 max = 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;
+		const offset = clamp(min$1, center, max);
+		const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+		const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;
 		return {
 			[axis]: coords[axis] + alignmentOffset,
 			data: {
-				[axis]: offset$3,
-				centerOffset: center - offset$3 - alignmentOffset,
+				[axis]: offset,
+				centerOffset: center - offset - alignmentOffset,
 				...shouldAddOffset && { alignmentOffset }
 			},
 			reset: shouldAddOffset
 		};
 	}
 });
+/**
+* Optimizes the visibility of the floating element by flipping the `placement`
+* in order to keep it in view when the preferred placement(s) will overflow the
+* clipping boundary. Alternative to `autoPlacement`.
+* @see https://floating-ui.com/docs/flip
+*/
 var flip$2 = function(options) {
 	if (options === void 0) options = {};
 	return {
@@ -867,33 +981,33 @@ var flip$2 = function(options) {
 		options,
 		async fn(state) {
 			var _middlewareData$arrow, _middlewareData$flip;
-			const { placement, middlewareData, rects, initialPlacement, platform: platform$1, elements } = state;
+			const { placement, middlewareData, rects, initialPlacement, platform, elements } = state;
 			const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true, fallbackPlacements: specifiedFallbackPlacements, fallbackStrategy = "bestFit", fallbackAxisSideDirection = "none", flipAlignment = true, ...detectOverflowOptions } = evaluate(options, state);
 			if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) return {};
 			const side = getSide(placement);
 			const initialSideAxis = getSideAxis(initialPlacement);
 			const isBasePlacement = getSide(initialPlacement) === initialPlacement;
-			const rtl = await (platform$1.isRTL == null ? void 0 : platform$1.isRTL(elements.floating));
+			const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
 			const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
 			const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
 			if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
-			const placements$1 = [initialPlacement, ...fallbackPlacements];
-			const overflow = await platform$1.detectOverflow(state, detectOverflowOptions);
+			const placements = [initialPlacement, ...fallbackPlacements];
+			const overflow = await platform.detectOverflow(state, detectOverflowOptions);
 			const overflows = [];
 			let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
 			if (checkMainAxis) overflows.push(overflow[side]);
 			if (checkCrossAxis) {
-				const sides$1 = getAlignmentSides(placement, rects, rtl);
-				overflows.push(overflow[sides$1[0]], overflow[sides$1[1]]);
+				const sides = getAlignmentSides(placement, rects, rtl);
+				overflows.push(overflow[sides[0]], overflow[sides[1]]);
 			}
 			overflowsData = [...overflowsData, {
 				placement,
 				overflows
 			}];
-			if (!overflows.every((side$1) => side$1 <= 0)) {
+			if (!overflows.every((side) => side <= 0)) {
 				var _middlewareData$flip2, _overflowsData$filter;
 				const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
-				const nextPlacement = placements$1[nextIndex];
+				const nextPlacement = placements[nextIndex];
 				if (nextPlacement) {
 					if (!(checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false) || overflowsData.every((d) => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) return {
 						data: {
@@ -907,14 +1021,14 @@ var flip$2 = function(options) {
 				if (!resetPlacement) switch (fallbackStrategy) {
 					case "bestFit": {
 						var _overflowsData$filter2;
-						const placement$1 = (_overflowsData$filter2 = overflowsData.filter((d) => {
+						const placement = (_overflowsData$filter2 = overflowsData.filter((d) => {
 							if (hasFallbackAxisSideDirection) {
 								const currentSideAxis = getSideAxis(d.placement);
 								return currentSideAxis === initialSideAxis || currentSideAxis === "y";
 							}
 							return true;
-						}).map((d) => [d.placement, d.overflows.filter((overflow$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;
+						}).map((d) => [d.placement, d.overflows.filter((overflow) => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
+						if (placement) resetPlacement = placement;
 						break;
 					}
 					case "initialPlacement":
@@ -938,17 +1052,22 @@ function getSideOffsets(overflow, rect) {
 function isAnySideFullyClipped(overflow) {
 	return sides.some((side) => overflow[side] >= 0);
 }
+/**
+* Provides data to hide the floating element in applicable situations, such as
+* when it is not in the same clipping context as the reference element.
+* @see https://floating-ui.com/docs/hide
+*/
 var hide$2 = function(options) {
 	if (options === void 0) options = {};
 	return {
 		name: "hide",
 		options,
 		async fn(state) {
-			const { rects, platform: platform$1 } = state;
+			const { rects, platform } = state;
 			const { strategy = "referenceHidden", ...detectOverflowOptions } = evaluate(options, state);
 			switch (strategy) {
 				case "referenceHidden": {
-					const offsets = getSideOffsets(await platform$1.detectOverflow(state, {
+					const offsets = getSideOffsets(await platform.detectOverflow(state, {
 						...detectOverflowOptions,
 						elementContext: "reference"
 					}), rects.reference);
@@ -958,7 +1077,7 @@ var hide$2 = function(options) {
 					} };
 				}
 				case "escaped": {
-					const offsets = getSideOffsets(await platform$1.detectOverflow(state, {
+					const offsets = getSideOffsets(await platform.detectOverflow(state, {
 						...detectOverflowOptions,
 						altBoundary: true
 					}), rects.floating);
@@ -974,8 +1093,8 @@ var hide$2 = function(options) {
 };
 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 { placement, platform, elements } = state;
+	const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
 	const side = getSide(placement);
 	const alignment = getAlignment(placement);
 	const isVertical = getSideAxis(placement) === "y";
@@ -1000,6 +1119,13 @@ async function convertValueToCoords(state, options) {
 		y: crossAxis * crossAxisMulti
 	};
 }
+/**
+* Modifies the placement by translating the floating element along the
+* specified axes.
+* A number (shorthand for `mainAxis` or distance), or an axes configuration
+* object may be passed.
+* @see https://floating-ui.com/docs/offset
+*/
 var offset$2 = function(options) {
 	if (options === void 0) options = 0;
 	return {
@@ -1021,25 +1147,30 @@ var offset$2 = function(options) {
 		}
 	};
 };
+/**
+* Optimizes the visibility of the floating element by shifting it in order to
+* keep it in view when it will overflow the clipping boundary.
+* @see https://floating-ui.com/docs/shift
+*/
 var shift$2 = function(options) {
 	if (options === void 0) options = {};
 	return {
 		name: "shift",
 		options,
 		async fn(state) {
-			const { x, y, placement, platform: platform$1 } = state;
+			const { x, y, placement, platform } = state;
 			const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = false, limiter = { fn: (_ref) => {
-				let { x: x$1, y: y$1 } = _ref;
+				let { x, y } = _ref;
 				return {
-					x: x$1,
-					y: y$1
+					x,
+					y
 				};
 			} }, ...detectOverflowOptions } = evaluate(options, state);
 			const coords = {
 				x,
 				y
 			};
-			const overflow = await platform$1.detectOverflow(state, detectOverflowOptions);
+			const overflow = await platform.detectOverflow(state, detectOverflowOptions);
 			const crossAxis = getSideAxis(getSide(placement));
 			const mainAxis = getOppositeAxis(crossAxis);
 			let mainAxisCoord = coords[mainAxis];
@@ -1047,16 +1178,16 @@ var shift$2 = function(options) {
 			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);
+				const min = mainAxisCoord + overflow[minSide];
+				const max = mainAxisCoord - overflow[maxSide];
+				mainAxisCoord = clamp(min, mainAxisCoord, max);
 			}
 			if (checkCrossAxis) {
 				const minSide = crossAxis === "y" ? "top" : "left";
 				const maxSide = crossAxis === "y" ? "bottom" : "right";
-				const min$1 = crossAxisCoord + overflow[minSide];
-				const max$1 = crossAxisCoord - overflow[maxSide];
-				crossAxisCoord = clamp(min$1, crossAxisCoord, max$1);
+				const min = crossAxisCoord + overflow[minSide];
+				const max = crossAxisCoord - overflow[maxSide];
+				crossAxisCoord = clamp(min, crossAxisCoord, max);
 			}
 			const limitedCoords = limiter.fn({
 				...state,
@@ -1077,6 +1208,12 @@ var shift$2 = function(options) {
 		}
 	};
 };
+/**
+* Provides data that allows you to change the size of the floating element —
+* for instance, prevent it from overflowing the clipping boundary or match the
+* width of the reference element.
+* @see https://floating-ui.com/docs/size
+*/
 var size$2 = function(options) {
 	if (options === void 0) options = {};
 	return {
@@ -1084,9 +1221,9 @@ var size$2 = function(options) {
 		options,
 		async fn(state) {
 			var _state$middlewareData, _state$middlewareData2;
-			const { placement, rects, platform: platform$1, elements } = state;
+			const { placement, rects, platform, elements } = state;
 			const { apply = () => {}, ...detectOverflowOptions } = evaluate(options, state);
-			const overflow = await platform$1.detectOverflow(state, detectOverflowOptions);
+			const overflow = await platform.detectOverflow(state, detectOverflowOptions);
 			const side = getSide(placement);
 			const alignment = getAlignment(placement);
 			const isYAxis = getSideAxis(placement) === "y";
@@ -1095,7 +1232,7 @@ var size$2 = function(options) {
 			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";
+				widthSide = alignment === (await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right";
 			} else {
 				widthSide = side;
 				heightSide = alignment === "end" ? "top" : "bottom";
@@ -1122,12 +1259,14 @@ var size$2 = function(options) {
 				availableWidth,
 				availableHeight
 			});
-			const nextDimensions = await platform$1.getDimensions(elements.floating);
+			const nextDimensions = await platform.getDimensions(elements.floating);
 			if (width !== nextDimensions.width || height !== nextDimensions.height) return { reset: { rects: true } };
 			return {};
 		}
 	};
 };
+//#endregion
+//#region ../../node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
 function getCssDimensions(element) {
 	const css = getComputedStyle$1(element);
 	let width = parseFloat(css.width) || 0;
@@ -1534,6 +1673,14 @@ function observeMove(element, onMove) {
 	refresh(true);
 	return cleanup;
 }
+/**
+* Automatically updates the position of the floating element when necessary.
+* Should only be called when the floating element is mounted on the DOM or
+* visible on the screen.
+* @returns cleanup function that should be invoked when the floating element is
+* removed from the DOM or hidden from the screen.
+* @see https://floating-ui.com/docs/autoUpdate
+*/
 function autoUpdate(reference, floating, update, options) {
 	if (options === void 0) options = {};
 	const { ancestorScroll = true, ancestorResize = true, elementResize = typeof ResizeObserver === "function", layoutShift = typeof IntersectionObserver === "function", animationFrame = false } = options;
@@ -1584,12 +1731,50 @@ function autoUpdate(reference, floating, update, options) {
 		if (animationFrame) cancelAnimationFrame(frameId);
 	};
 }
+/**
+* Modifies the placement by translating the floating element along the
+* specified axes.
+* A number (shorthand for `mainAxis` or distance), or an axes configuration
+* object may be passed.
+* @see https://floating-ui.com/docs/offset
+*/
 var offset$1 = offset$2;
+/**
+* Optimizes the visibility of the floating element by shifting it in order to
+* keep it in view when it will overflow the clipping boundary.
+* @see https://floating-ui.com/docs/shift
+*/
 var shift$1 = shift$2;
+/**
+* Optimizes the visibility of the floating element by flipping the `placement`
+* in order to keep it in view when the preferred placement(s) will overflow the
+* clipping boundary. Alternative to `autoPlacement`.
+* @see https://floating-ui.com/docs/flip
+*/
 var flip$1 = flip$2;
+/**
+* Provides data that allows you to change the size of the floating element —
+* for instance, prevent it from overflowing the clipping boundary or match the
+* width of the reference element.
+* @see https://floating-ui.com/docs/size
+*/
 var size$1 = size$2;
+/**
+* Provides data to hide the floating element in applicable situations, such as
+* when it is not in the same clipping context as the reference element.
+* @see https://floating-ui.com/docs/hide
+*/
 var hide$1 = hide$2;
-var arrow$1 = arrow$2;
+/**
+* Provides data to position an inner element of the floating element so that it
+* appears centered to the reference element.
+* @see https://floating-ui.com/docs/arrow
+*/
+var arrow$2 = arrow$3;
+/**
+* Computes the `x` and `y` coordinates that will place the floating element
+* next to a given reference element.
+*/
 var computePosition = (reference, floating, options) => {
 	const cache = /* @__PURE__ */ new Map();
 	const mergedOptions = {
@@ -1605,7 +1790,9 @@ var computePosition = (reference, floating, options) => {
 		platform: platformWithCache
 	});
 };
-var index$1 = typeof document !== "undefined" ? useLayoutEffect : function noop() {};
+//#endregion
+//#region ../../node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs
+var index = typeof document !== "undefined" ? useLayoutEffect : function noop() {};
 function deepEqual(a, b) {
 	if (a === b) return true;
 	if (typeof a !== typeof b) return false;
@@ -1641,16 +1828,20 @@ function roundByDPR(element, value) {
 	const dpr = getDPR(element);
 	return Math.round(value * dpr) / dpr;
 }
-function useLatestRef$1(value) {
+function useLatestRef(value) {
 	const ref = React$1.useRef(value);
-	index$1(() => {
+	index(() => {
 		ref.current = value;
 	});
 	return ref;
 }
-function useFloating(options) {
+/**
+* Provides data to position a floating element.
+* @see https://floating-ui.com/docs/useFloating
+*/
+function useFloating$1(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 { placement = "bottom", strategy = "absolute", middleware = [], platform, elements: { reference: externalReference, floating: externalFloating } = {}, transform = true, whileElementsMounted, open } = options;
 	const [data, setData] = React$1.useState({
 		x: 0,
 		y: 0,
@@ -1681,9 +1872,9 @@ function useFloating(options) {
 	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 whileElementsMountedRef = useLatestRef(whileElementsMounted);
+	const platformRef = useLatestRef(platform);
+	const openRef = useLatestRef(open);
 	const update = React$1.useCallback(() => {
 		if (!referenceRef.current || !floatingRef.current) return;
 		const config = {
@@ -1692,9 +1883,9 @@ function useFloating(options) {
 			middleware: latestMiddleware
 		};
 		if (platformRef.current) config.platform = platformRef.current;
-		computePosition(referenceRef.current, floatingRef.current, config).then((data$1) => {
+		computePosition(referenceRef.current, floatingRef.current, config).then((data) => {
 			const fullData = {
-				...data$1,
+				...data,
 				isPositioned: openRef.current !== false
 			};
 			if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
@@ -1711,23 +1902,23 @@ function useFloating(options) {
 		platformRef,
 		openRef
 	]);
-	index$1(() => {
+	index(() => {
 		if (open === false && dataRef.current.isPositioned) {
 			dataRef.current.isPositioned = false;
-			setData((data$1) => ({
-				...data$1,
+			setData((data) => ({
+				...data,
 				isPositioned: false
 			}));
 		}
 	}, [open]);
 	const isMountedRef = React$1.useRef(false);
-	index$1(() => {
+	index(() => {
 		isMountedRef.current = true;
 		return () => {
 			isMountedRef.current = false;
 		};
 	}, []);
-	index$1(() => {
+	index(() => {
 		if (referenceEl) referenceRef.current = referenceEl;
 		if (floatingEl) floatingRef.current = floatingEl;
 		if (referenceEl && floatingEl) {
@@ -1791,7 +1982,13 @@ function useFloating(options) {
 		floatingStyles
 	]);
 }
-var arrow$1$1 = (options) => {
+/**
+* Provides data to position an inner element of the floating element so that it
+* appears centered to the reference element.
+* This wraps the core `arrow` middleware to allow React refs as the element.
+* @see https://floating-ui.com/docs/arrow
+*/
+var arrow$1 = (options) => {
 	function isRef(value) {
 		return {}.hasOwnProperty.call(value, "current");
 	}
@@ -1801,13 +1998,13 @@ var arrow$1$1 = (options) => {
 		fn(state) {
 			const { element, padding } = typeof options === "function" ? options(state) : options;
 			if (element && isRef(element)) {
-				if (element.current != null) return arrow$1({
+				if (element.current != null) return arrow$2({
 					element: element.current,
 					padding
 				}).fn(state);
 				return {};
 			}
-			if (element) return arrow$1({
+			if (element) return arrow$2({
 				element,
 				padding
 			}).fn(state);
@@ -1815,6 +2012,13 @@ var arrow$1$1 = (options) => {
 		}
 	};
 };
+/**
+* Modifies the placement by translating the floating element along the
+* specified axes.
+* A number (shorthand for `mainAxis` or distance), or an axes configuration
+* object may be passed.
+* @see https://floating-ui.com/docs/offset
+*/
 var offset = (options, deps) => {
 	const result = offset$1(options);
 	return {
@@ -1823,6 +2027,11 @@ var offset = (options, deps) => {
 		options: [options, deps]
 	};
 };
+/**
+* Optimizes the visibility of the floating element by shifting it in order to
+* keep it in view when it will overflow the clipping boundary.
+* @see https://floating-ui.com/docs/shift
+*/
 var shift = (options, deps) => {
 	const result = shift$1(options);
 	return {
@@ -1831,6 +2040,12 @@ var shift = (options, deps) => {
 		options: [options, deps]
 	};
 };
+/**
+* Optimizes the visibility of the floating element by flipping the `placement`
+* in order to keep it in view when the preferred placement(s) will overflow the
+* clipping boundary. Alternative to `autoPlacement`.
+* @see https://floating-ui.com/docs/flip
+*/
 var flip = (options, deps) => {
 	const result = flip$1(options);
 	return {
@@ -1839,6 +2054,12 @@ var flip = (options, deps) => {
 		options: [options, deps]
 	};
 };
+/**
+* Provides data that allows you to change the size of the floating element —
+* for instance, prevent it from overflowing the clipping boundary or match the
+* width of the reference element.
+* @see https://floating-ui.com/docs/size
+*/
 var size = (options, deps) => {
 	const result = size$1(options);
 	return {
@@ -1847,6 +2068,11 @@ var size = (options, deps) => {
 		options: [options, deps]
 	};
 };
+/**
+* Provides data to hide the floating element in applicable situations, such as
+* when it is not in the same clipping context as the reference element.
+* @see https://floating-ui.com/docs/hide
+*/
 var hide = (options, deps) => {
 	const result = hide$1(options);
 	return {
@@ -1855,14 +2081,26 @@ var hide = (options, deps) => {
 		options: [options, deps]
 	};
 };
+/**
+* Provides data to position an inner element of the floating element so that it
+* appears centered to the reference element.
+* This wraps the core `arrow` middleware to allow React refs as the element.
+* @see https://floating-ui.com/docs/arrow
+*/
 var arrow = (options, deps) => {
-	const result = arrow$1$1(options);
+	const result = arrow$1(options);
 	return {
 		name: result.name,
 		fn: result.fn,
 		options: [options, deps]
 	};
 };
+//#endregion
+//#region ../../node_modules/@floating-ui/react/dist/floating-ui.react.mjs
+/**
+* Merges an array of refs into a single memoized callback ref or `null`.
+* @see https://floating-ui.com/docs/react-utils#usemergerefs
+*/
 function useMergeRefs(refs) {
 	const cleanupRef = React$1.useRef(void 0);
 	const refEffect = React$1.useCallback((instance) => {
@@ -1911,7 +2149,7 @@ 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(() => {
+	index$1(() => {
 		if (id == null) setId(genId());
 	}, []);
 	React$1.useEffect(() => {
@@ -1919,6 +2157,12 @@ function useFloatingId() {
 	}, []);
 	return id;
 }
+/**
+* Uses React 18's built-in `useId()` when available, or falls back to a
+* slightly less performant (requiring a double render) implementation for
+* earlier React versions.
+* @see https://floating-ui.com/docs/react-utils#useid
+*/
 var useId$1 = SafeReact.useId || useFloatingId;
 var devMessageSet;
 if (process.env.NODE_ENV !== "production") devMessageSet = /* @__PURE__ */ new Set();
@@ -1942,14 +2186,18 @@ function error() {
 		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;
+/**
+* Renders a pointing arrow triangle.
+* @see https://floating-ui.com/docs/FloatingArrow
+*/
+var FloatingArrow = /* @__PURE__ */ React$1.forwardRef(function FloatingArrow(props, ref) {
+	const { context: { placement, elements: { floating }, middlewareData: { arrow, shift } }, 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(() => {
+	const [isRTL, setIsRTL] = React$1.useState(false);
+	index$1(() => {
 		if (!floating) return;
 		if (getComputedStyle$1(floating).direction === "rtl") setIsRTL(true);
 	}, [floating]);
@@ -1957,7 +2205,7 @@ var FloatingArrow = /* @__PURE__ */ React$1.forwardRef(function FloatingArrow$1(
 	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;
+	if (isVerticalSide && shift != null && shift.x || !isVerticalSide && shift != null && shift.y) computedStaticOffset = null;
 	const computedStrokeWidth = strokeWidth * 2;
 	const halfStrokeWidth = computedStrokeWidth / 2;
 	const svgX = width / 2 * (tipRadius / -8 + 1);
@@ -1965,9 +2213,9 @@ var FloatingArrow = /* @__PURE__ */ React$1.forwardRef(function FloatingArrow$1(
 	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 : "";
+	if (computedStaticOffset && isRTL) xOffsetProp = alignment === "end" ? "left" : "right";
+	const arrowX = (arrow == null ? void 0 : arrow.x) != null ? computedStaticOffset || arrow.x : "";
+	const arrowY = (arrow == null ? void 0 : arrow.y) != null ? computedStaticOffset || arrow.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)" : "",
@@ -2034,10 +2282,17 @@ function createEventEmitter() {
 }
 var FloatingNodeContext = /* @__PURE__ */ React$1.createContext(null);
 var FloatingTreeContext = /* @__PURE__ */ React$1.createContext(null);
+/**
+* Returns the parent node id for nested floating elements, if available.
+* Returns `null` for top-level floating elements.
+*/
 var useFloatingParentNodeId = () => {
 	var _React$useContext;
 	return ((_React$useContext = React$1.useContext(FloatingNodeContext)) == null ? void 0 : _React$useContext.id) || null;
 };
+/**
+* Returns the nearest floating tree context, if available.
+*/
 var useFloatingTree = () => React$1.useContext(FloatingTreeContext);
 function createAttribute(name) {
 	return "data-floating-ui-" + name;
@@ -2063,16 +2318,21 @@ function getRestMs(value) {
 	if (typeof value === "function") return value();
 	return value;
 }
+/**
+* Opens the floating element while hovering over the reference element, like
+* CSS `:hover`.
+* @see https://floating-ui.com/docs/useHover
+*/
 function useHover(context, props) {
 	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 handleCloseRef = useLatestRef$1(handleClose);
+	const delayRef = useLatestRef$1(delay);
+	const openRef = useLatestRef$1(open);
+	const restMsRef = useLatestRef$1(restMs);
 	const pointerTypeRef = React$1.useRef();
 	const timeoutRef = React$1.useRef(-1);
 	const handlerRef = React$1.useRef();
@@ -2088,18 +2348,18 @@ function useHover(context, props) {
 	});
 	React$1.useEffect(() => {
 		if (!enabled) return;
-		function onOpenChange$1(_ref) {
-			let { open: open$1 } = _ref;
-			if (!open$1) {
+		function onOpenChange(_ref) {
+			let { open } = _ref;
+			if (!open) {
 				clearTimeoutIfSet(timeoutRef);
 				clearTimeoutIfSet(restTimeoutRef);
 				blockMouseMoveRef.current = true;
 				restTimeoutPendingRef.current = false;
 			}
 		}
-		events.on("openchange", onOpenChange$1);
+		events.on("openchange", onOpenChange);
 		return () => {
-			events.off("openchange", onOpenChange$1);
+			events.off("openchange", onOpenChange);
 		};
 	}, [enabled, events]);
 	React$1.useEffect(() => {
@@ -2109,7 +2369,7 @@ function useHover(context, props) {
 		function onLeave(event) {
 			if (isHoverOpen()) onOpenChange(false, event, "hover");
 		}
-		const html = getDocument(elements.floating).documentElement;
+		const html = getDocument$1(elements.floating).documentElement;
 		html.addEventListener("mouseleave", onLeave);
 		return () => {
 			html.removeEventListener("mouseleave", onLeave);
@@ -2140,7 +2400,7 @@ function useHover(context, props) {
 	});
 	const clearPointerEvents = useEffectEvent(() => {
 		if (performedPointerEventsMutationRef.current) {
-			const body = getDocument(elements.floating).body;
+			const body = getDocument$1(elements.floating).body;
 			body.style.pointerEvents = "";
 			body.removeAttribute(safePolygonIdentifier);
 			performedPointerEventsMutationRef.current = false;
@@ -2167,7 +2427,7 @@ function useHover(context, props) {
 				return;
 			}
 			unbindMouseMoveRef.current();
-			const doc = getDocument(elements.floating);
+			const doc = getDocument$1(elements.floating);
 			clearTimeoutIfSet(restTimeoutRef);
 			restTimeoutPendingRef.current = false;
 			if (handleCloseRef.current && dataRef.current.floatingContext) {
@@ -2214,22 +2474,22 @@ function useHover(context, props) {
 			if (!isClickLikeOpenEvent()) closeWithDelay(event, false);
 		}
 		if (isElement(elements.domReference)) {
-			const reference$1 = elements.domReference;
+			const reference = 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 (open) reference.addEventListener("mouseleave", onScrollMouseLeave);
+			if (move) reference.addEventListener("mousemove", onReferenceMouseEnter, { once: true });
+			reference.addEventListener("mouseenter", onReferenceMouseEnter);
+			reference.addEventListener("mouseleave", onReferenceMouseLeave);
 			if (floating) {
 				floating.addEventListener("mouseleave", onScrollMouseLeave);
 				floating.addEventListener("mouseenter", onFloatingMouseEnter);
 				floating.addEventListener("mouseleave", onFloatingMouseLeave);
 			}
 			return () => {
-				if (open) reference$1.removeEventListener("mouseleave", onScrollMouseLeave);
-				if (move) reference$1.removeEventListener("mousemove", onReferenceMouseEnter);
-				reference$1.removeEventListener("mouseenter", onReferenceMouseEnter);
-				reference$1.removeEventListener("mouseleave", onReferenceMouseLeave);
+				if (open) reference.removeEventListener("mouseleave", onScrollMouseLeave);
+				if (move) reference.removeEventListener("mousemove", onReferenceMouseEnter);
+				reference.removeEventListener("mouseenter", onReferenceMouseEnter);
+				reference.removeEventListener("mouseleave", onReferenceMouseLeave);
 				if (floating) {
 					floating.removeEventListener("mouseleave", onScrollMouseLeave);
 					floating.removeEventListener("mouseenter", onFloatingMouseEnter);
@@ -2256,7 +2516,7 @@ function useHover(context, props) {
 		isClickLikeOpenEvent,
 		restMsRef
 	]);
-	index(() => {
+	index$1(() => {
 		var _handleCloseRef$curre;
 		if (!enabled) return;
 		if (open && (_handleCloseRef$curre = handleCloseRef.current) != null && (_handleCloseRef$curre = _handleCloseRef$curre.__options) != null && _handleCloseRef$curre.blockPointerEvents && isHoverOpen()) {
@@ -2264,7 +2524,7 @@ function useHover(context, props) {
 			const floatingEl = elements.floating;
 			if (isElement(elements.domReference) && floatingEl) {
 				var _tree$nodesRef$curren;
-				const body = getDocument(elements.floating).body;
+				const body = getDocument$1(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;
@@ -2288,7 +2548,7 @@ function useHover(context, props) {
 		handleCloseRef,
 		isHoverOpen
 	]);
-	index(() => {
+	index$1(() => {
 		if (!open) {
 			pointerTypeRef.current = void 0;
 			restTimeoutPendingRef.current = false;
@@ -2355,6 +2615,11 @@ var FloatingDelayGroupContext = /* @__PURE__ */ React$1.createContext({
 	setState: NOOP,
 	isInstantPhase: false
 });
+/**
+* Provides context for a group of floating elements that should share a
+* `delay`.
+* @see https://floating-ui.com/docs/FloatingDelayGroup
+*/
 function FloatingDelayGroup(props) {
 	const { children, delay, timeoutMs = 0 } = props;
 	const [state, setState] = React$1.useReducer((prev, next) => ({
@@ -2371,7 +2636,7 @@ function FloatingDelayGroup(props) {
 	const setCurrentId = React$1.useCallback((currentId) => {
 		setState({ currentId });
 	}, []);
-	index(() => {
+	index$1(() => {
 		if (state.currentId) {
 			if (initialCurrentIdRef.current === null) initialCurrentIdRef.current = state.currentId;
 			else if (!state.isInstantPhase) setState({ isInstantPhase: true });
@@ -2398,7 +2663,7 @@ function enqueueFocus(el, options) {
 	if (sync) exec();
 	else rafId = requestAnimationFrame(exec);
 }
-function getDocument$1(node) {
+function getDocument(node) {
 	return (node == null ? void 0 : node.ownerDocument) || document;
 }
 var counters = {
@@ -2489,7 +2754,7 @@ function applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, iner
 function markOthers(avoidElements, ariaHidden, inert) {
 	if (ariaHidden === void 0) ariaHidden = false;
 	if (inert === void 0) inert = false;
-	const body = getDocument$1(avoidElements[0]).body;
+	const body = getDocument(avoidElements[0]).body;
 	return applyAttributeToOthers(avoidElements.concat(Array.from(body.querySelectorAll("[aria-live],[role=\"status\"],output"))), body, ariaHidden, inert);
 }
 var HIDDEN_STYLES = {
@@ -2505,9 +2770,9 @@ var HIDDEN_STYLES = {
 	top: 0,
 	left: 0
 };
-var FocusGuard = /* @__PURE__ */ React$1.forwardRef(function FocusGuard$1(props, ref) {
+var FocusGuard = /* @__PURE__ */ React$1.forwardRef(function FocusGuard(props, ref) {
 	const [role, setRole] = React$1.useState();
-	index(() => {
+	index$1(() => {
 		if (isSafari()) setRole("button");
 	}, []);
 	const restProps = {
@@ -2575,7 +2840,7 @@ function handleTabIndex(floatingFocusElement, orderRef) {
 		floatingFocusElement.setAttribute("data-tabindex", "-1");
 	}
 }
-var VisuallyHiddenDismiss = /* @__PURE__ */ React$1.forwardRef(function VisuallyHiddenDismiss$1(props, ref) {
+var VisuallyHiddenDismiss = /* @__PURE__ */ React$1.forwardRef(function VisuallyHiddenDismiss(props, ref) {
 	return /* @__PURE__ */ jsx("button", {
 		...props,
 		type: "button",
@@ -2584,6 +2849,10 @@ var VisuallyHiddenDismiss = /* @__PURE__ */ React$1.forwardRef(function Visually
 		style: HIDDEN_STYLES
 	});
 });
+/**
+* Provides focus management for the floating element.
+* @see https://floating-ui.com/docs/FloatingFocusManager
+*/
 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;
@@ -2597,9 +2866,9 @@ function FloatingFocusManager(props) {
 	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 orderRef = useLatestRef$1(order);
+	const initialFocusRef = useLatestRef$1(initialFocus);
+	const returnFocusRef = useLatestRef$1(returnFocus);
 	const tree = useFloatingTree();
 	const portalContext = usePortalContext();
 	const startDismissButtonRef = React$1.useRef(null);
@@ -2627,7 +2896,7 @@ function FloatingFocusManager(props) {
 		if (!modal) return;
 		function onKeyDown(event) {
 			if (event.key === "Tab") {
-				if (contains(floatingFocusElement, activeElement(getDocument(floatingFocusElement))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) stopEvent(event);
+				if (contains(floatingFocusElement, activeElement(getDocument$1(floatingFocusElement))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) stopEvent(event);
 				const els = getTabbableElements();
 				const target = getTarget(event);
 				if (orderRef.current[0] === "reference" && target === domReference) {
@@ -2641,7 +2910,7 @@ function FloatingFocusManager(props) {
 				}
 			}
 		}
-		const doc = getDocument(floatingFocusElement);
+		const doc = getDocument$1(floatingFocusElement);
 		doc.addEventListener("keydown", onKeyDown);
 		return () => {
 			doc.removeEventListener("keydown", onKeyDown);
@@ -2696,7 +2965,7 @@ function FloatingFocusManager(props) {
 					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 (restoreFocus && currentTarget !== domReference && !(target != null && target.isConnected) && activeElement(getDocument$1(floatingFocusElement)) === getDocument$1(floatingFocusElement).body) {
 					if (isHTMLElement(floatingFocusElement)) floatingFocusElement.focus();
 					const prevTabbableIndex = tabbableIndexRef.current;
 					const tabbableContent = getTabbableContent();
@@ -2793,9 +3062,9 @@ function FloatingFocusManager(props) {
 		getNodeId,
 		getInsideElements
 	]);
-	index(() => {
+	index$1(() => {
 		if (disabled || !isHTMLElement(floatingFocusElement)) return;
-		const previouslyFocusedElement = activeElement(getDocument(floatingFocusElement));
+		const previouslyFocusedElement = activeElement(getDocument$1(floatingFocusElement));
 		queueMicrotask(() => {
 			const focusableElements = getTabbableElements(floatingFocusElement);
 			const initialFocusValue = initialFocusRef.current;
@@ -2811,11 +3080,11 @@ function FloatingFocusManager(props) {
 		getTabbableElements,
 		initialFocusRef
 	]);
-	index(() => {
+	index$1(() => {
 		if (disabled || !floatingFocusElement) return;
-		const doc = getDocument(floatingFocusElement);
+		const doc = getDocument$1(floatingFocusElement);
 		addPreviouslyFocusedElement(activeElement(doc));
-		function onOpenChange$1(_ref) {
+		function onOpenChange(_ref) {
 			let { reason, event, nested } = _ref;
 			if (["hover", "safe-polygon"].includes(reason) && event.type === "mouseleave") preventReturnFocusRef.current = true;
 			if (reason !== "outside-press") return;
@@ -2831,7 +3100,7 @@ function FloatingFocusManager(props) {
 				else preventReturnFocusRef.current = true;
 			}
 		}
-		events.on("openchange", onOpenChange$1);
+		events.on("openchange", onOpenChange);
 		const fallbackEl = doc.createElement("span");
 		fallbackEl.setAttribute("tabindex", "-1");
 		fallbackEl.setAttribute("aria-hidden", "true");
@@ -2845,7 +3114,7 @@ function FloatingFocusManager(props) {
 			return returnFocusRef.current.current || fallbackEl;
 		}
 		return () => {
-			events.off("openchange", onOpenChange$1);
+			events.off("openchange", onOpenChange);
 			const activeEl = activeElement(doc);
 			const isFocusInsideFloatingTree = contains(floating, activeEl) || tree && getNodeChildren(tree.nodesRef.current, getNodeId(), false).some((node) => {
 				var _node$context7;
@@ -2878,7 +3147,7 @@ function FloatingFocusManager(props) {
 			queueMicrotask(clearDisconnectedPreviouslyFocusedElements);
 		};
 	}, [disabled]);
-	index(() => {
+	index$1(() => {
 		if (disabled) return;
 		if (!portalContext) return;
 		portalContext.setFocusManagerState({
@@ -2900,7 +3169,7 @@ function FloatingFocusManager(props) {
 		closeOnFocusOut,
 		domReference
 	]);
-	index(() => {
+	index$1(() => {
 		if (disabled) return;
 		if (!floatingFocusElement) return;
 		handleTabIndex(floatingFocusElement, orderRef);
@@ -2965,6 +3234,10 @@ function isAnchorTarget(event) {
 function isSpaceIgnored(element) {
 	return isTypeableElement(element);
 }
+/**
+* Opens or closes the floating element when clicking the reference element.
+* @see https://floating-ui.com/docs/useClick
+*/
 function useClick(context, props) {
 	if (props === void 0) props = {};
 	const { open, onOpenChange, dataRef, elements: { domReference } } = context;
@@ -3045,6 +3318,11 @@ var normalizeProp = (normalizable) => {
 		outsidePress: typeof normalizable === "boolean" ? normalizable : (_normalizable$outside = normalizable == null ? void 0 : normalizable.outsidePress) != null ? _normalizable$outside : true
 	};
 };
+/**
+* Closes the floating element when a dismissal is requested — by default, when
+* the user presses the `escape` key or outside of the floating element.
+* @see https://floating-ui.com/docs/useDismiss
+*/
 function useDismiss(context, props) {
 	if (props === void 0) props = {};
 	const { open, onOpenChange, elements, dataRef } = context;
@@ -3098,7 +3376,7 @@ function useDismiss(context, props) {
 		if (typeof outsidePress === "function" && !outsidePress(event)) return;
 		const target = getTarget(event);
 		const inertSelector = "[" + createAttribute("inert") + "]";
-		const markers = getDocument(elements.floating).querySelectorAll(inertSelector);
+		const markers = getDocument$1(elements.floating).querySelectorAll(inertSelector);
 		let targetRootAncestor = isElement(target) ? target : null;
 		while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {
 			const nextParent = getParentNode(targetRootAncestor);
@@ -3114,8 +3392,8 @@ function useDismiss(context, props) {
 			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 isRTL = style.direction === "rtl";
+			const pressedVerticalScrollbar = canScrollY && (isRTL ? event.offsetX <= target.offsetWidth - target.clientWidth : event.offsetX > target.clientWidth);
 			const pressedHorizontalScrollbar = canScrollX && event.offsetY > target.clientHeight;
 			if (pressedVerticalScrollbar || pressedHorizontalScrollbar) return;
 		}
@@ -3165,7 +3443,7 @@ function useDismiss(context, props) {
 				isComposingRef.current = false;
 			}, isWebKit() ? 5 : 0);
 		}
-		const doc = getDocument(elements.floating);
+		const doc = getDocument$1(elements.floating);
 		if (escapeKey) {
 			doc.addEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
 			doc.addEventListener("compositionstart", handleCompositionStart);
@@ -3277,15 +3555,15 @@ function useFloatingRootContext(options) {
 		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;
+	const onOpenChange = useEffectEvent((open, event, reason) => {
+		dataRef.current.openEvent = open ? event : void 0;
 		events.emit("openchange", {
-			open: open$1,
+			open,
 			event,
 			reason,
 			nested
 		});
-		onOpenChangeProp?.(open$1, event, reason);
+		onOpenChangeProp?.(open, event, reason);
 	});
 	const refs = React$1.useMemo(() => ({ setPositionReference }), []);
 	const elements = React$1.useMemo(() => ({
@@ -3314,7 +3592,11 @@ function useFloatingRootContext(options) {
 		refs
 	]);
 }
-function useFloating$1(options) {
+/**
+* Provides data to position a floating element and context to add interactions.
+* @see https://floating-ui.com/docs/useFloating
+*/
+function useFloating(options) {
 	if (options === void 0) options = {};
 	const { nodeId } = options;
 	const internalRootContext = useFloatingRootContext({
@@ -3332,10 +3614,10 @@ function useFloating$1(options) {
 	const domReference = (computedElements == null ? void 0 : computedElements.domReference) || _domReference;
 	const domReferenceRef = React$1.useRef(null);
 	const tree = useFloatingTree();
-	index(() => {
+	index$1(() => {
 		if (domReference) domReferenceRef.current = domReference;
 	}, [domReference]);
-	const position = useFloating({
+	const position = useFloating$1({
 		...options,
 		elements: {
 			...computedElements,
@@ -3385,9 +3667,9 @@ function useFloating$1(options) {
 		nodeId,
 		rootContext
 	]);
-	index(() => {
+	index$1(() => {
 		rootContext.dataRef.current.floatingContext = context;
-		const node = tree == null ? void 0 : tree.nodesRef.current.find((node$1) => node$1.id === nodeId);
+		const node = tree == null ? void 0 : tree.nodesRef.current.find((node) => node.id === nodeId);
 		if (node) node.context = context;
 	});
 	return React$1.useMemo(() => ({
@@ -3405,6 +3687,11 @@ function useFloating$1(options) {
 function isMacSafari() {
 	return isMac() && isSafari();
 }
+/**
+* Opens the floating element while the reference element has focus, like CSS
+* `:focus`.
+* @see https://floating-ui.com/docs/useFocus
+*/
 function useFocus(context, props) {
 	if (props === void 0) props = {};
 	const { open, onOpenChange, events, dataRef, elements } = context;
@@ -3416,7 +3703,7 @@ function useFocus(context, props) {
 		if (!enabled) return;
 		const win = getWindow(elements.domReference);
 		function onBlur() {
-			if (!open && isHTMLElement(elements.domReference) && elements.domReference === activeElement(getDocument(elements.domReference))) blockFocusRef.current = true;
+			if (!open && isHTMLElement(elements.domReference) && elements.domReference === activeElement(getDocument$1(elements.domReference))) blockFocusRef.current = true;
 		}
 		function onKeyDown() {
 			keyboardModalityRef.current = true;
@@ -3443,13 +3730,13 @@ function useFocus(context, props) {
 	]);
 	React$1.useEffect(() => {
 		if (!enabled) return;
-		function onOpenChange$1(_ref) {
+		function onOpenChange(_ref) {
 			let { reason } = _ref;
 			if (reason === "reference-press" || reason === "escape-key") blockFocusRef.current = true;
 		}
-		events.on("openchange", onOpenChange$1);
+		events.on("openchange", onOpenChange);
 		return () => {
-			events.off("openchange", onOpenChange$1);
+			events.off("openchange", onOpenChange);
 		};
 	}, [events, enabled]);
 	React$1.useEffect(() => {
@@ -3532,6 +3819,12 @@ function mergeProps(userProps, propsList, elementKey) {
 		}, {})
 	};
 }
+/**
+* Merges an array of interaction hooks' props into prop getters, allowing
+* event handler functions to be composed together without overwriting one
+* another.
+* @see https://floating-ui.com/docs/useInteractions
+*/
 function useInteractions(propsList) {
 	if (propsList === void 0) propsList = [];
 	const referenceDeps = propsList.map((key) => key == null ? void 0 : key.reference);
@@ -3550,6 +3843,7 @@ function useInteractions(propsList) {
 		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 };
+//#endregion
+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 as o, hide as p, FloatingFocusManager as r, useFocus as s, FloatingArrow as t, useMergeRefs as u };
 
 //# sourceMappingURL=floating-ui.react.js.map