likec4 1.56.0 → 1.58.0

package/__app__/src/chunks/libs/@floating-ui.mjs

@@ -0,0 +1,2218 @@
+import { i as e } from "../rolldown-runtime.mjs";
+import * as t from "react";
+import { useLayoutEffect as n } from "react";
+import { jsx as r } from "react/jsx-runtime";
+import * as i from "react-dom";
+//#region ../../node_modules/.pnpm/@floating-ui+utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
+function hasWindow() {
+	return typeof window < "u";
+}
+function getNodeName(e) {
+	return isNode(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function getWindow(e) {
+	var t;
+	return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function getDocumentElement(e) {
+	return ((isNode(e) ? e.ownerDocument : e.document) || window.document)?.documentElement;
+}
+function isNode(e) {
+	return hasWindow() ? e instanceof Node || e instanceof getWindow(e).Node : !1;
+}
+function isElement(e) {
+	return hasWindow() ? e instanceof Element || e instanceof getWindow(e).Element : !1;
+}
+function isHTMLElement(e) {
+	return hasWindow() ? e instanceof HTMLElement || e instanceof getWindow(e).HTMLElement : !1;
+}
+function isShadowRoot(e) {
+	return !hasWindow() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof getWindow(e).ShadowRoot;
+}
+function isOverflowElement(e) {
+	let { overflow: t, overflowX: n, overflowY: r, display: i } = getComputedStyle$1(e);
+	return /auto|scroll|overlay|hidden|clip/.test(t + r + n) && i !== "inline" && i !== "contents";
+}
+function isTableElement(e) {
+	return /^(table|td|th)$/.test(getNodeName(e));
+}
+function isTopLayer(e) {
+	try {
+		if (e.matches(":popover-open")) return !0;
+	} catch {}
+	try {
+		return e.matches(":modal");
+	} catch {
+		return !1;
+	}
+}
+var a = /transform|translate|scale|rotate|perspective|filter/, o = /paint|layout|strict|content/, isNotNone = (e) => !!e && e !== "none", s;
+function isContainingBlock(e) {
+	let t = isElement(e) ? getComputedStyle$1(e) : e;
+	return isNotNone(t.transform) || isNotNone(t.translate) || isNotNone(t.scale) || isNotNone(t.rotate) || isNotNone(t.perspective) || !isWebKit() && (isNotNone(t.backdropFilter) || isNotNone(t.filter)) || a.test(t.willChange || "") || o.test(t.contain || "");
+}
+function getContainingBlock(e) {
+	let t = getParentNode(e);
+	for (; isHTMLElement(t) && !isLastTraversableNode(t);) {
+		if (isContainingBlock(t)) return t;
+		if (isTopLayer(t)) return null;
+		t = getParentNode(t);
+	}
+	return null;
+}
+function isWebKit() {
+	return s ??= typeof CSS < "u" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none"), s;
+}
+function isLastTraversableNode(e) {
+	return /^(html|body|#document)$/.test(getNodeName(e));
+}
+function getComputedStyle$1(e) {
+	return getWindow(e).getComputedStyle(e);
+}
+e(getComputedStyle$1, "getComputedStyle");
+function getNodeScroll(e) {
+	return isElement(e) ? {
+		scrollLeft: e.scrollLeft,
+		scrollTop: e.scrollTop
+	} : {
+		scrollLeft: e.scrollX,
+		scrollTop: e.scrollY
+	};
+}
+function getParentNode(e) {
+	if (getNodeName(e) === "html") return e;
+	let t = e.assignedSlot || e.parentNode || isShadowRoot(e) && e.host || getDocumentElement(e);
+	return isShadowRoot(t) ? t.host : t;
+}
+function getNearestOverflowAncestor(e) {
+	let t = getParentNode(e);
+	return isLastTraversableNode(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : isHTMLElement(t) && isOverflowElement(t) ? t : getNearestOverflowAncestor(t);
+}
+function getOverflowAncestors(e, t, n) {
+	t === void 0 && (t = []), n === void 0 && (n = !0);
+	let r = getNearestOverflowAncestor(e), i = r === e.ownerDocument?.body, a = getWindow(r);
+	if (i) {
+		let e = getFrameElement(a);
+		return t.concat(a, a.visualViewport || [], isOverflowElement(r) ? r : [], e && n ? getOverflowAncestors(e) : []);
+	} else return t.concat(r, getOverflowAncestors(r, [], n));
+}
+function getFrameElement(e) {
+	return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@floating-ui+utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
+var c = [
+	"top",
+	"right",
+	"bottom",
+	"left"
+], l = ["start", "end"], u = /* @__PURE__ */ c.reduce((e, t) => e.concat(t, t + "-" + l[0], t + "-" + l[1]), []), d = Math.min, f = Math.max, p = Math.round, m = Math.floor, createCoords = (e) => ({
+	x: e,
+	y: e
+}), h = {
+	left: "right",
+	right: "left",
+	bottom: "top",
+	top: "bottom"
+};
+function clamp(e, t, n) {
+	return f(e, d(t, n));
+}
+function evaluate(e, t) {
+	return typeof e == "function" ? e(t) : e;
+}
+function getSide(e) {
+	return e.split("-")[0];
+}
+function getAlignment(e) {
+	return e.split("-")[1];
+}
+function getOppositeAxis(e) {
+	return e === "x" ? "y" : "x";
+}
+function getAxisLength(e) {
+	return e === "y" ? "height" : "width";
+}
+function getSideAxis(e) {
+	let t = e[0];
+	return t === "t" || t === "b" ? "y" : "x";
+}
+function getAlignmentAxis(e) {
+	return getOppositeAxis(getSideAxis(e));
+}
+function getAlignmentSides(e, t, n) {
+	n === void 0 && (n = !1);
+	let r = getAlignment(e), i = getAlignmentAxis(e), a = getAxisLength(i), o = i === "x" ? r === (n ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+	return t.reference[a] > t.floating[a] && (o = getOppositePlacement(o)), [o, getOppositePlacement(o)];
+}
+function getExpandedPlacements(e) {
+	let t = getOppositePlacement(e);
+	return [
+		getOppositeAlignmentPlacement(e),
+		t,
+		getOppositeAlignmentPlacement(t)
+	];
+}
+function getOppositeAlignmentPlacement(e) {
+	return e.includes("start") ? e.replace("start", "end") : e.replace("end", "start");
+}
+var g = ["left", "right"], _ = ["right", "left"], v = ["top", "bottom"], y = ["bottom", "top"];
+function getSideList(e, t, n) {
+	switch (e) {
+		case "top":
+		case "bottom": return n ? t ? _ : g : t ? g : _;
+		case "left":
+		case "right": return t ? v : y;
+		default: return [];
+	}
+}
+function getOppositeAxisPlacements(e, t, n, r) {
+	let i = getAlignment(e), a = getSideList(getSide(e), n === "start", r);
+	return i && (a = a.map((e) => e + "-" + i), t && (a = a.concat(a.map(getOppositeAlignmentPlacement)))), a;
+}
+function getOppositePlacement(e) {
+	let t = getSide(e);
+	return h[t] + e.slice(t.length);
+}
+function expandPaddingObject(e) {
+	return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0,
+		...e
+	};
+}
+function getPaddingObject(e) {
+	return typeof e == "number" ? {
+		top: e,
+		right: e,
+		bottom: e,
+		left: e
+	} : expandPaddingObject(e);
+}
+function rectToClientRect(e) {
+	let { x: t, y: n, width: r, height: i } = e;
+	return {
+		width: r,
+		height: i,
+		top: n,
+		left: t,
+		right: t + r,
+		bottom: n + i,
+		x: t,
+		y: n
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@floating-ui+react@0.27.19_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@floating-ui/react/dist/floating-ui.react.utils.mjs
+function getPlatform() {
+	let e = navigator.userAgentData;
+	return e != null && e.platform ? e.platform : navigator.platform;
+}
+function getUserAgent() {
+	let e = navigator.userAgentData;
+	return e && Array.isArray(e.brands) ? e.brands.map((e) => {
+		let { brand: t, version: n } = e;
+		return t + "/" + n;
+	}).join(" ") : navigator.userAgent;
+}
+function isSafari() {
+	return /apple/i.test(navigator.vendor);
+}
+function isMac() {
+	return getPlatform().toLowerCase().startsWith("mac") && !navigator.maxTouchPoints;
+}
+function isJSDOM() {
+	return getUserAgent().includes("jsdom/");
+}
+var b = "data-floating-ui-focusable", x = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+function activeElement(e) {
+	let t = e.activeElement;
+	for (; ((n = t) == null || (n = n.shadowRoot) == null ? void 0 : n.activeElement) != null;) {
+		var n;
+		t = t.shadowRoot.activeElement;
+	}
+	return t;
+}
+function contains$1(e, t) {
+	if (!e || !t) return !1;
+	let n = t.getRootNode == null ? void 0 : t.getRootNode();
+	if (e.contains(t)) return !0;
+	if (n && isShadowRoot(n)) {
+		let n = t;
+		for (; n;) {
+			if (e === n) return !0;
+			n = n.parentNode || n.host;
+		}
+	}
+	return !1;
+}
+e(contains$1, "contains");
+function getTarget$1(e) {
+	return "composedPath" in e ? e.composedPath()[0] : e.target;
+}
+e(getTarget$1, "getTarget");
+function isEventTargetWithin(e, t) {
+	if (t == null) return !1;
+	if ("composedPath" in e) return e.composedPath().includes(t);
+	let n = e;
+	return n.target != null && t.contains(n.target);
+}
+function isRootElement(e) {
+	return e.matches("html,body");
+}
+function getDocument(e) {
+	return e?.ownerDocument || document;
+}
+function isTypeableElement(e) {
+	return isHTMLElement(e) && e.matches(x);
+}
+function matchesFocusVisible(e) {
+	if (!e || isJSDOM()) return !0;
+	try {
+		return e.matches(":focus-visible");
+	} catch {
+		return !0;
+	}
+}
+function getFloatingFocusElement(e) {
+	return e ? e.hasAttribute(b) ? e : e.querySelector("[data-floating-ui-focusable]") || e : null;
+}
+function getNodeChildren$1(e, t, n) {
+	return n === void 0 && (n = !0), e.filter((e) => e.parentId === t && (!n || e.context?.open)).flatMap((t) => [t, ...getNodeChildren$1(e, t.id, n)]);
+}
+e(getNodeChildren$1, "getNodeChildren");
+function isReactEvent(e) {
+	return "nativeEvent" in e;
+}
+function isMouseLikePointerType(e, t) {
+	let n = ["mouse", "pen"];
+	return t || n.push("", void 0), n.includes(e);
+}
+var S = typeof document < "u" ? n : function noop() {}, C = { ...t };
+function useLatestRef$1(e) {
+	let n = t.useRef(e);
+	return S(() => {
+		n.current = e;
+	}), n;
+}
+e(useLatestRef$1, "useLatestRef");
+var w = C.useInsertionEffect || ((e) => e());
+function useEffectEvent$1(e) {
+	let n = t.useRef(() => {});
+	return w(() => {
+		n.current = e;
+	}), t.useCallback(function() {
+		var e = [...arguments];
+		return n.current == null ? void 0 : n.current(...e);
+	}, []);
+}
+e(useEffectEvent$1, "useEffectEvent");
+//#endregion
+//#region ../../node_modules/.pnpm/@floating-ui+core@1.7.5/node_modules/@floating-ui/core/dist/floating-ui.core.mjs
+function computeCoordsFromPlacement(e, t, n) {
+	let { reference: r, floating: i } = e, a = getSideAxis(t), o = getAlignmentAxis(t), s = getAxisLength(o), c = getSide(t), l = a === "y", u = r.x + r.width / 2 - i.width / 2, d = r.y + r.height / 2 - i.height / 2, f = r[s] / 2 - i[s] / 2, p;
+	switch (c) {
+		case "top":
+			p = {
+				x: u,
+				y: r.y - i.height
+			};
+			break;
+		case "bottom":
+			p = {
+				x: u,
+				y: r.y + r.height
+			};
+			break;
+		case "right":
+			p = {
+				x: r.x + r.width,
+				y: d
+			};
+			break;
+		case "left":
+			p = {
+				x: r.x - i.width,
+				y: d
+			};
+			break;
+		default: p = {
+			x: r.x,
+			y: r.y
+		};
+	}
+	switch (getAlignment(t)) {
+		case "start":
+			p[o] -= f * (n && l ? -1 : 1);
+			break;
+		case "end":
+			p[o] += f * (n && l ? -1 : 1);
+			break;
+	}
+	return p;
+}
+async function detectOverflow(e, t) {
+	t === void 0 && (t = {});
+	let { x: n, y: r, platform: i, rects: a, elements: o, strategy: s } = e, { boundary: c = "clippingAncestors", rootBoundary: l = "viewport", elementContext: u = "floating", altBoundary: d = !1, padding: f = 0 } = evaluate(t, e), p = getPaddingObject(f), m = o[d ? u === "floating" ? "reference" : "floating" : u], h = rectToClientRect(await i.getClippingRect({
+		element: await (i.isElement == null ? void 0 : i.isElement(m)) ?? !0 ? m : m.contextElement || await (i.getDocumentElement == null ? void 0 : i.getDocumentElement(o.floating)),
+		boundary: c,
+		rootBoundary: l,
+		strategy: s
+	})), g = u === "floating" ? {
+		x: n,
+		y: r,
+		width: a.floating.width,
+		height: a.floating.height
+	} : a.reference, _ = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(o.floating)), v = await (i.isElement == null ? void 0 : i.isElement(_)) && await (i.getScale == null ? void 0 : i.getScale(_)) || {
+		x: 1,
+		y: 1
+	}, y = rectToClientRect(i.convertOffsetParentRelativeRectToViewportRelativeRect ? await i.convertOffsetParentRelativeRectToViewportRelativeRect({
+		elements: o,
+		rect: g,
+		offsetParent: _,
+		strategy: s
+	}) : g);
+	return {
+		top: (h.top - y.top + p.top) / v.y,
+		bottom: (y.bottom - h.bottom + p.bottom) / v.y,
+		left: (h.left - y.left + p.left) / v.x,
+		right: (y.right - h.right + p.right) / v.x
+	};
+}
+var T = 50, E = /* @__PURE__ */ e(async (e, t, n) => {
+	let { placement: r = "bottom", strategy: i = "absolute", middleware: a = [], platform: o } = n, s = o.detectOverflow ? o : {
+		...o,
+		detectOverflow
+	}, c = await (o.isRTL == null ? void 0 : o.isRTL(t)), l = await o.getElementRects({
+		reference: e,
+		floating: t,
+		strategy: i
+	}), { x: u, y: d } = computeCoordsFromPlacement(l, r, c), f = r, p = 0, m = {};
+	for (let n = 0; n < a.length; n++) {
+		let h = a[n];
+		if (!h) continue;
+		let { name: g, fn: _ } = h, { x: v, y, data: b, reset: x } = await _({
+			x: u,
+			y: d,
+			initialPlacement: r,
+			placement: f,
+			strategy: i,
+			middlewareData: m,
+			rects: l,
+			platform: s,
+			elements: {
+				reference: e,
+				floating: t
+			}
+		});
+		u = v ?? u, d = y ?? d, m[g] = {
+			...m[g],
+			...b
+		}, x && p < T && (p++, typeof x == "object" && (x.placement && (f = x.placement), x.rects && (l = x.rects === !0 ? await o.getElementRects({
+			reference: e,
+			floating: t,
+			strategy: i
+		}) : x.rects), {x: u, y: d} = computeCoordsFromPlacement(l, f, c)), n = -1);
+	}
+	return {
+		x: u,
+		y: d,
+		placement: f,
+		strategy: i,
+		middlewareData: m
+	};
+}, "computePosition"), D = /* @__PURE__ */ e((e) => ({
+	name: "arrow",
+	options: e,
+	async fn(t) {
+		let { x: n, y: r, placement: i, rects: a, platform: o, elements: s, middlewareData: c } = t, { element: l, padding: u = 0 } = evaluate(e, t) || {};
+		if (l == null) return {};
+		let f = getPaddingObject(u), p = {
+			x: n,
+			y: r
+		}, m = getAlignmentAxis(i), h = getAxisLength(m), g = await o.getDimensions(l), _ = m === "y", v = _ ? "top" : "left", y = _ ? "bottom" : "right", b = _ ? "clientHeight" : "clientWidth", x = a.reference[h] + a.reference[m] - p[m] - a.floating[h], S = p[m] - a.reference[m], C = await (o.getOffsetParent == null ? void 0 : o.getOffsetParent(l)), w = C ? C[b] : 0;
+		(!w || !await (o.isElement == null ? void 0 : o.isElement(C))) && (w = s.floating[b] || a.floating[h]);
+		let T = x / 2 - S / 2, E = w / 2 - g[h] / 2 - 1, D = d(f[v], E), O = d(f[y], E), k = D, A = w - g[h] - O, j = w / 2 - g[h] / 2 + T, M = clamp(k, j, A), N = !c.arrow && getAlignment(i) != null && j !== M && a.reference[h] / 2 - (j < k ? D : O) - g[h] / 2 < 0, P = N ? j < k ? j - k : j - A : 0;
+		return {
+			[m]: p[m] + P,
+			data: {
+				[m]: M,
+				centerOffset: j - M - P,
+				...N && { alignmentOffset: P }
+			},
+			reset: N
+		};
+	}
+}), "arrow");
+function getPlacementList(e, t, n) {
+	return (e ? [...n.filter((t) => getAlignment(t) === e), ...n.filter((t) => getAlignment(t) !== e)] : n.filter((e) => getSide(e) === e)).filter((n) => e ? getAlignment(n) === e || (t ? getOppositeAlignmentPlacement(n) !== n : !1) : !0);
+}
+var O = /* @__PURE__ */ e(function(e) {
+	return e === void 0 && (e = {}), {
+		name: "autoPlacement",
+		options: e,
+		async fn(t) {
+			let { rects: n, middlewareData: r, placement: i, platform: a, elements: o } = t, { crossAxis: s = !1, alignment: c, allowedPlacements: l = u, autoAlignment: d = !0, ...f } = evaluate(e, t), p = c !== void 0 || l === u ? getPlacementList(c || null, d, l) : l, m = await a.detectOverflow(t, f), h = r.autoPlacement?.index || 0, g = p[h];
+			if (g == null) return {};
+			let _ = getAlignmentSides(g, n, await (a.isRTL == null ? void 0 : a.isRTL(o.floating)));
+			if (i !== g) return { reset: { placement: p[0] } };
+			let v = [
+				m[getSide(g)],
+				m[_[0]],
+				m[_[1]]
+			], y = [...r.autoPlacement?.overflows || [], {
+				placement: g,
+				overflows: v
+			}], b = p[h + 1];
+			if (b) return {
+				data: {
+					index: h + 1,
+					overflows: y
+				},
+				reset: { placement: b }
+			};
+			let x = y.map((e) => {
+				let t = getAlignment(e.placement);
+				return [
+					e.placement,
+					t && s ? e.overflows.slice(0, 2).reduce((e, t) => e + t, 0) : e.overflows[0],
+					e.overflows
+				];
+			}).sort((e, t) => e[1] - t[1]), S = x.filter((e) => e[2].slice(0, getAlignment(e[0]) ? 2 : 3).every((e) => e <= 0))[0]?.[0] || x[0][0];
+			return S === i ? {} : {
+				data: {
+					index: h + 1,
+					overflows: y
+				},
+				reset: { placement: S }
+			};
+		}
+	};
+}, "autoPlacement"), k = /* @__PURE__ */ e(function(e) {
+	return e === void 0 && (e = {}), {
+		name: "flip",
+		options: e,
+		async fn(t) {
+			var n;
+			let { placement: r, middlewareData: i, rects: a, initialPlacement: o, platform: s, elements: c } = t, { mainAxis: l = !0, crossAxis: u = !0, fallbackPlacements: d, fallbackStrategy: f = "bestFit", fallbackAxisSideDirection: p = "none", flipAlignment: m = !0, ...h } = evaluate(e, t);
+			if ((n = i.arrow) != null && n.alignmentOffset) return {};
+			let g = getSide(r), _ = getSideAxis(o), v = getSide(o) === o, y = await (s.isRTL == null ? void 0 : s.isRTL(c.floating)), b = d || (v || !m ? [getOppositePlacement(o)] : getExpandedPlacements(o)), x = p !== "none";
+			!d && x && b.push(...getOppositeAxisPlacements(o, m, p, y));
+			let S = [o, ...b], C = await s.detectOverflow(t, h), w = [], T = i.flip?.overflows || [];
+			if (l && w.push(C[g]), u) {
+				let e = getAlignmentSides(r, a, y);
+				w.push(C[e[0]], C[e[1]]);
+			}
+			if (T = [...T, {
+				placement: r,
+				overflows: w
+			}], !w.every((e) => e <= 0)) {
+				let e = (i.flip?.index || 0) + 1, t = S[e];
+				if (t && (!(u === "alignment" && _ !== getSideAxis(t)) || T.every((e) => getSideAxis(e.placement) === _ ? e.overflows[0] > 0 : !0))) return {
+					data: {
+						index: e,
+						overflows: T
+					},
+					reset: { placement: t }
+				};
+				let n = T.filter((e) => e.overflows[0] <= 0).sort((e, t) => e.overflows[1] - t.overflows[1])[0]?.placement;
+				if (!n) switch (f) {
+					case "bestFit": {
+						let e = T.filter((e) => {
+							if (x) {
+								let t = getSideAxis(e.placement);
+								return t === _ || t === "y";
+							}
+							return !0;
+						}).map((e) => [e.placement, e.overflows.filter((e) => e > 0).reduce((e, t) => e + t, 0)]).sort((e, t) => e[1] - t[1])[0]?.[0];
+						e && (n = e);
+						break;
+					}
+					case "initialPlacement":
+						n = o;
+						break;
+				}
+				if (r !== n) return { reset: { placement: n } };
+			}
+			return {};
+		}
+	};
+}, "flip");
+function getSideOffsets(e, t) {
+	return {
+		top: e.top - t.height,
+		right: e.right - t.width,
+		bottom: e.bottom - t.height,
+		left: e.left - t.width
+	};
+}
+function isAnySideFullyClipped(e) {
+	return c.some((t) => e[t] >= 0);
+}
+var A = /* @__PURE__ */ e(function(e) {
+	return e === void 0 && (e = {}), {
+		name: "hide",
+		options: e,
+		async fn(t) {
+			let { rects: n, platform: r } = t, { strategy: i = "referenceHidden", ...a } = evaluate(e, t);
+			switch (i) {
+				case "referenceHidden": {
+					let e = getSideOffsets(await r.detectOverflow(t, {
+						...a,
+						elementContext: "reference"
+					}), n.reference);
+					return { data: {
+						referenceHiddenOffsets: e,
+						referenceHidden: isAnySideFullyClipped(e)
+					} };
+				}
+				case "escaped": {
+					let e = getSideOffsets(await r.detectOverflow(t, {
+						...a,
+						altBoundary: !0
+					}), n.floating);
+					return { data: {
+						escapedOffsets: e,
+						escaped: isAnySideFullyClipped(e)
+					} };
+				}
+				default: return {};
+			}
+		}
+	};
+}, "hide");
+function getBoundingRect(e) {
+	let t = d(...e.map((e) => e.left)), n = d(...e.map((e) => e.top)), r = f(...e.map((e) => e.right)), i = f(...e.map((e) => e.bottom));
+	return {
+		x: t,
+		y: n,
+		width: r - t,
+		height: i - n
+	};
+}
+function getRectsByLine(e) {
+	let t = e.slice().sort((e, t) => e.y - t.y), n = [], r = null;
+	for (let e = 0; e < t.length; e++) {
+		let i = t[e];
+		!r || i.y - r.y > r.height / 2 ? n.push([i]) : n[n.length - 1].push(i), r = i;
+	}
+	return n.map((e) => rectToClientRect(getBoundingRect(e)));
+}
+var j = /* @__PURE__ */ e(function(e) {
+	return e === void 0 && (e = {}), {
+		name: "inline",
+		options: e,
+		async fn(t) {
+			let { placement: n, elements: r, rects: i, platform: a, strategy: o } = t, { padding: s = 2, x: c, y: l } = evaluate(e, t), u = Array.from(await (a.getClientRects == null ? void 0 : a.getClientRects(r.reference)) || []), p = getRectsByLine(u), m = rectToClientRect(getBoundingRect(u)), h = getPaddingObject(s);
+			function getBoundingClientRect() {
+				if (p.length === 2 && p[0].left > p[1].right && c != null && l != null) return p.find((e) => c > e.left - h.left && c < e.right + h.right && l > e.top - h.top && l < e.bottom + h.bottom) || m;
+				if (p.length >= 2) {
+					if (getSideAxis(n) === "y") {
+						let e = p[0], t = p[p.length - 1], r = getSide(n) === "top", i = e.top, a = t.bottom, o = r ? e.left : t.left, s = r ? e.right : t.right;
+						return {
+							top: i,
+							bottom: a,
+							left: o,
+							right: s,
+							width: s - o,
+							height: a - i,
+							x: o,
+							y: i
+						};
+					}
+					let e = getSide(n) === "left", t = f(...p.map((e) => e.right)), r = d(...p.map((e) => e.left)), i = p.filter((n) => e ? n.left === r : n.right === t), a = i[0].top, o = i[i.length - 1].bottom, s = r, c = t;
+					return {
+						top: a,
+						bottom: o,
+						left: s,
+						right: c,
+						width: c - s,
+						height: o - a,
+						x: s,
+						y: a
+					};
+				}
+				return m;
+			}
+			let g = await a.getElementRects({
+				reference: { getBoundingClientRect },
+				floating: r.floating,
+				strategy: o
+			});
+			return i.reference.x !== g.reference.x || i.reference.y !== g.reference.y || i.reference.width !== g.reference.width || i.reference.height !== g.reference.height ? { reset: { rects: g } } : {};
+		}
+	};
+}, "inline"), M = /* @__PURE__ */ new Set(["left", "top"]);
+async function convertValueToCoords(e, t) {
+	let { placement: n, platform: r, elements: i } = e, a = await (r.isRTL == null ? void 0 : r.isRTL(i.floating)), o = getSide(n), s = getAlignment(n), c = getSideAxis(n) === "y", l = M.has(o) ? -1 : 1, u = a && c ? -1 : 1, d = evaluate(t, e), { mainAxis: f, crossAxis: p, alignmentAxis: m } = typeof d == "number" ? {
+		mainAxis: d,
+		crossAxis: 0,
+		alignmentAxis: null
+	} : {
+		mainAxis: d.mainAxis || 0,
+		crossAxis: d.crossAxis || 0,
+		alignmentAxis: d.alignmentAxis
+	};
+	return s && typeof m == "number" && (p = s === "end" ? m * -1 : m), c ? {
+		x: p * u,
+		y: f * l
+	} : {
+		x: f * l,
+		y: p * u
+	};
+}
+var N = /* @__PURE__ */ e(function(e) {
+	return e === void 0 && (e = 0), {
+		name: "offset",
+		options: e,
+		async fn(t) {
+			var n;
+			let { x: r, y: i, placement: a, middlewareData: o } = t, s = await convertValueToCoords(t, e);
+			return a === o.offset?.placement && (n = o.arrow) != null && n.alignmentOffset ? {} : {
+				x: r + s.x,
+				y: i + s.y,
+				data: {
+					...s,
+					placement: a
+				}
+			};
+		}
+	};
+}, "offset"), P = /* @__PURE__ */ e(function(e) {
+	return e === void 0 && (e = {}), {
+		name: "shift",
+		options: e,
+		async fn(t) {
+			let { x: n, y: r, placement: i, platform: a } = t, { mainAxis: o = !0, crossAxis: s = !1, limiter: c = { fn: (e) => {
+				let { x: t, y: n } = e;
+				return {
+					x: t,
+					y: n
+				};
+			} }, ...l } = evaluate(e, t), u = {
+				x: n,
+				y: r
+			}, d = await a.detectOverflow(t, l), f = getSideAxis(getSide(i)), p = getOppositeAxis(f), m = u[p], h = u[f];
+			if (o) {
+				let e = p === "y" ? "top" : "left", t = p === "y" ? "bottom" : "right", n = m + d[e], r = m - d[t];
+				m = clamp(n, m, r);
+			}
+			if (s) {
+				let e = f === "y" ? "top" : "left", t = f === "y" ? "bottom" : "right", n = h + d[e], r = h - d[t];
+				h = clamp(n, h, r);
+			}
+			let g = c.fn({
+				...t,
+				[p]: m,
+				[f]: h
+			});
+			return {
+				...g,
+				data: {
+					x: g.x - n,
+					y: g.y - r,
+					enabled: {
+						[p]: o,
+						[f]: s
+					}
+				}
+			};
+		}
+	};
+}, "shift"), F = /* @__PURE__ */ e(function(e) {
+	return e === void 0 && (e = {}), {
+		options: e,
+		fn(t) {
+			let { x: n, y: r, placement: i, rects: a, middlewareData: o } = t, { offset: s = 0, mainAxis: c = !0, crossAxis: l = !0 } = evaluate(e, t), u = {
+				x: n,
+				y: r
+			}, d = getSideAxis(i), f = getOppositeAxis(d), p = u[f], m = u[d], h = evaluate(s, t), g = typeof h == "number" ? {
+				mainAxis: h,
+				crossAxis: 0
+			} : {
+				mainAxis: 0,
+				crossAxis: 0,
+				...h
+			};
+			if (c) {
+				let e = f === "y" ? "height" : "width", t = a.reference[f] - a.floating[e] + g.mainAxis, n = a.reference[f] + a.reference[e] - g.mainAxis;
+				p < t ? p = t : p > n && (p = n);
+			}
+			if (l) {
+				let e = f === "y" ? "width" : "height", t = M.has(getSide(i)), n = a.reference[d] - a.floating[e] + (t && o.offset?.[d] || 0) + (t ? 0 : g.crossAxis), r = a.reference[d] + a.reference[e] + (t ? 0 : o.offset?.[d] || 0) - (t ? g.crossAxis : 0);
+				m < n ? m = n : m > r && (m = r);
+			}
+			return {
+				[f]: p,
+				[d]: m
+			};
+		}
+	};
+}, "limitShift"), ee = /* @__PURE__ */ e(function(e) {
+	return e === void 0 && (e = {}), {
+		name: "size",
+		options: e,
+		async fn(t) {
+			var n, r;
+			let { placement: i, rects: a, platform: o, elements: s } = t, { apply = () => {}, ...c } = evaluate(e, t), l = await o.detectOverflow(t, c), u = getSide(i), p = getAlignment(i), m = getSideAxis(i) === "y", { width: h, height: g } = a.floating, _, v;
+			u === "top" || u === "bottom" ? (_ = u, v = p === (await (o.isRTL == null ? void 0 : o.isRTL(s.floating)) ? "start" : "end") ? "left" : "right") : (v = u, _ = p === "end" ? "top" : "bottom");
+			let y = g - l.top - l.bottom, b = h - l.left - l.right, x = d(g - l[_], y), S = d(h - l[v], b), C = !t.middlewareData.shift, w = x, T = S;
+			if ((n = t.middlewareData.shift) != null && n.enabled.x && (T = b), (r = t.middlewareData.shift) != null && r.enabled.y && (w = y), C && !p) {
+				let e = f(l.left, 0), t = f(l.right, 0), n = f(l.top, 0), r = f(l.bottom, 0);
+				m ? T = h - 2 * (e !== 0 || t !== 0 ? e + t : f(l.left, l.right)) : w = g - 2 * (n !== 0 || r !== 0 ? n + r : f(l.top, l.bottom));
+			}
+			await apply({
+				...t,
+				availableWidth: T,
+				availableHeight: w
+			});
+			let E = await o.getDimensions(s.floating);
+			return h !== E.width || g !== E.height ? { reset: { rects: !0 } } : {};
+		}
+	};
+}, "size");
+//#endregion
+//#region ../../node_modules/.pnpm/@floating-ui+dom@1.7.6/node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
+function getCssDimensions(e) {
+	let t = getComputedStyle$1(e), n = parseFloat(t.width) || 0, r = parseFloat(t.height) || 0, i = isHTMLElement(e), a = i ? e.offsetWidth : n, o = i ? e.offsetHeight : r, s = p(n) !== a || p(r) !== o;
+	return s && (n = a, r = o), {
+		width: n,
+		height: r,
+		$: s
+	};
+}
+function unwrapElement(e) {
+	return isElement(e) ? e : e.contextElement;
+}
+function getScale(e) {
+	let t = unwrapElement(e);
+	if (!isHTMLElement(t)) return createCoords(1);
+	let n = t.getBoundingClientRect(), { width: r, height: i, $: a } = getCssDimensions(t), o = (a ? p(n.width) : n.width) / r, s = (a ? p(n.height) : n.height) / i;
+	return (!o || !Number.isFinite(o)) && (o = 1), (!s || !Number.isFinite(s)) && (s = 1), {
+		x: o,
+		y: s
+	};
+}
+var te = /* @__PURE__ */ createCoords(0);
+function getVisualOffsets(e) {
+	let t = getWindow(e);
+	return !isWebKit() || !t.visualViewport ? te : {
+		x: t.visualViewport.offsetLeft,
+		y: t.visualViewport.offsetTop
+	};
+}
+function shouldAddVisualOffsets(e, t, n) {
+	return t === void 0 && (t = !1), !n || t && n !== getWindow(e) ? !1 : t;
+}
+function getBoundingClientRect(e, t, n, r) {
+	t === void 0 && (t = !1), n === void 0 && (n = !1);
+	let i = e.getBoundingClientRect(), a = unwrapElement(e), o = createCoords(1);
+	t && (r ? isElement(r) && (o = getScale(r)) : o = getScale(e));
+	let s = shouldAddVisualOffsets(a, n, r) ? getVisualOffsets(a) : createCoords(0), c = (i.left + s.x) / o.x, l = (i.top + s.y) / o.y, u = i.width / o.x, d = i.height / o.y;
+	if (a) {
+		let e = getWindow(a), t = r && isElement(r) ? getWindow(r) : r, n = e, i = getFrameElement(n);
+		for (; i && r && t !== n;) {
+			let e = getScale(i), t = i.getBoundingClientRect(), r = getComputedStyle$1(i), a = t.left + (i.clientLeft + parseFloat(r.paddingLeft)) * e.x, o = t.top + (i.clientTop + parseFloat(r.paddingTop)) * e.y;
+			c *= e.x, l *= e.y, u *= e.x, d *= e.y, c += a, l += o, n = getWindow(i), i = getFrameElement(n);
+		}
+	}
+	return rectToClientRect({
+		width: u,
+		height: d,
+		x: c,
+		y: l
+	});
+}
+function getWindowScrollBarX(e, t) {
+	let n = getNodeScroll(e).scrollLeft;
+	return t ? t.left + n : getBoundingClientRect(getDocumentElement(e)).left + n;
+}
+function getHTMLOffset(e, t) {
+	let n = e.getBoundingClientRect();
+	return {
+		x: n.left + t.scrollLeft - getWindowScrollBarX(e, n),
+		y: n.top + t.scrollTop
+	};
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(e) {
+	let { elements: t, rect: n, offsetParent: r, strategy: i } = e, a = i === "fixed", o = getDocumentElement(r), s = t ? isTopLayer(t.floating) : !1;
+	if (r === o || s && a) return n;
+	let c = {
+		scrollLeft: 0,
+		scrollTop: 0
+	}, l = createCoords(1), u = createCoords(0), d = isHTMLElement(r);
+	if ((d || !d && !a) && ((getNodeName(r) !== "body" || isOverflowElement(o)) && (c = getNodeScroll(r)), d)) {
+		let e = getBoundingClientRect(r);
+		l = getScale(r), u.x = e.x + r.clientLeft, u.y = e.y + r.clientTop;
+	}
+	let f = o && !d && !a ? getHTMLOffset(o, c) : createCoords(0);
+	return {
+		width: n.width * l.x,
+		height: n.height * l.y,
+		x: n.x * l.x - c.scrollLeft * l.x + u.x + f.x,
+		y: n.y * l.y - c.scrollTop * l.y + u.y + f.y
+	};
+}
+function getClientRects(e) {
+	return Array.from(e.getClientRects());
+}
+function getDocumentRect(e) {
+	let t = getDocumentElement(e), n = getNodeScroll(e), r = e.ownerDocument.body, i = f(t.scrollWidth, t.clientWidth, r.scrollWidth, r.clientWidth), a = f(t.scrollHeight, t.clientHeight, r.scrollHeight, r.clientHeight), o = -n.scrollLeft + getWindowScrollBarX(e), s = -n.scrollTop;
+	return getComputedStyle$1(r).direction === "rtl" && (o += f(t.clientWidth, r.clientWidth) - i), {
+		width: i,
+		height: a,
+		x: o,
+		y: s
+	};
+}
+var I = 25;
+function getViewportRect(e, t) {
+	let n = getWindow(e), r = getDocumentElement(e), i = n.visualViewport, a = r.clientWidth, o = r.clientHeight, s = 0, c = 0;
+	if (i) {
+		a = i.width, o = i.height;
+		let e = isWebKit();
+		(!e || e && t === "fixed") && (s = i.offsetLeft, c = i.offsetTop);
+	}
+	let l = getWindowScrollBarX(r);
+	if (l <= 0) {
+		let e = r.ownerDocument, t = e.body, n = getComputedStyle(t), i = e.compatMode === "CSS1Compat" && parseFloat(n.marginLeft) + parseFloat(n.marginRight) || 0, o = Math.abs(r.clientWidth - t.clientWidth - i);
+		o <= I && (a -= o);
+	} else l <= I && (a += l);
+	return {
+		width: a,
+		height: o,
+		x: s,
+		y: c
+	};
+}
+function getInnerBoundingClientRect(e, t) {
+	let n = getBoundingClientRect(e, !0, t === "fixed"), r = n.top + e.clientTop, i = n.left + e.clientLeft, a = isHTMLElement(e) ? getScale(e) : createCoords(1);
+	return {
+		width: e.clientWidth * a.x,
+		height: e.clientHeight * a.y,
+		x: i * a.x,
+		y: r * a.y
+	};
+}
+function getClientRectFromClippingAncestor(e, t, n) {
+	let r;
+	if (t === "viewport") r = getViewportRect(e, n);
+	else if (t === "document") r = getDocumentRect(getDocumentElement(e));
+	else if (isElement(t)) r = getInnerBoundingClientRect(t, n);
+	else {
+		let n = getVisualOffsets(e);
+		r = {
+			x: t.x - n.x,
+			y: t.y - n.y,
+			width: t.width,
+			height: t.height
+		};
+	}
+	return rectToClientRect(r);
+}
+function hasFixedPositionAncestor(e, t) {
+	let n = getParentNode(e);
+	return n === t || !isElement(n) || isLastTraversableNode(n) ? !1 : getComputedStyle$1(n).position === "fixed" || hasFixedPositionAncestor(n, t);
+}
+function getClippingElementAncestors(e, t) {
+	let n = t.get(e);
+	if (n) return n;
+	let r = getOverflowAncestors(e, [], !1).filter((e) => isElement(e) && getNodeName(e) !== "body"), i = null, a = getComputedStyle$1(e).position === "fixed", o = a ? getParentNode(e) : e;
+	for (; isElement(o) && !isLastTraversableNode(o);) {
+		let t = getComputedStyle$1(o), n = isContainingBlock(o);
+		!n && t.position === "fixed" && (i = null), (a ? !n && !i : !n && t.position === "static" && i && (i.position === "absolute" || i.position === "fixed") || isOverflowElement(o) && !n && hasFixedPositionAncestor(e, o)) ? r = r.filter((e) => e !== o) : i = t, o = getParentNode(o);
+	}
+	return t.set(e, r), r;
+}
+function getClippingRect(e) {
+	let { element: t, boundary: n, rootBoundary: r, strategy: i } = e, a = [...n === "clippingAncestors" ? isTopLayer(t) ? [] : getClippingElementAncestors(t, this._c) : [].concat(n), r], o = getClientRectFromClippingAncestor(t, a[0], i), s = o.top, c = o.right, l = o.bottom, u = o.left;
+	for (let e = 1; e < a.length; e++) {
+		let n = getClientRectFromClippingAncestor(t, a[e], i);
+		s = f(n.top, s), c = d(n.right, c), l = d(n.bottom, l), u = f(n.left, u);
+	}
+	return {
+		width: c - u,
+		height: l - s,
+		x: u,
+		y: s
+	};
+}
+function getDimensions(e) {
+	let { width: t, height: n } = getCssDimensions(e);
+	return {
+		width: t,
+		height: n
+	};
+}
+function getRectRelativeToOffsetParent(e, t, n) {
+	let r = isHTMLElement(t), i = getDocumentElement(t), a = n === "fixed", o = getBoundingClientRect(e, !0, a, t), s = {
+		scrollLeft: 0,
+		scrollTop: 0
+	}, c = createCoords(0);
+	function setLeftRTLScrollbarOffset() {
+		c.x = getWindowScrollBarX(i);
+	}
+	if (r || !r && !a) if ((getNodeName(t) !== "body" || isOverflowElement(i)) && (s = getNodeScroll(t)), r) {
+		let e = getBoundingClientRect(t, !0, a, t);
+		c.x = e.x + t.clientLeft, c.y = e.y + t.clientTop;
+	} else i && setLeftRTLScrollbarOffset();
+	a && !r && i && setLeftRTLScrollbarOffset();
+	let l = i && !r && !a ? getHTMLOffset(i, s) : createCoords(0);
+	return {
+		x: o.left + s.scrollLeft - c.x - l.x,
+		y: o.top + s.scrollTop - c.y - l.y,
+		width: o.width,
+		height: o.height
+	};
+}
+function isStaticPositioned(e) {
+	return getComputedStyle$1(e).position === "static";
+}
+function getTrueOffsetParent(e, t) {
+	if (!isHTMLElement(e) || getComputedStyle$1(e).position === "fixed") return null;
+	if (t) return t(e);
+	let n = e.offsetParent;
+	return getDocumentElement(e) === n && (n = n.ownerDocument.body), n;
+}
+function getOffsetParent(e, t) {
+	let n = getWindow(e);
+	if (isTopLayer(e)) return n;
+	if (!isHTMLElement(e)) {
+		let t = getParentNode(e);
+		for (; t && !isLastTraversableNode(t);) {
+			if (isElement(t) && !isStaticPositioned(t)) return t;
+			t = getParentNode(t);
+		}
+		return n;
+	}
+	let r = getTrueOffsetParent(e, t);
+	for (; r && isTableElement(r) && isStaticPositioned(r);) r = getTrueOffsetParent(r, t);
+	return r && isLastTraversableNode(r) && isStaticPositioned(r) && !isContainingBlock(r) ? n : r || getContainingBlock(e) || n;
+}
+var getElementRects = async function(e) {
+	let t = this.getOffsetParent || getOffsetParent, n = this.getDimensions, r = await n(e.floating);
+	return {
+		reference: getRectRelativeToOffsetParent(e.reference, await t(e.floating), e.strategy),
+		floating: {
+			x: 0,
+			y: 0,
+			width: r.width,
+			height: r.height
+		}
+	};
+};
+function isRTL(e) {
+	return getComputedStyle$1(e).direction === "rtl";
+}
+var ne = {
+	convertOffsetParentRelativeRectToViewportRelativeRect,
+	getDocumentElement,
+	getClippingRect,
+	getOffsetParent,
+	getElementRects,
+	getClientRects,
+	getDimensions,
+	getScale,
+	isElement,
+	isRTL
+};
+function rectsAreEqual(e, t) {
+	return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function observeMove(e, t) {
+	let n = null, r, i = getDocumentElement(e);
+	function cleanup() {
+		var e;
+		clearTimeout(r), (e = n) == null || e.disconnect(), n = null;
+	}
+	function refresh(a, o) {
+		a === void 0 && (a = !1), o === void 0 && (o = 1), cleanup();
+		let s = e.getBoundingClientRect(), { left: c, top: l, width: u, height: p } = s;
+		if (a || t(), !u || !p) return;
+		let h = m(l), g = m(i.clientWidth - (c + u)), _ = m(i.clientHeight - (l + p)), v = m(c), y = {
+			rootMargin: -h + "px " + -g + "px " + -_ + "px " + -v + "px",
+			threshold: f(0, d(1, o)) || 1
+		}, b = !0;
+		function handleObserve(t) {
+			let n = t[0].intersectionRatio;
+			if (n !== o) {
+				if (!b) return refresh();
+				n ? refresh(!1, n) : r = setTimeout(() => {
+					refresh(!1, 1e-7);
+				}, 1e3);
+			}
+			n === 1 && !rectsAreEqual(s, e.getBoundingClientRect()) && refresh(), b = !1;
+		}
+		try {
+			n = new IntersectionObserver(handleObserve, {
+				...y,
+				root: i.ownerDocument
+			});
+		} catch {
+			n = new IntersectionObserver(handleObserve, y);
+		}
+		n.observe(e);
+	}
+	return refresh(!0), cleanup;
+}
+function autoUpdate(e, t, n, r) {
+	r === void 0 && (r = {});
+	let { ancestorScroll: i = !0, ancestorResize: a = !0, elementResize: o = typeof ResizeObserver == "function", layoutShift: s = typeof IntersectionObserver == "function", animationFrame: c = !1 } = r, l = unwrapElement(e), u = i || a ? [...l ? getOverflowAncestors(l) : [], ...t ? getOverflowAncestors(t) : []] : [];
+	u.forEach((e) => {
+		i && e.addEventListener("scroll", n, { passive: !0 }), a && e.addEventListener("resize", n);
+	});
+	let d = l && s ? observeMove(l, n) : null, f = -1, p = null;
+	o && (p = new ResizeObserver((e) => {
+		let [r] = e;
+		r && r.target === l && p && t && (p.unobserve(t), cancelAnimationFrame(f), f = requestAnimationFrame(() => {
+			var e;
+			(e = p) == null || e.observe(t);
+		})), n();
+	}), l && !c && p.observe(l), t && p.observe(t));
+	let m, h = c ? getBoundingClientRect(e) : null;
+	c && frameLoop();
+	function frameLoop() {
+		let t = getBoundingClientRect(e);
+		h && !rectsAreEqual(h, t) && n(), h = t, m = requestAnimationFrame(frameLoop);
+	}
+	return n(), () => {
+		var e;
+		u.forEach((e) => {
+			i && e.removeEventListener("scroll", n), a && e.removeEventListener("resize", n);
+		}), d?.(), (e = p) == null || e.disconnect(), p = null, c && cancelAnimationFrame(m);
+	};
+}
+var L = N, R = O, z = P, B = k, V = ee, H = A, U = D, re = j, ie = F, computePosition = (e, t, n) => {
+	let r = /* @__PURE__ */ new Map(), i = {
+		platform: ne,
+		...n
+	}, a = {
+		...i.platform,
+		_c: r
+	};
+	return E(e, t, {
+		...i,
+		platform: a
+	});
+}, W = typeof document < "u" ? n : function noop() {};
+function deepEqual(e, t) {
+	if (e === t) return !0;
+	if (typeof e != typeof t) return !1;
+	if (typeof e == "function" && e.toString() === t.toString()) return !0;
+	let n, r, i;
+	if (e && t && typeof e == "object") {
+		if (Array.isArray(e)) {
+			if (n = e.length, n !== t.length) return !1;
+			for (r = n; r-- !== 0;) if (!deepEqual(e[r], t[r])) return !1;
+			return !0;
+		}
+		if (i = Object.keys(e), n = i.length, n !== Object.keys(t).length) return !1;
+		for (r = n; r-- !== 0;) if (!{}.hasOwnProperty.call(t, i[r])) return !1;
+		for (r = n; r-- !== 0;) {
+			let n = i[r];
+			if (!(n === "_owner" && e.$$typeof) && !deepEqual(e[n], t[n])) return !1;
+		}
+		return !0;
+	}
+	return e !== e && t !== t;
+}
+function getDPR(e) {
+	return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function roundByDPR(e, t) {
+	let n = getDPR(e);
+	return Math.round(t * n) / n;
+}
+function useLatestRef(e) {
+	let n = t.useRef(e);
+	return W(() => {
+		n.current = e;
+	}), n;
+}
+function useFloating$1(e) {
+	e === void 0 && (e = {});
+	let { placement: n = "bottom", strategy: r = "absolute", middleware: a = [], platform: o, elements: { reference: s, floating: c } = {}, transform: l = !0, whileElementsMounted: u, open: d } = e, [f, p] = t.useState({
+		x: 0,
+		y: 0,
+		strategy: r,
+		placement: n,
+		middlewareData: {},
+		isPositioned: !1
+	}), [m, h] = t.useState(a);
+	deepEqual(m, a) || h(a);
+	let [g, _] = t.useState(null), [v, y] = t.useState(null), b = t.useCallback((e) => {
+		e !== w.current && (w.current = e, _(e));
+	}, []), x = t.useCallback((e) => {
+		e !== T.current && (T.current = e, y(e));
+	}, []), S = s || g, C = c || v, w = t.useRef(null), T = t.useRef(null), E = t.useRef(f), D = u != null, O = useLatestRef(u), k = useLatestRef(o), A = useLatestRef(d), j = t.useCallback(() => {
+		if (!w.current || !T.current) return;
+		let e = {
+			placement: n,
+			strategy: r,
+			middleware: m
+		};
+		k.current && (e.platform = k.current), computePosition(w.current, T.current, e).then((e) => {
+			let t = {
+				...e,
+				isPositioned: A.current !== !1
+			};
+			M.current && !deepEqual(E.current, t) && (E.current = t, i.flushSync(() => {
+				p(t);
+			}));
+		});
+	}, [
+		m,
+		n,
+		r,
+		k,
+		A
+	]);
+	W(() => {
+		d === !1 && E.current.isPositioned && (E.current.isPositioned = !1, p((e) => ({
+			...e,
+			isPositioned: !1
+		})));
+	}, [d]);
+	let M = t.useRef(!1);
+	W(() => (M.current = !0, () => {
+		M.current = !1;
+	}), []), W(() => {
+		if (S && (w.current = S), C && (T.current = C), S && C) {
+			if (O.current) return O.current(S, C, j);
+			j();
+		}
+	}, [
+		S,
+		C,
+		j,
+		O,
+		D
+	]);
+	let N = t.useMemo(() => ({
+		reference: w,
+		floating: T,
+		setReference: b,
+		setFloating: x
+	}), [b, x]), P = t.useMemo(() => ({
+		reference: S,
+		floating: C
+	}), [S, C]), F = t.useMemo(() => {
+		let e = {
+			position: r,
+			left: 0,
+			top: 0
+		};
+		if (!P.floating) return e;
+		let t = roundByDPR(P.floating, f.x), n = roundByDPR(P.floating, f.y);
+		return l ? {
+			...e,
+			transform: "translate(" + t + "px, " + n + "px)",
+			...getDPR(P.floating) >= 1.5 && { willChange: "transform" }
+		} : {
+			position: r,
+			left: t,
+			top: n
+		};
+	}, [
+		r,
+		l,
+		P.floating,
+		f.x,
+		f.y
+	]);
+	return t.useMemo(() => ({
+		...f,
+		update: j,
+		refs: N,
+		elements: P,
+		floatingStyles: F
+	}), [
+		f,
+		j,
+		N,
+		P,
+		F
+	]);
+}
+e(useFloating$1, "useFloating");
+var arrow$1 = (e) => {
+	function isRef(e) {
+		return {}.hasOwnProperty.call(e, "current");
+	}
+	return {
+		name: "arrow",
+		options: e,
+		fn(t) {
+			let { element: n, padding: r } = typeof e == "function" ? e(t) : e;
+			return n && isRef(n) ? n.current == null ? {} : U({
+				element: n.current,
+				padding: r
+			}).fn(t) : n ? U({
+				element: n,
+				padding: r
+			}).fn(t) : {};
+		}
+	};
+}, offset = (e, t) => {
+	let n = L(e);
+	return {
+		name: n.name,
+		fn: n.fn,
+		options: [e, t]
+	};
+}, shift = (e, t) => {
+	let n = z(e);
+	return {
+		name: n.name,
+		fn: n.fn,
+		options: [e, t]
+	};
+}, limitShift = (e, t) => ({
+	fn: ie(e).fn,
+	options: [e, t]
+}), flip = (e, t) => {
+	let n = B(e);
+	return {
+		name: n.name,
+		fn: n.fn,
+		options: [e, t]
+	};
+}, size = (e, t) => {
+	let n = V(e);
+	return {
+		name: n.name,
+		fn: n.fn,
+		options: [e, t]
+	};
+}, hide = (e, t) => {
+	let n = H(e);
+	return {
+		name: n.name,
+		fn: n.fn,
+		options: [e, t]
+	};
+}, inline = (e, t) => {
+	let n = re(e);
+	return {
+		name: n.name,
+		fn: n.fn,
+		options: [e, t]
+	};
+}, arrow = (e, t) => {
+	let n = arrow$1(e);
+	return {
+		name: n.name,
+		fn: n.fn,
+		options: [e, t]
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@floating-ui+react@0.27.19_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@floating-ui/react/dist/floating-ui.react.mjs
+function useMergeRefs(e) {
+	let n = t.useRef(void 0), r = t.useCallback((t) => {
+		let n = e.map((e) => {
+			if (e != null) {
+				if (typeof e == "function") {
+					let n = e, r = n(t);
+					return typeof r == "function" ? r : () => {
+						n(null);
+					};
+				}
+				return e.current = t, () => {
+					e.current = null;
+				};
+			}
+		});
+		return () => {
+			n.forEach((e) => e?.());
+		};
+	}, e);
+	return t.useMemo(() => e.every((e) => e == null) ? null : (e) => {
+		n.current &&= (n.current(), void 0), e != null && (n.current = r(e));
+	}, e);
+}
+var G = "data-floating-ui-focusable", K = "active", q = "selected", J = "ArrowLeft", ae = "ArrowRight", oe = "ArrowUp", se = "ArrowDown", ce = [J, ae], le = [oe, se];
+[...ce, ...le];
+var ue = { ...t }, Y = !1, de = 0, genId = () => "floating-ui-" + Math.random().toString(36).slice(2, 6) + de++;
+function useFloatingId() {
+	let [e, n] = t.useState(() => Y ? genId() : void 0);
+	return S(() => {
+		e ?? n(genId());
+	}, []), t.useEffect(() => {
+		Y = !0;
+	}, []), e;
+}
+var X = ue.useId || useFloatingId;
+function createEventEmitter() {
+	let e = /* @__PURE__ */ new Map();
+	return {
+		emit(t, n) {
+			var r;
+			(r = e.get(t)) == null || r.forEach((e) => e(n));
+		},
+		on(t, n) {
+			e.has(t) || e.set(t, /* @__PURE__ */ new Set()), e.get(t).add(n);
+		},
+		off(t, n) {
+			var r;
+			(r = e.get(t)) == null || r.delete(n);
+		}
+	};
+}
+var Z = /* @__PURE__ */ t.createContext(null), fe = /* @__PURE__ */ t.createContext(null), useFloatingParentNodeId = () => t.useContext(Z)?.id || null, useFloatingTree = () => t.useContext(fe);
+function createAttribute(e) {
+	return "data-floating-ui-" + e;
+}
+function clearTimeoutIfSet(e) {
+	e.current !== -1 && (clearTimeout(e.current), e.current = -1);
+}
+var Q = /* @__PURE__ */ createAttribute("safe-polygon");
+function getDelay(e, t, n) {
+	if (n && !isMouseLikePointerType(n)) return 0;
+	if (typeof e == "number") return e;
+	if (typeof e == "function") {
+		let n = e();
+		return typeof n == "number" ? n : n?.[t];
+	}
+	return e?.[t];
+}
+function getRestMs(e) {
+	return typeof e == "function" ? e() : e;
+}
+function useHover(e, n) {
+	n === void 0 && (n = {});
+	let { open: r, onOpenChange: i, dataRef: a, events: o, elements: s } = e, { enabled: c = !0, delay: l = 0, handleClose: u = null, mouseOnly: d = !1, restMs: f = 0, move: p = !0 } = n, m = useFloatingTree(), h = useFloatingParentNodeId(), g = useLatestRef$1(u), _ = useLatestRef$1(l), v = useLatestRef$1(r), y = useLatestRef$1(f), b = t.useRef(), x = t.useRef(-1), C = t.useRef(), w = t.useRef(-1), T = t.useRef(!0), E = t.useRef(!1), D = t.useRef(() => {}), O = t.useRef(!1), k = useEffectEvent$1(() => {
+		let e = a.current.openEvent?.type;
+		return e?.includes("mouse") && e !== "mousedown";
+	});
+	t.useEffect(() => {
+		if (!c) return;
+		function onOpenChange(e) {
+			let { open: t } = e;
+			t || (clearTimeoutIfSet(x), clearTimeoutIfSet(w), T.current = !0, O.current = !1);
+		}
+		return o.on("openchange", onOpenChange), () => {
+			o.off("openchange", onOpenChange);
+		};
+	}, [c, o]), t.useEffect(() => {
+		if (!c || !g.current || !r) return;
+		function onLeave(e) {
+			k() && i(!1, e, "hover");
+		}
+		let e = getDocument(s.floating).documentElement;
+		return e.addEventListener("mouseleave", onLeave), () => {
+			e.removeEventListener("mouseleave", onLeave);
+		};
+	}, [
+		s.floating,
+		r,
+		i,
+		c,
+		g,
+		k
+	]);
+	let A = t.useCallback(function(e, t, n) {
+		t === void 0 && (t = !0), n === void 0 && (n = "hover");
+		let r = getDelay(_.current, "close", b.current);
+		r && !C.current ? (clearTimeoutIfSet(x), x.current = window.setTimeout(() => i(!1, e, n), r)) : t && (clearTimeoutIfSet(x), i(!1, e, n));
+	}, [_, i]), j = useEffectEvent$1(() => {
+		D.current(), C.current = void 0;
+	}), M = useEffectEvent$1(() => {
+		if (E.current) {
+			let e = getDocument(s.floating).body;
+			e.style.pointerEvents = "", e.removeAttribute(Q), E.current = !1;
+		}
+	}), N = useEffectEvent$1(() => a.current.openEvent ? ["click", "mousedown"].includes(a.current.openEvent.type) : !1);
+	t.useEffect(() => {
+		if (!c) return;
+		function onReferenceMouseEnter(e) {
+			if (clearTimeoutIfSet(x), T.current = !1, d && !isMouseLikePointerType(b.current) || getRestMs(y.current) > 0 && !getDelay(_.current, "open")) return;
+			let t = getDelay(_.current, "open", b.current);
+			t ? x.current = window.setTimeout(() => {
+				v.current || i(!0, e, "hover");
+			}, t) : r || i(!0, e, "hover");
+		}
+		function onReferenceMouseLeave(e) {
+			if (N()) {
+				M();
+				return;
+			}
+			D.current();
+			let t = getDocument(s.floating);
+			if (clearTimeoutIfSet(w), O.current = !1, g.current && a.current.floatingContext) {
+				r || clearTimeoutIfSet(x), C.current = g.current({
+					...a.current.floatingContext,
+					tree: m,
+					x: e.clientX,
+					y: e.clientY,
+					onClose() {
+						M(), j(), N() || A(e, !0, "safe-polygon");
+					}
+				});
+				let n = C.current;
+				t.addEventListener("mousemove", n), D.current = () => {
+					t.removeEventListener("mousemove", n);
+				};
+				return;
+			}
+			(b.current !== "touch" || !contains$1(s.floating, e.relatedTarget)) && A(e);
+		}
+		function onScrollMouseLeave(e) {
+			N() || a.current.floatingContext && (g.current == null || g.current({
+				...a.current.floatingContext,
+				tree: m,
+				x: e.clientX,
+				y: e.clientY,
+				onClose() {
+					M(), j(), N() || A(e);
+				}
+			})(e));
+		}
+		function onFloatingMouseEnter() {
+			clearTimeoutIfSet(x);
+		}
+		function onFloatingMouseLeave(e) {
+			N() || A(e, !1);
+		}
+		if (isElement(s.domReference)) {
+			let e = s.domReference, t = s.floating;
+			return r && e.addEventListener("mouseleave", onScrollMouseLeave), p && e.addEventListener("mousemove", onReferenceMouseEnter, { once: !0 }), e.addEventListener("mouseenter", onReferenceMouseEnter), e.addEventListener("mouseleave", onReferenceMouseLeave), t && (t.addEventListener("mouseleave", onScrollMouseLeave), t.addEventListener("mouseenter", onFloatingMouseEnter), t.addEventListener("mouseleave", onFloatingMouseLeave)), () => {
+				r && e.removeEventListener("mouseleave", onScrollMouseLeave), p && e.removeEventListener("mousemove", onReferenceMouseEnter), e.removeEventListener("mouseenter", onReferenceMouseEnter), e.removeEventListener("mouseleave", onReferenceMouseLeave), t && (t.removeEventListener("mouseleave", onScrollMouseLeave), t.removeEventListener("mouseenter", onFloatingMouseEnter), t.removeEventListener("mouseleave", onFloatingMouseLeave));
+			};
+		}
+	}, [
+		s,
+		c,
+		e,
+		d,
+		p,
+		A,
+		j,
+		M,
+		i,
+		r,
+		v,
+		m,
+		_,
+		g,
+		a,
+		N,
+		y
+	]), S(() => {
+		var e;
+		if (c && r && (e = g.current) != null && (e = e.__options) != null && e.blockPointerEvents && k()) {
+			E.current = !0;
+			let e = s.floating;
+			if (isElement(s.domReference) && e) {
+				var t;
+				let n = getDocument(s.floating).body;
+				n.setAttribute(Q, "");
+				let r = s.domReference, i = m == null || (t = m.nodesRef.current.find((e) => e.id === h)) == null || (t = t.context) == null ? void 0 : t.elements.floating;
+				return i && (i.style.pointerEvents = ""), n.style.pointerEvents = "none", r.style.pointerEvents = "auto", e.style.pointerEvents = "auto", () => {
+					n.style.pointerEvents = "", r.style.pointerEvents = "", e.style.pointerEvents = "";
+				};
+			}
+		}
+	}, [
+		c,
+		r,
+		h,
+		s,
+		m,
+		g,
+		k
+	]), S(() => {
+		r || (b.current = void 0, O.current = !1, j(), M());
+	}, [
+		r,
+		j,
+		M
+	]), t.useEffect(() => () => {
+		j(), clearTimeoutIfSet(x), clearTimeoutIfSet(w), M();
+	}, [
+		c,
+		s.domReference,
+		j,
+		M
+	]);
+	let P = t.useMemo(() => {
+		function setPointerRef(e) {
+			b.current = e.pointerType;
+		}
+		return {
+			onPointerDown: setPointerRef,
+			onPointerEnter: setPointerRef,
+			onMouseMove(e) {
+				let { nativeEvent: t } = e;
+				function handleMouseMove() {
+					!T.current && !v.current && i(!0, t, "hover");
+				}
+				d && !isMouseLikePointerType(b.current) || r || getRestMs(y.current) === 0 || O.current && e.movementX ** 2 + e.movementY ** 2 < 2 || (clearTimeoutIfSet(w), b.current === "touch" ? handleMouseMove() : (O.current = !0, w.current = window.setTimeout(handleMouseMove, getRestMs(y.current))));
+			}
+		};
+	}, [
+		d,
+		i,
+		r,
+		v,
+		y
+	]);
+	return t.useMemo(() => c ? { reference: P } : {}, [c, P]);
+}
+var NOOP = () => {}, $ = /* @__PURE__ */ t.createContext({
+	delay: 0,
+	initialDelay: 0,
+	timeoutMs: 0,
+	currentId: null,
+	setCurrentId: NOOP,
+	setState: NOOP,
+	isInstantPhase: !1
+}), useDelayGroupContext = () => t.useContext($);
+function FloatingDelayGroup(e) {
+	let { children: n, delay: i, timeoutMs: a = 0 } = e, [o, s] = t.useReducer((e, t) => ({
+		...e,
+		...t
+	}), {
+		delay: i,
+		timeoutMs: a,
+		initialDelay: i,
+		currentId: null,
+		isInstantPhase: !1
+	}), c = t.useRef(null), l = t.useCallback((e) => {
+		s({ currentId: e });
+	}, []);
+	return S(() => {
+		o.currentId ? c.current === null ? c.current = o.currentId : o.isInstantPhase || s({ isInstantPhase: !0 }) : (o.isInstantPhase && s({ isInstantPhase: !1 }), c.current = null);
+	}, [o.currentId, o.isInstantPhase]), /* @__PURE__ */ r($.Provider, {
+		value: t.useMemo(() => ({
+			...o,
+			setState: s,
+			setCurrentId: l
+		}), [o, l]),
+		children: n
+	});
+}
+function useDelayGroup(e, t) {
+	t === void 0 && (t = {});
+	let { open: n, onOpenChange: r, floatingId: i } = e, { id: a, enabled: o = !0 } = t, s = a ?? i, c = useDelayGroupContext(), { currentId: l, setCurrentId: u, initialDelay: d, setState: f, timeoutMs: p } = c;
+	return S(() => {
+		o && l && (f({ delay: {
+			open: 1,
+			close: getDelay(d, "close")
+		} }), l !== s && r(!1));
+	}, [
+		o,
+		s,
+		r,
+		f,
+		l,
+		d
+	]), S(() => {
+		function unset() {
+			r(!1), f({
+				delay: d,
+				currentId: null
+			});
+		}
+		if (o && l && !n && l === s) {
+			if (p) {
+				let e = window.setTimeout(unset, p);
+				return () => {
+					clearTimeout(e);
+				};
+			}
+			unset();
+		}
+	}, [
+		o,
+		n,
+		f,
+		l,
+		s,
+		r,
+		d,
+		p
+	]), S(() => {
+		o && (u === NOOP || !n || u(s));
+	}, [
+		o,
+		n,
+		u,
+		s
+	]), c;
+}
+function contains(e, t) {
+	if (!e || !t) return !1;
+	let n = t.getRootNode == null ? void 0 : t.getRootNode();
+	if (e.contains(t)) return !0;
+	if (n && isShadowRoot(n)) {
+		let n = t;
+		for (; n;) {
+			if (e === n) return !0;
+			n = n.parentNode || n.host;
+		}
+	}
+	return !1;
+}
+function getTarget(e) {
+	return "composedPath" in e ? e.composedPath()[0] : e.target;
+}
+var pe = {
+	pointerdown: "onPointerDown",
+	mousedown: "onMouseDown",
+	click: "onClick"
+}, me = {
+	pointerdown: "onPointerDownCapture",
+	mousedown: "onMouseDownCapture",
+	click: "onClickCapture"
+}, normalizeProp = (e) => ({
+	escapeKey: typeof e == "boolean" ? e : e?.escapeKey ?? !1,
+	outsidePress: typeof e == "boolean" ? e : e?.outsidePress ?? !0
+});
+function useDismiss(e, n) {
+	n === void 0 && (n = {});
+	let { open: r, onOpenChange: i, elements: a, dataRef: o } = e, { enabled: s = !0, escapeKey: c = !0, outsidePress: l = !0, outsidePressEvent: u = "pointerdown", referencePress: d = !1, referencePressEvent: f = "pointerdown", ancestorScroll: p = !1, bubbles: m, capture: h } = n, g = useFloatingTree(), _ = useEffectEvent$1(typeof l == "function" ? l : () => !1), v = typeof l == "function" ? _ : l, y = t.useRef(!1), { escapeKey: b, outsidePress: x } = normalizeProp(m), { escapeKey: S, outsidePress: C } = normalizeProp(h), w = t.useRef(!1), T = useEffectEvent$1((e) => {
+		if (!r || !s || !c || e.key !== "Escape" || w.current) return;
+		let t = o.current.floatingContext?.nodeId, n = g ? getNodeChildren$1(g.nodesRef.current, t) : [];
+		if (!b && (e.stopPropagation(), n.length > 0)) {
+			let e = !0;
+			if (n.forEach((t) => {
+				var n;
+				if ((n = t.context) != null && n.open && !t.context.dataRef.current.__escapeKeyBubbles) {
+					e = !1;
+					return;
+				}
+			}), !e) return;
+		}
+		i(!1, isReactEvent(e) ? e.nativeEvent : e, "escape-key");
+	}), E = useEffectEvent$1((e) => {
+		var t;
+		let callback = () => {
+			var t;
+			T(e), (t = getTarget$1(e)) == null || t.removeEventListener("keydown", callback);
+		};
+		(t = getTarget$1(e)) == null || t.addEventListener("keydown", callback);
+	}), D = useEffectEvent$1((e) => {
+		let t = o.current.insideReactTree;
+		o.current.insideReactTree = !1;
+		let n = y.current;
+		if (y.current = !1, u === "click" && n || t || typeof v == "function" && !v(e)) return;
+		let r = getTarget$1(e), s = "[" + createAttribute("inert") + "]", c = getDocument(a.floating).querySelectorAll(s), l = isElement(r) ? r : null;
+		for (; l && !isLastTraversableNode(l);) {
+			let e = getParentNode(l);
+			if (isLastTraversableNode(e) || !isElement(e)) break;
+			l = e;
+		}
+		if (c.length && isElement(r) && !isRootElement(r) && !contains$1(r, a.floating) && Array.from(c).every((e) => !contains$1(l, e))) return;
+		if (isHTMLElement(r) && A) {
+			let t = isLastTraversableNode(r), n = getComputedStyle$1(r), i = /auto|scroll/, a = t || i.test(n.overflowX), o = t || i.test(n.overflowY), s = a && r.clientWidth > 0 && r.scrollWidth > r.clientWidth, c = o && r.clientHeight > 0 && r.scrollHeight > r.clientHeight, l = n.direction === "rtl", u = c && (l ? e.offsetX <= r.offsetWidth - r.clientWidth : e.offsetX > r.clientWidth), d = s && e.offsetY > r.clientHeight;
+			if (u || d) return;
+		}
+		let d = o.current.floatingContext?.nodeId, f = g && getNodeChildren$1(g.nodesRef.current, d).some((t) => isEventTargetWithin(e, t.context?.elements.floating));
+		if (isEventTargetWithin(e, a.floating) || isEventTargetWithin(e, a.domReference) || f) return;
+		let p = g ? getNodeChildren$1(g.nodesRef.current, d) : [];
+		if (p.length > 0) {
+			let e = !0;
+			if (p.forEach((t) => {
+				var n;
+				if ((n = t.context) != null && n.open && !t.context.dataRef.current.__outsidePressBubbles) {
+					e = !1;
+					return;
+				}
+			}), !e) return;
+		}
+		i(!1, e, "outside-press");
+	}), O = useEffectEvent$1((e) => {
+		var t;
+		let callback = () => {
+			var t;
+			D(e), (t = getTarget$1(e)) == null || t.removeEventListener(u, callback);
+		};
+		(t = getTarget$1(e)) == null || t.addEventListener(u, callback);
+	});
+	t.useEffect(() => {
+		if (!r || !s) return;
+		o.current.__escapeKeyBubbles = b, o.current.__outsidePressBubbles = x;
+		let e = -1;
+		function onScroll(e) {
+			i(!1, e, "ancestor-scroll");
+		}
+		function handleCompositionStart() {
+			window.clearTimeout(e), w.current = !0;
+		}
+		function handleCompositionEnd() {
+			e = window.setTimeout(() => {
+				w.current = !1;
+			}, isWebKit() ? 5 : 0);
+		}
+		let t = getDocument(a.floating);
+		c && (t.addEventListener("keydown", S ? E : T, S), t.addEventListener("compositionstart", handleCompositionStart), t.addEventListener("compositionend", handleCompositionEnd)), v && t.addEventListener(u, C ? O : D, C);
+		let n = [];
+		return p && (isElement(a.domReference) && (n = getOverflowAncestors(a.domReference)), isElement(a.floating) && (n = n.concat(getOverflowAncestors(a.floating))), !isElement(a.reference) && a.reference && a.reference.contextElement && (n = n.concat(getOverflowAncestors(a.reference.contextElement)))), n = n.filter((e) => e !== t.defaultView?.visualViewport), n.forEach((e) => {
+			e.addEventListener("scroll", onScroll, { passive: !0 });
+		}), () => {
+			c && (t.removeEventListener("keydown", S ? E : T, S), t.removeEventListener("compositionstart", handleCompositionStart), t.removeEventListener("compositionend", handleCompositionEnd)), v && t.removeEventListener(u, C ? O : D, C), n.forEach((e) => {
+				e.removeEventListener("scroll", onScroll);
+			}), window.clearTimeout(e);
+		};
+	}, [
+		o,
+		a,
+		c,
+		v,
+		u,
+		r,
+		i,
+		p,
+		s,
+		b,
+		x,
+		T,
+		S,
+		E,
+		D,
+		C,
+		O
+	]), t.useEffect(() => {
+		o.current.insideReactTree = !1;
+	}, [
+		o,
+		v,
+		u
+	]);
+	let k = t.useMemo(() => ({
+		onKeyDown: T,
+		...d && {
+			[pe[f]]: (e) => {
+				i(!1, e.nativeEvent, "reference-press");
+			},
+			...f !== "click" && { onClick(e) {
+				i(!1, e.nativeEvent, "reference-press");
+			} }
+		}
+	}), [
+		T,
+		i,
+		d,
+		f
+	]), A = t.useMemo(() => {
+		function setMouseDownOrUpInside(e) {
+			e.button === 0 && (y.current = !0);
+		}
+		return {
+			onKeyDown: T,
+			onMouseDown: setMouseDownOrUpInside,
+			onMouseUp: setMouseDownOrUpInside,
+			[me[u]]: () => {
+				o.current.insideReactTree = !0;
+			}
+		};
+	}, [
+		T,
+		u,
+		o
+	]);
+	return t.useMemo(() => s ? {
+		reference: k,
+		floating: A
+	} : {}, [
+		s,
+		k,
+		A
+	]);
+}
+function useFloatingRootContext(e) {
+	let { open: n = !1, onOpenChange: r, elements: i } = e, a = X(), o = t.useRef({}), [s] = t.useState(() => createEventEmitter()), c = useFloatingParentNodeId() != null, [l, u] = t.useState(i.reference), d = useEffectEvent$1((e, t, n) => {
+		o.current.openEvent = e ? t : void 0, s.emit("openchange", {
+			open: e,
+			event: t,
+			reason: n,
+			nested: c
+		}), r?.(e, t, n);
+	}), f = t.useMemo(() => ({ setPositionReference: u }), []), p = t.useMemo(() => ({
+		reference: l || i.reference || null,
+		floating: i.floating || null,
+		domReference: i.reference
+	}), [
+		l,
+		i.reference,
+		i.floating
+	]);
+	return t.useMemo(() => ({
+		dataRef: o,
+		open: n,
+		onOpenChange: d,
+		elements: p,
+		events: s,
+		floatingId: a,
+		refs: f
+	}), [
+		n,
+		d,
+		p,
+		s,
+		a,
+		f
+	]);
+}
+function useFloating(e) {
+	e === void 0 && (e = {});
+	let { nodeId: n } = e, r = useFloatingRootContext({
+		...e,
+		elements: {
+			reference: null,
+			floating: null,
+			...e.elements
+		}
+	}), i = e.rootContext || r, a = i.elements, [o, s] = t.useState(null), [c, l] = t.useState(null), u = a?.domReference || o, d = t.useRef(null), f = useFloatingTree();
+	S(() => {
+		u && (d.current = u);
+	}, [u]);
+	let p = useFloating$1({
+		...e,
+		elements: {
+			...a,
+			...c && { reference: c }
+		}
+	}), m = t.useCallback((e) => {
+		let t = isElement(e) ? {
+			getBoundingClientRect: () => e.getBoundingClientRect(),
+			getClientRects: () => e.getClientRects(),
+			contextElement: e
+		} : e;
+		l(t), p.refs.setReference(t);
+	}, [p.refs]), h = t.useCallback((e) => {
+		(isElement(e) || e === null) && (d.current = e, s(e)), (isElement(p.refs.reference.current) || p.refs.reference.current === null || e !== null && !isElement(e)) && p.refs.setReference(e);
+	}, [p.refs]), g = t.useMemo(() => ({
+		...p.refs,
+		setReference: h,
+		setPositionReference: m,
+		domReference: d
+	}), [
+		p.refs,
+		h,
+		m
+	]), _ = t.useMemo(() => ({
+		...p.elements,
+		domReference: u
+	}), [p.elements, u]), v = t.useMemo(() => ({
+		...p,
+		...i,
+		refs: g,
+		elements: _,
+		nodeId: n
+	}), [
+		p,
+		g,
+		_,
+		n,
+		i
+	]);
+	return S(() => {
+		i.dataRef.current.floatingContext = v;
+		let e = f?.nodesRef.current.find((e) => e.id === n);
+		e && (e.context = v);
+	}), t.useMemo(() => ({
+		...p,
+		context: v,
+		refs: g,
+		elements: _
+	}), [
+		p,
+		g,
+		_,
+		v
+	]);
+}
+function isMacSafari() {
+	return isMac() && isSafari();
+}
+function useFocus(e, n) {
+	n === void 0 && (n = {});
+	let { open: r, onOpenChange: i, events: a, dataRef: o, elements: s } = e, { enabled: c = !0, visibleOnly: l = !0 } = n, u = t.useRef(!1), d = t.useRef(-1), f = t.useRef(!0);
+	t.useEffect(() => {
+		if (!c) return;
+		let e = getWindow(s.domReference);
+		function onBlur() {
+			!r && isHTMLElement(s.domReference) && s.domReference === activeElement(getDocument(s.domReference)) && (u.current = !0);
+		}
+		function onKeyDown() {
+			f.current = !0;
+		}
+		function onPointerDown() {
+			f.current = !1;
+		}
+		return e.addEventListener("blur", onBlur), isMacSafari() && (e.addEventListener("keydown", onKeyDown, !0), e.addEventListener("pointerdown", onPointerDown, !0)), () => {
+			e.removeEventListener("blur", onBlur), isMacSafari() && (e.removeEventListener("keydown", onKeyDown, !0), e.removeEventListener("pointerdown", onPointerDown, !0));
+		};
+	}, [
+		s.domReference,
+		r,
+		c
+	]), t.useEffect(() => {
+		if (!c) return;
+		function onOpenChange(e) {
+			let { reason: t } = e;
+			(t === "reference-press" || t === "escape-key") && (u.current = !0);
+		}
+		return a.on("openchange", onOpenChange), () => {
+			a.off("openchange", onOpenChange);
+		};
+	}, [a, c]), t.useEffect(() => () => {
+		clearTimeoutIfSet(d);
+	}, []);
+	let p = t.useMemo(() => ({
+		onMouseLeave() {
+			u.current = !1;
+		},
+		onFocus(e) {
+			if (u.current) return;
+			let t = getTarget$1(e.nativeEvent);
+			if (l && isElement(t)) {
+				if (isMacSafari() && !e.relatedTarget) {
+					if (!f.current && !isTypeableElement(t)) return;
+				} else if (!matchesFocusVisible(t)) return;
+			}
+			i(!0, e.nativeEvent, "focus");
+		},
+		onBlur(e) {
+			u.current = !1;
+			let t = e.relatedTarget, n = e.nativeEvent, r = isElement(t) && t.hasAttribute(createAttribute("focus-guard")) && t.getAttribute("data-type") === "outside";
+			d.current = window.setTimeout(() => {
+				let e = activeElement(s.domReference ? s.domReference.ownerDocument : document);
+				!t && e === s.domReference || contains$1(o.current.floatingContext?.refs.floating.current, e) || contains$1(s.domReference, e) || r || i(!1, n, "focus");
+			});
+		}
+	}), [
+		o,
+		s.domReference,
+		i,
+		l
+	]);
+	return t.useMemo(() => c ? { reference: p } : {}, [c, p]);
+}
+function mergeProps(e, t, n) {
+	let r = /* @__PURE__ */ new Map(), i = n === "item", a = e;
+	if (i && e) {
+		let { [K]: t, [q]: n, ...r } = e;
+		a = r;
+	}
+	return {
+		...n === "floating" && {
+			tabIndex: -1,
+			[G]: ""
+		},
+		...a,
+		...t.map((t) => {
+			let r = t ? t[n] : null;
+			return typeof r == "function" ? e ? r(e) : null : r;
+		}).concat(e).reduce((e, t) => (t && Object.entries(t).forEach((t) => {
+			let [n, a] = t;
+			if (!(i && [K, q].includes(n))) if (n.indexOf("on") === 0) {
+				if (r.has(n) || r.set(n, []), typeof a == "function") {
+					var o;
+					(o = r.get(n)) == null || o.push(a), e[n] = function() {
+						var e = [...arguments];
+						return r.get(n)?.map((t) => t(...e)).find((e) => e !== void 0);
+					};
+				}
+			} else e[n] = a;
+		}), e), {})
+	};
+}
+function useInteractions(e) {
+	e === void 0 && (e = []);
+	let n = e.map((e) => e?.reference), r = e.map((e) => e?.floating), i = e.map((e) => e?.item), a = t.useCallback((t) => mergeProps(t, e, "reference"), n), o = t.useCallback((t) => mergeProps(t, e, "floating"), r), s = t.useCallback((t) => mergeProps(t, e, "item"), i);
+	return t.useMemo(() => ({
+		getReferenceProps: a,
+		getFloatingProps: o,
+		getItemProps: s
+	}), [
+		a,
+		o,
+		s
+	]);
+}
+var he = /* @__PURE__ */ new Map([
+	["select", "listbox"],
+	["combobox", "listbox"],
+	["label", !1]
+]);
+function useRole(e, n) {
+	n === void 0 && (n = {});
+	let { open: r, elements: i, floatingId: a } = e, { enabled: o = !0, role: s = "dialog" } = n, c = X(), l = i.domReference?.id || c, u = t.useMemo(() => getFloatingFocusElement(i.floating)?.id || a, [i.floating, a]), d = he.get(s) ?? s, f = useFloatingParentNodeId() != null, p = t.useMemo(() => d === "tooltip" || s === "label" ? { ["aria-" + (s === "label" ? "labelledby" : "describedby")]: r ? u : void 0 } : {
+		"aria-expanded": r ? "true" : "false",
+		"aria-haspopup": d === "alertdialog" ? "dialog" : d,
+		"aria-controls": r ? u : void 0,
+		...d === "listbox" && { role: "combobox" },
+		...d === "menu" && { id: l },
+		...d === "menu" && f && { role: "menuitem" },
+		...s === "select" && { "aria-autocomplete": "none" },
+		...s === "combobox" && { "aria-autocomplete": "list" }
+	}, [
+		d,
+		u,
+		f,
+		r,
+		l,
+		s
+	]), m = t.useMemo(() => {
+		let e = {
+			id: u,
+			...d && { role: d }
+		};
+		return d === "tooltip" || s === "label" ? e : {
+			...e,
+			...d === "menu" && { "aria-labelledby": l }
+		};
+	}, [
+		d,
+		u,
+		l,
+		s
+	]), h = t.useCallback((e) => {
+		let { active: t, selected: n } = e, r = {
+			role: "option",
+			...t && { id: u + "-fui-option" }
+		};
+		switch (s) {
+			case "select":
+			case "combobox": return {
+				...r,
+				"aria-selected": n
+			};
+		}
+		return {};
+	}, [u, s]);
+	return t.useMemo(() => o ? {
+		reference: p,
+		floating: m,
+		item: h
+	} : {}, [
+		o,
+		p,
+		m,
+		h
+	]);
+}
+function getNodeChildren(e, t, n) {
+	return n === void 0 && (n = !0), e.filter((e) => e.parentId === t && (!n || e.context?.open)).flatMap((t) => [t, ...getNodeChildren(e, t.id, n)]);
+}
+function isPointInPolygon(e, t) {
+	let [n, r] = e, i = !1, a = t.length;
+	for (let e = 0, o = a - 1; e < a; o = e++) {
+		let [a, s] = t[e] || [0, 0], [c, l] = t[o] || [0, 0];
+		s >= r != l >= r && n <= (c - a) * (r - s) / (l - s) + a && (i = !i);
+	}
+	return i;
+}
+function isInside(e, t) {
+	return e[0] >= t.x && e[0] <= t.x + t.width && e[1] >= t.y && e[1] <= t.y + t.height;
+}
+function safePolygon(e) {
+	e === void 0 && (e = {});
+	let { buffer: t = .5, blockPointerEvents: n = !1, requireIntent: r = !0 } = e, i = { current: -1 }, a = !1, o = null, s = null, c = typeof performance < "u" ? performance.now() : 0;
+	function getCursorSpeed(e, t) {
+		let n = performance.now(), r = n - c;
+		if (o === null || s === null || r === 0) return o = e, s = t, c = n, null;
+		let i = e - o, a = t - s, l = Math.sqrt(i * i + a * a) / r;
+		return o = e, s = t, c = n, l;
+	}
+	let fn = (e) => {
+		let { x: n, y: o, placement: s, elements: c, onClose: l, nodeId: u, tree: d } = e;
+		return function onMouseMove(e) {
+			function close() {
+				clearTimeoutIfSet(i), l();
+			}
+			if (clearTimeoutIfSet(i), !c.domReference || !c.floating || s == null || n == null || o == null) return;
+			let { clientX: f, clientY: p } = e, m = [f, p], h = getTarget(e), g = e.type === "mouseleave", _ = contains(c.floating, h), v = contains(c.domReference, h), y = c.domReference.getBoundingClientRect(), b = c.floating.getBoundingClientRect(), x = s.split("-")[0], S = n > b.right - b.width / 2, C = o > b.bottom - b.height / 2, w = isInside(m, y), T = b.width > y.width, E = b.height > y.height, D = (T ? y : b).left, O = (T ? y : b).right, k = (E ? y : b).top, A = (E ? y : b).bottom;
+			if (_ && (a = !0, !g)) return;
+			if (v && (a = !1), v && !g) {
+				a = !0;
+				return;
+			}
+			if (g && isElement(e.relatedTarget) && contains(c.floating, e.relatedTarget) || d && getNodeChildren(d.nodesRef.current, u).length) return;
+			if (x === "top" && o >= y.bottom - 1 || x === "bottom" && o <= y.top + 1 || x === "left" && n >= y.right - 1 || x === "right" && n <= y.left + 1) return close();
+			let j = [];
+			switch (x) {
+				case "top":
+					j = [
+						[D, y.top + 1],
+						[D, b.bottom - 1],
+						[O, b.bottom - 1],
+						[O, y.top + 1]
+					];
+					break;
+				case "bottom":
+					j = [
+						[D, b.top + 1],
+						[D, y.bottom - 1],
+						[O, y.bottom - 1],
+						[O, b.top + 1]
+					];
+					break;
+				case "left":
+					j = [
+						[b.right - 1, A],
+						[b.right - 1, k],
+						[y.left + 1, k],
+						[y.left + 1, A]
+					];
+					break;
+				case "right":
+					j = [
+						[y.right - 1, A],
+						[y.right - 1, k],
+						[b.left + 1, k],
+						[b.left + 1, A]
+					];
+					break;
+			}
+			function getPolygon(e) {
+				let [n, r] = e;
+				switch (x) {
+					case "top": return [
+						[T ? n + t / 2 : S ? n + t * 4 : n - t * 4, r + t + 1],
+						[T ? n - t / 2 : S ? n + t * 4 : n - t * 4, r + t + 1],
+						[b.left, S || T ? b.bottom - t : b.top],
+						[b.right, S ? T ? b.bottom - t : b.top : b.bottom - t]
+					];
+					case "bottom": return [
+						[T ? n + t / 2 : S ? n + t * 4 : n - t * 4, r - t],
+						[T ? n - t / 2 : S ? n + t * 4 : n - t * 4, r - t],
+						[b.left, S || T ? b.top + t : b.bottom],
+						[b.right, S ? T ? b.top + t : b.bottom : b.top + t]
+					];
+					case "left": {
+						let e = [n + t + 1, E ? r + t / 2 : C ? r + t * 4 : r - t * 4], i = [n + t + 1, E ? r - t / 2 : C ? r + t * 4 : r - t * 4];
+						return [
+							[C || E ? b.right - t : b.left, b.top],
+							[C ? E ? b.right - t : b.left : b.right - t, b.bottom],
+							e,
+							i
+						];
+					}
+					case "right": return [
+						[n - t, E ? r + t / 2 : C ? r + t * 4 : r - t * 4],
+						[n - t, E ? r - t / 2 : C ? r + t * 4 : r - t * 4],
+						[C || E ? b.left + t : b.right, b.top],
+						[C ? E ? b.left + t : b.right : b.left + t, b.bottom]
+					];
+				}
+			}
+			if (!isPointInPolygon([f, p], j)) {
+				if (a && !w) return close();
+				if (!g && r) {
+					let t = getCursorSpeed(e.clientX, e.clientY);
+					if (t !== null && t < .1) return close();
+				}
+				isPointInPolygon([f, p], getPolygon([n, o])) ? !a && r && (i.current = window.setTimeout(close, 40)) : close();
+			}
+		};
+	};
+	return fn.__options = { blockPointerEvents: n }, fn;
+}
+//#endregion
+export { L as C, H as S, getOverflowAncestors as T, shift as _, useFloating as a, autoUpdate as b, useInteractions as c, arrow as d, flip as f, offset as g, limitShift as h, useDismiss as i, useMergeRefs as l, inline as m, safePolygon as n, useFocus as o, hide as p, useDelayGroup as r, useHover as s, FloatingDelayGroup as t, useRole as u, size as v, V as w, computePosition as x, R as y };