@gatewaze/admin-embed 0.1.0

package/dist/floating-ui.dom-Cyv879E9.js

@@ -0,0 +1,987 @@
+import { r as e } from "./react-DB2tPNit.js";
+//#region ../../node_modules/.pnpm/@floating-ui+utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
+function t(e, t, n) {
+	return S(e, x(t, n));
+}
+function n(e, t) {
+	return typeof e == "function" ? e(t) : e;
+}
+function r(e) {
+	return e.split("-")[0];
+}
+function i(e) {
+	return e.split("-")[1];
+}
+function a(e) {
+	return e === "x" ? "y" : "x";
+}
+function o(e) {
+	return e === "y" ? "height" : "width";
+}
+function s(e) {
+	let t = e[0];
+	return t === "t" || t === "b" ? "y" : "x";
+}
+function c(e) {
+	return a(s(e));
+}
+function l(e, t, n) {
+	n === void 0 && (n = !1);
+	let r = i(e), a = c(e), s = o(a), l = a === "x" ? r === (n ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+	return t.reference[s] > t.floating[s] && (l = m(l)), [l, m(l)];
+}
+function u(e) {
+	let t = m(e);
+	return [
+		d(e),
+		t,
+		d(t)
+	];
+}
+function d(e) {
+	return e.includes("start") ? e.replace("start", "end") : e.replace("end", "start");
+}
+function f(e, t, n) {
+	switch (e) {
+		case "top":
+		case "bottom": return n ? t ? O : D : t ? D : O;
+		case "left":
+		case "right": return t ? k : A;
+		default: return [];
+	}
+}
+function p(e, t, n, a) {
+	let o = i(e), s = f(r(e), n === "start", a);
+	return o && (s = s.map((e) => e + "-" + o), t && (s = s.concat(s.map(d)))), s;
+}
+function m(e) {
+	let t = r(e);
+	return E[t] + e.slice(t.length);
+}
+function h(e) {
+	return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0,
+		...e
+	};
+}
+function g(e) {
+	return typeof e == "number" ? {
+		top: e,
+		right: e,
+		bottom: e,
+		left: e
+	} : h(e);
+}
+function _(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
+	};
+}
+var v, y, b, x, S, C, w, T, E, D, O, k, A, j = e((() => {
+	v = [
+		"top",
+		"right",
+		"bottom",
+		"left"
+	], y = ["start", "end"], b = /*#__PURE__*/ v.reduce((e, t) => e.concat(t, t + "-" + y[0], t + "-" + y[1]), []), x = Math.min, S = Math.max, C = Math.round, w = Math.floor, T = (e) => ({
+		x: e,
+		y: e
+	}), E = {
+		left: "right",
+		right: "left",
+		bottom: "top",
+		top: "bottom"
+	}, D = ["left", "right"], O = ["right", "left"], k = ["top", "bottom"], A = ["bottom", "top"];
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@floating-ui+core@1.7.5/node_modules/@floating-ui/core/dist/floating-ui.core.mjs
+function M(e, t, n) {
+	let { reference: a, floating: l } = e, u = s(t), d = c(t), f = o(d), p = r(t), m = u === "y", h = a.x + a.width / 2 - l.width / 2, g = a.y + a.height / 2 - l.height / 2, _ = a[f] / 2 - l[f] / 2, v;
+	switch (p) {
+		case "top":
+			v = {
+				x: h,
+				y: a.y - l.height
+			};
+			break;
+		case "bottom":
+			v = {
+				x: h,
+				y: a.y + a.height
+			};
+			break;
+		case "right":
+			v = {
+				x: a.x + a.width,
+				y: g
+			};
+			break;
+		case "left":
+			v = {
+				x: a.x - l.width,
+				y: g
+			};
+			break;
+		default: v = {
+			x: a.x,
+			y: a.y
+		};
+	}
+	switch (i(t)) {
+		case "start":
+			v[d] -= _ * (n && m ? -1 : 1);
+			break;
+		case "end": v[d] += _ * (n && m ? -1 : 1);
+	}
+	return v;
+}
+async function N(e, t) {
+	t === void 0 && (t = {});
+	let { x: r, y: i, platform: a, rects: o, elements: s, strategy: c } = e, { boundary: l = "clippingAncestors", rootBoundary: u = "viewport", elementContext: d = "floating", altBoundary: f = !1, padding: p = 0 } = n(t, e), m = g(p), h = s[f ? d === "floating" ? "reference" : "floating" : d], v = _(await a.getClippingRect({
+		element: await (a.isElement == null ? void 0 : a.isElement(h)) ?? !0 ? h : h.contextElement || await (a.getDocumentElement == null ? void 0 : a.getDocumentElement(s.floating)),
+		boundary: l,
+		rootBoundary: u,
+		strategy: c
+	})), y = d === "floating" ? {
+		x: r,
+		y: i,
+		width: o.floating.width,
+		height: o.floating.height
+	} : o.reference, b = await (a.getOffsetParent == null ? void 0 : a.getOffsetParent(s.floating)), x = await (a.isElement == null ? void 0 : a.isElement(b)) && await (a.getScale == null ? void 0 : a.getScale(b)) || {
+		x: 1,
+		y: 1
+	}, S = _(a.convertOffsetParentRelativeRectToViewportRelativeRect ? await a.convertOffsetParentRelativeRectToViewportRelativeRect({
+		elements: s,
+		rect: y,
+		offsetParent: b,
+		strategy: c
+	}) : y);
+	return {
+		top: (v.top - S.top + m.top) / x.y,
+		bottom: (S.bottom - v.bottom + m.bottom) / x.y,
+		left: (v.left - S.left + m.left) / x.x,
+		right: (S.right - v.right + m.right) / x.x
+	};
+}
+function ee(e, t, n) {
+	return (e ? [...n.filter((t) => i(t) === e), ...n.filter((t) => i(t) !== e)] : n.filter((e) => r(e) === e)).filter((n) => !e || i(n) === e || (t ? d(n) !== n : !1));
+}
+function P(e, t) {
+	return {
+		top: e.top - t.height,
+		right: e.right - t.width,
+		bottom: e.bottom - t.height,
+		left: e.left - t.width
+	};
+}
+function F(e) {
+	return v.some((t) => e[t] >= 0);
+}
+function I(e) {
+	let t = x(...e.map((e) => e.left)), n = x(...e.map((e) => e.top)), r = S(...e.map((e) => e.right)), i = S(...e.map((e) => e.bottom));
+	return {
+		x: t,
+		y: n,
+		width: r - t,
+		height: i - n
+	};
+}
+function L(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) => _(I(e)));
+}
+async function R(e, t) {
+	let { placement: a, platform: o, elements: c } = e, l = await (o.isRTL == null ? void 0 : o.isRTL(c.floating)), u = r(a), d = i(a), f = s(a) === "y", p = se.has(u) ? -1 : 1, m = l && f ? -1 : 1, h = n(t, e), { mainAxis: g, crossAxis: _, alignmentAxis: v } = typeof h == "number" ? {
+		mainAxis: h,
+		crossAxis: 0,
+		alignmentAxis: null
+	} : {
+		mainAxis: h.mainAxis || 0,
+		crossAxis: h.crossAxis || 0,
+		alignmentAxis: h.alignmentAxis
+	};
+	return d && typeof v == "number" && (_ = d === "end" ? v * -1 : v), f ? {
+		x: _ * m,
+		y: g * p
+	} : {
+		x: g * p,
+		y: _ * m
+	};
+}
+var z, te, ne, re, ie, ae, oe, se, ce, le, ue, de, fe = e((() => {
+	j(), z = 50, te = async (e, t, n) => {
+		let { placement: r = "bottom", strategy: i = "absolute", middleware: a = [], platform: o } = n, s = o.detectOverflow ? o : {
+			...o,
+			detectOverflow: N
+		}, c = await (o.isRTL == null ? void 0 : o.isRTL(t)), l = await o.getElementRects({
+			reference: e,
+			floating: t,
+			strategy: i
+		}), { x: u, y: d } = M(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 < z && (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} = M(l, f, c)), n = -1);
+		}
+		return {
+			x: u,
+			y: d,
+			placement: f,
+			strategy: i,
+			middlewareData: m
+		};
+	}, ne = (e) => ({
+		name: "arrow",
+		options: e,
+		async fn(r) {
+			let { x: a, y: s, placement: l, rects: u, platform: d, elements: f, middlewareData: p } = r, { element: m, padding: h = 0 } = n(e, r) || {};
+			if (m == null) return {};
+			let _ = g(h), v = {
+				x: a,
+				y: s
+			}, y = c(l), b = o(y), S = await d.getDimensions(m), C = y === "y", w = C ? "top" : "left", T = C ? "bottom" : "right", E = C ? "clientHeight" : "clientWidth", D = u.reference[b] + u.reference[y] - v[y] - u.floating[b], O = v[y] - u.reference[y], k = await (d.getOffsetParent == null ? void 0 : d.getOffsetParent(m)), A = k ? k[E] : 0;
+			(!A || !await (d.isElement == null ? void 0 : d.isElement(k))) && (A = f.floating[E] || u.floating[b]);
+			let j = D / 2 - O / 2, M = A / 2 - S[b] / 2 - 1, N = x(_[w], M), ee = x(_[T], M), P = N, F = A - S[b] - ee, I = A / 2 - S[b] / 2 + j, L = t(P, I, F), R = !p.arrow && i(l) != null && I !== L && u.reference[b] / 2 - (I < P ? N : ee) - S[b] / 2 < 0, z = R ? I < P ? I - P : I - F : 0;
+			return {
+				[y]: v[y] + z,
+				data: {
+					[y]: L,
+					centerOffset: I - L - z,
+					...R && { alignmentOffset: z }
+				},
+				reset: R
+			};
+		}
+	}), re = function(e) {
+		return e === void 0 && (e = {}), {
+			name: "autoPlacement",
+			options: e,
+			async fn(t) {
+				let { rects: a, middlewareData: o, placement: s, platform: c, elements: u } = t, { crossAxis: d = !1, alignment: f, allowedPlacements: p = b, autoAlignment: m = !0, ...h } = n(e, t), g = f !== void 0 || p === b ? ee(f || null, m, p) : p, _ = await c.detectOverflow(t, h), v = o.autoPlacement?.index || 0, y = g[v];
+				if (y == null) return {};
+				let x = l(y, a, await (c.isRTL == null ? void 0 : c.isRTL(u.floating)));
+				if (s !== y) return { reset: { placement: g[0] } };
+				let S = [
+					_[r(y)],
+					_[x[0]],
+					_[x[1]]
+				], C = [...o.autoPlacement?.overflows || [], {
+					placement: y,
+					overflows: S
+				}], w = g[v + 1];
+				if (w) return {
+					data: {
+						index: v + 1,
+						overflows: C
+					},
+					reset: { placement: w }
+				};
+				let T = C.map((e) => {
+					let t = i(e.placement);
+					return [
+						e.placement,
+						t && d ? e.overflows.slice(0, 2).reduce((e, t) => e + t, 0) : e.overflows[0],
+						e.overflows
+					];
+				}).sort((e, t) => e[1] - t[1]), E = T.filter((e) => e[2].slice(0, i(e[0]) ? 2 : 3).every((e) => e <= 0))[0]?.[0] || T[0][0];
+				return E === s ? {} : {
+					data: {
+						index: v + 1,
+						overflows: C
+					},
+					reset: { placement: E }
+				};
+			}
+		};
+	}, ie = function(e) {
+		return e === void 0 && (e = {}), {
+			name: "flip",
+			options: e,
+			async fn(t) {
+				var i;
+				let { placement: a, middlewareData: o, rects: c, initialPlacement: d, platform: f, elements: h } = t, { mainAxis: g = !0, crossAxis: _ = !0, fallbackPlacements: v, fallbackStrategy: y = "bestFit", fallbackAxisSideDirection: b = "none", flipAlignment: x = !0, ...S } = n(e, t);
+				if ((i = o.arrow) != null && i.alignmentOffset) return {};
+				let C = r(a), w = s(d), T = r(d) === d, E = await (f.isRTL == null ? void 0 : f.isRTL(h.floating)), D = v || (T || !x ? [m(d)] : u(d)), O = b !== "none";
+				!v && O && D.push(...p(d, x, b, E));
+				let k = [d, ...D], A = await f.detectOverflow(t, S), j = [], M = o.flip?.overflows || [];
+				if (g && j.push(A[C]), _) {
+					let e = l(a, c, E);
+					j.push(A[e[0]], A[e[1]]);
+				}
+				if (M = [...M, {
+					placement: a,
+					overflows: j
+				}], !j.every((e) => e <= 0)) {
+					let e = (o.flip?.index || 0) + 1, t = k[e];
+					if (t && (_ !== "alignment" || w === s(t) || M.every((e) => s(e.placement) !== w || e.overflows[0] > 0))) return {
+						data: {
+							index: e,
+							overflows: M
+						},
+						reset: { placement: t }
+					};
+					let n = M.filter((e) => e.overflows[0] <= 0).sort((e, t) => e.overflows[1] - t.overflows[1])[0]?.placement;
+					if (!n) switch (y) {
+						case "bestFit": {
+							let e = M.filter((e) => {
+								if (O) {
+									let t = s(e.placement);
+									return t === w || 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 = d;
+					}
+					if (a !== n) return { reset: { placement: n } };
+				}
+				return {};
+			}
+		};
+	}, ae = function(e) {
+		return e === void 0 && (e = {}), {
+			name: "hide",
+			options: e,
+			async fn(t) {
+				let { rects: r, platform: i } = t, { strategy: a = "referenceHidden", ...o } = n(e, t);
+				switch (a) {
+					case "referenceHidden": {
+						let e = P(await i.detectOverflow(t, {
+							...o,
+							elementContext: "reference"
+						}), r.reference);
+						return { data: {
+							referenceHiddenOffsets: e,
+							referenceHidden: F(e)
+						} };
+					}
+					case "escaped": {
+						let e = P(await i.detectOverflow(t, {
+							...o,
+							altBoundary: !0
+						}), r.floating);
+						return { data: {
+							escapedOffsets: e,
+							escaped: F(e)
+						} };
+					}
+					default: return {};
+				}
+			}
+		};
+	}, oe = function(e) {
+		return e === void 0 && (e = {}), {
+			name: "inline",
+			options: e,
+			async fn(t) {
+				let { placement: i, elements: a, rects: o, platform: c, strategy: l } = t, { padding: u = 2, x: d, y: f } = n(e, t), p = Array.from(await (c.getClientRects == null ? void 0 : c.getClientRects(a.reference)) || []), m = L(p), h = _(I(p)), v = g(u);
+				function y() {
+					if (m.length === 2 && m[0].left > m[1].right && d != null && f != null) return m.find((e) => d > e.left - v.left && d < e.right + v.right && f > e.top - v.top && f < e.bottom + v.bottom) || h;
+					if (m.length >= 2) {
+						if (s(i) === "y") {
+							let e = m[0], t = m[m.length - 1], n = r(i) === "top", a = e.top, o = t.bottom, s = n ? e.left : t.left, c = n ? e.right : t.right;
+							return {
+								top: a,
+								bottom: o,
+								left: s,
+								right: c,
+								width: c - s,
+								height: o - a,
+								x: s,
+								y: a
+							};
+						}
+						let e = r(i) === "left", t = S(...m.map((e) => e.right)), n = x(...m.map((e) => e.left)), a = m.filter((r) => e ? r.left === n : r.right === t), o = a[0].top, c = a[a.length - 1].bottom, l = n, u = t;
+						return {
+							top: o,
+							bottom: c,
+							left: l,
+							right: u,
+							width: u - l,
+							height: c - o,
+							x: l,
+							y: o
+						};
+					}
+					return h;
+				}
+				let b = await c.getElementRects({
+					reference: { getBoundingClientRect: y },
+					floating: a.floating,
+					strategy: l
+				});
+				return o.reference.x !== b.reference.x || o.reference.y !== b.reference.y || o.reference.width !== b.reference.width || o.reference.height !== b.reference.height ? { reset: { rects: b } } : {};
+			}
+		};
+	}, se = /*#__PURE__*/ new Set(["left", "top"]), ce = 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 R(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
+					}
+				};
+			}
+		};
+	}, le = function(e) {
+		return e === void 0 && (e = {}), {
+			name: "shift",
+			options: e,
+			async fn(i) {
+				let { x: o, y: c, placement: l, platform: u } = i, { mainAxis: d = !0, crossAxis: f = !1, limiter: p = { fn: (e) => {
+					let { x: t, y: n } = e;
+					return {
+						x: t,
+						y: n
+					};
+				} }, ...m } = n(e, i), h = {
+					x: o,
+					y: c
+				}, g = await u.detectOverflow(i, m), _ = s(r(l)), v = a(_), y = h[v], b = h[_];
+				if (d) {
+					let e = v === "y" ? "top" : "left", n = v === "y" ? "bottom" : "right", r = y + g[e], i = y - g[n];
+					y = t(r, y, i);
+				}
+				if (f) {
+					let e = _ === "y" ? "top" : "left", n = _ === "y" ? "bottom" : "right", r = b + g[e], i = b - g[n];
+					b = t(r, b, i);
+				}
+				let x = p.fn({
+					...i,
+					[v]: y,
+					[_]: b
+				});
+				return {
+					...x,
+					data: {
+						x: x.x - o,
+						y: x.y - c,
+						enabled: {
+							[v]: d,
+							[_]: f
+						}
+					}
+				};
+			}
+		};
+	}, ue = function(e) {
+		return e === void 0 && (e = {}), {
+			options: e,
+			fn(t) {
+				let { x: i, y: o, placement: c, rects: l, middlewareData: u } = t, { offset: d = 0, mainAxis: f = !0, crossAxis: p = !0 } = n(e, t), m = {
+					x: i,
+					y: o
+				}, h = s(c), g = a(h), _ = m[g], v = m[h], y = n(d, t), b = typeof y == "number" ? {
+					mainAxis: y,
+					crossAxis: 0
+				} : {
+					mainAxis: 0,
+					crossAxis: 0,
+					...y
+				};
+				if (f) {
+					let e = g === "y" ? "height" : "width", t = l.reference[g] - l.floating[e] + b.mainAxis, n = l.reference[g] + l.reference[e] - b.mainAxis;
+					_ < t ? _ = t : _ > n && (_ = n);
+				}
+				if (p) {
+					let e = g === "y" ? "width" : "height", t = se.has(r(c)), n = l.reference[h] - l.floating[e] + (t && u.offset?.[h] || 0) + (t ? 0 : b.crossAxis), i = l.reference[h] + l.reference[e] + (t ? 0 : u.offset?.[h] || 0) - (t ? b.crossAxis : 0);
+					v < n ? v = n : v > i && (v = i);
+				}
+				return {
+					[g]: _,
+					[h]: v
+				};
+			}
+		};
+	}, de = function(e) {
+		return e === void 0 && (e = {}), {
+			name: "size",
+			options: e,
+			async fn(t) {
+				var a, o;
+				let { placement: c, rects: l, platform: u, elements: d } = t, { apply: f = () => {}, ...p } = n(e, t), m = await u.detectOverflow(t, p), h = r(c), g = i(c), _ = s(c) === "y", { width: v, height: y } = l.floating, b, C;
+				h === "top" || h === "bottom" ? (b = h, C = g === (await (u.isRTL == null ? void 0 : u.isRTL(d.floating)) ? "start" : "end") ? "left" : "right") : (C = h, b = g === "end" ? "top" : "bottom");
+				let w = y - m.top - m.bottom, T = v - m.left - m.right, E = x(y - m[b], w), D = x(v - m[C], T), O = !t.middlewareData.shift, k = E, A = D;
+				if ((a = t.middlewareData.shift) != null && a.enabled.x && (A = T), (o = t.middlewareData.shift) != null && o.enabled.y && (k = w), O && !g) {
+					let e = S(m.left, 0), t = S(m.right, 0), n = S(m.top, 0), r = S(m.bottom, 0);
+					_ ? A = v - 2 * (e !== 0 || t !== 0 ? e + t : S(m.left, m.right)) : k = y - 2 * (n !== 0 || r !== 0 ? n + r : S(m.top, m.bottom));
+				}
+				await f({
+					...t,
+					availableWidth: A,
+					availableHeight: k
+				});
+				let j = await u.getDimensions(d.floating);
+				return v !== j.width || y !== j.height ? { reset: { rects: !0 } } : {};
+			}
+		};
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@floating-ui+utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
+function B() {
+	return typeof window < "u";
+}
+function V(e) {
+	return pe(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function H(e) {
+	var t;
+	return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function U(e) {
+	return ((pe(e) ? e.ownerDocument : e.document) || window.document)?.documentElement;
+}
+function pe(e) {
+	return B() ? e instanceof Node || e instanceof H(e).Node : !1;
+}
+function W(e) {
+	return B() ? e instanceof Element || e instanceof H(e).Element : !1;
+}
+function G(e) {
+	return B() ? e instanceof HTMLElement || e instanceof H(e).HTMLElement : !1;
+}
+function me(e) {
+	return !B() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof H(e).ShadowRoot;
+}
+function K(e) {
+	let { overflow: t, overflowX: n, overflowY: r, display: i } = J(e);
+	return /auto|scroll|overlay|hidden|clip/.test(t + r + n) && i !== "inline" && i !== "contents";
+}
+function he(e) {
+	return /^(table|td|th)$/.test(V(e));
+}
+function ge(e) {
+	try {
+		if (e.matches(":popover-open")) return !0;
+	} catch {}
+	try {
+		return e.matches(":modal");
+	} catch {
+		return !1;
+	}
+}
+function _e(e) {
+	let t = W(e) ? J(e) : e;
+	return Z(t.transform) || Z(t.translate) || Z(t.scale) || Z(t.rotate) || Z(t.perspective) || !ye() && (Z(t.backdropFilter) || Z(t.filter)) || Ce.test(t.willChange || "") || we.test(t.contain || "");
+}
+function ve(e) {
+	let t = Y(e);
+	for (; G(t) && !q(t);) {
+		if (_e(t)) return t;
+		if (ge(t)) return null;
+		t = Y(t);
+	}
+	return null;
+}
+function ye() {
+	return Te ??= typeof CSS < "u" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none"), Te;
+}
+function q(e) {
+	return /^(html|body|#document)$/.test(V(e));
+}
+function J(e) {
+	return H(e).getComputedStyle(e);
+}
+function be(e) {
+	return W(e) ? {
+		scrollLeft: e.scrollLeft,
+		scrollTop: e.scrollTop
+	} : {
+		scrollLeft: e.scrollX,
+		scrollTop: e.scrollY
+	};
+}
+function Y(e) {
+	if (V(e) === "html") return e;
+	let t = e.assignedSlot || e.parentNode || me(e) && e.host || U(e);
+	return me(t) ? t.host : t;
+}
+function xe(e) {
+	let t = Y(e);
+	return q(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : G(t) && K(t) ? t : xe(t);
+}
+function X(e, t, n) {
+	t === void 0 && (t = []), n === void 0 && (n = !0);
+	let r = xe(e), i = r === e.ownerDocument?.body, a = H(r);
+	if (i) {
+		let e = Se(a);
+		return t.concat(a, a.visualViewport || [], K(r) ? r : [], e && n ? X(e) : []);
+	}
+	return t.concat(r, X(r, [], n));
+}
+function Se(e) {
+	return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+var Ce, we, Z, Te, Ee = e((() => {
+	Ce = /transform|translate|scale|rotate|perspective|filter/, we = /paint|layout|strict|content/, Z = (e) => !!e && e !== "none";
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@floating-ui+dom@1.7.6/node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
+function De(e) {
+	let t = J(e), n = parseFloat(t.width) || 0, r = parseFloat(t.height) || 0, i = G(e), a = i ? e.offsetWidth : n, o = i ? e.offsetHeight : r, s = C(n) !== a || C(r) !== o;
+	return s && (n = a, r = o), {
+		width: n,
+		height: r,
+		$: s
+	};
+}
+function Oe(e) {
+	return W(e) ? e : e.contextElement;
+}
+function Q(e) {
+	let t = Oe(e);
+	if (!G(t)) return T(1);
+	let n = t.getBoundingClientRect(), { width: r, height: i, $: a } = De(t), o = (a ? C(n.width) : n.width) / r, s = (a ? C(n.height) : n.height) / i;
+	return (!o || !Number.isFinite(o)) && (o = 1), (!s || !Number.isFinite(s)) && (s = 1), {
+		x: o,
+		y: s
+	};
+}
+function ke(e) {
+	let t = H(e);
+	return !ye() || !t.visualViewport ? Ze : {
+		x: t.visualViewport.offsetLeft,
+		y: t.visualViewport.offsetTop
+	};
+}
+function Ae(e, t, n) {
+	return t === void 0 && (t = !1), !n || t && n !== H(e) ? !1 : t;
+}
+function $(e, t, n, r) {
+	t === void 0 && (t = !1), n === void 0 && (n = !1);
+	let i = e.getBoundingClientRect(), a = Oe(e), o = T(1);
+	t && (r ? W(r) && (o = Q(r)) : o = Q(e));
+	let s = Ae(a, n, r) ? ke(a) : T(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 = H(a), t = r && W(r) ? H(r) : r, n = e, i = Se(n);
+		for (; i && r && t !== n;) {
+			let e = Q(i), t = i.getBoundingClientRect(), r = J(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 = H(i), i = Se(n);
+		}
+	}
+	return _({
+		width: u,
+		height: d,
+		x: c,
+		y: l
+	});
+}
+function je(e, t) {
+	let n = be(e).scrollLeft;
+	return t ? t.left + n : $(U(e)).left + n;
+}
+function Me(e, t) {
+	let n = e.getBoundingClientRect();
+	return {
+		x: n.left + t.scrollLeft - je(e, n),
+		y: n.top + t.scrollTop
+	};
+}
+function Ne(e) {
+	let { elements: t, rect: n, offsetParent: r, strategy: i } = e, a = i === "fixed", o = U(r), s = t ? ge(t.floating) : !1;
+	if (r === o || s && a) return n;
+	let c = {
+		scrollLeft: 0,
+		scrollTop: 0
+	}, l = T(1), u = T(0), d = G(r);
+	if ((d || !d && !a) && ((V(r) !== "body" || K(o)) && (c = be(r)), d)) {
+		let e = $(r);
+		l = Q(r), u.x = e.x + r.clientLeft, u.y = e.y + r.clientTop;
+	}
+	let f = o && !d && !a ? Me(o, c) : T(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 Pe(e) {
+	return Array.from(e.getClientRects());
+}
+function Fe(e) {
+	let t = U(e), n = be(e), r = e.ownerDocument.body, i = S(t.scrollWidth, t.clientWidth, r.scrollWidth, r.clientWidth), a = S(t.scrollHeight, t.clientHeight, r.scrollHeight, r.clientHeight), o = -n.scrollLeft + je(e), s = -n.scrollTop;
+	return J(r).direction === "rtl" && (o += S(t.clientWidth, r.clientWidth) - i), {
+		width: i,
+		height: a,
+		x: o,
+		y: s
+	};
+}
+function Ie(e, t) {
+	let n = H(e), r = U(e), i = n.visualViewport, a = r.clientWidth, o = r.clientHeight, s = 0, c = 0;
+	if (i) {
+		a = i.width, o = i.height;
+		let e = ye();
+		(!e || e && t === "fixed") && (s = i.offsetLeft, c = i.offsetTop);
+	}
+	let l = je(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 <= Qe && (a -= o);
+	} else l <= Qe && (a += l);
+	return {
+		width: a,
+		height: o,
+		x: s,
+		y: c
+	};
+}
+function Le(e, t) {
+	let n = $(e, !0, t === "fixed"), r = n.top + e.clientTop, i = n.left + e.clientLeft, a = G(e) ? Q(e) : T(1);
+	return {
+		width: e.clientWidth * a.x,
+		height: e.clientHeight * a.y,
+		x: i * a.x,
+		y: r * a.y
+	};
+}
+function Re(e, t, n) {
+	let r;
+	if (t === "viewport") r = Ie(e, n);
+	else if (t === "document") r = Fe(U(e));
+	else if (W(t)) r = Le(t, n);
+	else {
+		let n = ke(e);
+		r = {
+			x: t.x - n.x,
+			y: t.y - n.y,
+			width: t.width,
+			height: t.height
+		};
+	}
+	return _(r);
+}
+function ze(e, t) {
+	let n = Y(e);
+	return n === t || !W(n) || q(n) ? !1 : J(n).position === "fixed" || ze(n, t);
+}
+function Be(e, t) {
+	let n = t.get(e);
+	if (n) return n;
+	let r = X(e, [], !1).filter((e) => W(e) && V(e) !== "body"), i = null, a = J(e).position === "fixed", o = a ? Y(e) : e;
+	for (; W(o) && !q(o);) {
+		let t = J(o), n = _e(o);
+		!n && t.position === "fixed" && (i = null), (a ? !n && !i : !n && t.position === "static" && i && (i.position === "absolute" || i.position === "fixed") || K(o) && !n && ze(e, o)) ? r = r.filter((e) => e !== o) : i = t, o = Y(o);
+	}
+	return t.set(e, r), r;
+}
+function Ve(e) {
+	let { element: t, boundary: n, rootBoundary: r, strategy: i } = e, a = [...n === "clippingAncestors" ? ge(t) ? [] : Be(t, this._c) : [].concat(n), r], o = Re(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 = Re(t, a[e], i);
+		s = S(n.top, s), c = x(n.right, c), l = x(n.bottom, l), u = S(n.left, u);
+	}
+	return {
+		width: c - u,
+		height: l - s,
+		x: u,
+		y: s
+	};
+}
+function He(e) {
+	let { width: t, height: n } = De(e);
+	return {
+		width: t,
+		height: n
+	};
+}
+function Ue(e, t, n) {
+	let r = G(t), i = U(t), a = n === "fixed", o = $(e, !0, a, t), s = {
+		scrollLeft: 0,
+		scrollTop: 0
+	}, c = T(0);
+	function l() {
+		c.x = je(i);
+	}
+	if (r || !r && !a) if ((V(t) !== "body" || K(i)) && (s = be(t)), r) {
+		let e = $(t, !0, a, t);
+		c.x = e.x + t.clientLeft, c.y = e.y + t.clientTop;
+	} else i && l();
+	a && !r && i && l();
+	let u = i && !r && !a ? Me(i, s) : T(0);
+	return {
+		x: o.left + s.scrollLeft - c.x - u.x,
+		y: o.top + s.scrollTop - c.y - u.y,
+		width: o.width,
+		height: o.height
+	};
+}
+function We(e) {
+	return J(e).position === "static";
+}
+function Ge(e, t) {
+	if (!G(e) || J(e).position === "fixed") return null;
+	if (t) return t(e);
+	let n = e.offsetParent;
+	return U(e) === n && (n = n.ownerDocument.body), n;
+}
+function Ke(e, t) {
+	let n = H(e);
+	if (ge(e)) return n;
+	if (!G(e)) {
+		let t = Y(e);
+		for (; t && !q(t);) {
+			if (W(t) && !We(t)) return t;
+			t = Y(t);
+		}
+		return n;
+	}
+	let r = Ge(e, t);
+	for (; r && he(r) && We(r);) r = Ge(r, t);
+	return r && q(r) && We(r) && !_e(r) ? n : r || ve(e) || n;
+}
+function qe(e) {
+	return J(e).direction === "rtl";
+}
+function Je(e, t) {
+	return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function Ye(e, t) {
+	let n = null, r, i = U(e);
+	function a() {
+		var e;
+		clearTimeout(r), (e = n) == null || e.disconnect(), n = null;
+	}
+	function o(s, c) {
+		s === void 0 && (s = !1), c === void 0 && (c = 1), a();
+		let l = e.getBoundingClientRect(), { left: u, top: d, width: f, height: p } = l;
+		if (s || t(), !f || !p) return;
+		let m = w(d), h = w(i.clientWidth - (u + f)), g = w(i.clientHeight - (d + p)), _ = w(u), v = {
+			rootMargin: -m + "px " + -h + "px " + -g + "px " + -_ + "px",
+			threshold: S(0, x(1, c)) || 1
+		}, y = !0;
+		function b(t) {
+			let n = t[0].intersectionRatio;
+			if (n !== c) {
+				if (!y) return o();
+				n ? o(!1, n) : r = setTimeout(() => {
+					o(!1, 1e-7);
+				}, 1e3);
+			}
+			n === 1 && !Je(l, e.getBoundingClientRect()) && o(), y = !1;
+		}
+		try {
+			n = new IntersectionObserver(b, {
+				...v,
+				root: i.ownerDocument
+			});
+		} catch {
+			n = new IntersectionObserver(b, v);
+		}
+		n.observe(e);
+	}
+	return o(!0), a;
+}
+function Xe(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 = Oe(e), u = i || a ? [...l ? X(l) : [], ...t ? X(t) : []] : [];
+	u.forEach((e) => {
+		i && e.addEventListener("scroll", n, { passive: !0 }), a && e.addEventListener("resize", n);
+	});
+	let d = l && s ? Ye(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 ? $(e) : null;
+	c && g();
+	function g() {
+		let t = $(e);
+		h && !Je(h, t) && n(), h = t, m = requestAnimationFrame(g);
+	}
+	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 Ze, Qe, $e, et, tt, nt, rt, it, at, ot, st, ct, lt, ut, dt, ft = e((() => {
+	fe(), j(), Ee(), Ze = /*#__PURE__*/ T(0), Qe = 25, $e = async function(e) {
+		let t = this.getOffsetParent || Ke, n = this.getDimensions, r = await n(e.floating);
+		return {
+			reference: Ue(e.reference, await t(e.floating), e.strategy),
+			floating: {
+				x: 0,
+				y: 0,
+				width: r.width,
+				height: r.height
+			}
+		};
+	}, et = {
+		convertOffsetParentRelativeRectToViewportRelativeRect: Ne,
+		getDocumentElement: U,
+		getClippingRect: Ve,
+		getOffsetParent: Ke,
+		getElementRects: $e,
+		getClientRects: Pe,
+		getDimensions: He,
+		getScale: Q,
+		isElement: W,
+		isRTL: qe
+	}, tt = N, nt = ce, rt = re, it = le, at = ie, ot = de, st = ae, ct = ne, lt = oe, ut = ue, dt = (e, t, n) => {
+		let r = /* @__PURE__ */ new Map(), i = {
+			platform: et,
+			...n
+		}, a = {
+			...i.platform,
+			_c: r
+		};
+		return te(e, t, {
+			...i,
+			platform: a
+		});
+	};
+}));
+//#endregion
+export { tt as a, ft as c, nt as d, et as f, Ee as g, X as h, dt as i, lt as l, ot as m, rt as n, at as o, it as p, Xe as r, st as s, ct as t, ut as u };