lildocs 0.0.0 → 0.1.0

package/dist/render/search.js

@@ -0,0 +1,3239 @@
+//#region node_modules/.pnpm/preact@10.29.2/node_modules/preact/dist/preact.module.js
+var n$1, l$3, u$3, t$2, i$3, r$2, o$3, e$2, f$3, c$2, a$2, s$2, h$3, p$3, v$2, y$3, d$3 = {}, w$3 = [], _$3 = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i, g$4 = Array.isArray;
+function m$3(n, l) {
+	for (var u in l) n[u] = l[u];
+	return n;
+}
+function b$2(n) {
+	n && n.parentNode && n.parentNode.removeChild(n);
+}
+function k$2(l, u, t) {
+	var i, r, o, e = {};
+	for (o in u) "key" == o ? i = u[o] : "ref" == o ? r = u[o] : e[o] = u[o];
+	if (arguments.length > 2 && (e.children = arguments.length > 3 ? n$1.call(arguments, 2) : t), "function" == typeof l && null != l.defaultProps) for (o in l.defaultProps) void 0 === e[o] && (e[o] = l.defaultProps[o]);
+	return x$2(l, e, i, r, null);
+}
+function x$2(n, t, i, r, o) {
+	var e = {
+		type: n,
+		props: t,
+		key: i,
+		ref: r,
+		__k: null,
+		__: null,
+		__b: 0,
+		__e: null,
+		__c: null,
+		constructor: void 0,
+		__v: null == o ? ++u$3 : o,
+		__i: -1,
+		__u: 0
+	};
+	return null == o && null != l$3.vnode && l$3.vnode(e), e;
+}
+function S$1(n) {
+	return n.children;
+}
+function C$1(n, l) {
+	this.props = n, this.context = l;
+}
+function $$1(n, l) {
+	if (null == l) return n.__ ? $$1(n.__, n.__i + 1) : null;
+	for (var u; l < n.__k.length; l++) if (null != (u = n.__k[l]) && null != u.__e) return u.__e;
+	return "function" == typeof n.type ? $$1(n) : null;
+}
+function I(n) {
+	if (n.__P && n.__d) {
+		var u = n.__v, t = u.__e, i = [], r = [], o = m$3({}, u);
+		o.__v = u.__v + 1, l$3.vnode && l$3.vnode(o), q$2(n.__P, o, u, n.__n, n.__P.namespaceURI, 32 & u.__u ? [t] : null, i, null == t ? $$1(u) : t, !!(32 & u.__u), r), o.__v = u.__v, o.__.__k[o.__i] = o, D$1(i, o, r), u.__e = u.__ = null, o.__e != t && P$1(o);
+	}
+}
+function P$1(n) {
+	if (null != (n = n.__) && null != n.__c) return n.__e = n.__c.base = null, n.__k.some(function(l) {
+		if (null != l && null != l.__e) return n.__e = n.__c.base = l.__e;
+	}), P$1(n);
+}
+function A$2(n) {
+	(!n.__d && (n.__d = !0) && i$3.push(n) && !H$1.__r++ || r$2 != l$3.debounceRendering) && ((r$2 = l$3.debounceRendering) || o$3)(H$1);
+}
+function H$1() {
+	try {
+		for (var n, l = 1; i$3.length;) i$3.length > l && i$3.sort(e$2), n = i$3.shift(), l = i$3.length, I(n);
+	} finally {
+		i$3.length = H$1.__r = 0;
+	}
+}
+function L$1(n, l, u, t, i, r, o, e, f, c, a) {
+	var s, h, p, v, y, _, g, m = t && t.__k || w$3, b = l.length;
+	for (f = T$2(u, l, m, f, b), s = 0; s < b; s++) null != (p = u.__k[s]) && (h = -1 != p.__i && m[p.__i] || d$3, p.__i = s, _ = q$2(n, p, h, i, r, o, e, f, c, a), v = p.__e, p.ref && h.ref != p.ref && (h.ref && J$1(h.ref, null, p), a.push(p.ref, p.__c || v, p)), null == y && null != v && (y = v), (g = !!(4 & p.__u)) || h.__k === p.__k ? (f = j$3(p, f, n, g), g && h.__e && (h.__e = null)) : "function" == typeof p.type && void 0 !== _ ? f = _ : v && (f = v.nextSibling), p.__u &= -7);
+	return u.__e = y, f;
+}
+function T$2(n, l, u, t, i) {
+	var r, o, e, f, c, a = u.length, s = a, h = 0;
+	for (n.__k = new Array(i), r = 0; r < i; r++) null != (o = l[r]) && "boolean" != typeof o && "function" != typeof o ? ("string" == typeof o || "number" == typeof o || "bigint" == typeof o || o.constructor == String ? o = n.__k[r] = x$2(null, o, null, null, null) : g$4(o) ? o = n.__k[r] = x$2(S$1, { children: o }, null, null, null) : void 0 === o.constructor && o.__b > 0 ? o = n.__k[r] = x$2(o.type, o.props, o.key, o.ref ? o.ref : null, o.__v) : n.__k[r] = o, f = r + h, o.__ = n, o.__b = n.__b + 1, e = null, -1 != (c = o.__i = O$1(o, u, f, s)) && (s--, (e = u[c]) && (e.__u |= 2)), null == e || null == e.__v ? (-1 == c && (i > a ? h-- : i < a && h++), "function" != typeof o.type && (o.__u |= 4)) : c != f && (c == f - 1 ? h-- : c == f + 1 ? h++ : (c > f ? h-- : h++, o.__u |= 4))) : n.__k[r] = null;
+	if (s) for (r = 0; r < a; r++) null != (e = u[r]) && 0 == (2 & e.__u) && (e.__e == t && (t = $$1(e)), K$1(e, e));
+	return t;
+}
+function j$3(n, l, u, t) {
+	var i, r;
+	if ("function" == typeof n.type) {
+		for (i = n.__k, r = 0; i && r < i.length; r++) i[r] && (i[r].__ = n, l = j$3(i[r], l, u, t));
+		return l;
+	}
+	n.__e != l && (t && (l && n.type && !l.parentNode && (l = $$1(n)), u.insertBefore(n.__e, l || null)), l = n.__e);
+	do
+		l = l && l.nextSibling;
+	while (null != l && 8 == l.nodeType);
+	return l;
+}
+function F$2(n, l) {
+	return l = l || [], null == n || "boolean" == typeof n || (g$4(n) ? n.some(function(n) {
+		F$2(n, l);
+	}) : l.push(n)), l;
+}
+function O$1(n, l, u, t) {
+	var i, r, o, e = n.key, f = n.type, c = l[u], a = null != c && 0 == (2 & c.__u);
+	if (null === c && null == e || a && e == c.key && f == c.type) return u;
+	if (t > (a ? 1 : 0)) {
+		for (i = u - 1, r = u + 1; i >= 0 || r < l.length;) if (null != (c = l[o = i >= 0 ? i-- : r++]) && 0 == (2 & c.__u) && e == c.key && f == c.type) return o;
+	}
+	return -1;
+}
+function z$1(n, l, u) {
+	"-" == l[0] ? n.setProperty(l, null == u ? "" : u) : n[l] = null == u ? "" : "number" != typeof u || _$3.test(l) ? u : u + "px";
+}
+function N(n, l, u, t, i) {
+	var r, o;
+	n: if ("style" == l) if ("string" == typeof u) n.style.cssText = u;
+	else {
+		if ("string" == typeof t && (n.style.cssText = t = ""), t) for (l in t) u && l in u || z$1(n.style, l, "");
+		if (u) for (l in u) t && u[l] == t[l] || z$1(n.style, l, u[l]);
+	}
+	else if ("o" == l[0] && "n" == l[1]) r = l != (l = l.replace(s$2, "$1")), o = l.toLowerCase(), l = o in n || "onFocusOut" == l || "onFocusIn" == l ? o.slice(2) : l.slice(2), n.l || (n.l = {}), n.l[l + r] = u, u ? t ? u[a$2] = t[a$2] : (u[a$2] = h$3, n.addEventListener(l, r ? v$2 : p$3, r)) : n.removeEventListener(l, r ? v$2 : p$3, r);
+	else {
+		if ("http://www.w3.org/2000/svg" == i) l = l.replace(/xlink(H|:h)/, "h").replace(/sName$/, "s");
+		else if ("width" != l && "height" != l && "href" != l && "list" != l && "form" != l && "tabIndex" != l && "download" != l && "rowSpan" != l && "colSpan" != l && "role" != l && "popover" != l && l in n) try {
+			n[l] = null == u ? "" : u;
+			break n;
+		} catch (n) {}
+		"function" == typeof u || (null == u || !1 === u && "-" != l[4] ? n.removeAttribute(l) : n.setAttribute(l, "popover" == l && 1 == u ? "" : u));
+	}
+}
+function V$1(n) {
+	return function(u) {
+		if (this.l) {
+			var t = this.l[u.type + n];
+			if (null == u[c$2]) u[c$2] = h$3++;
+			else if (u[c$2] < t[a$2]) return;
+			return t(l$3.event ? l$3.event(u) : u);
+		}
+	};
+}
+function q$2(n, u, t, i, r, o, e, f, c, a) {
+	var s, h, p, v, y, d, _, k, x, M, $, I, P, A, H, T = u.type;
+	if (void 0 !== u.constructor) return null;
+	128 & t.__u && (c = !!(32 & t.__u), o = [f = u.__e = t.__e]), (s = l$3.__b) && s(u);
+	n: if ("function" == typeof T) try {
+		if (k = u.props, x = T.prototype && T.prototype.render, M = (s = T.contextType) && i[s.__c], $ = s ? M ? M.props.value : s.__ : i, t.__c ? _ = (h = u.__c = t.__c).__ = h.__E : (x ? u.__c = h = new T(k, $) : (u.__c = h = new C$1(k, $), h.constructor = T, h.render = Q$1), M && M.sub(h), h.state || (h.state = {}), h.__n = i, p = h.__d = !0, h.__h = [], h._sb = []), x && null == h.__s && (h.__s = h.state), x && null != T.getDerivedStateFromProps && (h.__s == h.state && (h.__s = m$3({}, h.__s)), m$3(h.__s, T.getDerivedStateFromProps(k, h.__s))), v = h.props, y = h.state, h.__v = u, p) x && null == T.getDerivedStateFromProps && null != h.componentWillMount && h.componentWillMount(), x && null != h.componentDidMount && h.__h.push(h.componentDidMount);
+		else {
+			if (x && null == T.getDerivedStateFromProps && k !== v && null != h.componentWillReceiveProps && h.componentWillReceiveProps(k, $), u.__v == t.__v || !h.__e && null != h.shouldComponentUpdate && !1 === h.shouldComponentUpdate(k, h.__s, $)) {
+				u.__v != t.__v && (h.props = k, h.state = h.__s, h.__d = !1), u.__e = t.__e, u.__k = t.__k, u.__k.some(function(n) {
+					n && (n.__ = u);
+				}), w$3.push.apply(h.__h, h._sb), h._sb = [], h.__h.length && e.push(h);
+				break n;
+			}
+			null != h.componentWillUpdate && h.componentWillUpdate(k, h.__s, $), x && null != h.componentDidUpdate && h.__h.push(function() {
+				h.componentDidUpdate(v, y, d);
+			});
+		}
+		if (h.context = $, h.props = k, h.__P = n, h.__e = !1, I = l$3.__r, P = 0, x) h.state = h.__s, h.__d = !1, I && I(u), s = h.render(h.props, h.state, h.context), w$3.push.apply(h.__h, h._sb), h._sb = [];
+		else do
+			h.__d = !1, I && I(u), s = h.render(h.props, h.state, h.context), h.state = h.__s;
+		while (h.__d && ++P < 25);
+		h.state = h.__s, null != h.getChildContext && (i = m$3(m$3({}, i), h.getChildContext())), x && !p && null != h.getSnapshotBeforeUpdate && (d = h.getSnapshotBeforeUpdate(v, y)), A = null != s && s.type === S$1 && null == s.key ? E$2(s.props.children) : s, f = L$1(n, g$4(A) ? A : [A], u, t, i, r, o, e, f, c, a), h.base = u.__e, u.__u &= -161, h.__h.length && e.push(h), _ && (h.__E = h.__ = null);
+	} catch (n) {
+		if (u.__v = null, c || null != o) if (n.then) {
+			for (u.__u |= c ? 160 : 128; f && 8 == f.nodeType && f.nextSibling;) f = f.nextSibling;
+			o[o.indexOf(f)] = null, u.__e = f;
+		} else {
+			for (H = o.length; H--;) b$2(o[H]);
+			B$2(u);
+		}
+		else u.__e = t.__e, u.__k = t.__k, n.then || B$2(u);
+		l$3.__e(n, u, t);
+	}
+	else null == o && u.__v == t.__v ? (u.__k = t.__k, u.__e = t.__e) : f = u.__e = G$1(t.__e, u, t, i, r, o, e, c, a);
+	return (s = l$3.diffed) && s(u), 128 & u.__u ? void 0 : f;
+}
+function B$2(n) {
+	n && (n.__c && (n.__c.__e = !0), n.__k && n.__k.some(B$2));
+}
+function D$1(n, u, t) {
+	for (var i = 0; i < t.length; i++) J$1(t[i], t[++i], t[++i]);
+	l$3.__c && l$3.__c(u, n), n.some(function(u) {
+		try {
+			n = u.__h, u.__h = [], n.some(function(n) {
+				n.call(u);
+			});
+		} catch (n) {
+			l$3.__e(n, u.__v);
+		}
+	});
+}
+function E$2(n) {
+	return "object" != typeof n || null == n || n.__b > 0 ? n : g$4(n) ? n.map(E$2) : void 0 !== n.constructor ? null : m$3({}, n);
+}
+function G$1(u, t, i, r, o, e, f, c, a) {
+	var s, h, p, v, y, w, _, m = i.props || d$3, k = t.props, x = t.type;
+	if ("svg" == x ? o = "http://www.w3.org/2000/svg" : "math" == x ? o = "http://www.w3.org/1998/Math/MathML" : o || (o = "http://www.w3.org/1999/xhtml"), null != e) {
+		for (s = 0; s < e.length; s++) if ((y = e[s]) && "setAttribute" in y == !!x && (x ? y.localName == x : 3 == y.nodeType)) {
+			u = y, e[s] = null;
+			break;
+		}
+	}
+	if (null == u) {
+		if (null == x) return document.createTextNode(k);
+		u = document.createElementNS(o, x, k.is && k), c && (l$3.__m && l$3.__m(t, e), c = !1), e = null;
+	}
+	if (null == x) m === k || c && u.data == k || (u.data = k);
+	else {
+		if (e = "textarea" == x && null != k.defaultValue ? null : e && n$1.call(u.childNodes), !c && null != e) for (m = {}, s = 0; s < u.attributes.length; s++) m[(y = u.attributes[s]).name] = y.value;
+		for (s in m) y = m[s], "dangerouslySetInnerHTML" == s ? p = y : "children" == s || s in k || "value" == s && "defaultValue" in k || "checked" == s && "defaultChecked" in k || N(u, s, null, y, o);
+		for (s in k) y = k[s], "children" == s ? v = y : "dangerouslySetInnerHTML" == s ? h = y : "value" == s ? w = y : "checked" == s ? _ = y : c && "function" != typeof y || m[s] === y || N(u, s, y, m[s], o);
+		if (h) c || p && (h.__html == p.__html || h.__html == u.innerHTML) || (u.innerHTML = h.__html), t.__k = [];
+		else if (p && (u.innerHTML = ""), L$1("template" == t.type ? u.content : u, g$4(v) ? v : [v], t, i, r, "foreignObject" == x ? "http://www.w3.org/1999/xhtml" : o, e, f, e ? e[0] : i.__k && $$1(i, 0), c, a), null != e) for (s = e.length; s--;) b$2(e[s]);
+		c && "textarea" != x || (s = "value", "progress" == x && null == w ? u.removeAttribute("value") : null != w && (w !== u[s] || "progress" == x && !w || "option" == x && w != m[s]) && N(u, s, w, m[s], o), s = "checked", null != _ && _ != u[s] && N(u, s, _, m[s], o));
+	}
+	return u;
+}
+function J$1(n, u, t) {
+	try {
+		if ("function" == typeof n) {
+			var i = "function" == typeof n.__u;
+			i && n.__u(), i && null == u || (n.__u = n(u));
+		} else n.current = u;
+	} catch (n) {
+		l$3.__e(n, t);
+	}
+}
+function K$1(n, u, t) {
+	var i, r;
+	if (l$3.unmount && l$3.unmount(n), (i = n.ref) && (i.current && i.current != n.__e || J$1(i, null, u)), null != (i = n.__c)) {
+		if (i.componentWillUnmount) try {
+			i.componentWillUnmount();
+		} catch (n) {
+			l$3.__e(n, u);
+		}
+		i.base = i.__P = null;
+	}
+	if (i = n.__k) for (r = 0; r < i.length; r++) i[r] && K$1(i[r], u, t || "function" != typeof n.type);
+	t || b$2(n.__e), n.__c = n.__ = n.__e = void 0;
+}
+function Q$1(n, l, u) {
+	return this.constructor(n, u);
+}
+function R(u, t, i) {
+	var r, o, e, f;
+	t == document && (t = document.documentElement), l$3.__ && l$3.__(u, t), o = (r = "function" == typeof i) ? null : i && i.__k || t.__k, e = [], f = [], q$2(t, u = (!r && i || t).__k = k$2(S$1, null, [u]), o || d$3, d$3, t.namespaceURI, !r && i ? [i] : o ? null : t.firstChild ? n$1.call(t.childNodes) : null, e, !r && i ? i : o ? o.__e : t.firstChild, r, f), D$1(e, u, f);
+}
+function U$1(n, l) {
+	R(n, l, U$1);
+}
+function X$1(n) {
+	function l(n) {
+		var u, t;
+		return this.getChildContext || (u = /* @__PURE__ */ new Set(), (t = {})[l.__c] = this, this.getChildContext = function() {
+			return t;
+		}, this.componentWillUnmount = function() {
+			u = null;
+		}, this.shouldComponentUpdate = function(n) {
+			this.props.value != n.value && u.forEach(function(n) {
+				n.__e = !0, A$2(n);
+			});
+		}, this.sub = function(n) {
+			u.add(n);
+			var l = n.componentWillUnmount;
+			n.componentWillUnmount = function() {
+				u && u.delete(n), l && l.call(n);
+			};
+		}), n.children;
+	}
+	return l.__c = "__cC" + y$3++, l.__ = n, l.Provider = l.__l = (l.Consumer = function(n, l) {
+		return n.children(l);
+	}).contextType = l, l;
+}
+n$1 = w$3.slice, l$3 = { __e: function(n, l, u, t) {
+	for (var i, r, o; l = l.__;) if ((i = l.__c) && !i.__) try {
+		if ((r = i.constructor) && null != r.getDerivedStateFromError && (i.setState(r.getDerivedStateFromError(n)), o = i.__d), null != i.componentDidCatch && (i.componentDidCatch(n, t || {}), o = i.__d), o) return i.__E = i;
+	} catch (l) {
+		n = l;
+	}
+	throw n;
+} }, u$3 = 0, t$2 = function(n) {
+	return null != n && void 0 === n.constructor;
+}, C$1.prototype.setState = function(n, l) {
+	var u = null != this.__s && this.__s != this.state ? this.__s : this.__s = m$3({}, this.state);
+	"function" == typeof n && (n = n(m$3({}, u), this.props)), n && m$3(u, n), null != n && this.__v && (l && this._sb.push(l), A$2(this));
+}, C$1.prototype.forceUpdate = function(n) {
+	this.__v && (this.__e = !0, n && this.__h.push(n), A$2(this));
+}, C$1.prototype.render = S$1, i$3 = [], o$3 = "function" == typeof Promise ? Promise.prototype.then.bind(Promise.resolve()) : setTimeout, e$2 = function(n, l) {
+	return n.__v.__b - l.__v.__b;
+}, H$1.__r = 0, f$3 = Math.random().toString(8), c$2 = "__d" + f$3, a$2 = "__a" + f$3, s$2 = /(PointerCapture)$|Capture$/i, h$3 = 0, p$3 = V$1(!1), v$2 = V$1(!0), y$3 = 0;
+//#endregion
+//#region node_modules/.pnpm/preact@10.29.2/node_modules/preact/hooks/dist/hooks.module.js
+var t$1, r$1, u$2, i$2, o$2 = 0, f$2 = [], c$1 = l$3, e$1 = c$1.__b, a$1 = c$1.__r, v$1 = c$1.diffed, l$2 = c$1.__c, m$2 = c$1.unmount, s$1 = c$1.__;
+function p$2(n, t) {
+	c$1.__h && c$1.__h(r$1, n, o$2 || t), o$2 = 0;
+	var u = r$1.__H || (r$1.__H = {
+		__: [],
+		__h: []
+	});
+	return n >= u.__.length && u.__.push({}), u.__[n];
+}
+function d$2(n) {
+	return o$2 = 1, h$2(D, n);
+}
+function h$2(n, u, i) {
+	var o = p$2(t$1++, 2);
+	if (o.t = n, !o.__c && (o.__ = [i ? i(u) : D(void 0, u), function(n) {
+		var t = o.__N ? o.__N[0] : o.__[0], r = o.t(t, n);
+		t !== r && (o.__N = [r, o.__[1]], o.__c.setState({}));
+	}], o.__c = r$1, !r$1.__f)) {
+		var f = function(n, t, r) {
+			if (!o.__c.__H) return !0;
+			var u = o.__c.__H.__.filter(function(n) {
+				return n.__c;
+			});
+			if (u.every(function(n) {
+				return !n.__N;
+			})) return !c || c.call(this, n, t, r);
+			var i = o.__c.props !== n;
+			return u.some(function(n) {
+				if (n.__N) {
+					var t = n.__[0];
+					n.__ = n.__N, n.__N = void 0, t !== n.__[0] && (i = !0);
+				}
+			}), c && c.call(this, n, t, r) || i;
+		};
+		r$1.__f = !0;
+		var c = r$1.shouldComponentUpdate, e = r$1.componentWillUpdate;
+		r$1.componentWillUpdate = function(n, t, r) {
+			if (this.__e) {
+				var u = c;
+				c = void 0, f(n, t, r), c = u;
+			}
+			e && e.call(this, n, t, r);
+		}, r$1.shouldComponentUpdate = f;
+	}
+	return o.__N || o.__;
+}
+function y$2(n, u) {
+	var i = p$2(t$1++, 3);
+	!c$1.__s && C(i.__H, u) && (i.__ = n, i.u = u, r$1.__H.__h.push(i));
+}
+function _$2(n, u) {
+	var i = p$2(t$1++, 4);
+	!c$1.__s && C(i.__H, u) && (i.__ = n, i.u = u, r$1.__h.push(i));
+}
+function A$1(n) {
+	return o$2 = 5, T$1(function() {
+		return { current: n };
+	}, []);
+}
+function T$1(n, r) {
+	var u = p$2(t$1++, 7);
+	return C(u.__H, r) && (u.__ = n(), u.__H = r, u.__h = n), u.__;
+}
+function g$3() {
+	var n = p$2(t$1++, 11);
+	if (!n.__) {
+		for (var u = r$1.__v; null !== u && !u.__m && null !== u.__;) u = u.__;
+		var i = u.__m || (u.__m = [0, 0]);
+		n.__ = "P" + i[0] + "-" + i[1]++;
+	}
+	return n.__;
+}
+function j$2() {
+	for (var n; n = f$2.shift();) {
+		var t = n.__H;
+		if (n.__P && t) try {
+			t.__h.some(z), t.__h.some(B$1), t.__h = [];
+		} catch (r) {
+			t.__h = [], c$1.__e(r, n.__v);
+		}
+	}
+}
+c$1.__b = function(n) {
+	r$1 = null, e$1 && e$1(n);
+}, c$1.__ = function(n, t) {
+	n && t.__k && t.__k.__m && (n.__m = t.__k.__m), s$1 && s$1(n, t);
+}, c$1.__r = function(n) {
+	a$1 && a$1(n), t$1 = 0;
+	var i = (r$1 = n.__c).__H;
+	i && (u$2 === r$1 ? (i.__h = [], r$1.__h = [], i.__.some(function(n) {
+		n.__N && (n.__ = n.__N), n.u = n.__N = void 0;
+	})) : (i.__h.some(z), i.__h.some(B$1), i.__h = [], t$1 = 0)), u$2 = r$1;
+}, c$1.diffed = function(n) {
+	v$1 && v$1(n);
+	var t = n.__c;
+	t && t.__H && (t.__H.__h.length && (1 !== f$2.push(t) && i$2 === c$1.requestAnimationFrame || ((i$2 = c$1.requestAnimationFrame) || w$2)(j$2)), t.__H.__.some(function(n) {
+		n.u && (n.__H = n.u), n.u = void 0;
+	})), u$2 = r$1 = null;
+}, c$1.__c = function(n, t) {
+	t.some(function(n) {
+		try {
+			n.__h.some(z), n.__h = n.__h.filter(function(n) {
+				return !n.__ || B$1(n);
+			});
+		} catch (r) {
+			t.some(function(n) {
+				n.__h && (n.__h = []);
+			}), t = [], c$1.__e(r, n.__v);
+		}
+	}), l$2 && l$2(n, t);
+}, c$1.unmount = function(n) {
+	m$2 && m$2(n);
+	var t, r = n.__c;
+	r && r.__H && (r.__H.__.some(function(n) {
+		try {
+			z(n);
+		} catch (n) {
+			t = n;
+		}
+	}), r.__H = void 0, t && c$1.__e(t, r.__v));
+};
+var k$1 = "function" == typeof requestAnimationFrame;
+function w$2(n) {
+	var t, r = function() {
+		clearTimeout(u), k$1 && cancelAnimationFrame(t), setTimeout(n);
+	}, u = setTimeout(r, 35);
+	k$1 && (t = requestAnimationFrame(r));
+}
+function z(n) {
+	var t = r$1, u = n.__c;
+	"function" == typeof u && (n.__c = void 0, u()), r$1 = t;
+}
+function B$1(n) {
+	var t = r$1;
+	n.__c = n.__(), r$1 = t;
+}
+function C(n, t) {
+	return !n || n.length !== t.length || t.some(function(t, r) {
+		return t !== n[r];
+	});
+}
+function D(n, t) {
+	return "function" == typeof t ? t(n) : t;
+}
+//#endregion
+//#region node_modules/.pnpm/@preact+signals-core@1.14.3/node_modules/@preact/signals-core/dist/signals-core.module.js
+var i$1 = Symbol.for("preact-signals");
+function t() {
+	if (!(s > 1)) {
+		var i, t = !1;
+		(function() {
+			var i = c;
+			c = void 0;
+			while (void 0 !== i) {
+				if (i.S.v === i.v) i.S.i = i.i;
+				i = i.o;
+			}
+		})();
+		while (void 0 !== h$1) {
+			var n = h$1;
+			h$1 = void 0;
+			v++;
+			while (void 0 !== n) {
+				var r = n.u;
+				n.u = void 0;
+				n.f &= -3;
+				if (!(8 & n.f) && w$1(n)) try {
+					n.c();
+				} catch (n) {
+					if (!t) {
+						i = n;
+						t = !0;
+					}
+				}
+				n = r;
+			}
+		}
+		v = 0;
+		s--;
+		if (t) throw i;
+	} else s--;
+}
+function n(i) {
+	if (s > 0) return i();
+	e = ++u$1;
+	s++;
+	try {
+		return i();
+	} finally {
+		t();
+	}
+}
+var r = void 0;
+function o$1(i) {
+	var t = r;
+	r = void 0;
+	try {
+		return i();
+	} finally {
+		r = t;
+	}
+}
+var f$1, h$1 = void 0, s = 0, v = 0, u$1 = 0, e = 0, c = void 0, d$1 = 0;
+function a(i) {
+	if (void 0 !== r) {
+		var t = i.n;
+		if (void 0 === t || t.t !== r) {
+			t = {
+				i: 0,
+				S: i,
+				p: r.s,
+				n: void 0,
+				t: r,
+				e: void 0,
+				x: void 0,
+				r: t
+			};
+			if (void 0 !== r.s) r.s.n = t;
+			r.s = t;
+			i.n = t;
+			if (32 & r.f) i.S(t);
+			return t;
+		} else if (-1 === t.i) {
+			t.i = 0;
+			if (void 0 !== t.n) {
+				t.n.p = t.p;
+				if (void 0 !== t.p) t.p.n = t.n;
+				t.p = r.s;
+				t.n = void 0;
+				r.s.n = t;
+				r.s = t;
+			}
+			return t;
+		}
+	}
+}
+function l$1(i, t) {
+	this.v = i;
+	this.i = 0;
+	this.n = void 0;
+	this.t = void 0;
+	this.l = 0;
+	this.W = null == t ? void 0 : t.watched;
+	this.Z = null == t ? void 0 : t.unwatched;
+	this.name = null == t ? void 0 : t.name;
+}
+l$1.prototype.brand = i$1;
+l$1.prototype.h = function() {
+	return !0;
+};
+l$1.prototype.S = function(i) {
+	var t = this, n = this.t;
+	if (n !== i && void 0 === i.e) {
+		i.x = n;
+		this.t = i;
+		if (void 0 !== n) n.e = i;
+		else o$1(function() {
+			var i;
+			null == (i = t.W) || i.call(t);
+		});
+	}
+};
+l$1.prototype.U = function(i) {
+	var t = this;
+	if (void 0 !== this.t) {
+		var n = i.e, r = i.x;
+		if (void 0 !== n) {
+			n.x = r;
+			i.e = void 0;
+		}
+		if (void 0 !== r) {
+			r.e = n;
+			i.x = void 0;
+		}
+		if (i === this.t) {
+			this.t = r;
+			if (void 0 === r) o$1(function() {
+				var i;
+				null == (i = t.Z) || i.call(t);
+			});
+		}
+	}
+};
+l$1.prototype.subscribe = function(i) {
+	var t = this;
+	return j$1(function() {
+		var n = t.value;
+		o$1(function() {
+			return i(n);
+		});
+	}, { name: "sub" });
+};
+l$1.prototype.valueOf = function() {
+	return this.value;
+};
+l$1.prototype.toString = function() {
+	return this.value + "";
+};
+l$1.prototype.toJSON = function() {
+	return this.value;
+};
+l$1.prototype.peek = function() {
+	var i = this;
+	return o$1(function() {
+		return i.value;
+	});
+};
+Object.defineProperty(l$1.prototype, "value", {
+	get: function() {
+		var i = a(this);
+		if (void 0 !== i) i.i = this.i;
+		return this.v;
+	},
+	set: function(i) {
+		if (i !== this.v) {
+			if (v > 100) throw new Error("Cycle detected");
+			(function(i) {
+				if (0 !== s && 0 === v) {
+					if (i.l !== e) {
+						i.l = e;
+						c = {
+							S: i,
+							v: i.v,
+							i: i.i,
+							o: c
+						};
+					}
+				}
+			})(this);
+			this.v = i;
+			this.i++;
+			d$1++;
+			s++;
+			try {
+				for (var n = this.t; void 0 !== n; n = n.x) n.t.N();
+			} finally {
+				t();
+			}
+		}
+	}
+});
+function y$1(i, t) {
+	return new l$1(i, t);
+}
+function w$1(i) {
+	for (var t = i.s; void 0 !== t; t = t.n) if (t.S.i !== t.i || !t.S.h() || t.S.i !== t.i) return !0;
+	return !1;
+}
+function _$1(i) {
+	for (var t = i.s; void 0 !== t; t = t.n) {
+		var n = t.S.n;
+		if (void 0 !== n) t.r = n;
+		t.S.n = t;
+		t.i = -1;
+		if (void 0 === t.n) {
+			i.s = t;
+			break;
+		}
+	}
+}
+function b$1(i) {
+	var t = i.s, n = void 0;
+	while (void 0 !== t) {
+		var r = t.p;
+		if (-1 === t.i) {
+			t.S.U(t);
+			if (void 0 !== r) r.n = t.n;
+			if (void 0 !== t.n) t.n.p = r;
+		} else n = t;
+		t.S.n = t.r;
+		if (void 0 !== t.r) t.r = void 0;
+		t = r;
+	}
+	i.s = n;
+}
+function p$1(i, t) {
+	l$1.call(this, void 0, t);
+	this.x = i;
+	this.s = void 0;
+	this.g = d$1 - 1;
+	this.f = 4;
+}
+p$1.prototype = new l$1();
+p$1.prototype.h = function() {
+	this.f &= -3;
+	if (1 & this.f) return !1;
+	if (32 == (36 & this.f)) return !0;
+	this.f &= -5;
+	if (this.g === d$1) return !0;
+	this.g = d$1;
+	this.f |= 1;
+	if (this.i > 0 && !w$1(this)) {
+		this.f &= -2;
+		return !0;
+	}
+	var i = r;
+	try {
+		_$1(this);
+		r = this;
+		var t = this.x();
+		if (16 & this.f || this.v !== t || 0 === this.i) {
+			this.v = t;
+			this.f &= -17;
+			this.i++;
+		}
+	} catch (i) {
+		this.v = i;
+		this.f |= 16;
+		this.i++;
+	}
+	r = i;
+	b$1(this);
+	this.f &= -2;
+	return !0;
+};
+p$1.prototype.S = function(i) {
+	if (void 0 === this.t) {
+		this.f |= 36;
+		for (var t = this.s; void 0 !== t; t = t.n) t.S.S(t);
+	}
+	l$1.prototype.S.call(this, i);
+};
+p$1.prototype.U = function(i) {
+	if (void 0 !== this.t) {
+		l$1.prototype.U.call(this, i);
+		if (void 0 === this.t) {
+			this.f &= -33;
+			for (var t = this.s; void 0 !== t; t = t.n) t.S.U(t);
+		}
+	}
+};
+p$1.prototype.N = function() {
+	if (!(2 & this.f)) {
+		this.f |= 6;
+		for (var i = this.t; void 0 !== i; i = i.x) i.t.N();
+	}
+};
+Object.defineProperty(p$1.prototype, "value", { get: function() {
+	if (1 & this.f) throw new Error("Cycle detected");
+	var i = a(this);
+	this.h();
+	if (void 0 !== i) i.i = this.i;
+	if (16 & this.f) throw this.v;
+	return this.v;
+} });
+function g$2(i, t) {
+	return new p$1(i, t);
+}
+function S(i) {
+	var n = i.m;
+	i.m = void 0;
+	if ("function" == typeof n) {
+		s++;
+		var o = r;
+		r = void 0;
+		try {
+			n();
+		} catch (t) {
+			i.f &= -2;
+			i.f |= 8;
+			m$1(i);
+			throw t;
+		} finally {
+			r = o;
+			t();
+		}
+	}
+}
+function m$1(i) {
+	for (var t = i.s; void 0 !== t; t = t.n) t.S.U(t);
+	i.x = void 0;
+	i.s = void 0;
+	S(i);
+}
+function x$1(i) {
+	if (r !== this) throw new Error("Out-of-order effect");
+	b$1(this);
+	r = i;
+	this.f &= -2;
+	if (8 & this.f) m$1(this);
+	t();
+}
+function E$1(i, t) {
+	this.x = i;
+	this.m = void 0;
+	this.s = void 0;
+	this.u = void 0;
+	this.f = 32;
+	this.name = null == t ? void 0 : t.name;
+	if (f$1) f$1.push(this);
+}
+E$1.prototype.c = function() {
+	var i = this.S();
+	try {
+		if (8 & this.f) return;
+		if (void 0 === this.x) return;
+		var t = this.x();
+		if ("function" == typeof t) this.m = t;
+	} finally {
+		i();
+	}
+};
+E$1.prototype.S = function() {
+	if (1 & this.f) throw new Error("Cycle detected");
+	this.f |= 1;
+	this.f &= -9;
+	S(this);
+	_$1(this);
+	s++;
+	var i = r;
+	r = this;
+	return x$1.bind(this, i);
+};
+E$1.prototype.N = function() {
+	if (!(2 & this.f)) {
+		this.f |= 2;
+		this.u = h$1;
+		h$1 = this;
+	}
+};
+E$1.prototype.d = function() {
+	this.f |= 8;
+	if (!(1 & this.f)) m$1(this);
+};
+E$1.prototype.dispose = function() {
+	this.d();
+};
+function j$1(i, t) {
+	var n = new E$1(i, t);
+	try {
+		n.c();
+	} catch (i) {
+		n.d();
+		throw i;
+	}
+	var r = n.d.bind(n);
+	r[Symbol.dispose] = r;
+	return r;
+}
+//#endregion
+//#region node_modules/.pnpm/@preact+signals@2.9.2_preact@10.29.2/node_modules/@preact/signals/dist/signals.module.js
+var l, h, p = "undefined" != typeof window && !!window.__PREACT_SIGNALS_DEVTOOLS__, _ = [];
+j$1(function() {
+	l = this.N;
+})();
+function g$1(i, r) {
+	l$3[i] = r.bind(null, l$3[i] || function() {});
+}
+function b(i) {
+	if (h) {
+		var n = h;
+		h = void 0;
+		n();
+	}
+	h = i && i.S();
+}
+function y(i) {
+	var n = this, t = i.data, f = useSignal(t);
+	f.value = t;
+	var e = T$1(function() {
+		var i = n, t = n.__v;
+		while (t = t.__) if (t.__c) {
+			t.__c.__$f |= 4;
+			break;
+		}
+		var o = g$2(function() {
+			var i = f.value.value;
+			return 0 === i ? 0 : !0 === i ? "" : i || "";
+		}), e = g$2(function() {
+			return !Array.isArray(o.value) && !t$2(o.value);
+		}), a = j$1(function() {
+			this.N = F$1;
+			if (e.value) {
+				var n = o.value;
+				if (i.__v && i.__v.__e && 3 === i.__v.__e.nodeType) i.__v.__e.data = n;
+			}
+		}), v = n.__$u.d;
+		n.__$u.d = function() {
+			a();
+			v.call(this);
+		};
+		return [e, o];
+	}, []), a = e[0], v = e[1];
+	return a.value ? v.peek() : v.value;
+}
+y.displayName = "ReactiveTextNode";
+Object.defineProperties(l$1.prototype, {
+	constructor: {
+		configurable: !0,
+		value: void 0
+	},
+	type: {
+		configurable: !0,
+		value: y
+	},
+	props: {
+		configurable: !0,
+		get: function() {
+			var i = this;
+			return { data: { get value() {
+				return i.value;
+			} } };
+		}
+	},
+	__b: {
+		configurable: !0,
+		value: 1
+	}
+});
+g$1("__b", function(i, n) {
+	if ("string" == typeof n.type) {
+		var r, t = n.props;
+		for (var o in t) if ("children" !== o) {
+			var f = t[o];
+			if (f instanceof l$1) {
+				if (!r) n.__np = r = {};
+				r[o] = f;
+				t[o] = f.peek();
+			}
+		}
+	}
+	i(n);
+});
+g$1("__r", function(i, n) {
+	i(n);
+	if (n.type !== S$1) {
+		b();
+		var r, o = n.__c;
+		if (o) {
+			o.__$f &= -2;
+			if (void 0 === (r = o.__$u)) o.__$u = r = function(i, n) {
+				var r;
+				j$1(function() {
+					r = this;
+				}, { name: n });
+				r.c = i;
+				return r;
+			}(function() {
+				var i;
+				if (p) null == (i = r.y) || i.call(r);
+				o.__$f |= 1;
+				o.setState({});
+			}, "function" == typeof n.type ? n.type.displayName || n.type.name : "");
+		}
+		b(r);
+	}
+});
+g$1("__e", function(i, n, r, t) {
+	b();
+	i(n, r, t);
+});
+g$1("diffed", function(i, n) {
+	b();
+	var r;
+	if ("string" == typeof n.type && (r = n.__e)) {
+		var t = n.__np, o = n.props;
+		if (t) {
+			var f = r.U;
+			if (f) for (var e in f) {
+				var u = f[e];
+				if (void 0 !== u && !(e in t)) {
+					u.d();
+					f[e] = void 0;
+				}
+			}
+			else {
+				f = {};
+				r.U = f;
+			}
+			for (var a in t) {
+				var c = f[a], v = t[a];
+				if (void 0 === c) {
+					c = w(r, a, v, o);
+					f[a] = c;
+				} else c.o(v, o);
+			}
+		}
+	}
+	i(n);
+});
+function w(i, n, r, t) {
+	var o = n in i && void 0 === i.ownerSVGElement, f = y$1(r);
+	return {
+		o: function(i, n) {
+			f.value = i;
+			t = n;
+		},
+		d: j$1(function() {
+			this.N = F$1;
+			var r = f.value.value;
+			if (t[n] !== r) {
+				t[n] = r;
+				if (o) i[n] = r;
+				else if (null != r && (!1 !== r || "-" === n[4])) i.setAttribute(n, r);
+				else i.removeAttribute(n);
+			}
+		})
+	};
+}
+g$1("unmount", function(i, n) {
+	if ("string" == typeof n.type) {
+		var r = n.__e;
+		if (r) {
+			var t = r.U;
+			if (t) {
+				r.U = void 0;
+				for (var o in t) {
+					var f = t[o];
+					if (f) f.d();
+				}
+			}
+		}
+		var e = n.__np;
+		if (e) {
+			var u = n.props;
+			for (var a in e) u[a] = e[a];
+		}
+		n.__np = void 0;
+	} else {
+		var c = n.__c;
+		if (c) {
+			var v = c.__$u;
+			if (v) {
+				c.__$u = void 0;
+				v.d();
+			}
+		}
+	}
+	i(n);
+});
+g$1("__h", function(i, n, r, t) {
+	if (t < 3 || 9 === t) n.__$f |= 2;
+	i(n, r, t);
+});
+C$1.prototype.shouldComponentUpdate = function(i, n) {
+	if (this.__R) return !0;
+	var r = this.__$u, t = r && void 0 !== r.s;
+	for (var o in n) return !0;
+	if (this.__f || "boolean" == typeof this.u && !0 === this.u) {
+		var f = 2 & this.__$f;
+		if (!(t || f || 4 & this.__$f)) return !0;
+		if (1 & this.__$f) return !0;
+	} else {
+		if (!(t || 4 & this.__$f)) return !0;
+		if (3 & this.__$f) return !0;
+	}
+	for (var e in i) if ("__source" !== e && i[e] !== this.props[e]) return !0;
+	for (var u in this.props) if (!(u in i)) return !0;
+	return !1;
+};
+function useSignal(i, n) {
+	return T$1(function() {
+		return y$1(i, n);
+	}, []);
+}
+var q$1 = function(i) {
+	queueMicrotask(function() {
+		queueMicrotask(i);
+	});
+};
+function x() {
+	n(function() {
+		var i;
+		while (i = _.shift()) l.call(i);
+	});
+}
+function F$1() {
+	if (1 === _.push(this)) (l$3.requestAnimationFrame || q$1)(x);
+}
+//#endregion
+//#region node_modules/.pnpm/preact@10.29.2/node_modules/preact/jsx-runtime/dist/jsxRuntime.module.js
+var f = 0;
+Array.isArray;
+function u(e, t, n, o, i, u) {
+	t || (t = {});
+	var a, c, p = t;
+	if ("ref" in p) for (c in p = {}, t) "ref" == c ? a = t[c] : p[c] = t[c];
+	var l = {
+		type: e,
+		props: p,
+		key: n,
+		ref: a,
+		__k: null,
+		__: null,
+		__b: 0,
+		__e: null,
+		__c: null,
+		constructor: void 0,
+		__v: --f,
+		__i: -1,
+		__u: 0,
+		__source: i,
+		__self: u
+	};
+	if ("function" == typeof e && (a = e.defaultProps)) for (c in a) void 0 === p[c] && (p[c] = a[c]);
+	return l$3.vnode && l$3.vnode(l), l;
+}
+/*!
+* tabbable 6.4.0
+* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
+*/
+var candidateSelector = /* @__PURE__ */ [
+	"input:not([inert]):not([inert] *)",
+	"select:not([inert]):not([inert] *)",
+	"textarea:not([inert]):not([inert] *)",
+	"a[href]:not([inert]):not([inert] *)",
+	"button:not([inert]):not([inert] *)",
+	"[tabindex]:not(slot):not([inert]):not([inert] *)",
+	"audio[controls]:not([inert]):not([inert] *)",
+	"video[controls]:not([inert]):not([inert] *)",
+	"[contenteditable]:not([contenteditable=\"false\"]):not([inert]):not([inert] *)",
+	"details>summary:first-of-type:not([inert]):not([inert] *)",
+	"details:not([inert]):not([inert] *)"
+].join(",");
+var NoElement = typeof Element === "undefined";
+var matches = NoElement ? function() {} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
+var getRootNode = !NoElement && Element.prototype.getRootNode ? function(element) {
+	var _element$getRootNode;
+	return element === null || element === void 0 ? void 0 : (_element$getRootNode = element.getRootNode) === null || _element$getRootNode === void 0 ? void 0 : _element$getRootNode.call(element);
+} : function(element) {
+	return element === null || element === void 0 ? void 0 : element.ownerDocument;
+};
+/**
+* Determines if a node is inert or in an inert ancestor.
+* @param {Node} [node]
+* @param {boolean} [lookUp] If true and `node` is not inert, looks up at ancestors to
+*  see if any of them are inert. If false, only `node` itself is considered.
+* @returns {boolean} True if inert itself or by way of being in an inert ancestor.
+*  False if `node` is falsy.
+*/
+var _isInert = function isInert(node, lookUp) {
+	var _node$getAttribute;
+	if (lookUp === void 0) lookUp = true;
+	var inertAtt = node === null || node === void 0 ? void 0 : (_node$getAttribute = node.getAttribute) === null || _node$getAttribute === void 0 ? void 0 : _node$getAttribute.call(node, "inert");
+	return inertAtt === "" || inertAtt === "true" || lookUp && node && (typeof node.closest === "function" ? node.closest("[inert]") : _isInert(node.parentNode));
+};
+/**
+* Determines if a node's content is editable.
+* @param {Element} [node]
+* @returns True if it's content-editable; false if it's not or `node` is falsy.
+*/
+var isContentEditable = function isContentEditable(node) {
+	var _node$getAttribute2;
+	var attValue = node === null || node === void 0 ? void 0 : (_node$getAttribute2 = node.getAttribute) === null || _node$getAttribute2 === void 0 ? void 0 : _node$getAttribute2.call(node, "contenteditable");
+	return attValue === "" || attValue === "true";
+};
+/**
+* @param {Element} el container to check in
+* @param {boolean} includeContainer add container to check
+* @param {(node: Element) => boolean} filter filter candidates
+* @returns {Element[]}
+*/
+var getCandidates = function getCandidates(el, includeContainer, filter) {
+	if (_isInert(el)) return [];
+	var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
+	if (includeContainer && matches.call(el, candidateSelector)) candidates.unshift(el);
+	candidates = candidates.filter(filter);
+	return candidates;
+};
+/**
+* @callback GetShadowRoot
+* @param {Element} element to check for shadow root
+* @returns {ShadowRoot|boolean} ShadowRoot if available or boolean indicating if a shadowRoot is attached but not available.
+*/
+/**
+* @callback ShadowRootFilter
+* @param {Element} shadowHostNode the element which contains shadow content
+* @returns {boolean} true if a shadow root could potentially contain valid candidates.
+*/
+/**
+* @typedef {Object} CandidateScope
+* @property {Element} scopeParent contains inner candidates
+* @property {Element[]} candidates list of candidates found in the scope parent
+*/
+/**
+* @typedef {Object} IterativeOptions
+* @property {GetShadowRoot|boolean} getShadowRoot true if shadow support is enabled; falsy if not;
+*  if a function, implies shadow support is enabled and either returns the shadow root of an element
+*  or a boolean stating if it has an undisclosed shadow root
+* @property {(node: Element) => boolean} filter filter candidates
+* @property {boolean} flatten if true then result will flatten any CandidateScope into the returned list
+* @property {ShadowRootFilter} shadowRootFilter filter shadow roots;
+*/
+/**
+* @param {Element[]} elements list of element containers to match candidates from
+* @param {boolean} includeContainer add container list to check
+* @param {IterativeOptions} options
+* @returns {Array.<Element|CandidateScope>}
+*/
+var _getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {
+	var candidates = [];
+	var elementsToCheck = Array.from(elements);
+	while (elementsToCheck.length) {
+		var element = elementsToCheck.shift();
+		if (_isInert(element, false)) continue;
+		if (element.tagName === "SLOT") {
+			var assigned = element.assignedElements();
+			var nestedCandidates = _getCandidatesIteratively(assigned.length ? assigned : element.children, true, options);
+			if (options.flatten) candidates.push.apply(candidates, nestedCandidates);
+			else candidates.push({
+				scopeParent: element,
+				candidates: nestedCandidates
+			});
+		} else {
+			if (matches.call(element, candidateSelector) && options.filter(element) && (includeContainer || !elements.includes(element))) candidates.push(element);
+			var shadowRoot = element.shadowRoot || typeof options.getShadowRoot === "function" && options.getShadowRoot(element);
+			var validShadowRoot = !_isInert(shadowRoot, false) && (!options.shadowRootFilter || options.shadowRootFilter(element));
+			if (shadowRoot && validShadowRoot) {
+				var _nestedCandidates = _getCandidatesIteratively(shadowRoot === true ? element.children : shadowRoot.children, true, options);
+				if (options.flatten) candidates.push.apply(candidates, _nestedCandidates);
+				else candidates.push({
+					scopeParent: element,
+					candidates: _nestedCandidates
+				});
+			} else elementsToCheck.unshift.apply(elementsToCheck, element.children);
+		}
+	}
+	return candidates;
+};
+/**
+* @private
+* Determines if the node has an explicitly specified `tabindex` attribute.
+* @param {HTMLElement} node
+* @returns {boolean} True if so; false if not.
+*/
+var hasTabIndex = function hasTabIndex(node) {
+	return !isNaN(parseInt(node.getAttribute("tabindex"), 10));
+};
+/**
+* Determine the tab index of a given node.
+* @param {HTMLElement} node
+* @returns {number} Tab order (negative, 0, or positive number).
+* @throws {Error} If `node` is falsy.
+*/
+var getTabIndex = function getTabIndex(node) {
+	if (!node) throw new Error("No node provided");
+	if (node.tabIndex < 0) {
+		if ((/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || isContentEditable(node)) && !hasTabIndex(node)) return 0;
+	}
+	return node.tabIndex;
+};
+/**
+* Determine the tab index of a given node __for sort order purposes__.
+* @param {HTMLElement} node
+* @param {boolean} [isScope] True for a custom element with shadow root or slot that, by default,
+*  has tabIndex -1, but needs to be sorted by document order in order for its content to be
+*  inserted into the correct sort position.
+* @returns {number} Tab order (negative, 0, or positive number).
+*/
+var getSortOrderTabIndex = function getSortOrderTabIndex(node, isScope) {
+	var tabIndex = getTabIndex(node);
+	if (tabIndex < 0 && isScope && !hasTabIndex(node)) return 0;
+	return tabIndex;
+};
+var sortOrderedTabbables = function sortOrderedTabbables(a, b) {
+	return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
+};
+var isInput = function isInput(node) {
+	return node.tagName === "INPUT";
+};
+var isHiddenInput = function isHiddenInput(node) {
+	return isInput(node) && node.type === "hidden";
+};
+var isDetailsWithSummary = function isDetailsWithSummary(node) {
+	return node.tagName === "DETAILS" && Array.prototype.slice.apply(node.children).some(function(child) {
+		return child.tagName === "SUMMARY";
+	});
+};
+var getCheckedRadio = function getCheckedRadio(nodes, form) {
+	for (var i = 0; i < nodes.length; i++) if (nodes[i].checked && nodes[i].form === form) return nodes[i];
+};
+var isTabbableRadio = function isTabbableRadio(node) {
+	if (!node.name) return true;
+	var radioScope = node.form || getRootNode(node);
+	var queryRadios = function queryRadios(name) {
+		return radioScope.querySelectorAll("input[type=\"radio\"][name=\"" + name + "\"]");
+	};
+	var radioSet;
+	if (typeof window !== "undefined" && typeof window.CSS !== "undefined" && typeof window.CSS.escape === "function") radioSet = queryRadios(window.CSS.escape(node.name));
+	else try {
+		radioSet = queryRadios(node.name);
+	} catch (err) {
+		console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", err.message);
+		return false;
+	}
+	var checked = getCheckedRadio(radioSet, node.form);
+	return !checked || checked === node;
+};
+var isRadio = function isRadio(node) {
+	return isInput(node) && node.type === "radio";
+};
+var isNonTabbableRadio = function isNonTabbableRadio(node) {
+	return isRadio(node) && !isTabbableRadio(node);
+};
+var isNodeAttached = function isNodeAttached(node) {
+	var _nodeRoot;
+	var nodeRoot = node && getRootNode(node);
+	var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;
+	var attached = false;
+	if (nodeRoot && nodeRoot !== node) {
+		var _nodeRootHost, _nodeRootHost$ownerDo, _node$ownerDocument;
+		attached = !!((_nodeRootHost = nodeRootHost) !== null && _nodeRootHost !== void 0 && (_nodeRootHost$ownerDo = _nodeRootHost.ownerDocument) !== null && _nodeRootHost$ownerDo !== void 0 && _nodeRootHost$ownerDo.contains(nodeRootHost) || node !== null && node !== void 0 && (_node$ownerDocument = node.ownerDocument) !== null && _node$ownerDocument !== void 0 && _node$ownerDocument.contains(node));
+		while (!attached && nodeRootHost) {
+			var _nodeRoot2, _nodeRootHost2, _nodeRootHost2$ownerD;
+			nodeRoot = getRootNode(nodeRootHost);
+			nodeRootHost = (_nodeRoot2 = nodeRoot) === null || _nodeRoot2 === void 0 ? void 0 : _nodeRoot2.host;
+			attached = !!((_nodeRootHost2 = nodeRootHost) !== null && _nodeRootHost2 !== void 0 && (_nodeRootHost2$ownerD = _nodeRootHost2.ownerDocument) !== null && _nodeRootHost2$ownerD !== void 0 && _nodeRootHost2$ownerD.contains(nodeRootHost));
+		}
+	}
+	return attached;
+};
+var isZeroArea = function isZeroArea(node) {
+	var _node$getBoundingClie = node.getBoundingClientRect(), width = _node$getBoundingClie.width, height = _node$getBoundingClie.height;
+	return width === 0 && height === 0;
+};
+var isHidden = function isHidden(node, _ref) {
+	var displayCheck = _ref.displayCheck, getShadowRoot = _ref.getShadowRoot;
+	if (displayCheck === "full-native") {
+		if ("checkVisibility" in node) return !node.checkVisibility({
+			checkOpacity: false,
+			opacityProperty: false,
+			contentVisibilityAuto: true,
+			visibilityProperty: true,
+			checkVisibilityCSS: true
+		});
+	}
+	if (getComputedStyle(node).visibility === "hidden") return true;
+	var nodeUnderDetails = matches.call(node, "details>summary:first-of-type") ? node.parentElement : node;
+	if (matches.call(nodeUnderDetails, "details:not([open]) *")) return true;
+	if (!displayCheck || displayCheck === "full" || displayCheck === "full-native" || displayCheck === "legacy-full") {
+		if (typeof getShadowRoot === "function") {
+			var originalNode = node;
+			while (node) {
+				var parentElement = node.parentElement;
+				var rootNode = getRootNode(node);
+				if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true) return isZeroArea(node);
+				else if (node.assignedSlot) node = node.assignedSlot;
+				else if (!parentElement && rootNode !== node.ownerDocument) node = rootNode.host;
+				else node = parentElement;
+			}
+			node = originalNode;
+		}
+		if (isNodeAttached(node)) return !node.getClientRects().length;
+		if (displayCheck !== "legacy-full") return true;
+	} else if (displayCheck === "non-zero-area") return isZeroArea(node);
+	return false;
+};
+var isDisabledFromFieldset = function isDisabledFromFieldset(node) {
+	if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {
+		var parentNode = node.parentElement;
+		while (parentNode) {
+			if (parentNode.tagName === "FIELDSET" && parentNode.disabled) {
+				for (var i = 0; i < parentNode.children.length; i++) {
+					var child = parentNode.children.item(i);
+					if (child.tagName === "LEGEND") return matches.call(parentNode, "fieldset[disabled] *") ? true : !child.contains(node);
+				}
+				return true;
+			}
+			parentNode = parentNode.parentElement;
+		}
+	}
+	return false;
+};
+var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable(options, node) {
+	if (node.disabled || isHiddenInput(node) || isHidden(node, options) || isDetailsWithSummary(node) || isDisabledFromFieldset(node)) return false;
+	return true;
+};
+var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable(options, node) {
+	if (isNonTabbableRadio(node) || getTabIndex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) return false;
+	return true;
+};
+var isShadowRootTabbable = function isShadowRootTabbable(shadowHostNode) {
+	var tabIndex = parseInt(shadowHostNode.getAttribute("tabindex"), 10);
+	if (isNaN(tabIndex) || tabIndex >= 0) return true;
+	return false;
+};
+/**
+* @param {Array.<Element|CandidateScope>} candidates
+* @returns Element[]
+*/
+var _sortByOrder = function sortByOrder(candidates) {
+	var regularTabbables = [];
+	var orderedTabbables = [];
+	candidates.forEach(function(item, i) {
+		var isScope = !!item.scopeParent;
+		var element = isScope ? item.scopeParent : item;
+		var candidateTabindex = getSortOrderTabIndex(element, isScope);
+		var elements = isScope ? _sortByOrder(item.candidates) : element;
+		if (candidateTabindex === 0) isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);
+		else orderedTabbables.push({
+			documentOrder: i,
+			tabIndex: candidateTabindex,
+			item,
+			isScope,
+			content: elements
+		});
+	});
+	return orderedTabbables.sort(sortOrderedTabbables).reduce(function(acc, sortable) {
+		sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);
+		return acc;
+	}, []).concat(regularTabbables);
+};
+var tabbable = function tabbable(container, options) {
+	options = options || {};
+	var candidates;
+	if (options.getShadowRoot) candidates = _getCandidatesIteratively([container], options.includeContainer, {
+		filter: isNodeMatchingSelectorTabbable.bind(null, options),
+		flatten: false,
+		getShadowRoot: options.getShadowRoot,
+		shadowRootFilter: isShadowRootTabbable
+	});
+	else candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
+	return _sortByOrder(candidates);
+};
+//#endregion
+//#region node_modules/.pnpm/preact@10.29.2/node_modules/preact/compat/dist/compat.module.js
+function g(n, t) {
+	for (var e in t) n[e] = t[e];
+	return n;
+}
+function E(n, t) {
+	for (var e in n) if ("__source" !== e && !(e in t)) return !0;
+	for (var r in t) if ("__source" !== r && n[r] !== t[r]) return !0;
+	return !1;
+}
+function M(n, t) {
+	this.props = n, this.context = t;
+}
+(M.prototype = new C$1()).isPureReactComponent = !0, M.prototype.shouldComponentUpdate = function(n, t) {
+	return E(this.props, n) || E(this.state, t);
+};
+var T = l$3.__b;
+l$3.__b = function(n) {
+	n.type && n.type.__f && n.ref && (n.props.ref = n.ref, n.ref = null), T && T(n);
+};
+"undefined" != typeof Symbol && Symbol.for;
+var O = l$3.__e;
+l$3.__e = function(n, t, e, r) {
+	if (n.then) {
+		for (var u, o = t; o = o.__;) if ((u = o.__c) && u.__c) return t.__e ?? (t.__e = e.__e, t.__k = e.__k), u.__c(n, t);
+	}
+	O(n, t, e, r);
+};
+var U = l$3.unmount;
+function V(n, t, e) {
+	return n && (n.__c && n.__c.__H && (n.__c.__H.__.forEach(function(n) {
+		"function" == typeof n.__c && n.__c();
+	}), n.__c.__H = null), null != (n = g({}, n)).__c && (n.__c.__P === e && (n.__c.__P = t), n.__c.__e = !0, n.__c = null), n.__k = n.__k && n.__k.map(function(n) {
+		return V(n, t, e);
+	})), n;
+}
+function W(n, t, e) {
+	return n && e && (n.__v = null, n.__k = n.__k && n.__k.map(function(n) {
+		return W(n, t, e);
+	}), n.__c && n.__c.__P === t && (n.__e && e.appendChild(n.__e), n.__c.__e = !0, n.__c.__P = e)), n;
+}
+function P() {
+	this.__u = 0, this.o = null, this.__b = null;
+}
+function j(n) {
+	var t = n.__ && n.__.__c;
+	return t && t.__a && t.__a(n);
+}
+function B() {
+	this.i = null, this.l = null;
+}
+l$3.unmount = function(n) {
+	var t = n.__c;
+	t && (t.__z = !0), t && t.__R && t.__R(), t && 32 & n.__u && (n.type = null), U && U(n);
+}, (P.prototype = new C$1()).__c = function(n, t) {
+	var e = t.__c, r = this;
+	r.o ??= [], r.o.push(e);
+	var u = j(r.__v), o = !1, i = function() {
+		o || r.__z || (o = !0, e.__R = null, u ? u(c) : c());
+	};
+	e.__R = i;
+	var l = e.__P;
+	e.__P = null;
+	var c = function() {
+		if (!--r.__u) {
+			if (r.state.__a) {
+				var n = r.state.__a;
+				r.__v.__k[0] = W(n, n.__c.__P, n.__c.__O);
+			}
+			var t;
+			for (r.setState({ __a: r.__b = null }); t = r.o.pop();) t.__P = l, t.forceUpdate();
+		}
+	};
+	r.__u++ || 32 & t.__u || r.setState({ __a: r.__b = r.__v.__k[0] }), n.then(i, i);
+}, P.prototype.componentWillUnmount = function() {
+	this.o = [];
+}, P.prototype.render = function(n, e) {
+	if (this.__b) {
+		if (this.__v.__k) {
+			var r = document.createElement("div"), o = this.__v.__k[0].__c;
+			this.__v.__k[0] = V(this.__b, r, o.__O = o.__P);
+		}
+		this.__b = null;
+	}
+	var i = e.__a && k$2(S$1, null, n.fallback);
+	return i && (i.__u &= -33), [k$2(S$1, null, e.__a ? null : n.children), i];
+};
+var H = function(n, t, e) {
+	if (++e[1] === e[0] && n.l.delete(t), n.props.revealOrder && ("t" !== n.props.revealOrder[0] || !n.l.size)) for (e = n.i; e;) {
+		for (; e.length > 3;) e.pop()();
+		if (e[1] < e[0]) break;
+		n.i = e = e[2];
+	}
+};
+function Z(n) {
+	return this.getChildContext = function() {
+		return n.context;
+	}, n.children;
+}
+function Y(n) {
+	var e = this, r = n.h;
+	if (e.componentWillUnmount = function() {
+		R(null, e.v), e.v = null, e.h = null;
+	}, e.h && e.h !== r && e.componentWillUnmount(), !e.v) {
+		for (var u = e.__v; null !== u && !u.__m && null !== u.__;) u = u.__;
+		e.h = r, e.v = {
+			nodeType: 1,
+			parentNode: r,
+			childNodes: [],
+			__k: { __m: u.__m },
+			contains: function() {
+				return !0;
+			},
+			namespaceURI: r.namespaceURI,
+			insertBefore: function(n, t) {
+				this.childNodes.push(n), e.h.insertBefore(n, t);
+			},
+			removeChild: function(n) {
+				this.childNodes.splice(this.childNodes.indexOf(n) >>> 1, 1), e.h.removeChild(n);
+			}
+		};
+	}
+	R(k$2(Z, { context: e.context }, n.__v), e.v);
+}
+function $(n, e) {
+	var r = k$2(Y, {
+		__v: n,
+		h: e
+	});
+	return r.containerInfo = e, r;
+}
+(B.prototype = new C$1()).__a = function(n) {
+	var t = this, e = j(t.__v), r = t.l.get(n);
+	return r[0]++, function(u) {
+		var o = function() {
+			t.props.revealOrder ? (r.push(u), H(t, n, r)) : u();
+		};
+		e ? e(o) : o();
+	};
+}, B.prototype.render = function(n) {
+	this.i = null, this.l = /* @__PURE__ */ new Map();
+	var t = F$2(n.children);
+	n.revealOrder && "b" === n.revealOrder[0] && t.reverse();
+	for (var e = t.length; e--;) this.l.set(t[e], this.i = [
+		1,
+		0,
+		this.i
+	]);
+	return n.children;
+}, B.prototype.componentDidUpdate = B.prototype.componentDidMount = function() {
+	var n = this;
+	this.l.forEach(function(t, e) {
+		H(n, e, t);
+	});
+};
+var q = "undefined" != typeof Symbol && Symbol.for && Symbol.for("react.element") || 60103, G = /^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|dominant|fill|flood|font|glyph(?!R)|horiz|image(!S)|letter|lighting|marker(?!H|W|U)|overline|paint|pointer|shape|stop|strikethrough|stroke|text(?!L)|transform|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/, J = /^on(Ani|Tra|Tou|BeforeInp|Compo)/, K = /[A-Z0-9]/g, Q = "undefined" != typeof document, X = function(n) {
+	return ("undefined" != typeof Symbol && "symbol" == typeof Symbol() ? /fil|che|rad/ : /fil|che|ra/).test(n);
+};
+C$1.prototype.isReactComponent = !0, [
+	"componentWillMount",
+	"componentWillReceiveProps",
+	"componentWillUpdate"
+].forEach(function(t) {
+	Object.defineProperty(C$1.prototype, t, {
+		configurable: !0,
+		get: function() {
+			return this["UNSAFE_" + t];
+		},
+		set: function(n) {
+			Object.defineProperty(this, t, {
+				configurable: !0,
+				writable: !0,
+				value: n
+			});
+		}
+	});
+});
+var en = l$3.event;
+l$3.event = function(n) {
+	return en && (n = en(n)), n.persist = function() {}, n.isPropagationStopped = function() {
+		return this.cancelBubble;
+	}, n.isDefaultPrevented = function() {
+		return this.defaultPrevented;
+	}, n.nativeEvent = n;
+};
+var un = {
+	configurable: !0,
+	get: function() {
+		return this.class;
+	}
+}, on = l$3.vnode;
+l$3.vnode = function(n) {
+	"string" == typeof n.type && function(n) {
+		var t = n.props, e = n.type, u = {}, o = -1 == e.indexOf("-");
+		for (var i in t) {
+			var l = t[i];
+			if (!("value" === i && "defaultValue" in t && null == l || Q && "children" === i && "noscript" === e || "class" === i || "className" === i)) {
+				var c = i.toLowerCase();
+				"defaultValue" === i && "value" in t && null == t.value ? i = "value" : "download" === i && !0 === l ? l = "" : "translate" === c && "no" === l ? l = !1 : "o" === c[0] && "n" === c[1] ? "ondoubleclick" === c ? i = "ondblclick" : "onchange" !== c || "input" !== e && "textarea" !== e || X(t.type) ? "onfocus" === c ? i = "onfocusin" : "onblur" === c ? i = "onfocusout" : J.test(i) && (i = c) : c = i = "oninput" : o && G.test(i) ? i = i.replace(K, "-$&").toLowerCase() : null === l && (l = void 0), "oninput" === c && u[i = c] && (i = "oninputCapture"), u[i] = l;
+			}
+		}
+		"select" == e && (u.multiple && Array.isArray(u.value) && (u.value = F$2(t.children).forEach(function(n) {
+			n.props.selected = -1 != u.value.indexOf(n.props.value);
+		})), null != u.defaultValue && (u.value = F$2(t.children).forEach(function(n) {
+			n.props.selected = u.multiple ? -1 != u.defaultValue.indexOf(n.props.value) : u.defaultValue == n.props.value;
+		}))), t.class && !t.className ? (u.class = t.class, Object.defineProperty(u, "className", un)) : t.className && (u.class = u.className = t.className), n.props = u;
+	}(n), n.$$typeof = q, on && on(n);
+};
+var ln = l$3.__r;
+l$3.__r = function(n) {
+	ln && ln(n), n.__c;
+};
+var cn = l$3.diffed;
+l$3.diffed = function(n) {
+	cn && cn(n);
+	var t = n.props, e = n.__e;
+	null != e && "textarea" === n.type && "value" in t && t.value !== e.value && (e.value = null == t.value ? "" : t.value);
+};
+//#endregion
+//#region node_modules/.pnpm/@floating-ui+utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = (v) => ({
+	x: v,
+	y: v
+});
+const oppositeSideMap = {
+	left: "right",
+	right: "left",
+	bottom: "top",
+	top: "bottom"
+};
+function clamp(start, value, end) {
+	return max(start, min(value, end));
+}
+function evaluate(value, param) {
+	return typeof value === "function" ? value(param) : value;
+}
+function getSide(placement) {
+	return placement.split("-")[0];
+}
+function getAlignment(placement) {
+	return placement.split("-")[1];
+}
+function getOppositeAxis(axis) {
+	return axis === "x" ? "y" : "x";
+}
+function getAxisLength(axis) {
+	return axis === "y" ? "height" : "width";
+}
+function getSideAxis(placement) {
+	const firstChar = placement[0];
+	return firstChar === "t" || firstChar === "b" ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+	return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+	if (rtl === void 0) rtl = false;
+	const alignment = getAlignment(placement);
+	const alignmentAxis = getAlignmentAxis(placement);
+	const length = getAxisLength(alignmentAxis);
+	let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
+	if (rects.reference[length] > rects.floating[length]) mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+	return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+	const oppositePlacement = getOppositePlacement(placement);
+	return [
+		getOppositeAlignmentPlacement(placement),
+		oppositePlacement,
+		getOppositeAlignmentPlacement(oppositePlacement)
+	];
+}
+function getOppositeAlignmentPlacement(placement) {
+	return placement.includes("start") ? placement.replace("start", "end") : placement.replace("end", "start");
+}
+const lrPlacement = ["left", "right"];
+const rlPlacement = ["right", "left"];
+const tbPlacement = ["top", "bottom"];
+const btPlacement = ["bottom", "top"];
+function getSideList(side, isStart, rtl) {
+	switch (side) {
+		case "top":
+		case "bottom":
+			if (rtl) return isStart ? rlPlacement : lrPlacement;
+			return isStart ? lrPlacement : rlPlacement;
+		case "left":
+		case "right": return isStart ? tbPlacement : btPlacement;
+		default: return [];
+	}
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+	const alignment = getAlignment(placement);
+	let list = getSideList(getSide(placement), direction === "start", rtl);
+	if (alignment) {
+		list = list.map((side) => side + "-" + alignment);
+		if (flipAlignment) list = list.concat(list.map(getOppositeAlignmentPlacement));
+	}
+	return list;
+}
+function getOppositePlacement(placement) {
+	const side = getSide(placement);
+	return oppositeSideMap[side] + placement.slice(side.length);
+}
+function expandPaddingObject(padding) {
+	return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0,
+		...padding
+	};
+}
+function getPaddingObject(padding) {
+	return typeof padding !== "number" ? expandPaddingObject(padding) : {
+		top: padding,
+		right: padding,
+		bottom: padding,
+		left: padding
+	};
+}
+function rectToClientRect(rect) {
+	const { x, y, width, height } = rect;
+	return {
+		width,
+		height,
+		top: y,
+		left: x,
+		right: x + width,
+		bottom: y + height,
+		x,
+		y
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@floating-ui+core@1.7.5/node_modules/@floating-ui/core/dist/floating-ui.core.mjs
+function computeCoordsFromPlacement(_ref, placement, rtl) {
+	let { reference, floating } = _ref;
+	const sideAxis = getSideAxis(placement);
+	const alignmentAxis = getAlignmentAxis(placement);
+	const alignLength = getAxisLength(alignmentAxis);
+	const side = getSide(placement);
+	const isVertical = sideAxis === "y";
+	const commonX = reference.x + reference.width / 2 - floating.width / 2;
+	const commonY = reference.y + reference.height / 2 - floating.height / 2;
+	const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+	let coords;
+	switch (side) {
+		case "top":
+			coords = {
+				x: commonX,
+				y: reference.y - floating.height
+			};
+			break;
+		case "bottom":
+			coords = {
+				x: commonX,
+				y: reference.y + reference.height
+			};
+			break;
+		case "right":
+			coords = {
+				x: reference.x + reference.width,
+				y: commonY
+			};
+			break;
+		case "left":
+			coords = {
+				x: reference.x - floating.width,
+				y: commonY
+			};
+			break;
+		default: coords = {
+			x: reference.x,
+			y: reference.y
+		};
+	}
+	switch (getAlignment(placement)) {
+		case "start":
+			coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+			break;
+		case "end":
+			coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+			break;
+	}
+	return coords;
+}
+/**
+* Resolves with an object of overflow side offsets that determine how much the
+* element is overflowing a given clipping boundary on each side.
+* - positive = overflowing the boundary by that number of pixels
+* - negative = how many pixels left before it will overflow
+* - 0 = lies flush with the boundary
+* @see https://floating-ui.com/docs/detectOverflow
+*/
+async function detectOverflow(state, options) {
+	var _await$platform$isEle;
+	if (options === void 0) options = {};
+	const { x, y, platform, rects, elements, strategy } = state;
+	const { boundary = "clippingAncestors", rootBoundary = "viewport", elementContext = "floating", altBoundary = false, padding = 0 } = evaluate(options, state);
+	const paddingObject = getPaddingObject(padding);
+	const element = elements[altBoundary ? elementContext === "floating" ? "reference" : "floating" : elementContext];
+	const clippingClientRect = rectToClientRect(await platform.getClippingRect({
+		element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating)),
+		boundary,
+		rootBoundary,
+		strategy
+	}));
+	const rect = elementContext === "floating" ? {
+		x,
+		y,
+		width: rects.floating.width,
+		height: rects.floating.height
+	} : rects.reference;
+	const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
+	const offsetScale = await (platform.isElement == null ? void 0 : platform.isElement(offsetParent)) ? await (platform.getScale == null ? void 0 : platform.getScale(offsetParent)) || {
+		x: 1,
+		y: 1
+	} : {
+		x: 1,
+		y: 1
+	};
+	const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+		elements,
+		rect,
+		offsetParent,
+		strategy
+	}) : rect);
+	return {
+		top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+		bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+		left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+		right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
+	};
+}
+const MAX_RESET_COUNT = 50;
+/**
+* Computes the `x` and `y` coordinates that will place the floating element
+* next to a given reference element.
+*
+* This export does not have any `platform` interface logic. You will need to
+* write one for the platform you are using Floating UI with.
+*/
+const computePosition$1 = async (reference, floating, config) => {
+	const { placement = "bottom", strategy = "absolute", middleware = [], platform } = config;
+	const platformWithDetectOverflow = platform.detectOverflow ? platform : {
+		...platform,
+		detectOverflow
+	};
+	const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
+	let rects = await platform.getElementRects({
+		reference,
+		floating,
+		strategy
+	});
+	let { x, y } = computeCoordsFromPlacement(rects, placement, rtl);
+	let statefulPlacement = placement;
+	let resetCount = 0;
+	const middlewareData = {};
+	for (let i = 0; i < middleware.length; i++) {
+		const currentMiddleware = middleware[i];
+		if (!currentMiddleware) continue;
+		const { name, fn } = currentMiddleware;
+		const { x: nextX, y: nextY, data, reset } = await fn({
+			x,
+			y,
+			initialPlacement: placement,
+			placement: statefulPlacement,
+			strategy,
+			middlewareData,
+			rects,
+			platform: platformWithDetectOverflow,
+			elements: {
+				reference,
+				floating
+			}
+		});
+		x = nextX != null ? nextX : x;
+		y = nextY != null ? nextY : y;
+		middlewareData[name] = {
+			...middlewareData[name],
+			...data
+		};
+		if (reset && resetCount < MAX_RESET_COUNT) {
+			resetCount++;
+			if (typeof reset === "object") {
+				if (reset.placement) statefulPlacement = reset.placement;
+				if (reset.rects) rects = reset.rects === true ? await platform.getElementRects({
+					reference,
+					floating,
+					strategy
+				}) : reset.rects;
+				({x, y} = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+			}
+			i = -1;
+		}
+	}
+	return {
+		x,
+		y,
+		placement: statefulPlacement,
+		strategy,
+		middlewareData
+	};
+};
+/**
+* Optimizes the visibility of the floating element by flipping the `placement`
+* in order to keep it in view when the preferred placement(s) will overflow the
+* clipping boundary. Alternative to `autoPlacement`.
+* @see https://floating-ui.com/docs/flip
+*/
+const flip$1 = function(options) {
+	if (options === void 0) options = {};
+	return {
+		name: "flip",
+		options,
+		async fn(state) {
+			var _middlewareData$arrow, _middlewareData$flip;
+			const { placement, middlewareData, rects, initialPlacement, platform, elements } = state;
+			const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true, fallbackPlacements: specifiedFallbackPlacements, fallbackStrategy = "bestFit", fallbackAxisSideDirection = "none", flipAlignment = true, ...detectOverflowOptions } = evaluate(options, state);
+			if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) return {};
+			const side = getSide(placement);
+			const initialSideAxis = getSideAxis(initialPlacement);
+			const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+			const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+			const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+			const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
+			if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+			const placements = [initialPlacement, ...fallbackPlacements];
+			const overflow = await platform.detectOverflow(state, detectOverflowOptions);
+			const overflows = [];
+			let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+			if (checkMainAxis) overflows.push(overflow[side]);
+			if (checkCrossAxis) {
+				const sides = getAlignmentSides(placement, rects, rtl);
+				overflows.push(overflow[sides[0]], overflow[sides[1]]);
+			}
+			overflowsData = [...overflowsData, {
+				placement,
+				overflows
+			}];
+			if (!overflows.every((side) => side <= 0)) {
+				var _middlewareData$flip2, _overflowsData$filter;
+				const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+				const nextPlacement = placements[nextIndex];
+				if (nextPlacement) {
+					if (!(checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false) || overflowsData.every((d) => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) return {
+						data: {
+							index: nextIndex,
+							overflows: overflowsData
+						},
+						reset: { placement: nextPlacement }
+					};
+				}
+				let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
+				if (!resetPlacement) switch (fallbackStrategy) {
+					case "bestFit": {
+						var _overflowsData$filter2;
+						const placement = (_overflowsData$filter2 = overflowsData.filter((d) => {
+							if (hasFallbackAxisSideDirection) {
+								const currentSideAxis = getSideAxis(d.placement);
+								return currentSideAxis === initialSideAxis || currentSideAxis === "y";
+							}
+							return true;
+						}).map((d) => [d.placement, d.overflows.filter((overflow) => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
+						if (placement) resetPlacement = placement;
+						break;
+					}
+					case "initialPlacement":
+						resetPlacement = initialPlacement;
+						break;
+				}
+				if (placement !== resetPlacement) return { reset: { placement: resetPlacement } };
+			}
+			return {};
+		}
+	};
+};
+const originSides = /* @__PURE__ */ new Set(["left", "top"]);
+async function convertValueToCoords(state, options) {
+	const { placement, platform, elements } = state;
+	const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+	const side = getSide(placement);
+	const alignment = getAlignment(placement);
+	const isVertical = getSideAxis(placement) === "y";
+	const mainAxisMulti = originSides.has(side) ? -1 : 1;
+	const crossAxisMulti = rtl && isVertical ? -1 : 1;
+	const rawValue = evaluate(options, state);
+	let { mainAxis, crossAxis, alignmentAxis } = typeof rawValue === "number" ? {
+		mainAxis: rawValue,
+		crossAxis: 0,
+		alignmentAxis: null
+	} : {
+		mainAxis: rawValue.mainAxis || 0,
+		crossAxis: rawValue.crossAxis || 0,
+		alignmentAxis: rawValue.alignmentAxis
+	};
+	if (alignment && typeof alignmentAxis === "number") crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
+	return isVertical ? {
+		x: crossAxis * crossAxisMulti,
+		y: mainAxis * mainAxisMulti
+	} : {
+		x: mainAxis * mainAxisMulti,
+		y: crossAxis * crossAxisMulti
+	};
+}
+/**
+* Modifies the placement by translating the floating element along the
+* specified axes.
+* A number (shorthand for `mainAxis` or distance), or an axes configuration
+* object may be passed.
+* @see https://floating-ui.com/docs/offset
+*/
+const offset$1 = function(options) {
+	if (options === void 0) options = 0;
+	return {
+		name: "offset",
+		options,
+		async fn(state) {
+			var _middlewareData$offse, _middlewareData$arrow;
+			const { x, y, placement, middlewareData } = state;
+			const diffCoords = await convertValueToCoords(state, options);
+			if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) return {};
+			return {
+				x: x + diffCoords.x,
+				y: y + diffCoords.y,
+				data: {
+					...diffCoords,
+					placement
+				}
+			};
+		}
+	};
+};
+/**
+* Optimizes the visibility of the floating element by shifting it in order to
+* keep it in view when it will overflow the clipping boundary.
+* @see https://floating-ui.com/docs/shift
+*/
+const shift$1 = function(options) {
+	if (options === void 0) options = {};
+	return {
+		name: "shift",
+		options,
+		async fn(state) {
+			const { x, y, placement, platform } = state;
+			const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = false, limiter = { fn: (_ref) => {
+				let { x, y } = _ref;
+				return {
+					x,
+					y
+				};
+			} }, ...detectOverflowOptions } = evaluate(options, state);
+			const coords = {
+				x,
+				y
+			};
+			const overflow = await platform.detectOverflow(state, detectOverflowOptions);
+			const crossAxis = getSideAxis(getSide(placement));
+			const mainAxis = getOppositeAxis(crossAxis);
+			let mainAxisCoord = coords[mainAxis];
+			let crossAxisCoord = coords[crossAxis];
+			if (checkMainAxis) {
+				const minSide = mainAxis === "y" ? "top" : "left";
+				const maxSide = mainAxis === "y" ? "bottom" : "right";
+				const min = mainAxisCoord + overflow[minSide];
+				const max = mainAxisCoord - overflow[maxSide];
+				mainAxisCoord = clamp(min, mainAxisCoord, max);
+			}
+			if (checkCrossAxis) {
+				const minSide = crossAxis === "y" ? "top" : "left";
+				const maxSide = crossAxis === "y" ? "bottom" : "right";
+				const min = crossAxisCoord + overflow[minSide];
+				const max = crossAxisCoord - overflow[maxSide];
+				crossAxisCoord = clamp(min, crossAxisCoord, max);
+			}
+			const limitedCoords = limiter.fn({
+				...state,
+				[mainAxis]: mainAxisCoord,
+				[crossAxis]: crossAxisCoord
+			});
+			return {
+				...limitedCoords,
+				data: {
+					x: limitedCoords.x - x,
+					y: limitedCoords.y - y,
+					enabled: {
+						[mainAxis]: checkMainAxis,
+						[crossAxis]: checkCrossAxis
+					}
+				}
+			};
+		}
+	};
+};
+/**
+* Provides data that allows you to change the size of the floating element —
+* for instance, prevent it from overflowing the clipping boundary or match the
+* width of the reference element.
+* @see https://floating-ui.com/docs/size
+*/
+const size$1 = function(options) {
+	if (options === void 0) options = {};
+	return {
+		name: "size",
+		options,
+		async fn(state) {
+			var _state$middlewareData, _state$middlewareData2;
+			const { placement, rects, platform, elements } = state;
+			const { apply = () => {}, ...detectOverflowOptions } = evaluate(options, state);
+			const overflow = await platform.detectOverflow(state, detectOverflowOptions);
+			const side = getSide(placement);
+			const alignment = getAlignment(placement);
+			const isYAxis = getSideAxis(placement) === "y";
+			const { width, height } = rects.floating;
+			let heightSide;
+			let widthSide;
+			if (side === "top" || side === "bottom") {
+				heightSide = side;
+				widthSide = alignment === (await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right";
+			} else {
+				widthSide = side;
+				heightSide = alignment === "end" ? "top" : "bottom";
+			}
+			const maximumClippingHeight = height - overflow.top - overflow.bottom;
+			const maximumClippingWidth = width - overflow.left - overflow.right;
+			const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);
+			const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);
+			const noShift = !state.middlewareData.shift;
+			let availableHeight = overflowAvailableHeight;
+			let availableWidth = overflowAvailableWidth;
+			if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) availableWidth = maximumClippingWidth;
+			if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) availableHeight = maximumClippingHeight;
+			if (noShift && !alignment) {
+				const xMin = max(overflow.left, 0);
+				const xMax = max(overflow.right, 0);
+				const yMin = max(overflow.top, 0);
+				const yMax = max(overflow.bottom, 0);
+				if (isYAxis) availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
+				else availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
+			}
+			await apply({
+				...state,
+				availableWidth,
+				availableHeight
+			});
+			const nextDimensions = await platform.getDimensions(elements.floating);
+			if (width !== nextDimensions.width || height !== nextDimensions.height) return { reset: { rects: true } };
+			return {};
+		}
+	};
+};
+//#endregion
+//#region node_modules/.pnpm/@floating-ui+utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
+function hasWindow() {
+	return typeof window !== "undefined";
+}
+function getNodeName(node) {
+	if (isNode(node)) return (node.nodeName || "").toLowerCase();
+	return "#document";
+}
+function getWindow(node) {
+	var _node$ownerDocument;
+	return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+	var _ref;
+	return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+	if (!hasWindow()) return false;
+	return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+	if (!hasWindow()) return false;
+	return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+	if (!hasWindow()) return false;
+	return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+	if (!hasWindow() || typeof ShadowRoot === "undefined") return false;
+	return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+	const { overflow, overflowX, overflowY, display } = getComputedStyle$1(element);
+	return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && display !== "inline" && display !== "contents";
+}
+function isTableElement(element) {
+	return /^(table|td|th)$/.test(getNodeName(element));
+}
+function isTopLayer(element) {
+	try {
+		if (element.matches(":popover-open")) return true;
+	} catch (_e) {}
+	try {
+		return element.matches(":modal");
+	} catch (_e) {
+		return false;
+	}
+}
+const willChangeRe = /transform|translate|scale|rotate|perspective|filter/;
+const containRe = /paint|layout|strict|content/;
+const isNotNone = (value) => !!value && value !== "none";
+let isWebKitValue;
+function isContainingBlock(elementOrCss) {
+	const css = isElement(elementOrCss) ? getComputedStyle$1(elementOrCss) : elementOrCss;
+	return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || "") || containRe.test(css.contain || "");
+}
+function getContainingBlock(element) {
+	let currentNode = getParentNode(element);
+	while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+		if (isContainingBlock(currentNode)) return currentNode;
+		else if (isTopLayer(currentNode)) return null;
+		currentNode = getParentNode(currentNode);
+	}
+	return null;
+}
+function isWebKit() {
+	if (isWebKitValue == null) isWebKitValue = typeof CSS !== "undefined" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none");
+	return isWebKitValue;
+}
+function isLastTraversableNode(node) {
+	return /^(html|body|#document)$/.test(getNodeName(node));
+}
+function getComputedStyle$1(element) {
+	return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+	if (isElement(element)) return {
+		scrollLeft: element.scrollLeft,
+		scrollTop: element.scrollTop
+	};
+	return {
+		scrollLeft: element.scrollX,
+		scrollTop: element.scrollY
+	};
+}
+function getParentNode(node) {
+	if (getNodeName(node) === "html") return node;
+	const result = node.assignedSlot || node.parentNode || isShadowRoot(node) && node.host || getDocumentElement(node);
+	return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+	const parentNode = getParentNode(node);
+	if (isLastTraversableNode(parentNode)) return node.ownerDocument ? node.ownerDocument.body : node.body;
+	if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) return parentNode;
+	return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+	var _node$ownerDocument2;
+	if (list === void 0) list = [];
+	if (traverseIframes === void 0) traverseIframes = true;
+	const scrollableAncestor = getNearestOverflowAncestor(node);
+	const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+	const win = getWindow(scrollableAncestor);
+	if (isBody) {
+		const frameElement = getFrameElement(win);
+		return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+	} else return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win) {
+	return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+//#endregion
+//#region node_modules/.pnpm/@floating-ui+dom@1.7.6/node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
+function getCssDimensions(element) {
+	const css = getComputedStyle$1(element);
+	let width = parseFloat(css.width) || 0;
+	let height = parseFloat(css.height) || 0;
+	const hasOffset = isHTMLElement(element);
+	const offsetWidth = hasOffset ? element.offsetWidth : width;
+	const offsetHeight = hasOffset ? element.offsetHeight : height;
+	const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+	if (shouldFallback) {
+		width = offsetWidth;
+		height = offsetHeight;
+	}
+	return {
+		width,
+		height,
+		$: shouldFallback
+	};
+}
+function unwrapElement(element) {
+	return !isElement(element) ? element.contextElement : element;
+}
+function getScale(element) {
+	const domElement = unwrapElement(element);
+	if (!isHTMLElement(domElement)) return createCoords(1);
+	const rect = domElement.getBoundingClientRect();
+	const { width, height, $ } = getCssDimensions(domElement);
+	let x = ($ ? round(rect.width) : rect.width) / width;
+	let y = ($ ? round(rect.height) : rect.height) / height;
+	if (!x || !Number.isFinite(x)) x = 1;
+	if (!y || !Number.isFinite(y)) y = 1;
+	return {
+		x,
+		y
+	};
+}
+const noOffsets = /* @__PURE__ */ createCoords(0);
+function getVisualOffsets(element) {
+	const win = getWindow(element);
+	if (!isWebKit() || !win.visualViewport) return noOffsets;
+	return {
+		x: win.visualViewport.offsetLeft,
+		y: win.visualViewport.offsetTop
+	};
+}
+function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+	if (isFixed === void 0) isFixed = false;
+	if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) return false;
+	return isFixed;
+}
+function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+	if (includeScale === void 0) includeScale = false;
+	if (isFixedStrategy === void 0) isFixedStrategy = false;
+	const clientRect = element.getBoundingClientRect();
+	const domElement = unwrapElement(element);
+	let scale = createCoords(1);
+	if (includeScale) if (offsetParent) {
+		if (isElement(offsetParent)) scale = getScale(offsetParent);
+	} else scale = getScale(element);
+	const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+	let x = (clientRect.left + visualOffsets.x) / scale.x;
+	let y = (clientRect.top + visualOffsets.y) / scale.y;
+	let width = clientRect.width / scale.x;
+	let height = clientRect.height / scale.y;
+	if (domElement) {
+		const win = getWindow(domElement);
+		const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+		let currentWin = win;
+		let currentIFrame = getFrameElement(currentWin);
+		while (currentIFrame && offsetParent && offsetWin !== currentWin) {
+			const iframeScale = getScale(currentIFrame);
+			const iframeRect = currentIFrame.getBoundingClientRect();
+			const css = getComputedStyle$1(currentIFrame);
+			const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+			const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+			x *= iframeScale.x;
+			y *= iframeScale.y;
+			width *= iframeScale.x;
+			height *= iframeScale.y;
+			x += left;
+			y += top;
+			currentWin = getWindow(currentIFrame);
+			currentIFrame = getFrameElement(currentWin);
+		}
+	}
+	return rectToClientRect({
+		width,
+		height,
+		x,
+		y
+	});
+}
+function getWindowScrollBarX(element, rect) {
+	const leftScroll = getNodeScroll(element).scrollLeft;
+	if (!rect) return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+	return rect.left + leftScroll;
+}
+function getHTMLOffset(documentElement, scroll) {
+	const htmlRect = documentElement.getBoundingClientRect();
+	return {
+		x: htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect),
+		y: htmlRect.top + scroll.scrollTop
+	};
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+	let { elements, rect, offsetParent, strategy } = _ref;
+	const isFixed = strategy === "fixed";
+	const documentElement = getDocumentElement(offsetParent);
+	const topLayer = elements ? isTopLayer(elements.floating) : false;
+	if (offsetParent === documentElement || topLayer && isFixed) return rect;
+	let scroll = {
+		scrollLeft: 0,
+		scrollTop: 0
+	};
+	let scale = createCoords(1);
+	const offsets = createCoords(0);
+	const isOffsetParentAnElement = isHTMLElement(offsetParent);
+	if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+		if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) scroll = getNodeScroll(offsetParent);
+		if (isOffsetParentAnElement) {
+			const offsetRect = getBoundingClientRect(offsetParent);
+			scale = getScale(offsetParent);
+			offsets.x = offsetRect.x + offsetParent.clientLeft;
+			offsets.y = offsetRect.y + offsetParent.clientTop;
+		}
+	}
+	const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+	return {
+		width: rect.width * scale.x,
+		height: rect.height * scale.y,
+		x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
+		y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
+	};
+}
+function getClientRects(element) {
+	return Array.from(element.getClientRects());
+}
+function getDocumentRect(element) {
+	const html = getDocumentElement(element);
+	const scroll = getNodeScroll(element);
+	const body = element.ownerDocument.body;
+	const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+	const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+	let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+	const y = -scroll.scrollTop;
+	if (getComputedStyle$1(body).direction === "rtl") x += max(html.clientWidth, body.clientWidth) - width;
+	return {
+		width,
+		height,
+		x,
+		y
+	};
+}
+const SCROLLBAR_MAX = 25;
+function getViewportRect(element, strategy) {
+	const win = getWindow(element);
+	const html = getDocumentElement(element);
+	const visualViewport = win.visualViewport;
+	let width = html.clientWidth;
+	let height = html.clientHeight;
+	let x = 0;
+	let y = 0;
+	if (visualViewport) {
+		width = visualViewport.width;
+		height = visualViewport.height;
+		const visualViewportBased = isWebKit();
+		if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
+			x = visualViewport.offsetLeft;
+			y = visualViewport.offsetTop;
+		}
+	}
+	const windowScrollbarX = getWindowScrollBarX(html);
+	if (windowScrollbarX <= 0) {
+		const doc = html.ownerDocument;
+		const body = doc.body;
+		const bodyStyles = getComputedStyle(body);
+		const bodyMarginInline = doc.compatMode === "CSS1Compat" ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
+		const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
+		if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) width -= clippingStableScrollbarWidth;
+	} else if (windowScrollbarX <= SCROLLBAR_MAX) width += windowScrollbarX;
+	return {
+		width,
+		height,
+		x,
+		y
+	};
+}
+function getInnerBoundingClientRect(element, strategy) {
+	const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
+	const top = clientRect.top + element.clientTop;
+	const left = clientRect.left + element.clientLeft;
+	const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+	return {
+		width: element.clientWidth * scale.x,
+		height: element.clientHeight * scale.y,
+		x: left * scale.x,
+		y: top * scale.y
+	};
+}
+function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+	let rect;
+	if (clippingAncestor === "viewport") rect = getViewportRect(element, strategy);
+	else if (clippingAncestor === "document") rect = getDocumentRect(getDocumentElement(element));
+	else if (isElement(clippingAncestor)) rect = getInnerBoundingClientRect(clippingAncestor, strategy);
+	else {
+		const visualOffsets = getVisualOffsets(element);
+		rect = {
+			x: clippingAncestor.x - visualOffsets.x,
+			y: clippingAncestor.y - visualOffsets.y,
+			width: clippingAncestor.width,
+			height: clippingAncestor.height
+		};
+	}
+	return rectToClientRect(rect);
+}
+function hasFixedPositionAncestor(element, stopNode) {
+	const parentNode = getParentNode(element);
+	if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) return false;
+	return getComputedStyle$1(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
+}
+function getClippingElementAncestors(element, cache) {
+	const cachedResult = cache.get(element);
+	if (cachedResult) return cachedResult;
+	let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
+	let currentContainingBlockComputedStyle = null;
+	const elementIsFixed = getComputedStyle$1(element).position === "fixed";
+	let currentNode = elementIsFixed ? getParentNode(element) : element;
+	while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
+		const computedStyle = getComputedStyle$1(currentNode);
+		const currentNodeIsContaining = isContainingBlock(currentNode);
+		if (!currentNodeIsContaining && computedStyle.position === "fixed") currentContainingBlockComputedStyle = null;
+		if (elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && (currentContainingBlockComputedStyle.position === "absolute" || currentContainingBlockComputedStyle.position === "fixed") || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode)) result = result.filter((ancestor) => ancestor !== currentNode);
+		else currentContainingBlockComputedStyle = computedStyle;
+		currentNode = getParentNode(currentNode);
+	}
+	cache.set(element, result);
+	return result;
+}
+function getClippingRect(_ref) {
+	let { element, boundary, rootBoundary, strategy } = _ref;
+	const clippingAncestors = [...boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary), rootBoundary];
+	const firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);
+	let top = firstRect.top;
+	let right = firstRect.right;
+	let bottom = firstRect.bottom;
+	let left = firstRect.left;
+	for (let i = 1; i < clippingAncestors.length; i++) {
+		const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i], strategy);
+		top = max(rect.top, top);
+		right = min(rect.right, right);
+		bottom = min(rect.bottom, bottom);
+		left = max(rect.left, left);
+	}
+	return {
+		width: right - left,
+		height: bottom - top,
+		x: left,
+		y: top
+	};
+}
+function getDimensions(element) {
+	const { width, height } = getCssDimensions(element);
+	return {
+		width,
+		height
+	};
+}
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+	const isOffsetParentAnElement = isHTMLElement(offsetParent);
+	const documentElement = getDocumentElement(offsetParent);
+	const isFixed = strategy === "fixed";
+	const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
+	let scroll = {
+		scrollLeft: 0,
+		scrollTop: 0
+	};
+	const offsets = createCoords(0);
+	function setLeftRTLScrollbarOffset() {
+		offsets.x = getWindowScrollBarX(documentElement);
+	}
+	if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+		if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) scroll = getNodeScroll(offsetParent);
+		if (isOffsetParentAnElement) {
+			const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
+			offsets.x = offsetRect.x + offsetParent.clientLeft;
+			offsets.y = offsetRect.y + offsetParent.clientTop;
+		} else if (documentElement) setLeftRTLScrollbarOffset();
+	}
+	if (isFixed && !isOffsetParentAnElement && documentElement) setLeftRTLScrollbarOffset();
+	const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+	return {
+		x: rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x,
+		y: rect.top + scroll.scrollTop - offsets.y - htmlOffset.y,
+		width: rect.width,
+		height: rect.height
+	};
+}
+function isStaticPositioned(element) {
+	return getComputedStyle$1(element).position === "static";
+}
+function getTrueOffsetParent(element, polyfill) {
+	if (!isHTMLElement(element) || getComputedStyle$1(element).position === "fixed") return null;
+	if (polyfill) return polyfill(element);
+	let rawOffsetParent = element.offsetParent;
+	if (getDocumentElement(element) === rawOffsetParent) rawOffsetParent = rawOffsetParent.ownerDocument.body;
+	return rawOffsetParent;
+}
+function getOffsetParent(element, polyfill) {
+	const win = getWindow(element);
+	if (isTopLayer(element)) return win;
+	if (!isHTMLElement(element)) {
+		let svgOffsetParent = getParentNode(element);
+		while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
+			if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) return svgOffsetParent;
+			svgOffsetParent = getParentNode(svgOffsetParent);
+		}
+		return win;
+	}
+	let offsetParent = getTrueOffsetParent(element, polyfill);
+	while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+	if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) return win;
+	return offsetParent || getContainingBlock(element) || win;
+}
+const getElementRects = async function(data) {
+	const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+	const getDimensionsFn = this.getDimensions;
+	const floatingDimensions = await getDimensionsFn(data.floating);
+	return {
+		reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
+		floating: {
+			x: 0,
+			y: 0,
+			width: floatingDimensions.width,
+			height: floatingDimensions.height
+		}
+	};
+};
+function isRTL(element) {
+	return getComputedStyle$1(element).direction === "rtl";
+}
+const platform = {
+	convertOffsetParentRelativeRectToViewportRelativeRect,
+	getDocumentElement,
+	getClippingRect,
+	getOffsetParent,
+	getElementRects,
+	getClientRects,
+	getDimensions,
+	getScale,
+	isElement,
+	isRTL
+};
+function rectsAreEqual(a, b) {
+	return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+function observeMove(element, onMove) {
+	let io = null;
+	let timeoutId;
+	const root = getDocumentElement(element);
+	function cleanup() {
+		var _io;
+		clearTimeout(timeoutId);
+		(_io = io) == null || _io.disconnect();
+		io = null;
+	}
+	function refresh(skip, threshold) {
+		if (skip === void 0) skip = false;
+		if (threshold === void 0) threshold = 1;
+		cleanup();
+		const elementRectForRootMargin = element.getBoundingClientRect();
+		const { left, top, width, height } = elementRectForRootMargin;
+		if (!skip) onMove();
+		if (!width || !height) return;
+		const insetTop = floor(top);
+		const insetRight = floor(root.clientWidth - (left + width));
+		const insetBottom = floor(root.clientHeight - (top + height));
+		const insetLeft = floor(left);
+		const options = {
+			rootMargin: -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px",
+			threshold: max(0, min(1, threshold)) || 1
+		};
+		let isFirstUpdate = true;
+		function handleObserve(entries) {
+			const ratio = entries[0].intersectionRatio;
+			if (ratio !== threshold) {
+				if (!isFirstUpdate) return refresh();
+				if (!ratio) timeoutId = setTimeout(() => {
+					refresh(false, 1e-7);
+				}, 1e3);
+				else refresh(false, ratio);
+			}
+			if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) refresh();
+			isFirstUpdate = false;
+		}
+		try {
+			io = new IntersectionObserver(handleObserve, {
+				...options,
+				root: root.ownerDocument
+			});
+		} catch (_e) {
+			io = new IntersectionObserver(handleObserve, options);
+		}
+		io.observe(element);
+	}
+	refresh(true);
+	return cleanup;
+}
+/**
+* Automatically updates the position of the floating element when necessary.
+* Should only be called when the floating element is mounted on the DOM or
+* visible on the screen.
+* @returns cleanup function that should be invoked when the floating element is
+* removed from the DOM or hidden from the screen.
+* @see https://floating-ui.com/docs/autoUpdate
+*/
+function autoUpdate(reference, floating, update, options) {
+	if (options === void 0) options = {};
+	const { ancestorScroll = true, ancestorResize = true, elementResize = typeof ResizeObserver === "function", layoutShift = typeof IntersectionObserver === "function", animationFrame = false } = options;
+	const referenceEl = unwrapElement(reference);
+	const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...floating ? getOverflowAncestors(floating) : []] : [];
+	ancestors.forEach((ancestor) => {
+		ancestorScroll && ancestor.addEventListener("scroll", update, { passive: true });
+		ancestorResize && ancestor.addEventListener("resize", update);
+	});
+	const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+	let reobserveFrame = -1;
+	let resizeObserver = null;
+	if (elementResize) {
+		resizeObserver = new ResizeObserver((_ref) => {
+			let [firstEntry] = _ref;
+			if (firstEntry && firstEntry.target === referenceEl && resizeObserver && floating) {
+				resizeObserver.unobserve(floating);
+				cancelAnimationFrame(reobserveFrame);
+				reobserveFrame = requestAnimationFrame(() => {
+					var _resizeObserver;
+					(_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
+				});
+			}
+			update();
+		});
+		if (referenceEl && !animationFrame) resizeObserver.observe(referenceEl);
+		if (floating) resizeObserver.observe(floating);
+	}
+	let frameId;
+	let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+	if (animationFrame) frameLoop();
+	function frameLoop() {
+		const nextRefRect = getBoundingClientRect(reference);
+		if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) update();
+		prevRefRect = nextRefRect;
+		frameId = requestAnimationFrame(frameLoop);
+	}
+	update();
+	return () => {
+		var _resizeObserver2;
+		ancestors.forEach((ancestor) => {
+			ancestorScroll && ancestor.removeEventListener("scroll", update);
+			ancestorResize && ancestor.removeEventListener("resize", update);
+		});
+		cleanupIo?.();
+		(_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
+		resizeObserver = null;
+		if (animationFrame) cancelAnimationFrame(frameId);
+	};
+}
+/**
+* Modifies the placement by translating the floating element along the
+* specified axes.
+* A number (shorthand for `mainAxis` or distance), or an axes configuration
+* object may be passed.
+* @see https://floating-ui.com/docs/offset
+*/
+const offset = offset$1;
+/**
+* Optimizes the visibility of the floating element by shifting it in order to
+* keep it in view when it will overflow the clipping boundary.
+* @see https://floating-ui.com/docs/shift
+*/
+const shift = shift$1;
+/**
+* Optimizes the visibility of the floating element by flipping the `placement`
+* in order to keep it in view when the preferred placement(s) will overflow the
+* clipping boundary. Alternative to `autoPlacement`.
+* @see https://floating-ui.com/docs/flip
+*/
+const flip = flip$1;
+/**
+* Provides data that allows you to change the size of the floating element —
+* for instance, prevent it from overflowing the clipping boundary or match the
+* width of the reference element.
+* @see https://floating-ui.com/docs/size
+*/
+const size = size$1;
+/**
+* Computes the `x` and `y` coordinates that will place the floating element
+* next to a given reference element.
+*/
+const computePosition = (reference, floating, options) => {
+	const cache = /* @__PURE__ */ new Map();
+	const mergedOptions = {
+		platform,
+		...options
+	};
+	const platformWithCache = {
+		...mergedOptions.platform,
+		_c: cache
+	};
+	return computePosition$1(reference, floating, {
+		...mergedOptions,
+		platform: platformWithCache
+	});
+};
+//#endregion
+//#region node_modules/.pnpm/@goddard-ai+ui-primitives@0.1.1_preact@10.29.2/node_modules/@goddard-ai/ui-primitives/dist/index.mjs
+function createOverlayStack() {
+	const entries = y$1([]);
+	let nextToken = 0;
+	function register(entry) {
+		const token = nextToken++;
+		entries.value = [...entries.value.filter((candidate) => candidate.id !== entry.id), {
+			...entry,
+			token
+		}];
+		return () => {
+			entries.value = entries.value.filter((candidate) => candidate.token !== token);
+		};
+	}
+	function isTopmost(id) {
+		return entries.value.at(-1)?.id === id;
+	}
+	function contains(target) {
+		if (!(target instanceof Node)) return false;
+		return entries.value.some((entry) => entry.elements.some((element) => element === target || element.contains(target)));
+	}
+	function closeTopmost() {
+		const entry = entries.value.at(-1);
+		if (!entry?.close) return false;
+		entries.value = entries.value.filter((candidate) => candidate.token !== entry.token);
+		entry.close();
+		return true;
+	}
+	return {
+		closeTopmost,
+		contains,
+		entries,
+		isTopmost,
+		register
+	};
+}
+var overlayStack = createOverlayStack();
+function startOverlayDismissal(options) {
+	function closeIfTopmost(reason) {
+		if (overlayStack.isTopmost(options.id)) options.close(reason);
+	}
+	function handleKeyDown(event) {
+		if (options.dismissOnEscape === false || event.key !== "Escape") return;
+		event.preventDefault();
+		closeIfTopmost("escape");
+	}
+	function handlePointerDown(event) {
+		if (options.dismissOnOutsidePointer === false || overlayStack.contains(event.target)) return;
+		closeIfTopmost("outside");
+	}
+	document.addEventListener("keydown", handleKeyDown);
+	document.addEventListener("pointerdown", handlePointerDown, true);
+	return () => {
+		document.removeEventListener("keydown", handleKeyDown);
+		document.removeEventListener("pointerdown", handlePointerDown, true);
+	};
+}
+function focusFirstElement(container) {
+	const firstElement = tabbable(container)[0];
+	if (!firstElement) return false;
+	firstElement.focus();
+	return true;
+}
+function restoreFocus(target) {
+	if (target instanceof HTMLElement && document.contains(target)) target.focus();
+}
+function keepFocusInside(container, event) {
+	if (event.key !== "Tab") return;
+	const focusableElements = tabbable(container);
+	const firstElement = focusableElements[0];
+	const lastElement = focusableElements.at(-1);
+	if (!firstElement || !lastElement) {
+		event.preventDefault();
+		container.focus();
+		return;
+	}
+	if (event.shiftKey && document.activeElement === firstElement) {
+		event.preventDefault();
+		lastElement.focus();
+		return;
+	}
+	if (!event.shiftKey && document.activeElement === lastElement) {
+		event.preventDefault();
+		firstElement.focus();
+	}
+}
+var portalRoots = {};
+function setOverlayPortalRoots(roots) {
+	Object.assign(portalRoots, roots);
+}
+function getOverlayPortalRoot(root) {
+	const resolver = portalRoots[root];
+	return typeof resolver === "function" ? resolver() : resolver ?? null;
+}
+function OverlayPortal(props) {
+	const portalRoot = getOverlayPortalRoot(props.root);
+	if (!portalRoot) return null;
+	return $(props.children, portalRoot);
+}
+function startFloatingPosition(referenceElement, floatingElement, options = {}) {
+	let disposed = false;
+	const reference = referenceElement instanceof Element ? referenceElement : { getBoundingClientRect() {
+		return new DOMRect(referenceElement.x, referenceElement.y, 0, 0);
+	} };
+	async function updatePosition() {
+		Object.assign(floatingElement.style, {
+			maxHeight: "",
+			maxWidth: "",
+			minHeight: "",
+			minWidth: ""
+		});
+		const { x, y } = await computePosition(reference, floatingElement, {
+			placement: options.placement ?? "bottom-start",
+			strategy: options.strategy ?? "absolute",
+			middleware: [
+				offset(options.offset ?? 4),
+				flip(),
+				shift({ padding: 8 }),
+				size({
+					padding: 8,
+					apply({ availableHeight, availableWidth, rects }) {
+						const boundedAvailableHeight = Math.max(0, availableHeight);
+						const boundedAvailableWidth = Math.max(0, availableWidth);
+						Object.assign(floatingElement.style, {
+							"--available-height": `${boundedAvailableHeight}px`,
+							"--available-width": `${boundedAvailableWidth}px`,
+							"--reference-width": `${rects.reference.width}px`
+						});
+						const floatingStyle = getComputedStyle(floatingElement);
+						const cssMaxHeight = parseCssPixelSize(floatingStyle.maxHeight);
+						const cssMaxWidth = parseCssPixelSize(floatingStyle.maxWidth);
+						const cssMinHeight = parseCssPixelSize(floatingStyle.minHeight);
+						const cssMinWidth = parseCssPixelSize(floatingStyle.minWidth);
+						Object.assign(floatingElement.style, {
+							maxHeight: `${Math.min(boundedAvailableHeight, cssMaxHeight ?? boundedAvailableHeight)}px`,
+							maxWidth: `${Math.min(boundedAvailableWidth, cssMaxWidth ?? boundedAvailableWidth)}px`,
+							minHeight: cssMinHeight !== null && cssMinHeight > boundedAvailableHeight ? `${boundedAvailableHeight}px` : "",
+							minWidth: cssMinWidth !== null && cssMinWidth > boundedAvailableWidth ? `${boundedAvailableWidth}px` : "",
+							width: options.sameWidth ? `${Math.min(rects.reference.width, boundedAvailableWidth)}px` : ""
+						});
+					}
+				})
+			]
+		});
+		if (disposed) return;
+		Object.assign(floatingElement.style, {
+			left: `${x}px`,
+			position: options.strategy ?? "absolute",
+			top: `${y}px`
+		});
+	}
+	const stopAutoUpdate = reference instanceof Element ? autoUpdate(reference, floatingElement, updatePosition) : (() => {
+		window.addEventListener("resize", updatePosition);
+		window.addEventListener("scroll", updatePosition, true);
+		return () => {
+			window.removeEventListener("resize", updatePosition);
+			window.removeEventListener("scroll", updatePosition, true);
+		};
+	})();
+	updatePosition();
+	return () => {
+		disposed = true;
+		stopAutoUpdate();
+	};
+}
+function parseCssPixelSize(value) {
+	if (!value.endsWith("px")) return null;
+	const size2 = Number.parseFloat(value);
+	return Number.isFinite(size2) ? size2 : null;
+}
+var Popover__StatementBodyHook1;
+var Popover__StatementBodyHook2;
+function Popover(props) {
+	if (!props.open.value) return u(Popover__StatementBodyHook1 ?? (Popover__StatementBodyHook1 = function StatementBodyHook12() {
+		return null;
+	}), {}, void 0, false, void 0, this);
+	return u(Popover__StatementBodyHook2 ?? (Popover__StatementBodyHook2 = function StatementBodyHook22({ props: props2 }) {
+		const popoverId = g$3();
+		const contentRef = A$1(null);
+		const close = (reason) => {
+			props2.open.value = false;
+			props2.onOpenChange?.(false, reason);
+		};
+		_$2(() => {
+			const anchorElement = props2.anchor();
+			const contentElement = contentRef.current;
+			if (!anchorElement || !contentElement) {
+				console.error("Popover opened without a mounted anchor or content element.", {
+					hasAnchor: Boolean(anchorElement),
+					hasContent: Boolean(contentElement)
+				});
+				return;
+			}
+			const previouslyFocusedElement = document.activeElement;
+			const unregisterOverlay = overlayStack.register({
+				id: popoverId,
+				elements: anchorElement instanceof HTMLElement ? [anchorElement, contentElement] : [contentElement]
+			});
+			const stopDismissal = startOverlayDismissal({
+				id: popoverId,
+				dismissOnEscape: props2.closeOnEscape ?? true,
+				dismissOnOutsidePointer: props2.closeOnOutsidePointer ?? true,
+				close
+			});
+			const stopPositioning = startFloatingPosition(anchorElement, contentElement, {
+				offset: props2.offset,
+				placement: props2.placement,
+				sameWidth: props2.sameWidth,
+				strategy: props2.strategy
+			});
+			if (props2.focusOnOpen ?? true) {
+				const initialFocusElement = props2.initialFocus?.();
+				if (initialFocusElement) initialFocusElement.focus();
+				else if (!focusFirstElement(contentElement)) contentElement.focus();
+			}
+			return () => {
+				stopPositioning();
+				stopDismissal();
+				unregisterOverlay();
+				if (props2.restoreFocus ?? true) restoreFocus(anchorElement instanceof Element ? anchorElement : previouslyFocusedElement);
+			};
+		}, [popoverId]);
+		return u(OverlayPortal, {
+			root: "menu",
+			children: u(S$1, { children: [props2.blockOutsidePointer ?? props2.closeOnOutsidePointer ?? true ? u("div", {
+				"aria-hidden": "true",
+				"data-overlay-pointer-blocker": "true",
+				style: {
+					position: "fixed",
+					inset: "0",
+					background: "transparent",
+					pointerEvents: "auto"
+				}
+			}, void 0, false, void 0, this) : null, u("div", {
+				ref: contentRef,
+				"aria-label": props2.ariaLabel,
+				class: props2.class,
+				role: props2.role,
+				tabIndex: props2.focusOnOpen ?? true ? -1 : void 0,
+				onKeyDown: (event) => {
+					if (props2.modalFocus) keepFocusInside(event.currentTarget, event);
+					props2.onKeyDown?.(event);
+				},
+				children: props2.children
+			}, void 0, false, void 0, this)] }, void 0, true, void 0, this)
+		}, void 0, false, void 0, this);
+	}), { props }, void 0, false, void 0, this);
+}
+X$1(null);
+//#endregion
+//#region src/render/search.tsx
+const open = y$1(false);
+(async () => {
+	const root = document.querySelector("#lildocs-search-root");
+	if (!root) return;
+	const embeddedIndex = document.querySelector("#lildocs-search-index");
+	const base = new URL(window.lildocsSearchUrl || "search-index.json", document.baseURI);
+	const index = embeddedIndex?.textContent ? JSON.parse(embeddedIndex.textContent) : await fetch(base).then((response) => response.json());
+	const siteRoot = new URL(".", base);
+	const preloadedUrls = /* @__PURE__ */ new Set();
+	setOverlayPortalRoots({
+		dialog: () => document.getElementById("lildocs-overlay-root"),
+		menu: () => document.getElementById("lildocs-overlay-root")
+	});
+	document.addEventListener("mouseover", (event) => {
+		const link = event.target?.closest?.("a[href]");
+		if (!link) return;
+		preloadRelativeUrl(link.getAttribute("href"), preloadedUrls);
+	});
+	U$1(/* @__PURE__ */ u(SearchBox, {
+		anchorElement: root,
+		index,
+		siteRoot,
+		preloadedUrls
+	}), root);
+})();
+function SearchBox({ anchorElement, index, siteRoot, preloadedUrls }) {
+	const inputRef = A$1(null);
+	const selectedRef = A$1(null);
+	const [query, setQuery] = d$2("");
+	const [selectedIndex, setSelectedIndex] = d$2(-1);
+	const matches = T$1(() => searchIndex(index, query), [index, query]);
+	y$2(() => {
+		selectedRef.current?.scrollIntoView({ block: "nearest" });
+		preloadRelativeUrl(selectedRef.current?.getAttribute("href"), preloadedUrls);
+	}, [
+		matches,
+		preloadedUrls,
+		selectedIndex
+	]);
+	const clearSearch = () => {
+		setQuery("");
+		setSelectedIndex(-1);
+		open.value = false;
+	};
+	const selectResult = (nextIndex) => {
+		if (matches.length === 0) {
+			setSelectedIndex(-1);
+			return;
+		}
+		setSelectedIndex((nextIndex + matches.length) % matches.length);
+	};
+	return /* @__PURE__ */ u(S$1, { children: [
+		/* @__PURE__ */ u("span", {
+			className: "searchIcon material-symbols-rounded",
+			"aria-hidden": "true",
+			children: "search"
+		}),
+		/* @__PURE__ */ u("input", {
+			ref: inputRef,
+			id: "lildocs-search-input",
+			type: "search",
+			placeholder: "Search docs",
+			"aria-label": "Search docs",
+			"aria-expanded": open.value,
+			"aria-controls": "lildocs-search-results",
+			value: query,
+			onInput: (event) => {
+				const nextQuery = event.currentTarget.value;
+				setQuery(nextQuery);
+				setSelectedIndex(nextQuery.trim() ? 0 : -1);
+				open.value = Boolean(nextQuery.trim());
+			},
+			onKeyDown: (event) => {
+				if (!open.value || matches.length === 0) return;
+				if (event.key === "ArrowDown") {
+					event.preventDefault();
+					selectResult(selectedIndex + 1);
+					return;
+				}
+				if (event.key === "ArrowUp") {
+					event.preventDefault();
+					selectResult(selectedIndex - 1);
+					return;
+				}
+				if (event.key === "Enter") {
+					event.preventDefault();
+					const selected = selectedRef.current;
+					if (selected) {
+						preloadRelativeUrl(selected.getAttribute("href"), preloadedUrls);
+						selected.click();
+					}
+					return;
+				}
+				if (event.key === "Escape") open.value = false;
+			}
+		}),
+		/* @__PURE__ */ u(Popover, {
+			open,
+			anchor: () => anchorElement,
+			ariaLabel: "Search results",
+			class: "searchResults",
+			closeOnOutsidePointer: true,
+			blockOutsidePointer: false,
+			focusOnOpen: false,
+			restoreFocus: false,
+			placement: "bottom-end",
+			sameWidth: false,
+			children: /* @__PURE__ */ u("div", {
+				id: "lildocs-search-results",
+				children: matches.length === 0 ? /* @__PURE__ */ u("p", { children: "No results" }) : matches.map((match, matchIndex) => {
+					const selected = matchIndex === selectedIndex;
+					return /* @__PURE__ */ u("a", {
+						ref: selected ? selectedRef : void 0,
+						href: new URL(match.entry.route, siteRoot).href,
+						"data-search-result": "true",
+						className: selected ? "selected" : void 0,
+						"aria-selected": selected,
+						onMouseOver: () => setSelectedIndex(matchIndex),
+						onClick: clearSearch,
+						children: [renderHighlighted(match.title, match.terms), /* @__PURE__ */ u("span", { children: renderHighlighted(match.subtitle, match.terms) })]
+					}, `${match.entry.route}:${match.title}`);
+				})
+			})
+		})
+	] });
+}
+function searchIndex(index, query) {
+	const normalizedQuery = normalizeQuery(query);
+	if (!normalizedQuery) return [];
+	const terms = normalizedQuery.split(/\s+/);
+	const matches = index.map((entry) => matchEntry(entry, terms, normalizedQuery)).filter(isMatch);
+	const titleMatches = matches.filter((match) => match.type === "title");
+	const sectionBodyMatches = matches.filter((match) => match.type === "body" && match.entry.kind === "section");
+	const bodyMatches = sectionBodyMatches.length > 0 ? sectionBodyMatches : matches.filter((match) => match.type === "body");
+	return (titleMatches.length < 4 ? [...titleMatches, ...bodyMatches] : titleMatches).toSorted((a, b) => b.score - a.score || a.title.localeCompare(b.title)).slice(0, 8);
+}
+function preloadRelativeUrl(href, preloadedUrls) {
+	if (!href || href.startsWith("mailto:") || href.startsWith("#")) return;
+	const url = new URL(href, document.baseURI);
+	if (url.origin !== window.location.origin || preloadedUrls.has(url.href)) return;
+	preloadedUrls.add(url.href);
+	const preload = document.createElement("link");
+	preload.rel = "prefetch";
+	preload.href = url.href;
+	document.head.append(preload);
+}
+function matchEntry(entry, terms, normalizedQuery) {
+	const titleScore = scoreText(entry.title, terms, normalizedQuery);
+	if (titleScore > 0) return {
+		entry,
+		title: entry.title,
+		subtitle: subtitleForEntry(entry),
+		score: (entry.kind === "page" ? 300 : 250) + titleScore,
+		terms,
+		type: "title"
+	};
+	const bodyScore = scoreText(entry.text, terms, normalizedQuery);
+	if (bodyScore > 0) return {
+		entry,
+		title: matchingSnippet(entry.text, terms),
+		subtitle: subtitleForEntry(entry),
+		score: 20 + bodyScore,
+		terms,
+		type: "body"
+	};
+}
+function scoreText(value, terms, normalizedQuery) {
+	const text = value.toLowerCase();
+	if (!text) return 0;
+	let score = 0;
+	if (text === normalizedQuery) score += 80;
+	else if (text.includes(normalizedQuery)) score += 40;
+	for (const term of terms) if (text.includes(term)) score += 10;
+	return score;
+}
+function subtitleForEntry(entry) {
+	if (entry.kind === "page") return entry.headings.slice(0, 3).join(" / ") || "Page";
+	const parents = entry.headings.slice(0, -1);
+	return uniqueParts([entry.pageTitle, ...parents]).join(" / ");
+}
+function matchingSnippet(text, terms) {
+	const lowerText = text.toLowerCase();
+	const matchStart = terms.map((term) => lowerText.indexOf(term)).filter((index) => index >= 0).toSorted((a, b) => a - b)[0] ?? 0;
+	const start = Math.max(0, matchStart - 36);
+	const end = Math.min(text.length, matchStart + 96);
+	const prefix = start > 0 ? "... " : "";
+	const suffix = end < text.length ? " ..." : "";
+	return `${prefix}${text.slice(start, end).trim()}${suffix}`;
+}
+function renderHighlighted(value, terms) {
+	const matchingTerms = terms.filter(Boolean).toSorted((a, b) => b.length - a.length);
+	if (matchingTerms.length === 0) return value;
+	const pattern = new RegExp(`(${matchingTerms.map(escapeRegExp).join("|")})`, "gi");
+	return value.split(pattern).map((part) => matchingTerms.some((term) => part.toLowerCase() === term) ? /* @__PURE__ */ u("mark", { children: part }) : part);
+}
+function normalizeQuery(value) {
+	return value.replace(/[^\p{L}\p{N}]+/gu, " ").replace(/\s+/g, " ").trim().toLowerCase();
+}
+function uniqueParts(parts) {
+	return parts.filter((part, index) => part && parts.indexOf(part) === index);
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isMatch(match) {
+	return Boolean(match);
+}
+//#endregion