@pubinfo-nightly/module-rbac 2025.12.9 → 2025.12.26

package/dist/ComponentSelect-D0OCk6H1.js

@@ -0,0 +1,3572 @@
+import { useViewStore } from "./index.js";
+import { Teleport, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, guardReactiveProps, isRef, mergeProps, normalizeClass, normalizeProps, onBeforeUnmount, onMounted, onUnmounted, openBlock, ref, resolveComponent, shallowRef, unref, useId, useModel, useTemplateRef, watch, watchEffect, withCtx } from "vue";
+import { CaretDownOutlined } from "@ant-design/icons-vue";
+import { Empty } from "ant-design-vue";
+import { DirectoryTree, Empty as Empty$1, FormItemRest, Input as Input$1 } from "ant-design-vue/es";
+import './ComponentSelect.css';var sides = [
+	"top",
+	"right",
+	"bottom",
+	"left"
+], min$1 = Math.min, max$1 = Math.max, round$1 = Math.round, floor$1 = Math.floor, createCoords = (i) => ({
+	x: i,
+	y: i
+}), oppositeSideMap = {
+	left: "right",
+	right: "left",
+	bottom: "top",
+	top: "bottom"
+}, oppositeAlignmentMap = {
+	start: "end",
+	end: "start"
+};
+function clamp(i, s, c) {
+	return max$1(i, min$1(s, c));
+}
+function evaluate(i, s) {
+	return typeof i == "function" ? i(s) : i;
+}
+function getSide(i) {
+	return i.split("-")[0];
+}
+function getAlignment(i) {
+	return i.split("-")[1];
+}
+function getOppositeAxis(i) {
+	return i === "x" ? "y" : "x";
+}
+function getAxisLength(i) {
+	return i === "y" ? "height" : "width";
+}
+var yAxisSides = /* @__PURE__ */ new Set(["top", "bottom"]);
+function getSideAxis(i) {
+	return yAxisSides.has(getSide(i)) ? "y" : "x";
+}
+function getAlignmentAxis(i) {
+	return getOppositeAxis(getSideAxis(i));
+}
+function getAlignmentSides(i, s, c) {
+	c === void 0 && (c = !1);
+	let l = getAlignment(i), u = getAlignmentAxis(i), d = getAxisLength(u), f = u === "x" ? l === (c ? "end" : "start") ? "right" : "left" : l === "start" ? "bottom" : "top";
+	return s.reference[d] > s.floating[d] && (f = getOppositePlacement(f)), [f, getOppositePlacement(f)];
+}
+function getExpandedPlacements(i) {
+	let s = getOppositePlacement(i);
+	return [
+		getOppositeAlignmentPlacement(i),
+		s,
+		getOppositeAlignmentPlacement(s)
+	];
+}
+function getOppositeAlignmentPlacement(i) {
+	return i.replace(/start|end/g, (i) => oppositeAlignmentMap[i]);
+}
+var lrPlacement = ["left", "right"], rlPlacement = ["right", "left"], tbPlacement = ["top", "bottom"], btPlacement = ["bottom", "top"];
+function getSideList(i, s, c) {
+	switch (i) {
+		case "top":
+		case "bottom": return c ? s ? rlPlacement : lrPlacement : s ? lrPlacement : rlPlacement;
+		case "left":
+		case "right": return s ? tbPlacement : btPlacement;
+		default: return [];
+	}
+}
+function getOppositeAxisPlacements(i, s, c, l) {
+	let u = getAlignment(i), d = getSideList(getSide(i), c === "start", l);
+	return u && (d = d.map((i) => i + "-" + u), s && (d = d.concat(d.map(getOppositeAlignmentPlacement)))), d;
+}
+function getOppositePlacement(i) {
+	return i.replace(/left|right|bottom|top/g, (i) => oppositeSideMap[i]);
+}
+function expandPaddingObject(i) {
+	return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0,
+		...i
+	};
+}
+function getPaddingObject(i) {
+	return typeof i == "number" ? {
+		top: i,
+		right: i,
+		bottom: i,
+		left: i
+	} : expandPaddingObject(i);
+}
+function rectToClientRect(i) {
+	let { x: s, y: c, width: l, height: u } = i;
+	return {
+		width: l,
+		height: u,
+		top: c,
+		left: s,
+		right: s + l,
+		bottom: c + u,
+		x: s,
+		y: c
+	};
+}
+function computeCoordsFromPlacement(i, s, c) {
+	let { reference: l, floating: u } = i, d = getSideAxis(s), f = getAlignmentAxis(s), p = getAxisLength(f), m = getSide(s), h = d === "y", g = l.x + l.width / 2 - u.width / 2, _ = l.y + l.height / 2 - u.height / 2, v = l[p] / 2 - u[p] / 2, y;
+	switch (m) {
+		case "top":
+			y = {
+				x: g,
+				y: l.y - u.height
+			};
+			break;
+		case "bottom":
+			y = {
+				x: g,
+				y: l.y + l.height
+			};
+			break;
+		case "right":
+			y = {
+				x: l.x + l.width,
+				y: _
+			};
+			break;
+		case "left":
+			y = {
+				x: l.x - u.width,
+				y: _
+			};
+			break;
+		default: y = {
+			x: l.x,
+			y: l.y
+		};
+	}
+	switch (getAlignment(s)) {
+		case "start":
+			y[f] -= v * (c && h ? -1 : 1);
+			break;
+		case "end":
+			y[f] += v * (c && h ? -1 : 1);
+			break;
+	}
+	return y;
+}
+var computePosition$1 = async (i, s, c) => {
+	let { placement: l = "bottom", strategy: u = "absolute", middleware: d = [], platform: f } = c, p = d.filter(Boolean), m = await (f.isRTL == null ? void 0 : f.isRTL(s)), h = await f.getElementRects({
+		reference: i,
+		floating: s,
+		strategy: u
+	}), { x: g, y: _ } = computeCoordsFromPlacement(h, l, m), v = l, y = {}, b = 0;
+	for (let c = 0; c < p.length; c++) {
+		let { name: d, fn: x } = p[c], { x: S, y: C, data: w, reset: T } = await x({
+			x: g,
+			y: _,
+			initialPlacement: l,
+			placement: v,
+			strategy: u,
+			middlewareData: y,
+			rects: h,
+			platform: f,
+			elements: {
+				reference: i,
+				floating: s
+			}
+		});
+		g = S ?? g, _ = C ?? _, y = {
+			...y,
+			[d]: {
+				...y[d],
+				...w
+			}
+		}, T && b <= 50 && (b++, typeof T == "object" && (T.placement && (v = T.placement), T.rects && (h = T.rects === !0 ? await f.getElementRects({
+			reference: i,
+			floating: s,
+			strategy: u
+		}) : T.rects), {x: g, y: _} = computeCoordsFromPlacement(h, v, m)), c = -1);
+	}
+	return {
+		x: g,
+		y: _,
+		placement: v,
+		strategy: u,
+		middlewareData: y
+	};
+};
+async function detectOverflow(i, s) {
+	s === void 0 && (s = {});
+	let { x: c, y: l, platform: u, rects: d, elements: f, strategy: p } = i, { boundary: m = "clippingAncestors", rootBoundary: h = "viewport", elementContext: g = "floating", altBoundary: _ = !1, padding: v = 0 } = evaluate(s, i), y = getPaddingObject(v), b = f[_ ? g === "floating" ? "reference" : "floating" : g], x = rectToClientRect(await u.getClippingRect({
+		element: await (u.isElement == null ? void 0 : u.isElement(b)) ?? !0 ? b : b.contextElement || await (u.getDocumentElement == null ? void 0 : u.getDocumentElement(f.floating)),
+		boundary: m,
+		rootBoundary: h,
+		strategy: p
+	})), S = g === "floating" ? {
+		x: c,
+		y: l,
+		width: d.floating.width,
+		height: d.floating.height
+	} : d.reference, C = await (u.getOffsetParent == null ? void 0 : u.getOffsetParent(f.floating)), w = await (u.isElement == null ? void 0 : u.isElement(C)) && await (u.getScale == null ? void 0 : u.getScale(C)) || {
+		x: 1,
+		y: 1
+	}, T = rectToClientRect(u.convertOffsetParentRelativeRectToViewportRelativeRect ? await u.convertOffsetParentRelativeRectToViewportRelativeRect({
+		elements: f,
+		rect: S,
+		offsetParent: C,
+		strategy: p
+	}) : S);
+	return {
+		top: (x.top - T.top + y.top) / w.y,
+		bottom: (T.bottom - x.bottom + y.bottom) / w.y,
+		left: (x.left - T.left + y.left) / w.x,
+		right: (T.right - x.right + y.right) / w.x
+	};
+}
+var arrow$1 = (i) => ({
+	name: "arrow",
+	options: i,
+	async fn(s) {
+		let { x: c, y: l, placement: u, rects: d, platform: f, elements: p, middlewareData: m } = s, { element: h, padding: g = 0 } = evaluate(i, s) || {};
+		if (h == null) return {};
+		let _ = getPaddingObject(g), v = {
+			x: c,
+			y: l
+		}, y = getAlignmentAxis(u), b = getAxisLength(y), x = await f.getDimensions(h), S = y === "y", C = S ? "top" : "left", w = S ? "bottom" : "right", T = S ? "clientHeight" : "clientWidth", E = d.reference[b] + d.reference[y] - v[y] - d.floating[b], D = v[y] - d.reference[y], O = await (f.getOffsetParent == null ? void 0 : f.getOffsetParent(h)), k = O ? O[T] : 0;
+		(!k || !await (f.isElement == null ? void 0 : f.isElement(O))) && (k = p.floating[T] || d.floating[b]);
+		let A = E / 2 - D / 2, j = k / 2 - x[b] / 2 - 1, M = min$1(_[C], j), N = min$1(_[w], j), P = M, F = k - x[b] - N, I = k / 2 - x[b] / 2 + A, L = clamp(P, I, F), R = !m.arrow && getAlignment(u) != null && I !== L && d.reference[b] / 2 - (I < P ? M : N) - x[b] / 2 < 0, z = R ? I < P ? I - P : I - F : 0;
+		return {
+			[y]: v[y] + z,
+			data: {
+				[y]: L,
+				centerOffset: I - L - z,
+				...R && { alignmentOffset: z }
+			},
+			reset: R
+		};
+	}
+}), flip$1 = function(i) {
+	return i === void 0 && (i = {}), {
+		name: "flip",
+		options: i,
+		async fn(s) {
+			var c;
+			let { placement: l, middlewareData: u, rects: d, initialPlacement: f, platform: p, elements: m } = s, { mainAxis: h = !0, crossAxis: g = !0, fallbackPlacements: _, fallbackStrategy: v = "bestFit", fallbackAxisSideDirection: y = "none", flipAlignment: b = !0, ...x } = evaluate(i, s);
+			if ((c = u.arrow) != null && c.alignmentOffset) return {};
+			let S = getSide(l), C = getSideAxis(f), w = getSide(f) === f, T = await (p.isRTL == null ? void 0 : p.isRTL(m.floating)), E = _ || (w || !b ? [getOppositePlacement(f)] : getExpandedPlacements(f)), D = y !== "none";
+			!_ && D && E.push(...getOppositeAxisPlacements(f, b, y, T));
+			let O = [f, ...E], k = await detectOverflow(s, x), A = [], j = u.flip?.overflows || [];
+			if (h && A.push(k[S]), g) {
+				let i = getAlignmentSides(l, d, T);
+				A.push(k[i[0]], k[i[1]]);
+			}
+			if (j = [...j, {
+				placement: l,
+				overflows: A
+			}], !A.every((i) => i <= 0)) {
+				let i = (u.flip?.index || 0) + 1, s = O[i];
+				if (s && (!(g === "alignment" && C !== getSideAxis(s)) || j.every((i) => i.overflows[0] > 0 && getSideAxis(i.placement) === C))) return {
+					data: {
+						index: i,
+						overflows: j
+					},
+					reset: { placement: s }
+				};
+				let c = j.filter((i) => i.overflows[0] <= 0).sort((i, s) => i.overflows[1] - s.overflows[1])[0]?.placement;
+				if (!c) switch (v) {
+					case "bestFit": {
+						let i = j.filter((i) => {
+							if (D) {
+								let s = getSideAxis(i.placement);
+								return s === C || s === "y";
+							}
+							return !0;
+						}).map((i) => [i.placement, i.overflows.filter((i) => i > 0).reduce((i, s) => i + s, 0)]).sort((i, s) => i[1] - s[1])[0]?.[0];
+						i && (c = i);
+						break;
+					}
+					case "initialPlacement":
+						c = f;
+						break;
+				}
+				if (l !== c) return { reset: { placement: c } };
+			}
+			return {};
+		}
+	};
+};
+function getSideOffsets(i, s) {
+	return {
+		top: i.top - s.height,
+		right: i.right - s.width,
+		bottom: i.bottom - s.height,
+		left: i.left - s.width
+	};
+}
+function isAnySideFullyClipped(i) {
+	return sides.some((s) => i[s] >= 0);
+}
+var hide$1 = function(i) {
+	return i === void 0 && (i = {}), {
+		name: "hide",
+		options: i,
+		async fn(s) {
+			let { rects: c } = s, { strategy: l = "referenceHidden", ...u } = evaluate(i, s);
+			switch (l) {
+				case "referenceHidden": {
+					let i = getSideOffsets(await detectOverflow(s, {
+						...u,
+						elementContext: "reference"
+					}), c.reference);
+					return { data: {
+						referenceHiddenOffsets: i,
+						referenceHidden: isAnySideFullyClipped(i)
+					} };
+				}
+				case "escaped": {
+					let i = getSideOffsets(await detectOverflow(s, {
+						...u,
+						altBoundary: !0
+					}), c.floating);
+					return { data: {
+						escapedOffsets: i,
+						escaped: isAnySideFullyClipped(i)
+					} };
+				}
+				default: return {};
+			}
+		}
+	};
+}, originSides = /* @__PURE__ */ new Set(["left", "top"]);
+async function convertValueToCoords(i, s) {
+	let { placement: c, platform: l, elements: u } = i, d = await (l.isRTL == null ? void 0 : l.isRTL(u.floating)), f = getSide(c), p = getAlignment(c), m = getSideAxis(c) === "y", h = originSides.has(f) ? -1 : 1, g = d && m ? -1 : 1, _ = evaluate(s, i), { mainAxis: v, crossAxis: y, alignmentAxis: b } = typeof _ == "number" ? {
+		mainAxis: _,
+		crossAxis: 0,
+		alignmentAxis: null
+	} : {
+		mainAxis: _.mainAxis || 0,
+		crossAxis: _.crossAxis || 0,
+		alignmentAxis: _.alignmentAxis
+	};
+	return p && typeof b == "number" && (y = p === "end" ? b * -1 : b), m ? {
+		x: y * g,
+		y: v * h
+	} : {
+		x: v * h,
+		y: y * g
+	};
+}
+var offset$1 = function(i) {
+	return i === void 0 && (i = 0), {
+		name: "offset",
+		options: i,
+		async fn(s) {
+			var c;
+			let { x: l, y: u, placement: d, middlewareData: f } = s, p = await convertValueToCoords(s, i);
+			return d === f.offset?.placement && (c = f.arrow) != null && c.alignmentOffset ? {} : {
+				x: l + p.x,
+				y: u + p.y,
+				data: {
+					...p,
+					placement: d
+				}
+			};
+		}
+	};
+}, shift$1 = function(i) {
+	return i === void 0 && (i = {}), {
+		name: "shift",
+		options: i,
+		async fn(s) {
+			let { x: c, y: l, placement: u } = s, { mainAxis: d = !0, crossAxis: f = !1, limiter: p = { fn: (i) => {
+				let { x: s, y: c } = i;
+				return {
+					x: s,
+					y: c
+				};
+			} }, ...m } = evaluate(i, s), h = {
+				x: c,
+				y: l
+			}, g = await detectOverflow(s, m), _ = getSideAxis(getSide(u)), v = getOppositeAxis(_), y = h[v], b = h[_];
+			if (d) {
+				let i = v === "y" ? "top" : "left", s = v === "y" ? "bottom" : "right", c = y + g[i], l = y - g[s];
+				y = clamp(c, y, l);
+			}
+			if (f) {
+				let i = _ === "y" ? "top" : "left", s = _ === "y" ? "bottom" : "right", c = b + g[i], l = b - g[s];
+				b = clamp(c, b, l);
+			}
+			let x = p.fn({
+				...s,
+				[v]: y,
+				[_]: b
+			});
+			return {
+				...x,
+				data: {
+					x: x.x - c,
+					y: x.y - l,
+					enabled: {
+						[v]: d,
+						[_]: f
+					}
+				}
+			};
+		}
+	};
+}, limitShift$1 = function(i) {
+	return i === void 0 && (i = {}), {
+		options: i,
+		fn(s) {
+			let { x: c, y: l, placement: u, rects: d, middlewareData: f } = s, { offset: p = 0, mainAxis: m = !0, crossAxis: h = !0 } = evaluate(i, s), g = {
+				x: c,
+				y: l
+			}, _ = getSideAxis(u), v = getOppositeAxis(_), y = g[v], b = g[_], x = evaluate(p, s), S = typeof x == "number" ? {
+				mainAxis: x,
+				crossAxis: 0
+			} : {
+				mainAxis: 0,
+				crossAxis: 0,
+				...x
+			};
+			if (m) {
+				let i = v === "y" ? "height" : "width", s = d.reference[v] - d.floating[i] + S.mainAxis, c = d.reference[v] + d.reference[i] - S.mainAxis;
+				y < s ? y = s : y > c && (y = c);
+			}
+			if (h) {
+				let i = v === "y" ? "width" : "height", s = originSides.has(getSide(u)), c = d.reference[_] - d.floating[i] + (s && f.offset?.[_] || 0) + (s ? 0 : S.crossAxis), l = d.reference[_] + d.reference[i] + (s ? 0 : f.offset?.[_] || 0) - (s ? S.crossAxis : 0);
+				b < c ? b = c : b > l && (b = l);
+			}
+			return {
+				[v]: y,
+				[_]: b
+			};
+		}
+	};
+}, size$1 = function(i) {
+	return i === void 0 && (i = {}), {
+		name: "size",
+		options: i,
+		async fn(s) {
+			var c, l;
+			let { placement: u, rects: d, platform: f, elements: p } = s, { apply: m = () => {}, ...h } = evaluate(i, s), g = await detectOverflow(s, h), _ = getSide(u), v = getAlignment(u), y = getSideAxis(u) === "y", { width: b, height: x } = d.floating, S, C;
+			_ === "top" || _ === "bottom" ? (S = _, C = v === (await (f.isRTL == null ? void 0 : f.isRTL(p.floating)) ? "start" : "end") ? "left" : "right") : (C = _, S = v === "end" ? "top" : "bottom");
+			let w = x - g.top - g.bottom, T = b - g.left - g.right, E = min$1(x - g[S], w), D = min$1(b - g[C], T), O = !s.middlewareData.shift, k = E, A = D;
+			if ((c = s.middlewareData.shift) != null && c.enabled.x && (A = T), (l = s.middlewareData.shift) != null && l.enabled.y && (k = w), O && !v) {
+				let i = max$1(g.left, 0), s = max$1(g.right, 0), c = max$1(g.top, 0), l = max$1(g.bottom, 0);
+				y ? A = b - 2 * (i !== 0 || s !== 0 ? i + s : max$1(g.left, g.right)) : k = x - 2 * (c !== 0 || l !== 0 ? c + l : max$1(g.top, g.bottom));
+			}
+			await m({
+				...s,
+				availableWidth: A,
+				availableHeight: k
+			});
+			let j = await f.getDimensions(p.floating);
+			return b !== j.width || x !== j.height ? { reset: { rects: !0 } } : {};
+		}
+	};
+};
+function hasWindow() {
+	return typeof window < "u";
+}
+function getNodeName$1(i) {
+	return isNode$1(i) ? (i.nodeName || "").toLowerCase() : "#document";
+}
+function getWindow$1(i) {
+	var s;
+	return (i == null || (s = i.ownerDocument) == null ? void 0 : s.defaultView) || window;
+}
+function getDocumentElement$1(i) {
+	return ((isNode$1(i) ? i.ownerDocument : i.document) || window.document)?.documentElement;
+}
+function isNode$1(i) {
+	return hasWindow() ? i instanceof Node || i instanceof getWindow$1(i).Node : !1;
+}
+function isElement$1(i) {
+	return hasWindow() ? i instanceof Element || i instanceof getWindow$1(i).Element : !1;
+}
+function isHTMLElement$1(i) {
+	return hasWindow() ? i instanceof HTMLElement || i instanceof getWindow$1(i).HTMLElement : !1;
+}
+function isShadowRoot$1(i) {
+	return !hasWindow() || typeof ShadowRoot > "u" ? !1 : i instanceof ShadowRoot || i instanceof getWindow$1(i).ShadowRoot;
+}
+var invalidOverflowDisplayValues = /* @__PURE__ */ new Set(["inline", "contents"]);
+function isOverflowElement$1(i) {
+	let { overflow: s, overflowX: c, overflowY: l, display: u } = getComputedStyle$1(i);
+	return /auto|scroll|overlay|hidden|clip/.test(s + l + c) && !invalidOverflowDisplayValues.has(u);
+}
+var tableElements = /* @__PURE__ */ new Set([
+	"table",
+	"td",
+	"th"
+]);
+function isTableElement(i) {
+	return tableElements.has(getNodeName$1(i));
+}
+var topLayerSelectors = [":popover-open", ":modal"];
+function isTopLayer(i) {
+	return topLayerSelectors.some((s) => {
+		try {
+			return i.matches(s);
+		} catch {
+			return !1;
+		}
+	});
+}
+var transformProperties = [
+	"transform",
+	"translate",
+	"scale",
+	"rotate",
+	"perspective"
+], willChangeValues = [
+	"transform",
+	"translate",
+	"scale",
+	"rotate",
+	"perspective",
+	"filter"
+], containValues = [
+	"paint",
+	"layout",
+	"strict",
+	"content"
+];
+function isContainingBlock(i) {
+	let s = isWebKit(), c = isElement$1(i) ? getComputedStyle$1(i) : i;
+	return transformProperties.some((i) => c[i] ? c[i] !== "none" : !1) || (c.containerType ? c.containerType !== "normal" : !1) || !s && (c.backdropFilter ? c.backdropFilter !== "none" : !1) || !s && (c.filter ? c.filter !== "none" : !1) || willChangeValues.some((i) => (c.willChange || "").includes(i)) || containValues.some((i) => (c.contain || "").includes(i));
+}
+function getContainingBlock(i) {
+	let s = getParentNode$2(i);
+	for (; isHTMLElement$1(s) && !isLastTraversableNode(s);) {
+		if (isContainingBlock(s)) return s;
+		if (isTopLayer(s)) return null;
+		s = getParentNode$2(s);
+	}
+	return null;
+}
+function isWebKit() {
+	return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+var lastTraversableNodeNames = /* @__PURE__ */ new Set([
+	"html",
+	"body",
+	"#document"
+]);
+function isLastTraversableNode(i) {
+	return lastTraversableNodeNames.has(getNodeName$1(i));
+}
+function getComputedStyle$1(i) {
+	return getWindow$1(i).getComputedStyle(i);
+}
+function getNodeScroll(i) {
+	return isElement$1(i) ? {
+		scrollLeft: i.scrollLeft,
+		scrollTop: i.scrollTop
+	} : {
+		scrollLeft: i.scrollX,
+		scrollTop: i.scrollY
+	};
+}
+function getParentNode$2(i) {
+	if (getNodeName$1(i) === "html") return i;
+	let s = i.assignedSlot || i.parentNode || isShadowRoot$1(i) && i.host || getDocumentElement$1(i);
+	return isShadowRoot$1(s) ? s.host : s;
+}
+function getNearestOverflowAncestor$1(i) {
+	let s = getParentNode$2(i);
+	return isLastTraversableNode(s) ? i.ownerDocument ? i.ownerDocument.body : i.body : isHTMLElement$1(s) && isOverflowElement$1(s) ? s : getNearestOverflowAncestor$1(s);
+}
+function getOverflowAncestors(i, s, c) {
+	s === void 0 && (s = []), c === void 0 && (c = !0);
+	let l = getNearestOverflowAncestor$1(i), u = l === i.ownerDocument?.body, d = getWindow$1(l);
+	if (u) {
+		let i = getFrameElement(d);
+		return s.concat(d, d.visualViewport || [], isOverflowElement$1(l) ? l : [], i && c ? getOverflowAncestors(i) : []);
+	}
+	return s.concat(l, getOverflowAncestors(l, [], c));
+}
+function getFrameElement(i) {
+	return i.parent && Object.getPrototypeOf(i.parent) ? i.frameElement : null;
+}
+var isEmpty = (i) => i.length === 0;
+function toKebabCase(i) {
+	return i.replace(/([a-z\d])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function createAnatomy(i, s = []) {
+	return {
+		parts: (...c) => {
+			if (isEmpty(s)) return createAnatomy(i, c);
+			throw Error("createAnatomy().parts(...) should only be called once. Did you mean to use .extendWith(...) ?");
+		},
+		extendWith: (...c) => createAnatomy(i, [...s, ...c]),
+		rename: (i) => createAnatomy(i, s),
+		keys: () => s,
+		build: () => [...new Set(s)].reduce((s, c) => Object.assign(s, { [c]: {
+			selector: [`&[data-scope="${toKebabCase(i)}"][data-part="${toKebabCase(c)}"]`, `& [data-scope="${toKebabCase(i)}"][data-part="${toKebabCase(c)}"]`].join(", "),
+			attrs: {
+				"data-scope": toKebabCase(i),
+				"data-part": toKebabCase(c)
+			}
+		} }), {})
+	};
+}
+var isObject$2 = (i) => typeof i == "object" && !!i, dataAttr = (i) => i ? "" : void 0, ELEMENT_NODE = 1, DOCUMENT_NODE = 9, DOCUMENT_FRAGMENT_NODE = 11;
+function isHTMLElement(i) {
+	return isObject$2(i) && i.nodeType === ELEMENT_NODE && typeof i.nodeName == "string";
+}
+var isDocument = (i) => isObject$2(i) && i.nodeType === DOCUMENT_NODE, isWindow = (i) => isObject$2(i) && i === i.window;
+function getNodeName(i) {
+	return isHTMLElement(i) ? i.localName || "" : "#document";
+}
+function isRootElement(i) {
+	return [
+		"html",
+		"body",
+		"#document"
+	].includes(getNodeName(i));
+}
+var isNode = (i) => isObject$2(i) && i.nodeType !== void 0;
+function isShadowRoot(i) {
+	return isNode(i) && i.nodeType === DOCUMENT_FRAGMENT_NODE && "host" in i;
+}
+var isInputElement = (i) => isHTMLElement(i) && i.localName === "input";
+function isElementVisible(i) {
+	return isHTMLElement(i) ? i.offsetWidth > 0 || i.offsetHeight > 0 || i.getClientRects().length > 0 : !1;
+}
+var TEXTAREA_SELECT_REGEX = /(textarea|select)/;
+function isEditableElement(i) {
+	if (i == null || !isHTMLElement(i)) return !1;
+	try {
+		return isInputElement(i) && i.selectionStart != null || TEXTAREA_SELECT_REGEX.test(i.localName) || i.isContentEditable || i.getAttribute("contenteditable") === "true" || i.getAttribute("contenteditable") === "";
+	} catch {
+		return !1;
+	}
+}
+function contains(i, s) {
+	if (!i || !s || !isHTMLElement(i) || !isHTMLElement(s)) return !1;
+	let c = s.getRootNode?.();
+	if (i === s || i.contains(s)) return !0;
+	if (c && isShadowRoot(c)) {
+		let c = s;
+		for (; c;) {
+			if (i === c) return !0;
+			c = c.parentNode || c.host;
+		}
+	}
+	return !1;
+}
+function getDocument(i) {
+	return isDocument(i) ? i : isWindow(i) ? i.document : i?.ownerDocument ?? document;
+}
+function getDocumentElement(i) {
+	return getDocument(i).documentElement;
+}
+function getWindow(i) {
+	return isShadowRoot(i) ? getWindow(i.host) : isDocument(i) ? i.defaultView ?? window : isHTMLElement(i) ? i.ownerDocument?.defaultView ?? window : window;
+}
+function getActiveElement(i) {
+	let s = i.activeElement;
+	for (; s?.shadowRoot;) {
+		let i = s.shadowRoot.activeElement;
+		if (i === s) break;
+		s = i;
+	}
+	return s;
+}
+function getParentNode$1(i) {
+	if (getNodeName(i) === "html") return i;
+	let s = i.assignedSlot || i.parentNode || isShadowRoot(i) && i.host || getDocumentElement(i);
+	return isShadowRoot(s) ? s.host : s;
+}
+var styleCache = /* @__PURE__ */ new WeakMap();
+function getComputedStyle(i) {
+	return styleCache.has(i) || styleCache.set(i, getWindow(i).getComputedStyle(i)), styleCache.get(i);
+}
+var isDom = () => typeof document < "u";
+function getPlatform() {
+	return navigator.userAgentData?.platform ?? navigator.platform;
+}
+var pt = (i) => isDom() && i.test(getPlatform()), vn = (i) => isDom() && i.test(navigator.vendor), isMac = () => pt(/^Mac/), isApple = () => pt(/mac|iphone|ipad|ipod/i), isSafari = () => isApple() && vn(/apple/i), isIos = () => pt(/iP(hone|ad|od)|iOS/);
+function getComposedPath(i) {
+	return i.composedPath?.() ?? i.nativeEvent?.composedPath?.();
+}
+function getEventTarget(i) {
+	return getComposedPath(i)?.[0] ?? i.target;
+}
+function isContextMenuEvent(i) {
+	return i.button === 2 || isMac() && i.ctrlKey && i.button === 0;
+}
+function addDomEvent(i, s, c, l) {
+	let u = typeof i == "function" ? i() : i;
+	return u?.addEventListener(s, c, l), () => {
+		u?.removeEventListener(s, c, l);
+	};
+}
+function getDescriptor(i, s) {
+	let { type: c = "HTMLInputElement", property: l = "value" } = s, u = getWindow(i)[c].prototype;
+	return Object.getOwnPropertyDescriptor(u, l) ?? {};
+}
+function getElementType(i) {
+	if (i.localName === "input") return "HTMLInputElement";
+	if (i.localName === "textarea") return "HTMLTextAreaElement";
+	if (i.localName === "select") return "HTMLSelectElement";
+}
+function setElementValue(i, s, c = "value") {
+	let l = getElementType(i);
+	l && getDescriptor(i, {
+		type: l,
+		property: c
+	}).set?.call(i, s), i.setAttribute(c, s);
+}
+var isFrame = (i) => isHTMLElement(i) && i.tagName === "IFRAME", hasTabIndex = (i) => !Number.isNaN(Number.parseInt(i.getAttribute("tabindex") || "0", 10)), hasNegativeTabIndex = (i) => Number.parseInt(i.getAttribute("tabindex") || "0", 10) < 0, focusableSelector = "input:not([type='hidden']):not([disabled]), select:not([disabled]), textarea:not([disabled]), a[href], button:not([disabled]), [tabindex], iframe, object, embed, area[href], audio[controls], video[controls], [contenteditable]:not([contenteditable='false']), details > summary:first-of-type";
+function getFocusables(i, s = !1) {
+	if (!i) return [];
+	let c = Array.from(i.querySelectorAll(focusableSelector));
+	(s === !0 || s === "if-empty" && c.length === 0) && isHTMLElement(i) && isFocusable(i) && c.unshift(i);
+	let l = c.filter(isFocusable);
+	return l.forEach((i, s) => {
+		if (isFrame(i) && i.contentDocument) {
+			let c = i.contentDocument.body;
+			l.splice(s, 1, ...getFocusables(c));
+		}
+	}), l;
+}
+function isFocusable(i) {
+	return !i || i.closest("[inert]") ? !1 : i.matches(focusableSelector) && isElementVisible(i);
+}
+function getTabbables(i, s) {
+	if (!i) return [];
+	let c = Array.from(i.querySelectorAll(focusableSelector)), l = c.filter(isTabbable);
+	return s && isTabbable(i) && l.unshift(i), l.forEach((i, s) => {
+		if (isFrame(i) && i.contentDocument) {
+			let c = i.contentDocument.body, u = getTabbables(c);
+			l.splice(s, 1, ...u);
+		}
+	}), !l.length && s ? c : l;
+}
+function isTabbable(i) {
+	return i != null && i.tabIndex > 0 ? !0 : isFocusable(i) && !hasNegativeTabIndex(i);
+}
+function getTabbableEdges(i, s) {
+	let c = getTabbables(i, s);
+	return [c[0] || null, c[c.length - 1] || null];
+}
+function getNextTabbable(i, s) {
+	let c = getTabbables(i), l = i?.ownerDocument || document, u = s ?? l.activeElement;
+	return u && c[c.indexOf(u) + 1] || null;
+}
+function getTabIndex(i) {
+	return i.tabIndex < 0 && (/^(audio|video|details)$/.test(i.localName) || isEditableElement(i)) && !hasTabIndex(i) ? 0 : i.tabIndex;
+}
+function getInitialFocus(i) {
+	let { root: s, getInitialEl: c, filter: l, enabled: u = !0 } = i;
+	if (!u) return;
+	let d = null;
+	if (d ||= typeof c == "function" ? c() : c, d ||= s?.querySelector("[data-autofocus],[autofocus]"), !d) {
+		let i = getTabbables(s);
+		d = l ? i.filter(l)[0] : i[0];
+	}
+	return d || s || void 0;
+}
+function raf$1(i) {
+	let s = globalThis.requestAnimationFrame(i);
+	return () => {
+		globalThis.cancelAnimationFrame(s);
+	};
+}
+function getNearestOverflowAncestor(i) {
+	let s = getParentNode$1(i);
+	return isRootElement(s) ? getDocument(s).body : isHTMLElement(s) && isOverflowElement(s) ? s : getNearestOverflowAncestor(s);
+}
+var OVERFLOW_RE = /auto|scroll|overlay|hidden|clip/;
+function isOverflowElement(i) {
+	let { overflow: s, overflowX: c, overflowY: l, display: u } = getWindow(i).getComputedStyle(i);
+	return OVERFLOW_RE.test(s + l + c) && !["inline", "contents"].includes(u);
+}
+function proxyTabFocusImpl(i, s = {}) {
+	let { triggerElement: c, onFocus: l } = s, u = i?.ownerDocument || document, d = u.body;
+	function f(s) {
+		if (s.key !== "Tab") return;
+		let f = null, [p, m] = getTabbableEdges(i, !0), h = !p && !m;
+		s.shiftKey && (u.activeElement === p || h) ? f = c : !s.shiftKey && u.activeElement === c ? f = p : !s.shiftKey && (u.activeElement === m || h) && (f = getNextTabbable(d, c)), f && (s.preventDefault(), typeof l == "function" ? l(f) : f.focus());
+	}
+	return addDomEvent(u, "keydown", f, !0);
+}
+function proxyTabFocus(i, s) {
+	let { defer: c, triggerElement: l, ...u } = s, d = c ? raf$1 : (i) => i(), f = [];
+	return f.push(d(() => {
+		let s = typeof i == "function" ? i() : i, c = typeof l == "function" ? l() : l;
+		f.push(proxyTabFocusImpl(s, {
+			triggerElement: c,
+			...u
+		}));
+	})), () => {
+		f.forEach((i) => i?.());
+	};
+}
+function createScope(i) {
+	let s = {
+		getRootNode: (i) => i.getRootNode?.() ?? document,
+		getDoc: (i) => getDocument(s.getRootNode(i)),
+		getWin: (i) => s.getDoc(i).defaultView ?? window,
+		getActiveElement: (i) => getActiveElement(s.getRootNode(i)),
+		isActiveElement: (i, c) => c === s.getActiveElement(i),
+		getById: (i, c) => s.getRootNode(i).getElementById(c),
+		setValue: (i, s) => {
+			i == null || s == null || setElementValue(i, s.toString());
+		}
+	};
+	return {
+		...s,
+		...i
+	};
+}
+var cleanups = /* @__PURE__ */ new WeakMap();
+function set$1(i, s, c) {
+	cleanups.has(i) || cleanups.set(i, /* @__PURE__ */ new Map());
+	let l = cleanups.get(i), u = l.get(s);
+	if (!u) return l.set(s, c()), () => {
+		l.get(s)?.(), l.delete(s);
+	};
+	let d = c(), f = () => {
+		d(), u(), l.delete(s);
+	};
+	return l.set(s, f), () => {
+		l.get(s) === f && (d(), l.set(s, u));
+	};
+}
+function setStyle(i, s) {
+	return i ? set$1(i, "style", () => {
+		let c = i.style.cssText;
+		return Object.assign(i.style, s), () => {
+			i.style.cssText = c;
+		};
+	}) : () => {};
+}
+var fps = 1e3 / 60;
+function waitForElement(i, s) {
+	let c = i();
+	if (isHTMLElement(c) && c.isConnected) return s(c), () => void 0;
+	{
+		let c = setInterval(() => {
+			let l = i();
+			isHTMLElement(l) && l.isConnected && (s(l), clearInterval(c));
+		}, fps);
+		return () => clearInterval(c);
+	}
+}
+function waitForElements(i, s) {
+	let c = [];
+	return i?.forEach((i) => {
+		let l = waitForElement(i, s);
+		c.push(l);
+	}), () => {
+		c.forEach((i) => i());
+	};
+}
+function clear(i) {
+	for (; i.length > 0;) i.pop();
+	return i;
+}
+function runIfFn(i, ...s) {
+	return (typeof i == "function" ? i(...s) : i) ?? void 0;
+}
+var cast = (i) => i;
+function noop() {}
+function callAll(...i) {
+	return (...s) => {
+		i.forEach((i) => {
+			i?.(...s);
+		});
+	};
+}
+var uuid = /* @__PURE__ */ (() => {
+	let i = 0;
+	return () => (i++, i.toString(36));
+})(), isArray = (i) => Array.isArray(i), isObjectLike = (i) => typeof i == "object" && !!i, isObject$1 = (i) => isObjectLike(i) && !isArray(i), isNumber = (i) => typeof i == "number" && !Number.isNaN(i), isString = (i) => typeof i == "string", isFunction = (i) => typeof i == "function", isNull = (i) => i == null;
+function hasProp(i, s) {
+	return Object.prototype.hasOwnProperty.call(i, s);
+}
+var baseGetTag = (i) => Object.prototype.toString.call(i), fnToString = Function.prototype.toString, objectCtorString = fnToString.call(Object);
+function isPlainObject(i) {
+	if (!isObjectLike(i) || baseGetTag(i) !== "[object Object]") return !1;
+	let s = Object.getPrototypeOf(i);
+	if (s === null) return !0;
+	let c = hasProp(s, "constructor") && s.constructor;
+	return typeof c == "function" && c instanceof c && fnToString.call(c) === objectCtorString;
+}
+var { floor, abs, round, min, max, sign } = Math;
+function compact(i) {
+	if (!isPlainObject$1(i) || i === void 0) return i;
+	let s = Reflect.ownKeys(i).filter((i) => typeof i == "string"), c = {};
+	for (let l of s) {
+		let s = i[l];
+		s !== void 0 && (c[l] = compact(s));
+	}
+	return c;
+}
+function isPlainObject$1(i) {
+	return i && typeof i == "object" && i.constructor === Object;
+}
+function getCssDimensions(i) {
+	let s = getComputedStyle$1(i), c = parseFloat(s.width) || 0, l = parseFloat(s.height) || 0, u = isHTMLElement$1(i), d = u ? i.offsetWidth : c, f = u ? i.offsetHeight : l, p = round$1(c) !== d || round$1(l) !== f;
+	return p && (c = d, l = f), {
+		width: c,
+		height: l,
+		$: p
+	};
+}
+function unwrapElement(i) {
+	return isElement$1(i) ? i : i.contextElement;
+}
+function getScale(i) {
+	let s = unwrapElement(i);
+	if (!isHTMLElement$1(s)) return createCoords(1);
+	let c = s.getBoundingClientRect(), { width: l, height: u, $: d } = getCssDimensions(s), f = (d ? round$1(c.width) : c.width) / l, p = (d ? round$1(c.height) : c.height) / u;
+	return (!f || !Number.isFinite(f)) && (f = 1), (!p || !Number.isFinite(p)) && (p = 1), {
+		x: f,
+		y: p
+	};
+}
+var noOffsets = /* @__PURE__ */ createCoords(0);
+function getVisualOffsets(i) {
+	let s = getWindow$1(i);
+	return !isWebKit() || !s.visualViewport ? noOffsets : {
+		x: s.visualViewport.offsetLeft,
+		y: s.visualViewport.offsetTop
+	};
+}
+function shouldAddVisualOffsets(i, s, c) {
+	return s === void 0 && (s = !1), !c || s && c !== getWindow$1(i) ? !1 : s;
+}
+function getBoundingClientRect(i, s, c, l) {
+	s === void 0 && (s = !1), c === void 0 && (c = !1);
+	let u = i.getBoundingClientRect(), d = unwrapElement(i), f = createCoords(1);
+	s && (l ? isElement$1(l) && (f = getScale(l)) : f = getScale(i));
+	let p = shouldAddVisualOffsets(d, c, l) ? getVisualOffsets(d) : createCoords(0), m = (u.left + p.x) / f.x, h = (u.top + p.y) / f.y, g = u.width / f.x, _ = u.height / f.y;
+	if (d) {
+		let i = getWindow$1(d), s = l && isElement$1(l) ? getWindow$1(l) : l, c = i, u = getFrameElement(c);
+		for (; u && l && s !== c;) {
+			let i = getScale(u), s = u.getBoundingClientRect(), l = getComputedStyle$1(u), d = s.left + (u.clientLeft + parseFloat(l.paddingLeft)) * i.x, f = s.top + (u.clientTop + parseFloat(l.paddingTop)) * i.y;
+			m *= i.x, h *= i.y, g *= i.x, _ *= i.y, m += d, h += f, c = getWindow$1(u), u = getFrameElement(c);
+		}
+	}
+	return rectToClientRect({
+		width: g,
+		height: _,
+		x: m,
+		y: h
+	});
+}
+function getWindowScrollBarX(i, s) {
+	let c = getNodeScroll(i).scrollLeft;
+	return s ? s.left + c : getBoundingClientRect(getDocumentElement$1(i)).left + c;
+}
+function getHTMLOffset(i, s, c) {
+	c === void 0 && (c = !1);
+	let l = i.getBoundingClientRect();
+	return {
+		x: l.left + s.scrollLeft - (c ? 0 : getWindowScrollBarX(i, l)),
+		y: l.top + s.scrollTop
+	};
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(i) {
+	let { elements: s, rect: c, offsetParent: l, strategy: u } = i, d = u === "fixed", f = getDocumentElement$1(l), p = s ? isTopLayer(s.floating) : !1;
+	if (l === f || p && d) return c;
+	let m = {
+		scrollLeft: 0,
+		scrollTop: 0
+	}, h = createCoords(1), g = createCoords(0), _ = isHTMLElement$1(l);
+	if ((_ || !_ && !d) && ((getNodeName$1(l) !== "body" || isOverflowElement$1(f)) && (m = getNodeScroll(l)), isHTMLElement$1(l))) {
+		let i = getBoundingClientRect(l);
+		h = getScale(l), g.x = i.x + l.clientLeft, g.y = i.y + l.clientTop;
+	}
+	let v = f && !_ && !d ? getHTMLOffset(f, m, !0) : createCoords(0);
+	return {
+		width: c.width * h.x,
+		height: c.height * h.y,
+		x: c.x * h.x - m.scrollLeft * h.x + g.x + v.x,
+		y: c.y * h.y - m.scrollTop * h.y + g.y + v.y
+	};
+}
+function getClientRects(i) {
+	return Array.from(i.getClientRects());
+}
+function getDocumentRect(i) {
+	let s = getDocumentElement$1(i), c = getNodeScroll(i), l = i.ownerDocument.body, u = max$1(s.scrollWidth, s.clientWidth, l.scrollWidth, l.clientWidth), d = max$1(s.scrollHeight, s.clientHeight, l.scrollHeight, l.clientHeight), f = -c.scrollLeft + getWindowScrollBarX(i), p = -c.scrollTop;
+	return getComputedStyle$1(l).direction === "rtl" && (f += max$1(s.clientWidth, l.clientWidth) - u), {
+		width: u,
+		height: d,
+		x: f,
+		y: p
+	};
+}
+function getViewportRect(i, s) {
+	let c = getWindow$1(i), l = getDocumentElement$1(i), u = c.visualViewport, d = l.clientWidth, f = l.clientHeight, p = 0, m = 0;
+	if (u) {
+		d = u.width, f = u.height;
+		let i = isWebKit();
+		(!i || i && s === "fixed") && (p = u.offsetLeft, m = u.offsetTop);
+	}
+	return {
+		width: d,
+		height: f,
+		x: p,
+		y: m
+	};
+}
+function getInnerBoundingClientRect(i, s) {
+	let c = getBoundingClientRect(i, !0, s === "fixed"), l = c.top + i.clientTop, u = c.left + i.clientLeft, d = isHTMLElement$1(i) ? getScale(i) : createCoords(1);
+	return {
+		width: i.clientWidth * d.x,
+		height: i.clientHeight * d.y,
+		x: u * d.x,
+		y: l * d.y
+	};
+}
+function getClientRectFromClippingAncestor(i, s, c) {
+	let l;
+	if (s === "viewport") l = getViewportRect(i, c);
+	else if (s === "document") l = getDocumentRect(getDocumentElement$1(i));
+	else if (isElement$1(s)) l = getInnerBoundingClientRect(s, c);
+	else {
+		let c = getVisualOffsets(i);
+		l = {
+			x: s.x - c.x,
+			y: s.y - c.y,
+			width: s.width,
+			height: s.height
+		};
+	}
+	return rectToClientRect(l);
+}
+function hasFixedPositionAncestor(i, s) {
+	let c = getParentNode$2(i);
+	return c === s || !isElement$1(c) || isLastTraversableNode(c) ? !1 : getComputedStyle$1(c).position === "fixed" || hasFixedPositionAncestor(c, s);
+}
+function getClippingElementAncestors(i, s) {
+	let c = s.get(i);
+	if (c) return c;
+	let l = getOverflowAncestors(i, [], !1).filter((i) => isElement$1(i) && getNodeName$1(i) !== "body"), u = null, d = getComputedStyle$1(i).position === "fixed", f = d ? getParentNode$2(i) : i;
+	for (; isElement$1(f) && !isLastTraversableNode(f);) {
+		let s = getComputedStyle$1(f), c = isContainingBlock(f);
+		!c && s.position === "fixed" && (u = null), (d ? !c && !u : !c && s.position === "static" && u && ["absolute", "fixed"].includes(u.position) || isOverflowElement$1(f) && !c && hasFixedPositionAncestor(i, f)) ? l = l.filter((i) => i !== f) : u = s, f = getParentNode$2(f);
+	}
+	return s.set(i, l), l;
+}
+function getClippingRect(i) {
+	let { element: s, boundary: c, rootBoundary: l, strategy: u } = i, d = [...c === "clippingAncestors" ? isTopLayer(s) ? [] : getClippingElementAncestors(s, this._c) : [].concat(c), l], f = d[0], p = d.reduce((i, c) => {
+		let l = getClientRectFromClippingAncestor(s, c, u);
+		return i.top = max$1(l.top, i.top), i.right = min$1(l.right, i.right), i.bottom = min$1(l.bottom, i.bottom), i.left = max$1(l.left, i.left), i;
+	}, getClientRectFromClippingAncestor(s, f, u));
+	return {
+		width: p.right - p.left,
+		height: p.bottom - p.top,
+		x: p.left,
+		y: p.top
+	};
+}
+function getDimensions(i) {
+	let { width: s, height: c } = getCssDimensions(i);
+	return {
+		width: s,
+		height: c
+	};
+}
+function getRectRelativeToOffsetParent(i, s, c) {
+	let l = isHTMLElement$1(s), u = getDocumentElement$1(s), d = c === "fixed", f = getBoundingClientRect(i, !0, d, s), p = {
+		scrollLeft: 0,
+		scrollTop: 0
+	}, m = createCoords(0);
+	function h() {
+		m.x = getWindowScrollBarX(u);
+	}
+	if (l || !l && !d) if ((getNodeName$1(s) !== "body" || isOverflowElement$1(u)) && (p = getNodeScroll(s)), l) {
+		let i = getBoundingClientRect(s, !0, d, s);
+		m.x = i.x + s.clientLeft, m.y = i.y + s.clientTop;
+	} else u && h();
+	d && !l && u && h();
+	let g = u && !l && !d ? getHTMLOffset(u, p) : createCoords(0);
+	return {
+		x: f.left + p.scrollLeft - m.x - g.x,
+		y: f.top + p.scrollTop - m.y - g.y,
+		width: f.width,
+		height: f.height
+	};
+}
+function isStaticPositioned(i) {
+	return getComputedStyle$1(i).position === "static";
+}
+function getTrueOffsetParent(i, s) {
+	if (!isHTMLElement$1(i) || getComputedStyle$1(i).position === "fixed") return null;
+	if (s) return s(i);
+	let c = i.offsetParent;
+	return getDocumentElement$1(i) === c && (c = c.ownerDocument.body), c;
+}
+function getOffsetParent(i, s) {
+	let c = getWindow$1(i);
+	if (isTopLayer(i)) return c;
+	if (!isHTMLElement$1(i)) {
+		let s = getParentNode$2(i);
+		for (; s && !isLastTraversableNode(s);) {
+			if (isElement$1(s) && !isStaticPositioned(s)) return s;
+			s = getParentNode$2(s);
+		}
+		return c;
+	}
+	let l = getTrueOffsetParent(i, s);
+	for (; l && isTableElement(l) && isStaticPositioned(l);) l = getTrueOffsetParent(l, s);
+	return l && isLastTraversableNode(l) && isStaticPositioned(l) && !isContainingBlock(l) ? c : l || getContainingBlock(i) || c;
+}
+var getElementRects = async function(i) {
+	let s = this.getOffsetParent || getOffsetParent, c = this.getDimensions, l = await c(i.floating);
+	return {
+		reference: getRectRelativeToOffsetParent(i.reference, await s(i.floating), i.strategy),
+		floating: {
+			x: 0,
+			y: 0,
+			width: l.width,
+			height: l.height
+		}
+	};
+};
+function isRTL(i) {
+	return getComputedStyle$1(i).direction === "rtl";
+}
+var platform = {
+	convertOffsetParentRelativeRectToViewportRelativeRect,
+	getDocumentElement: getDocumentElement$1,
+	getClippingRect,
+	getOffsetParent,
+	getElementRects,
+	getClientRects,
+	getDimensions,
+	getScale,
+	isElement: isElement$1,
+	isRTL
+};
+function rectsAreEqual(i, s) {
+	return i.x === s.x && i.y === s.y && i.width === s.width && i.height === s.height;
+}
+function observeMove(i, s) {
+	let c = null, l, u = getDocumentElement$1(i);
+	function d() {
+		var i;
+		clearTimeout(l), (i = c) == null || i.disconnect(), c = null;
+	}
+	function f(p, m) {
+		p === void 0 && (p = !1), m === void 0 && (m = 1), d();
+		let h = i.getBoundingClientRect(), { left: g, top: _, width: v, height: y } = h;
+		if (p || s(), !v || !y) return;
+		let b = floor$1(_), x = floor$1(u.clientWidth - (g + v)), S = floor$1(u.clientHeight - (_ + y)), C = floor$1(g), w = {
+			rootMargin: -b + "px " + -x + "px " + -S + "px " + -C + "px",
+			threshold: max$1(0, min$1(1, m)) || 1
+		}, T = !0;
+		function E(s) {
+			let c = s[0].intersectionRatio;
+			if (c !== m) {
+				if (!T) return f();
+				c ? f(!1, c) : l = setTimeout(() => {
+					f(!1, 1e-7);
+				}, 1e3);
+			}
+			c === 1 && !rectsAreEqual(h, i.getBoundingClientRect()) && f(), T = !1;
+		}
+		try {
+			c = new IntersectionObserver(E, {
+				...w,
+				root: u.ownerDocument
+			});
+		} catch {
+			c = new IntersectionObserver(E, w);
+		}
+		c.observe(i);
+	}
+	return f(!0), d;
+}
+function autoUpdate(i, s, c, l) {
+	l === void 0 && (l = {});
+	let { ancestorScroll: u = !0, ancestorResize: d = !0, elementResize: f = typeof ResizeObserver == "function", layoutShift: p = typeof IntersectionObserver == "function", animationFrame: m = !1 } = l, h = unwrapElement(i), g = u || d ? [...h ? getOverflowAncestors(h) : [], ...getOverflowAncestors(s)] : [];
+	g.forEach((i) => {
+		u && i.addEventListener("scroll", c, { passive: !0 }), d && i.addEventListener("resize", c);
+	});
+	let _ = h && p ? observeMove(h, c) : null, v = -1, y = null;
+	f && (y = new ResizeObserver((i) => {
+		let [l] = i;
+		l && l.target === h && y && (y.unobserve(s), cancelAnimationFrame(v), v = requestAnimationFrame(() => {
+			var i;
+			(i = y) == null || i.observe(s);
+		})), c();
+	}), h && !m && y.observe(h), y.observe(s));
+	let b, x = m ? getBoundingClientRect(i) : null;
+	m && S();
+	function S() {
+		let s = getBoundingClientRect(i);
+		x && !rectsAreEqual(x, s) && c(), x = s, b = requestAnimationFrame(S);
+	}
+	return c(), () => {
+		var i;
+		g.forEach((i) => {
+			u && i.removeEventListener("scroll", c), d && i.removeEventListener("resize", c);
+		}), _?.(), (i = y) == null || i.disconnect(), y = null, m && cancelAnimationFrame(b);
+	};
+}
+var offset = offset$1, shift = shift$1, flip = flip$1, size = size$1, hide = hide$1, arrow = arrow$1, limitShift = limitShift$1, computePosition = (i, s, c) => {
+	let l = /* @__PURE__ */ new Map(), u = {
+		platform,
+		...c
+	}, d = {
+		...u.platform,
+		_c: l
+	};
+	return computePosition$1(i, s, {
+		...u,
+		platform: d
+	});
+};
+function createDOMRect(i = 0, s = 0, c = 0, l = 0) {
+	if (typeof DOMRect == "function") return new DOMRect(i, s, c, l);
+	let u = {
+		x: i,
+		y: s,
+		width: c,
+		height: l,
+		top: s,
+		right: i + c,
+		bottom: s + l,
+		left: i
+	};
+	return {
+		...u,
+		toJSON: () => u
+	};
+}
+function getDOMRect(i) {
+	if (!i) return createDOMRect();
+	let { x: s, y: c, width: l, height: u } = i;
+	return createDOMRect(s, c, l, u);
+}
+function getAnchorElement(i, s) {
+	return {
+		contextElement: isHTMLElement(i) ? i : void 0,
+		getBoundingClientRect: () => {
+			let c = i, l = s?.(c);
+			return l || !c ? getDOMRect(l) : c.getBoundingClientRect();
+		}
+	};
+}
+var toVar = (i) => ({
+	variable: i,
+	reference: `var(${i})`
+}), cssVars = {
+	arrowSize: toVar("--arrow-size"),
+	arrowSizeHalf: toVar("--arrow-size-half"),
+	arrowBg: toVar("--arrow-background"),
+	transformOrigin: toVar("--transform-origin"),
+	arrowOffset: toVar("--arrow-offset")
+};
+function getTransformOrigin(i) {
+	return {
+		top: "bottom center",
+		"top-start": i ? `${i.x}px bottom` : "left bottom",
+		"top-end": i ? `${i.x}px bottom` : "right bottom",
+		bottom: "top center",
+		"bottom-start": i ? `${i.x}px top` : "top left",
+		"bottom-end": i ? `${i.x}px top` : "top right",
+		left: "right center",
+		"left-start": i ? `right ${i.y}px` : "right top",
+		"left-end": i ? `right ${i.y}px` : "right bottom",
+		right: "left center",
+		"right-start": i ? `left ${i.y}px` : "left top",
+		"right-end": i ? `left ${i.y}px` : "left bottom"
+	};
+}
+var transformOriginMiddleware = {
+	name: "transformOrigin",
+	fn({ placement: i, elements: s, middlewareData: c }) {
+		let { arrow: l } = c, u = getTransformOrigin(l)[i], { floating: d } = s;
+		return d.style.setProperty(cssVars.transformOrigin.variable, u), { data: { transformOrigin: u } };
+	}
+}, rectMiddleware = {
+	name: "rects",
+	fn({ rects: i }) {
+		return { data: i };
+	}
+};
+function shiftArrowMiddleware(i) {
+	if (i) return {
+		name: "shiftArrow",
+		fn({ placement: s, middlewareData: c }) {
+			if (!c.arrow) return {};
+			let { x: l, y: u } = c.arrow, d = s.split("-")[0];
+			return Object.assign(i.style, {
+				left: l == null ? "" : `${l}px`,
+				top: u == null ? "" : `${u}px`,
+				[d]: `calc(100% + ${cssVars.arrowOffset.reference})`
+			}), {};
+		}
+	};
+}
+function getPlacementDetails(i) {
+	let [s, c] = i.split("-");
+	return {
+		side: s,
+		align: c,
+		hasAlign: c != null
+	};
+}
+var defaultOptions = {
+	strategy: "absolute",
+	placement: "bottom",
+	listeners: !0,
+	gutter: 8,
+	flip: !0,
+	slide: !0,
+	overlap: !1,
+	sameWidth: !1,
+	fitViewport: !1,
+	overflowPadding: 8,
+	arrowPadding: 4
+};
+function roundByDpr(i, s) {
+	let c = i.devicePixelRatio || 1;
+	return Math.round(s * c) / c;
+}
+function getBoundaryMiddleware(i) {
+	return runIfFn(i.boundary);
+}
+function getArrowMiddleware(i, s) {
+	if (i) return arrow({
+		element: i,
+		padding: s.arrowPadding
+	});
+}
+function getOffsetMiddleware(i, s) {
+	if (!isNull(s.offset ?? s.gutter)) return offset(({ placement: c }) => {
+		let l = (i?.clientHeight || 0) / 2, u = s.offset?.mainAxis ?? s.gutter, d = typeof u == "number" ? u + l : u ?? l, { hasAlign: f } = getPlacementDetails(c), p = f ? void 0 : s.shift;
+		return compact({
+			crossAxis: s.offset?.crossAxis ?? p,
+			mainAxis: d,
+			alignmentAxis: s.shift
+		});
+	});
+}
+function getFlipMiddleware(i) {
+	if (i.flip) return flip({
+		boundary: getBoundaryMiddleware(i),
+		padding: i.overflowPadding,
+		fallbackPlacements: i.flip === !0 ? void 0 : i.flip
+	});
+}
+function getShiftMiddleware(i) {
+	if (!(!i.slide && !i.overlap)) return shift({
+		boundary: getBoundaryMiddleware(i),
+		mainAxis: i.slide,
+		crossAxis: i.overlap,
+		padding: i.overflowPadding,
+		limiter: limitShift()
+	});
+}
+function getSizeMiddleware(i) {
+	return size({
+		padding: i.overflowPadding,
+		apply({ elements: i, rects: s, availableHeight: c, availableWidth: l }) {
+			let u = i.floating, d = Math.round(s.reference.width);
+			l = Math.floor(l), c = Math.floor(c), u.style.setProperty("--reference-width", `${d}px`), u.style.setProperty("--available-width", `${l}px`), u.style.setProperty("--available-height", `${c}px`);
+		}
+	});
+}
+function hideWhenDetachedMiddleware(i) {
+	if (i.hideWhenDetached) return hide({
+		strategy: "referenceHidden",
+		boundary: i.boundary?.() ?? "clippingAncestors"
+	});
+}
+function getAutoUpdateOptions(i) {
+	return i ? i === !0 ? {
+		ancestorResize: !0,
+		ancestorScroll: !0,
+		elementResize: !0,
+		layoutShift: !0
+	} : i : {};
+}
+function getPlacementImpl(i, s, c = {}) {
+	let l = getAnchorElement(i, c.getAnchorRect);
+	if (!s || !l) return;
+	let u = Object.assign({}, defaultOptions, c), d = s.querySelector("[data-part=arrow]"), f = [
+		getOffsetMiddleware(d, u),
+		getFlipMiddleware(u),
+		getShiftMiddleware(u),
+		getArrowMiddleware(d, u),
+		shiftArrowMiddleware(d),
+		transformOriginMiddleware,
+		getSizeMiddleware(u),
+		hideWhenDetachedMiddleware(u),
+		rectMiddleware
+	], { placement: p, strategy: m, onComplete: h, onPositioned: g } = u, _ = async () => {
+		if (!l || !s) return;
+		let i = await computePosition(l, s, {
+			placement: p,
+			middleware: f,
+			strategy: m
+		});
+		h?.(i), g?.({ placed: !0 });
+		let c = getWindow(s), d = roundByDpr(c, i.x), _ = roundByDpr(c, i.y);
+		s.style.setProperty("--x", `${d}px`), s.style.setProperty("--y", `${_}px`), u.hideWhenDetached && (i.middlewareData.hide?.referenceHidden ? (s.style.setProperty("visibility", "hidden"), s.style.setProperty("pointer-events", "none")) : (s.style.removeProperty("visibility"), s.style.removeProperty("pointer-events")));
+		let v = s.firstElementChild;
+		if (v) {
+			let i = getComputedStyle(v);
+			s.style.setProperty("--z-index", i.zIndex);
+		}
+	}, v = async () => {
+		c.updatePosition ? (await c.updatePosition({ updatePosition: _ }), g?.({ placed: !0 })) : await _();
+	}, y = getAutoUpdateOptions(u.listeners), b = u.listeners ? autoUpdate(l, s, v, y) : noop;
+	return v(), () => {
+		b?.(), g?.({ placed: !1 });
+	};
+}
+function getPlacement(i, s, c = {}) {
+	let { defer: l, ...u } = c, d = l ? raf$1 : (i) => i(), f = [];
+	return f.push(d(() => {
+		let c = typeof i == "function" ? i() : i, l = typeof s == "function" ? s() : s;
+		f.push(getPlacementImpl(c, l, u));
+	})), () => {
+		f.forEach((i) => i?.());
+	};
+}
+var ARROW_FLOATING_STYLE = {
+	bottom: "rotate(45deg)",
+	left: "rotate(135deg)",
+	top: "rotate(225deg)",
+	right: "rotate(315deg)"
+};
+function getPlacementStyles(i = {}) {
+	let { placement: s, sameWidth: c, fitViewport: l, strategy: u = "absolute" } = i;
+	return {
+		arrow: {
+			position: "absolute",
+			width: cssVars.arrowSize.reference,
+			height: cssVars.arrowSize.reference,
+			[cssVars.arrowSizeHalf.variable]: `calc(${cssVars.arrowSize.reference} / 2)`,
+			[cssVars.arrowOffset.variable]: `calc(${cssVars.arrowSizeHalf.reference} * -1)`
+		},
+		arrowTip: {
+			transform: s ? ARROW_FLOATING_STYLE[s.split("-")[0]] : void 0,
+			background: cssVars.arrowBg.reference,
+			top: "0",
+			left: "0",
+			width: "100%",
+			height: "100%",
+			position: "absolute",
+			zIndex: "inherit"
+		},
+		floating: {
+			position: u,
+			isolation: "isolate",
+			minWidth: c ? void 0 : "max-content",
+			width: c ? "var(--reference-width)" : void 0,
+			maxWidth: l ? "var(--available-width)" : void 0,
+			maxHeight: l ? "var(--available-height)" : void 0,
+			top: "0px",
+			left: "0px",
+			transform: s ? "translate3d(var(--x), var(--y), 0)" : "translate3d(0, -100vh, 0)",
+			zIndex: "var(--z-index)"
+		}
+	};
+}
+var counterMap = /* @__PURE__ */ new WeakMap(), uncontrolledNodes = /* @__PURE__ */ new WeakMap(), markerMap = {}, lockCount = 0;
+function unwrapHost(i) {
+	return i && (i.host || unwrapHost(i.parentNode));
+}
+function correctTargets(i, s) {
+	return s.map((s) => {
+		if (i.contains(s)) return s;
+		let c = unwrapHost(s);
+		return c && i.contains(c) ? c : (console.error("[@destyler/aria-hidden] target", s, "in not contained inside", i, ". Doing nothing"), null);
+	}).filter((i) => !!i);
+}
+function isIgnoredNode(i) {
+	return i.localName === "next-route-announcer" || i.localName === "script" || i.hasAttribute("aria-live") ? !0 : i.matches("[data-live-announcer]");
+}
+function walkTreeOutside(i, s) {
+	let { parentNode: c, markerName: l, controlAttribute: u, explicitBooleanValue: d } = s, f = correctTargets(c, Array.isArray(i) ? i : [i]);
+	markerMap[l] ||= /* @__PURE__ */ new WeakMap();
+	let p = markerMap[l], m = [], h = /* @__PURE__ */ new Set(), g = new Set(f), _ = (i) => {
+		!i || h.has(i) || (h.add(i), _(i.parentNode));
+	};
+	f.forEach(_);
+	let v = (i) => {
+		!i || g.has(i) || Array.prototype.forEach.call(i.children, (i) => {
+			if (h.has(i)) v(i);
+			else try {
+				if (isIgnoredNode(i)) return;
+				let s = i.getAttribute(u), c = d ? s === "true" : s !== null && s !== "false", f = (counterMap.get(i) || 0) + 1, h = (p.get(i) || 0) + 1;
+				counterMap.set(i, f), p.set(i, h), m.push(i), f === 1 && c && uncontrolledNodes.set(i, !0), h === 1 && i.setAttribute(l, ""), c || i.setAttribute(u, d ? "true" : "");
+			} catch (s) {
+				console.error("[@destyler/aria-hidden] cannot operate on ", i, s);
+			}
+		});
+	};
+	return v(c), h.clear(), lockCount++, () => {
+		m.forEach((i) => {
+			let s = counterMap.get(i) - 1, c = p.get(i) - 1;
+			counterMap.set(i, s), p.set(i, c), s || (uncontrolledNodes.has(i) || i.removeAttribute(u), uncontrolledNodes.delete(i)), c || i.removeAttribute(l);
+		}), lockCount--, lockCount || (counterMap = /* @__PURE__ */ new WeakMap(), counterMap = /* @__PURE__ */ new WeakMap(), uncontrolledNodes = /* @__PURE__ */ new WeakMap(), markerMap = {});
+	};
+}
+function getParentNode(i) {
+	return (Array.isArray(i) ? i[0] : i).ownerDocument.body;
+}
+function hideOthers(i, s = getParentNode(i), c = "data-aria-hidden") {
+	if (s) return walkTreeOutside(i, {
+		parentNode: s,
+		markerName: c,
+		controlAttribute: "aria-hidden",
+		explicitBooleanValue: !0
+	});
+}
+function raf(i) {
+	let s = requestAnimationFrame(() => i());
+	return () => cancelAnimationFrame(s);
+}
+function ariaHidden(i, s = {}) {
+	let { defer: c = !0 } = s, l = c ? raf : (i) => i(), u = [];
+	return u.push(l(() => {
+		let s = (typeof i == "function" ? i() : i).filter(Boolean);
+		s.length !== 0 && u.push(hideOthers(s));
+	})), () => {
+		u.forEach((i) => i?.());
+	};
+}
+function getWindowFrames(i) {
+	let s = {
+		each(s) {
+			for (let c = 0; c < i.frames?.length; c += 1) {
+				let l = i.frames[c];
+				l && s(l);
+			}
+		},
+		addEventListener(i, c, l) {
+			return s.each((s) => {
+				try {
+					s.document.addEventListener(i, c, l);
+				} catch {}
+			}), () => {
+				try {
+					s.removeEventListener(i, c, l);
+				} catch {}
+			};
+		},
+		removeEventListener(i, c, l) {
+			s.each((s) => {
+				try {
+					s.document.removeEventListener(i, c, l);
+				} catch {}
+			});
+		}
+	};
+	return s;
+}
+function getParentWindow(i) {
+	let s = i.frameElement == null ? null : i.parent;
+	return {
+		addEventListener: (i, c, l) => {
+			try {
+				s?.addEventListener(i, c, l);
+			} catch {}
+			return () => {
+				try {
+					s?.removeEventListener(i, c, l);
+				} catch {}
+			};
+		},
+		removeEventListener: (i, c, l) => {
+			try {
+				s?.removeEventListener(i, c, l);
+			} catch {}
+		}
+	};
+}
+var POINTER_OUTSIDE_EVENT = "pointerdown.outside", FOCUS_OUTSIDE_EVENT = "focus.outside";
+function isComposedPathFocusable(i) {
+	for (let s of i) if (isHTMLElement(s) && isFocusable(s)) return !0;
+	return !1;
+}
+var isPointerEvent = (i) => "clientY" in i;
+function isEventPointWithin(i, s) {
+	if (!isPointerEvent(s) || !i) return !1;
+	let c = i.getBoundingClientRect();
+	return c.width === 0 || c.height === 0 ? !1 : c.top <= s.clientY && s.clientY <= c.top + c.height && c.left <= s.clientX && s.clientX <= c.left + c.width;
+}
+function isPointInRect(i, s) {
+	return i.y <= s.y && s.y <= i.y + i.height && i.x <= s.x && s.x <= i.x + i.width;
+}
+function isEventWithinScrollbar(i, s) {
+	if (!s || !isPointerEvent(i)) return !1;
+	let c = s.scrollHeight > s.clientHeight, l = c && i.clientX > s.offsetLeft + s.clientWidth, u = s.scrollWidth > s.clientWidth, d = u && i.clientY > s.offsetTop + s.clientHeight;
+	return isPointInRect({
+		x: s.offsetLeft,
+		y: s.offsetTop,
+		width: s.clientWidth + (c ? 16 : 0),
+		height: s.clientHeight + (u ? 16 : 0)
+	}, {
+		x: i.clientX,
+		y: i.clientY
+	}) ? l || d : !1;
+}
+function trackInteractOutsideImpl(i, s) {
+	let { exclude: c, onFocusOutside: l, onPointerDownOutside: u, onInteractOutside: d, defer: f } = s;
+	if (!i) return;
+	let p = getDocument(i), m = getWindow(i), h = getWindowFrames(m), g = getParentWindow(m);
+	function _(s) {
+		let l = getEventTarget(s);
+		if (!isHTMLElement(l) || !l.isConnected || contains(i, l) || isEventPointWithin(i, s)) return !1;
+		let u = p.querySelector(`[aria-controls="${i.id}"]`);
+		return u && isEventWithinScrollbar(s, getNearestOverflowAncestor(u)) || isEventWithinScrollbar(s, getNearestOverflowAncestor(i)) ? !1 : !c?.(l);
+	}
+	let v = /* @__PURE__ */ new Set();
+	function y(s) {
+		function c() {
+			let c = f ? raf$1 : (i) => i(), l = s.composedPath?.() ?? [s.target];
+			c(() => {
+				if (!(!i || !_(s))) {
+					if (u || d) {
+						let s = callAll(u, d);
+						i.addEventListener(POINTER_OUTSIDE_EVENT, s, { once: !0 });
+					}
+					fireCustomEvent(i, POINTER_OUTSIDE_EVENT, {
+						bubbles: !1,
+						cancelable: !0,
+						detail: {
+							originalEvent: s,
+							contextmenu: isContextMenuEvent(s),
+							focusable: isComposedPathFocusable(l)
+						}
+					});
+				}
+			});
+		}
+		s.pointerType === "touch" ? (v.forEach((i) => i()), v.add(addDomEvent(p, "click", c, { once: !0 })), v.add(g.addEventListener("click", c, { once: !0 })), v.add(h.addEventListener("click", c, { once: !0 }))) : c();
+	}
+	let b = /* @__PURE__ */ new Set(), x = setTimeout(() => {
+		b.add(addDomEvent(p, "pointerdown", y, !0)), b.add(g.addEventListener("pointerdown", y, !0)), b.add(h.addEventListener("pointerdown", y, !0));
+	}, 0);
+	function S(s) {
+		(f ? raf$1 : (i) => i())(() => {
+			if (!(!i || !_(s))) {
+				if (l || d) {
+					let s = callAll(l, d);
+					i.addEventListener(FOCUS_OUTSIDE_EVENT, s, { once: !0 });
+				}
+				fireCustomEvent(i, FOCUS_OUTSIDE_EVENT, {
+					bubbles: !1,
+					cancelable: !0,
+					detail: {
+						originalEvent: s,
+						contextmenu: !1,
+						focusable: isFocusable(getEventTarget(s))
+					}
+				});
+			}
+		});
+	}
+	return b.add(addDomEvent(p, "focusin", S, !0)), b.add(g.addEventListener("focusin", S, !0)), b.add(h.addEventListener("focusin", S, !0)), () => {
+		clearTimeout(x), v.forEach((i) => i()), b.forEach((i) => i());
+	};
+}
+function trackInteractOutside(i, s) {
+	let { defer: c } = s, l = c ? raf$1 : (i) => i(), u = [];
+	return u.push(l(() => {
+		let c = typeof i == "function" ? i() : i;
+		u.push(trackInteractOutsideImpl(c, s));
+	})), () => {
+		u.forEach((i) => i?.());
+	};
+}
+function fireCustomEvent(i, s, c) {
+	let l = new (i.ownerDocument.defaultView || window).CustomEvent(s, c);
+	return i.dispatchEvent(l);
+}
+function trackEscapeKeydown(i, s) {
+	return addDomEvent(getDocument(i), "keydown", (i) => {
+		i.key === "Escape" && (i.isComposing || s?.(i));
+	}, { capture: !0 });
+}
+var layerStack = {
+	layers: [],
+	branches: [],
+	count() {
+		return this.layers.length;
+	},
+	pointerBlockingLayers() {
+		return this.layers.filter((i) => i.pointerBlocking);
+	},
+	topMostPointerBlockingLayer() {
+		return [...this.pointerBlockingLayers()].slice(-1)[0];
+	},
+	hasPointerBlockingLayer() {
+		return this.pointerBlockingLayers().length > 0;
+	},
+	isBelowPointerBlockingLayer(i) {
+		return this.indexOf(i) < (this.topMostPointerBlockingLayer() ? this.indexOf(this.topMostPointerBlockingLayer()?.node) : -1);
+	},
+	isTopMost(i) {
+		return this.layers[this.count() - 1]?.node === i;
+	},
+	getNestedLayers(i) {
+		return Array.from(this.layers).slice(this.indexOf(i) + 1);
+	},
+	isInNestedLayer(i, s) {
+		return this.getNestedLayers(i).some((i) => contains(i.node, s));
+	},
+	isInBranch(i) {
+		return Array.from(this.branches).some((s) => contains(s, i));
+	},
+	add(i) {
+		let s = this.layers.push(i);
+		i.node.style.setProperty("--layer-index", `${s}`);
+	},
+	addBranch(i) {
+		this.branches.push(i);
+	},
+	remove(i) {
+		let s = this.indexOf(i);
+		s < 0 || (s < this.count() - 1 && this.getNestedLayers(i).forEach((i) => i.dismiss()), this.layers.splice(s, 1), i.style.removeProperty("--layer-index"));
+	},
+	removeBranch(i) {
+		let s = this.branches.indexOf(i);
+		s >= 0 && this.branches.splice(s, 1);
+	},
+	indexOf(i) {
+		return this.layers.findIndex((s) => s.node === i);
+	},
+	dismiss(i) {
+		this.layers[this.indexOf(i)]?.dismiss();
+	},
+	clear() {
+		this.remove(this.layers[0].node);
+	}
+}, originalBodyPointerEvents;
+function assignPointerEventToLayers() {
+	layerStack.layers.forEach(({ node: i }) => {
+		i.style.pointerEvents = layerStack.isBelowPointerBlockingLayer(i) ? "none" : "auto";
+	});
+}
+function clearPointerEvent(i) {
+	i.style.pointerEvents = "";
+}
+function disablePointerEventsOutside(i, s) {
+	let c = getDocument(i), l = [];
+	if (layerStack.hasPointerBlockingLayer() && !c.body.hasAttribute("data-inert") && (originalBodyPointerEvents = document.body.style.pointerEvents, queueMicrotask(() => {
+		c.body.style.pointerEvents = "none", c.body.setAttribute("data-inert", "");
+	})), s) {
+		let i = waitForElements(s, (i) => {
+			l.push(setStyle(i, { pointerEvents: "auto" }));
+		});
+		l.push(i);
+	}
+	return () => {
+		layerStack.hasPointerBlockingLayer() || (queueMicrotask(() => {
+			c.body.style.pointerEvents = originalBodyPointerEvents, c.body.removeAttribute("data-inert"), c.body.style.length === 0 && c.body.removeAttribute("style");
+		}), l.forEach((i) => i()));
+	};
+}
+function trackDismissableElementImpl(i, s) {
+	if (!i) throw Error("[@destyler/dismissable] node is `null` or `undefined`");
+	let { onDismiss: c, pointerBlocking: l, exclude: u, debug: d } = s, f = {
+		dismiss: c,
+		node: i,
+		pointerBlocking: l
+	};
+	layerStack.add(f), assignPointerEventToLayers();
+	function p(l) {
+		let u = getEventTarget(l.detail.originalEvent);
+		layerStack.isBelowPointerBlockingLayer(i) || layerStack.isInBranch(u) || (s.onPointerDownOutside?.(l), s.onInteractOutside?.(l), !l.defaultPrevented && (d && console.log("onPointerDownOutside:", l.detail.originalEvent), c?.()));
+	}
+	function m(i) {
+		let l = getEventTarget(i.detail.originalEvent);
+		layerStack.isInBranch(l) || (s.onFocusOutside?.(i), s.onInteractOutside?.(i), !i.defaultPrevented && (d && console.log("onFocusOutside:", i.detail.originalEvent), c?.()));
+	}
+	function h(l) {
+		layerStack.isTopMost(i) && (s.onEscapeKeyDown?.(l), !l.defaultPrevented && c && (l.preventDefault(), c()));
+	}
+	function g(c) {
+		if (!i) return !1;
+		let l = typeof u == "function" ? u() : u, d = Array.isArray(l) ? l : [l], f = s.persistentElements?.map((i) => i()).filter(isHTMLElement);
+		return f && d.push(...f), d.some((i) => contains(i, c)) || layerStack.isInNestedLayer(i, c);
+	}
+	let _ = [
+		l ? disablePointerEventsOutside(i, s.persistentElements) : void 0,
+		trackEscapeKeydown(i, h),
+		trackInteractOutside(i, {
+			exclude: g,
+			onFocusOutside: m,
+			onPointerDownOutside: p,
+			defer: s.defer
+		})
+	];
+	return () => {
+		layerStack.remove(i), assignPointerEventToLayers(), clearPointerEvent(i), _.forEach((i) => i?.());
+	};
+}
+function trackDismissableElement(i, s) {
+	let { defer: c } = s, l = c ? raf$1 : (i) => i(), u = [];
+	return u.push(l(() => {
+		let c = isFunction(i) ? i() : i;
+		u.push(trackDismissableElementImpl(c, s));
+	})), () => {
+		u.forEach((i) => i?.());
+	};
+}
+var isTabEvent = (i) => i.key === "Tab", valueOrHandler = (i, ...s) => typeof i == "function" ? i(...s) : i, isEscapeEvent = (i) => !i.isComposing && i.key === "Escape", delay = (i) => setTimeout(i, 0);
+function isSelectableInput(i) {
+	return i.localName === "input" && "select" in i && typeof i.select == "function";
+}
+var activeFocusTraps = {
+	activateTrap(i, s) {
+		if (i.length > 0) {
+			let c = i[i.length - 1];
+			c !== s && c.pause();
+		}
+		let c = i.indexOf(s);
+		c === -1 || i.splice(c, 1), i.push(s);
+	},
+	deactivateTrap(i, s) {
+		let c = i.indexOf(s);
+		c !== -1 && i.splice(c, 1), i.length > 0 && i[i.length - 1].unpause();
+	}
+}, sharedTrapStack = [], FocusTrap = class {
+	trapStack;
+	config;
+	doc;
+	state = {
+		containers: [],
+		containerGroups: [],
+		tabbableGroups: [],
+		nodeFocusedBeforeActivation: null,
+		mostRecentlyFocusedNode: null,
+		active: !1,
+		paused: !1,
+		delayInitialFocusTimer: void 0,
+		recentNavEvent: void 0
+	};
+	get active() {
+		return this.state.active;
+	}
+	get paused() {
+		return this.state.paused;
+	}
+	constructor(i, s) {
+		this.trapStack = s.trapStack || sharedTrapStack;
+		let c = {
+			returnFocusOnDeactivate: !0,
+			escapeDeactivates: !0,
+			delayInitialFocus: !0,
+			isKeyForward(i) {
+				return isTabEvent(i) && !i.shiftKey;
+			},
+			isKeyBackward(i) {
+				return isTabEvent(i) && i.shiftKey;
+			},
+			...s
+		};
+		this.doc = c.document || getDocument(Array.isArray(i) ? i[0] : i), this.config = c, this.updateContainerElements(i), this.setupMutationObserver();
+	}
+	findContainerIndex(i, s) {
+		let c = typeof s?.composedPath == "function" ? s.composedPath() : void 0;
+		return this.state.containerGroups.findIndex(({ container: s, tabbableNodes: l }) => s.contains(i) || c?.includes(s) || l.find((s) => s === i));
+	}
+	updateTabbableNodes() {
+		if (this.state.containerGroups = this.state.containers.map((i) => {
+			let s = getTabbables(i), c = getFocusables(i), l = s.length > 0 ? s[0] : void 0, u = s.length > 0 ? s[s.length - 1] : void 0, d = c.find((i) => isTabbable(i)), f = c.slice().reverse().find((i) => isTabbable(i)), p = !!s.find((i) => getTabIndex(i) > 0);
+			function m(i, l = !0) {
+				let u = s.indexOf(i);
+				return u < 0 ? l ? c.slice(c.indexOf(i) + 1).find((i) => isTabbable(i)) : c.slice(0, c.indexOf(i)).reverse().find((i) => isTabbable(i)) : s[u + (l ? 1 : -1)];
+			}
+			return {
+				container: i,
+				tabbableNodes: s,
+				focusableNodes: c,
+				posTabIndexesFound: p,
+				firstTabbableNode: l,
+				lastTabbableNode: u,
+				firstDomTabbableNode: d,
+				lastDomTabbableNode: f,
+				nextTabbableNode: m
+			};
+		}), this.state.tabbableGroups = this.state.containerGroups.filter((i) => i.tabbableNodes.length > 0), this.state.tabbableGroups.length <= 0 && !this.getNodeForOption("fallbackFocus")) throw Error("Your focus-trap must have at least one container with at least one tabbable node in it at all times");
+		if (this.state.containerGroups.find((i) => i.posTabIndexesFound) && this.state.containerGroups.length > 1) throw Error("At least one node with a positive tabindex was found in one of your focus-trap's multiple containers. Positive tabindexes are only supported in single-container focus-traps.");
+	}
+	listenerCleanups = [];
+	addListeners() {
+		if (this.state.active) return activeFocusTraps.activateTrap(this.trapStack, this), this.state.delayInitialFocusTimer = this.config.delayInitialFocus ? delay(() => {
+			this.tryFocus(this.getInitialFocusNode());
+		}) : this.tryFocus(this.getInitialFocusNode()), this.listenerCleanups.push(addDomEvent(this.doc, "focusin", this.handleFocus, !0), addDomEvent(this.doc, "mousedown", this.handlePointerDown, {
+			capture: !0,
+			passive: !1
+		}), addDomEvent(this.doc, "touchstart", this.handlePointerDown, {
+			capture: !0,
+			passive: !1
+		}), addDomEvent(this.doc, "click", this.handleClick, {
+			capture: !0,
+			passive: !1
+		}), addDomEvent(this.doc, "keydown", this.handleTabKey, {
+			capture: !0,
+			passive: !1
+		}), addDomEvent(this.doc, "keydown", this.handleEscapeKey)), this;
+	}
+	removeListeners() {
+		if (this.state.active) return this.listenerCleanups.forEach((i) => i()), this.listenerCleanups = [], this;
+	}
+	handleFocus = (i) => {
+		let s = getEventTarget(i), c = this.findContainerIndex(s, i) >= 0;
+		if (c || isDocument(s)) c && (this.state.mostRecentlyFocusedNode = s);
+		else {
+			i.stopImmediatePropagation();
+			let s, c = !0;
+			if (this.state.mostRecentlyFocusedNode) if (getTabIndex(this.state.mostRecentlyFocusedNode) > 0) {
+				let i = this.findContainerIndex(this.state.mostRecentlyFocusedNode), { tabbableNodes: l } = this.state.containerGroups[i];
+				if (l.length > 0) {
+					let i = l.findIndex((i) => i === this.state.mostRecentlyFocusedNode);
+					i >= 0 && (this.config.isKeyForward(this.state.recentNavEvent) ? i + 1 < l.length && (s = l[i + 1], c = !1) : i - 1 >= 0 && (s = l[i - 1], c = !1));
+				}
+			} else this.state.containerGroups.some((i) => i.tabbableNodes.some((i) => getTabIndex(i) > 0)) || (c = !1);
+			else c = !1;
+			c && (s = this.findNextNavNode({
+				target: this.state.mostRecentlyFocusedNode,
+				isBackward: this.config.isKeyBackward(this.state.recentNavEvent)
+			})), s ? this.tryFocus(s) : this.tryFocus(this.state.mostRecentlyFocusedNode || this.getInitialFocusNode());
+		}
+		this.state.recentNavEvent = void 0;
+	};
+	handlePointerDown = (i) => {
+		let s = getEventTarget(i);
+		if (!(this.findContainerIndex(s, i) >= 0)) {
+			if (valueOrHandler(this.config.clickOutsideDeactivates, i)) {
+				this.deactivate({ returnFocus: this.config.returnFocusOnDeactivate });
+				return;
+			}
+			valueOrHandler(this.config.allowOutsideClick, i) || i.preventDefault();
+		}
+	};
+	handleClick = (i) => {
+		let s = getEventTarget(i);
+		this.findContainerIndex(s, i) >= 0 || valueOrHandler(this.config.clickOutsideDeactivates, i) || valueOrHandler(this.config.allowOutsideClick, i) || (i.preventDefault(), i.stopImmediatePropagation());
+	};
+	handleTabKey = (i) => {
+		if (this.config.isKeyForward(i) || this.config.isKeyBackward(i)) {
+			this.state.recentNavEvent = i;
+			let s = this.config.isKeyBackward(i), c = this.findNextNavNode({
+				event: i,
+				isBackward: s
+			});
+			if (!c) return;
+			isTabEvent(i) && i.preventDefault(), this.tryFocus(c);
+		}
+	};
+	handleEscapeKey = (i) => {
+		isEscapeEvent(i) && valueOrHandler(this.config.escapeDeactivates, i) !== !1 && (i.preventDefault(), this.deactivate());
+	};
+	_mutationObserver;
+	setupMutationObserver = () => {
+		this._mutationObserver = new (this.doc.defaultView || window).MutationObserver((i) => {
+			i.some((i) => Array.from(i.removedNodes).includes(this.state.mostRecentlyFocusedNode)) && this.tryFocus(this.getInitialFocusNode());
+		});
+	};
+	updateObservedNodes = () => {
+		this._mutationObserver?.disconnect(), this.state.active && !this.state.paused && this.state.containers.forEach((i) => {
+			this._mutationObserver?.observe(i, {
+				subtree: !0,
+				childList: !0
+			});
+		});
+	};
+	getInitialFocusNode = () => {
+		let i = this.getNodeForOption("initialFocus", { hasFallback: !0 });
+		if (i === !1) return !1;
+		if (i === void 0 || i && !isFocusable(i)) if (this.findContainerIndex(this.doc.activeElement) >= 0) i = this.doc.activeElement;
+		else {
+			let s = this.state.tabbableGroups[0];
+			i = s && s.firstTabbableNode || this.getNodeForOption("fallbackFocus");
+		}
+		else i === null && (i = this.getNodeForOption("fallbackFocus"));
+		if (!i) throw Error("Your focus-trap needs to have at least one focusable element");
+		return i.isConnected || (i = this.getNodeForOption("fallbackFocus")), i;
+	};
+	tryFocus = (i) => {
+		if (i !== !1 && i !== getActiveElement(this.doc)) {
+			if (!i || !i.focus) {
+				this.tryFocus(this.getInitialFocusNode());
+				return;
+			}
+			i.focus({ preventScroll: !!this.config.preventScroll }), this.state.mostRecentlyFocusedNode = i, isSelectableInput(i) && i.select();
+		}
+	};
+	activate(i) {
+		if (this.state.active) return this;
+		let s = this.getOption(i, "onActivate"), c = this.getOption(i, "onPostActivate"), l = this.getOption(i, "checkCanFocusTrap");
+		l || this.updateTabbableNodes(), this.state.active = !0, this.state.paused = !1, this.state.nodeFocusedBeforeActivation = this.doc.activeElement || null, s?.();
+		let u = () => {
+			l && this.updateTabbableNodes(), this.addListeners(), this.updateObservedNodes(), c?.();
+		};
+		return l ? (l(this.state.containers.concat()).then(u, u), this) : (u(), this);
+	}
+	deactivate = (i) => {
+		if (!this.state.active) return this;
+		let s = {
+			onDeactivate: this.config.onDeactivate,
+			onPostDeactivate: this.config.onPostDeactivate,
+			checkCanReturnFocus: this.config.checkCanReturnFocus,
+			...i
+		};
+		clearTimeout(this.state.delayInitialFocusTimer), this.state.delayInitialFocusTimer = void 0, this.removeListeners(), this.state.active = !1, this.state.paused = !1, this.updateObservedNodes(), activeFocusTraps.deactivateTrap(this.trapStack, this);
+		let c = this.getOption(s, "onDeactivate"), l = this.getOption(s, "onPostDeactivate"), u = this.getOption(s, "checkCanReturnFocus"), d = this.getOption(s, "returnFocus", "returnFocusOnDeactivate");
+		c?.();
+		let f = () => {
+			delay(() => {
+				if (d) {
+					let i = this.getReturnFocusNode(this.state.nodeFocusedBeforeActivation);
+					this.tryFocus(i);
+				}
+				l?.();
+			});
+		};
+		return d && u ? (u(this.getReturnFocusNode(this.state.nodeFocusedBeforeActivation)).then(f, f), this) : (f(), this);
+	};
+	pause = (i) => {
+		if (this.state.paused || !this.state.active) return this;
+		let s = this.getOption(i, "onPause"), c = this.getOption(i, "onPostPause");
+		return this.state.paused = !0, s?.(), this.removeListeners(), this.updateObservedNodes(), c?.(), this;
+	};
+	unpause = (i) => {
+		if (!this.state.paused || !this.state.active) return this;
+		let s = this.getOption(i, "onUnpause"), c = this.getOption(i, "onPostUnpause");
+		return this.state.paused = !1, s?.(), this.updateTabbableNodes(), this.addListeners(), this.updateObservedNodes(), c?.(), this;
+	};
+	updateContainerElements = (i) => (this.state.containers = Array.isArray(i) ? i.filter(Boolean) : [i].filter(Boolean), this.state.active && this.updateTabbableNodes(), this.updateObservedNodes(), this);
+	getReturnFocusNode = (i) => {
+		let s = this.getNodeForOption("setReturnFocus", { params: [i] });
+		return s || (s === !1 ? !1 : i);
+	};
+	getOption = (i, s, c) => i && i[s] !== void 0 ? i[s] : this.config[c || s];
+	getNodeForOption = (i, { hasFallback: s = !1, params: c = [] } = {}) => {
+		let l = this.config[i];
+		if (typeof l == "function" && (l = l(...c)), l === !0 && (l = void 0), !l) {
+			if (l === void 0 || l === !1) return l;
+			throw Error(`\`${i}\` was specified but was not a node, or did not return a node`);
+		}
+		let u = l;
+		if (typeof l == "string") {
+			try {
+				u = this.doc.querySelector(l);
+			} catch (s) {
+				throw Error(`\`${i}\` appears to be an invalid selector; error="${s.message}"`);
+			}
+			if (!u && !s) throw Error(`\`${i}\` as selector refers to no known node`);
+		}
+		return u;
+	};
+	findNextNavNode = (i) => {
+		let { event: s, isBackward: c = !1 } = i, l = i.target || getEventTarget(s);
+		this.updateTabbableNodes();
+		let u = null;
+		if (this.state.tabbableGroups.length > 0) {
+			let i = this.findContainerIndex(l, s), d = i >= 0 ? this.state.containerGroups[i] : void 0;
+			if (i < 0) u = c ? this.state.tabbableGroups[this.state.tabbableGroups.length - 1].lastTabbableNode : this.state.tabbableGroups[0].firstTabbableNode;
+			else if (c) {
+				let c = this.state.tabbableGroups.findIndex(({ firstTabbableNode: i }) => l === i);
+				if (c < 0 && (d?.container === l || isFocusable(l) && !isTabbable(l) && !d?.nextTabbableNode(l, !1)) && (c = i), c >= 0) {
+					let i = c === 0 ? this.state.tabbableGroups.length - 1 : c - 1, s = this.state.tabbableGroups[i];
+					u = getTabIndex(l) >= 0 ? s.lastTabbableNode : s.lastDomTabbableNode;
+				} else isTabEvent(s) || (u = d?.nextTabbableNode(l, !1));
+			} else {
+				let c = this.state.tabbableGroups.findIndex(({ lastTabbableNode: i }) => l === i);
+				if (c < 0 && (d?.container === l || isFocusable(l) && !isTabbable(l) && !d?.nextTabbableNode(l)) && (c = i), c >= 0) {
+					let i = c === this.state.tabbableGroups.length - 1 ? 0 : c + 1, s = this.state.tabbableGroups[i];
+					u = getTabIndex(l) >= 0 ? s.firstTabbableNode : s.firstDomTabbableNode;
+				} else isTabEvent(s) || (u = d?.nextTabbableNode(l));
+			}
+		} else u = this.getNodeForOption("fallbackFocus");
+		return u;
+	};
+};
+function trapFocus(i, s = {}) {
+	let c, l = raf$1(() => {
+		let l = typeof i == "function" ? i() : i;
+		if (l) {
+			c = new FocusTrap(l, {
+				escapeDeactivates: !1,
+				allowOutsideClick: !0,
+				preventScroll: !0,
+				returnFocusOnDeactivate: !0,
+				delayInitialFocus: !1,
+				fallbackFocus: l,
+				...s,
+				document: getDocument(l)
+			});
+			try {
+				c.activate();
+			} catch {}
+		}
+	});
+	return function() {
+		c?.deactivate(), l();
+	};
+}
+var LOCK_CLASSNAME = "data-scroll-lock";
+function assignStyle(i, s) {
+	if (!i) return;
+	let c = Object.keys(s).reduce((s, c) => (s[c] = i.style.getPropertyValue(c), s), {});
+	return Object.assign(i.style, s), () => {
+		Object.assign(i.style, c);
+	};
+}
+function setCSSProperty(i, s, c) {
+	if (!i) return;
+	let l = i.style.getPropertyValue(s);
+	return i.style.setProperty(s, c), () => {
+		l ? i.style.setProperty(s, l) : i.style.removeProperty(s);
+	};
+}
+function getPaddingProperty(i) {
+	let s = i.getBoundingClientRect().left;
+	return Math.round(s) + i.scrollLeft ? "paddingLeft" : "paddingRight";
+}
+function preventBodyScroll(i) {
+	let s = i ?? document, c = s.defaultView ?? window, { documentElement: l, body: u } = s;
+	if (u.hasAttribute(LOCK_CLASSNAME)) return;
+	u.setAttribute(LOCK_CLASSNAME, "");
+	let d = c.innerWidth - l.clientWidth, f = () => setCSSProperty(l, "--scrollbar-width", `${d}px`), p = getPaddingProperty(l), m = [f(), isIos() ? (() => {
+		let { scrollX: i, scrollY: s, visualViewport: l } = c, f = l?.offsetLeft ?? 0, m = l?.offsetTop ?? 0, h = assignStyle(u, {
+			position: "fixed",
+			overflow: "hidden",
+			top: `${-(s - Math.floor(m))}px`,
+			left: `${-(i - Math.floor(f))}px`,
+			right: "0",
+			[p]: `${d}px`
+		});
+		return () => {
+			h?.(), c.scrollTo({
+				left: i,
+				top: s,
+				behavior: "instant"
+			});
+		};
+	})() : (() => assignStyle(u, {
+		overflow: "hidden",
+		[p]: `${d}px`
+	}))()];
+	return () => {
+		m.forEach((i) => i?.()), u.removeAttribute(LOCK_CLASSNAME);
+	};
+}
+var GET_ORIGINAL_SYMBOL = Symbol(), getProto = Object.getPrototypeOf, objectsToTrack = /* @__PURE__ */ new WeakMap(), isObjectToTrack = (i) => i && (objectsToTrack.has(i) ? objectsToTrack.get(i) : getProto(i) === Object.prototype || getProto(i) === Array.prototype);
+const getUntracked = (i) => isObjectToTrack(i) && i[GET_ORIGINAL_SYMBOL] || null, markToTrack = (i, s = !0) => {
+	objectsToTrack.set(i, s);
+};
+function glob() {
+	if (typeof globalThis < "u" || typeof globalThis < "u") return globalThis;
+	if (typeof window < "u") return window;
+}
+function globalRef(i, s) {
+	let c = glob();
+	return c ? (c[i] ||= s(), c[i]) : s();
+}
+var refSet = globalRef("__destyler__refSet", () => /* @__PURE__ */ new WeakSet()), isReactElement = (i) => typeof i == "object" && !!i && "$$typeof" in i && "props" in i, isVueElement = (i) => typeof i == "object" && !!i && "__v_isVNode" in i;
+function isDOMElement(i) {
+	return typeof i == "object" && !!i && "nodeType" in i && typeof i.nodeName == "string";
+}
+var isElement = (i) => isReactElement(i) || isVueElement(i) || isDOMElement(i), isObject = (i) => typeof i == "object" && !!i;
+function canProxy(i) {
+	return isObject(i) && !refSet.has(i) && (Array.isArray(i) || !(Symbol.iterator in i)) && !isElement(i) && !(i instanceof WeakMap) && !(i instanceof WeakSet) && !(i instanceof Error) && typeof i != "number" && !(i instanceof Date) && typeof i != "string" && !(i instanceof RegExp) && !(i instanceof ArrayBuffer) && !(i instanceof Promise);
+}
+function set(i, s, c) {
+	typeof c.value == "object" && !canProxy(c.value) && (c.value = clone(c.value)), !c.enumerable || c.get || c.set || !c.configurable || !c.writable || s === "__proto__" ? Object.defineProperty(i, s, c) : i[s] = c.value;
+}
+function clone(i) {
+	if (typeof i != "object") return i;
+	let s = 0, c, l, u, d = Object.prototype.toString.call(i);
+	if (d === "[object Object]" ? u = Object.create(Object.getPrototypeOf(i) || null) : d === "[object Array]" ? u = Array.from({ length: i.length }) : d === "[object Set]" ? (u = /* @__PURE__ */ new Set(), i.forEach((i) => {
+		u.add(clone(i));
+	})) : d === "[object Map]" ? (u = /* @__PURE__ */ new Map(), i.forEach((i, s) => {
+		u.set(clone(s), clone(i));
+	})) : d === "[object Date]" ? u = /* @__PURE__ */ new Date(+i) : d === "[object RegExp]" ? u = new RegExp(i.source, i.flags) : d === "[object DataView]" ? u = new i.constructor(clone(i.buffer)) : d === "[object ArrayBuffer]" ? u = i.slice(0) : d === "[object Blob]" ? u = i.slice() : d.slice(-6) === "Array]" && (u = new i.constructor(i)), u) {
+		for (l = Object.getOwnPropertySymbols(i); s < l.length; s++) set(u, l[s], Object.getOwnPropertyDescriptor(i, l[s]));
+		for (s = 0, l = Object.getOwnPropertyNames(i); s < l.length; s++) Object.hasOwnProperty.call(u, c = l[s]) && u[c] === i[c] || set(u, c, Object.getOwnPropertyDescriptor(i, c));
+	}
+	return u || i;
+}
+var proxyStateMap = globalRef("__destyler__proxyStateMap", () => /* @__PURE__ */ new WeakMap());
+function buildProxyFunction(i = Object.is, s = (i, s) => new Proxy(i, s), c = /* @__PURE__ */ new WeakMap(), l = (i, s) => {
+	let l = c.get(i);
+	if (l?.[0] === s) return l[1];
+	let u = Array.isArray(i) ? [] : Object.create(Object.getPrototypeOf(i));
+	return markToTrack(u, !0), c.set(i, [s, u]), Reflect.ownKeys(i).forEach((s) => {
+		let c = Reflect.get(i, s);
+		refSet.has(c) ? (markToTrack(c, !1), u[s] = c) : proxyStateMap.has(c) ? u[s] = snapshot(c) : u[s] = c;
+	}), Object.freeze(u);
+}, u = /* @__PURE__ */ new WeakMap(), d = [1, 1], f = (c) => {
+	if (!isObject(c)) throw Error("object required");
+	let f = u.get(c);
+	if (f) return f;
+	let p = d[0], m = /* @__PURE__ */ new Set(), h = /* @__PURE__ */ new Map(), g = (i, s = ++d[0]) => {
+		p !== s && (p = s, m.forEach((c) => c(i, s)));
+	}, _ = d[1], v = (i = ++d[1]) => (_ !== i && !m.size && (_ = i, h.forEach(([s]) => {
+		let c = s[1](i);
+		c > p && (p = c);
+	})), p), y = (i) => (s, c) => {
+		let l = [...s];
+		l[1] = [i, ...l[1]], g(l, c);
+	}, b = (i, s) => {
+		if (m.size) {
+			let c = s[3](y(i));
+			h.set(i, [s, c]);
+		} else h.set(i, [s]);
+	}, x = (i) => {
+		let s = h.get(i);
+		s && (h.delete(i), s[1]?.());
+	}, S = (i) => (m.add(i), m.size === 1 && h.forEach(([i], s) => {
+		let c = i[3](y(s));
+		h.set(s, [i, c]);
+	}), () => {
+		m.delete(i), m.size === 0 && h.forEach(([i, s], c) => {
+			s && (s(), h.set(c, [i]));
+		});
+	}), C = Array.isArray(c) ? [] : Object.create(Object.getPrototypeOf(c)), w = s(C, {
+		deleteProperty(i, s) {
+			let c = Reflect.get(i, s);
+			x(s);
+			let l = Reflect.deleteProperty(i, s);
+			return l && g([
+				"delete",
+				[s],
+				c
+			]), l;
+		},
+		set(s, c, l, d) {
+			let f = Reflect.has(s, c), p = Reflect.get(s, c, d);
+			if (f && (i(p, l) || u.has(l) && i(p, u.get(l)))) return !0;
+			x(c), isObject(l) && (l = getUntracked(l) || l);
+			let m = l;
+			if (!Object.getOwnPropertyDescriptor(s, c)?.set) {
+				!proxyStateMap.has(l) && canProxy(l) && (m = proxy(l));
+				let i = !refSet.has(m) && proxyStateMap.get(m);
+				i && b(c, i);
+			}
+			return Reflect.set(s, c, m, d), g([
+				"set",
+				[c],
+				l,
+				p
+			]), !0;
+		}
+	});
+	u.set(c, w);
+	let T = [
+		C,
+		v,
+		l,
+		S
+	];
+	return proxyStateMap.set(w, T), Reflect.ownKeys(c).forEach((i) => {
+		let s = Object.getOwnPropertyDescriptor(c, i);
+		s.get || s.set ? Object.defineProperty(C, i, s) : w[i] = c[i];
+	}), w;
+}) {
+	return [
+		f,
+		proxyStateMap,
+		refSet,
+		i,
+		s,
+		canProxy,
+		c,
+		l,
+		u,
+		d
+	];
+}
+var [proxyFunction] = buildProxyFunction();
+function proxy(i = {}) {
+	return proxyFunction(i);
+}
+function subscribe(i, s, c) {
+	let l = proxyStateMap.get(i), u, d = [], f = l[3], p = !1, m = f((i) => {
+		if (d.push(i), c) {
+			s(d.splice(0));
+			return;
+		}
+		u ||= Promise.resolve().then(() => {
+			u = void 0, p && s(d.splice(0));
+		});
+	});
+	return p = !0, () => {
+		p = !1, m();
+	};
+}
+function snapshot(i) {
+	let [s, c, l] = proxyStateMap.get(i);
+	return l(s, c());
+}
+function ref$1(i) {
+	return refSet.add(i), i;
+}
+function proxyWithComputed(i, s) {
+	let c = Object.keys(s);
+	c.forEach((s) => {
+		if (Object.getOwnPropertyDescriptor(i, s)) throw Error("object property already defined");
+	});
+	let l = proxy(i);
+	return c.forEach((i) => {
+		let c = s[i], { get: u, set: d } = typeof c == "function" ? { get: c } : c, f = {};
+		f.get = () => u(snapshot(l)), d && (f.set = (i) => d(l, i)), Object.defineProperty(l, i, f);
+	}), l;
+}
+function deepMerge(i, ...s) {
+	if (!isPlainObject(i)) throw TypeError("Source argument must be a plain object");
+	let c = i;
+	for (let i of s) {
+		if (!isPlainObject(i)) continue;
+		let s = compact(i);
+		for (let l in s) {
+			if (!Object.prototype.hasOwnProperty.call(s, l) || l === "__proto__" || l === "constructor" || l === "prototype") continue;
+			let u = c[l], d = i[l];
+			isPlainObject(d) ? c[l] = isPlainObject(u) ? deepMerge(u, d) : { ...d } : c[l] = d;
+		}
+	}
+	return c;
+}
+function toEvent(i) {
+	return isString(i) ? { type: i } : i;
+}
+function toArray(i) {
+	return i ? isArray(i) ? i.slice() : [i] : [];
+}
+function isGuardHelper(i) {
+	return isObject$1(i) && i.predicate != null;
+}
+var Truthy = () => !0;
+function determineGuardFn(i, s) {
+	return i ??= Truthy, (c, l, u) => {
+		if (isString(i)) {
+			let d = s[i];
+			return isFunction(d) ? d(c, l, u) : d;
+		}
+		return isGuardHelper(i) ? i.predicate(s)(c, l, u) : i?.(c, l, u);
+	};
+}
+function determineActionsFn(i, s) {
+	return (c, l, u) => isGuardHelper(i) ? i.predicate(s)(c, l, u) : i;
+}
+var MachineStatus = /* @__PURE__ */ function(i) {
+	return i.NotStarted = "Not Started", i.Running = "Running", i.Stopped = "Stopped", i;
+}({}), ActionTypes = /* @__PURE__ */ function(i) {
+	return i.Start = "machine.start", i.Stop = "machine.stop", i.Created = "machine.created", i.Init = "machine.init", i;
+}({}), MachineType = /* @__PURE__ */ function(i) {
+	return i.Machine = "machine", i.Actor = "machine.actor", i;
+}({});
+function createProxy(i) {
+	let s = i.computed ?? cast({}), c = i.context ?? cast({}), l = i.initial ? i.states?.[i.initial]?.tags : [];
+	return cast(proxy({
+		value: i.initial ?? "",
+		previousValue: "",
+		event: cast({}),
+		previousEvent: cast({}),
+		context: proxyWithComputed(c, s),
+		done: !1,
+		tags: l ?? [],
+		hasTag(i) {
+			return this.tags.includes(i);
+		},
+		matches(...i) {
+			return i.includes(this.value);
+		},
+		can(i) {
+			return cast(this).nextEvents.includes(i);
+		},
+		get nextEvents() {
+			let s = i.states?.[this.value]?.on ?? {}, c = i?.on ?? {};
+			return Object.keys({
+				...s,
+				...c
+			});
+		},
+		get changed() {
+			return this.event.value === ActionTypes.Init || !this.previousValue ? !1 : this.value !== this.previousValue;
+		}
+	}));
+}
+function determineDelayFn(i, s) {
+	return (c, l) => {
+		if (isNumber(i)) return i;
+		if (isFunction(i)) return i(c, l);
+		if (isString(i)) {
+			let u = Number.parseFloat(i);
+			if (!Number.isNaN(u)) return u;
+			if (s) {
+				let u = s?.[i];
+				if (u === null) throw Error(`[@destyler/xstate > determine-delay] Cannot determine delay for \`${i}\`. It is set to null in \`options.delays\``);
+				return isFunction(u) ? u(c, l) : u;
+			}
+		}
+	};
+}
+function toTarget(i) {
+	return isString(i) ? { target: i } : i;
+}
+function determineTransitionFn(i, s) {
+	return (c, l, u) => toArray(i).map(toTarget).find((i) => determineGuardFn(i.guard, s)(c, l, u) ?? i.target ?? i.actions);
+}
+var Machine = class {
+	status = MachineStatus.NotStarted;
+	state;
+	initialState;
+	initialContext;
+	id;
+	type = MachineType.Machine;
+	activityEvents = /* @__PURE__ */ new Map();
+	delayedEvents = /* @__PURE__ */ new Map();
+	stateListeners = /* @__PURE__ */ new Set();
+	doneListeners = /* @__PURE__ */ new Set();
+	contextWatchers = /* @__PURE__ */ new Set();
+	removeStateListener = noop;
+	parent;
+	children = /* @__PURE__ */ new Map();
+	guardMap;
+	actionMap;
+	delayMap;
+	activityMap;
+	sync;
+	options;
+	config;
+	constructor(i, s) {
+		this.config = clone(i), this.options = clone(s ?? {}), this.id = this.config.id ?? `machine-${uuid()}`, this.guardMap = this.options?.guards ?? {}, this.actionMap = this.options?.actions ?? {}, this.delayMap = this.options?.delays ?? {}, this.activityMap = this.options?.activities ?? {}, this.sync = this.options?.sync ?? !1, this.state = createProxy(this.config), this.initialContext = snapshot(this.state.context);
+	}
+	get stateSnapshot() {
+		return cast(snapshot(this.state));
+	}
+	getState() {
+		return this.stateSnapshot;
+	}
+	get contextSnapshot() {
+		return this.stateSnapshot.context;
+	}
+	_created = () => {
+		if (!this.config.created) return;
+		let i = toEvent(ActionTypes.Created);
+		this.executeActions(this.config.created, i);
+	};
+	start = (i) => {
+		if (this.state.value = "", this.state.tags = [], this.status === MachineStatus.Running) return this;
+		this.status = MachineStatus.Running, this.removeStateListener = subscribe(this.state, () => {
+			this.stateListeners.forEach((i) => {
+				i(this.stateSnapshot);
+			});
+		}, this.sync), this.setupContextWatchers(), this.executeActivities(toEvent(ActionTypes.Start), toArray(this.config.activities), ActionTypes.Start), this.executeActions(this.config.entry, toEvent(ActionTypes.Start));
+		let s = toEvent(ActionTypes.Init), c = isObject$1(i) ? i.value : i, l = isObject$1(i) ? i.context : void 0;
+		l && this.setContext(l);
+		let u = { target: c ?? this.config.initial }, d = this.getNextStateInfo(u, s);
+		return this.initialState = d, this.performStateChangeEffects(this.state.value, d, s), this;
+	};
+	setupContextWatchers = () => {
+		let { watch: i } = this.config;
+		if (!i) return;
+		let s = snapshot(this.state.context), c = subscribe(this.state.context, () => {
+			let c = snapshot(this.state.context);
+			for (let [l, u] of Object.entries(i)) (this.options.compareFns?.[l] ?? Object.is)(s[l], c[l]) || this.executeActions(u, this.state.event);
+			s = c;
+		});
+		this.contextWatchers.add(c);
+	};
+	stop = () => {
+		if (this.status !== MachineStatus.Stopped) return this.performExitEffects(this.state.value, toEvent(ActionTypes.Stop)), this.executeActions(this.config.exit, toEvent(ActionTypes.Stop)), this.setState(""), this.setEvent(ActionTypes.Stop), this.stopStateListeners(), this.stopChildren(), this.stopActivities(), this.stopDelayedEvents(), this.stopContextWatchers(), this.status = MachineStatus.Stopped, this;
+	};
+	stopStateListeners = () => {
+		this.removeStateListener(), this.stateListeners.clear();
+	};
+	stopContextWatchers = () => {
+		this.contextWatchers.forEach((i) => i()), this.contextWatchers.clear();
+	};
+	stopDelayedEvents = () => {
+		this.delayedEvents.forEach((i) => {
+			i.forEach((i) => i());
+		}), this.delayedEvents.clear();
+	};
+	stopActivities = (i) => {
+		i ? (this.activityEvents.get(i)?.forEach((i) => i()), this.activityEvents.get(i)?.clear(), this.activityEvents.delete(i)) : (this.activityEvents.forEach((i) => {
+			i.forEach((i) => i()), i.clear();
+		}), this.activityEvents.clear());
+	};
+	sendChild = (i, s) => {
+		let c = toEvent(i), l = runIfFn(s, this.contextSnapshot), u = this.children.get(l);
+		if (!u) throw Error(`[@destyler/xstate] Cannot send '${c.type}' event to unknown child`);
+		u.send(c);
+	};
+	stopChild = (i) => {
+		if (!this.children.has(i)) throw Error(`[@destyler.xstate > stop-child] Cannot stop unknown child ${i}`);
+		this.children.get(i).stop(), this.children.delete(i);
+	};
+	removeChild = (i) => {
+		this.children.delete(i);
+	};
+	stopChildren = () => {
+		this.children.forEach((i) => i.stop()), this.children.clear();
+	};
+	setParent = (i) => {
+		this.parent = i;
+	};
+	spawn = (i, s) => {
+		let c = runIfFn(i);
+		return s && (c.id = s), c.type = MachineType.Actor, c.setParent(this), this.children.set(c.id, cast(c)), c.onDone(() => {
+			this.removeChild(c.id);
+		}).start(), cast(ref$1(c));
+	};
+	stopActivity = (i) => {
+		if (!this.state.value) return;
+		let s = this.activityEvents.get(this.state.value);
+		s?.get(i)?.(), s?.delete(i);
+	};
+	addActivityCleanup = (i, s, c) => {
+		i && (this.activityEvents.has(i) ? this.activityEvents.get(i)?.set(s, c) : this.activityEvents.set(i, new Map([[s, c]])));
+	};
+	setState = (i) => {
+		this.state.previousValue = this.state.value, this.state.value = i;
+		let s = this.getStateNode(i);
+		i == null ? clear(this.state.tags) : this.state.tags = toArray(s?.tags);
+	};
+	setContext = (i) => {
+		i && deepMerge(this.state.context, i);
+	};
+	setOptions = (i) => {
+		let s = compact(i);
+		this.actionMap = {
+			...this.actionMap,
+			...s.actions
+		}, this.delayMap = {
+			...this.delayMap,
+			...s.delays
+		}, this.activityMap = {
+			...this.activityMap,
+			...s.activities
+		}, this.guardMap = {
+			...this.guardMap,
+			...s.guards
+		};
+	};
+	getStateNode = (i) => {
+		if (i) return this.config.states?.[i];
+	};
+	getNextStateInfo = (i, s) => {
+		let c = this.determineTransition(i, s), l = !c?.target, u = c?.target ?? this.state.value, d = this.state.value !== u, f = this.getStateNode(u), p = {
+			reenter: !l && !d && !c?.internal,
+			transition: c,
+			stateNode: f,
+			target: u,
+			changed: d
+		};
+		return this.log("NextState:", `[${s.type}]`, this.state.value, "---->", p.target), p;
+	};
+	getAfterActions = (i, s) => {
+		let c, l = this.state.value;
+		return {
+			entry: () => {
+				c = globalThis.setTimeout(() => {
+					let s = this.getNextStateInfo(i, this.state.event);
+					this.performStateChangeEffects(l, s, this.state.event);
+				}, s);
+			},
+			exit: () => {
+				globalThis.clearTimeout(c);
+			}
+		};
+	};
+	getDelayedEventActions = (i) => {
+		let s = this.getStateNode(i), c = this.state.event;
+		if (!s || !s.after) return;
+		let l = [], u = [];
+		if (isArray(s.after)) {
+			let i = this.determineTransition(s.after, c);
+			if (!i) return;
+			if (!hasProp(i, "delay")) throw Error(`[@destyler/xstate > after] Delay is required for after transition: ${JSON.stringify(i)}`);
+			let d = determineDelayFn(i.delay, this.delayMap)(this.contextSnapshot, c), f = this.getAfterActions(i, d);
+			return l.push(f.entry), u.push(f.exit), {
+				entries: l,
+				exits: u
+			};
+		}
+		if (isObject$1(s.after)) for (let i in s.after) {
+			let d = s.after[i], f = determineDelayFn(i, this.delayMap)(this.contextSnapshot, c), p = this.getAfterActions(d, f);
+			l.push(p.entry), u.push(p.exit);
+		}
+		return {
+			entries: l,
+			exits: u
+		};
+	};
+	get self() {
+		let i = this;
+		return {
+			id: this.id,
+			send: this.send.bind(this),
+			sendParent: this.sendParent.bind(this),
+			sendChild: this.sendChild.bind(this),
+			stop: this.stop.bind(this),
+			stopChild: this.stopChild.bind(this),
+			spawn: this.spawn.bind(this),
+			stopActivity: this.stopActivity.bind(this),
+			get state() {
+				return i.stateSnapshot;
+			},
+			get initialContext() {
+				return i.initialContext;
+			},
+			get initialState() {
+				return i.initialState?.target ?? "";
+			}
+		};
+	}
+	get meta() {
+		return {
+			state: this.stateSnapshot,
+			guards: this.guardMap,
+			send: this.send.bind(this),
+			self: this.self,
+			initialContext: this.initialContext,
+			initialState: this.initialState?.target ?? "",
+			getState: () => this.stateSnapshot,
+			getAction: (i) => this.actionMap[i],
+			getGuard: (i) => this.guardMap[i]
+		};
+	}
+	get guardMeta() {
+		return { state: this.stateSnapshot };
+	}
+	executeActions = (i, s) => {
+		let c = determineActionsFn(i, this.guardMap)(this.contextSnapshot, s, this.guardMeta);
+		for (let i of toArray(c)) {
+			let c = isString(i) ? this.actionMap?.[i] : i;
+			isString(i) && !c && console.warn(`[@destyler/xstate > execute-actions] No implementation found for action: \`${i}\``), c?.(this.state.context, s, this.meta);
+		}
+	};
+	executeActivities = (i, s, c) => {
+		for (let l of s) {
+			let s = isString(l) ? this.activityMap?.[l] : l;
+			if (!s) {
+				console.warn(`[@destyler/xstate > execute-activity] No implementation found for activity: \`${l}\``);
+				continue;
+			}
+			let u = s(this.state.context, i, this.meta);
+			if (u) {
+				let i = isString(l) ? l : l.name || uuid();
+				this.addActivityCleanup(c ?? this.state.value, i, u);
+			}
+		}
+	};
+	createEveryActivities = (i, s) => {
+		if (i) if (isArray(i)) {
+			let c = toArray(i).find((i) => {
+				let s = i.delay, c = determineDelayFn(s, this.delayMap)(this.contextSnapshot, this.state.event);
+				return determineGuardFn(i.guard, this.guardMap)(this.contextSnapshot, this.state.event, this.guardMeta) ?? c != null;
+			});
+			if (!c) return;
+			let l = determineDelayFn(c.delay, this.delayMap)(this.contextSnapshot, this.state.event);
+			s(() => {
+				let i = globalThis.setInterval(() => {
+					this.executeActions(c.actions, this.state.event);
+				}, l);
+				return () => {
+					globalThis.clearInterval(i);
+				};
+			});
+		} else for (let c in i) {
+			let l = i?.[c], u = determineDelayFn(c, this.delayMap)(this.contextSnapshot, this.state.event);
+			s(() => {
+				let i = globalThis.setInterval(() => {
+					this.executeActions(l, this.state.event);
+				}, u);
+				return () => {
+					globalThis.clearInterval(i);
+				};
+			});
+		}
+	};
+	setEvent = (i) => {
+		this.state.previousEvent = this.state.event, this.state.event = ref$1(toEvent(i));
+	};
+	performExitEffects = (i, s) => {
+		let c = this.state.value;
+		if (c === "") return;
+		let l = i ? this.getStateNode(i) : void 0;
+		this.stopActivities(c);
+		let u = toArray(determineActionsFn(l?.exit, this.guardMap)(this.contextSnapshot, s, this.guardMeta)), d = this.delayedEvents.get(c);
+		d && u.push(...d), this.executeActions(u, s), this.delayedEvents.delete(c);
+	};
+	performEntryEffects = (i, s) => {
+		let c = this.getStateNode(i), l = toArray(c?.activities);
+		this.createEveryActivities(c?.every, (i) => {
+			l.unshift(i);
+		}), l.length > 0 && this.executeActivities(s, l);
+		let u = toArray(determineActionsFn(c?.entry, this.guardMap)(this.contextSnapshot, s, this.guardMeta)), d = this.getDelayedEventActions(i);
+		c?.after && d && (this.delayedEvents.set(i, d?.exits), u.push(...d.entries)), this.executeActions(u, s), c?.type === "final" && (this.state.done = !0, this.doneListeners.forEach((i) => {
+			i(this.stateSnapshot);
+		}), this.stop());
+	};
+	performTransitionEffects = (i, s) => {
+		let c = this.determineTransition(i, s);
+		this.executeActions(c?.actions, s);
+	};
+	performStateChangeEffects = (i, s, c) => {
+		this.setEvent(c);
+		let l = s.changed || s.reenter;
+		l && this.performExitEffects(i, c), this.performTransitionEffects(s.transition, c), this.setState(s.target), l && this.performEntryEffects(s.target, c);
+	};
+	determineTransition = (i, s) => determineTransitionFn(i, this.guardMap)?.(this.contextSnapshot, s, this.guardMeta);
+	sendParent = (i) => {
+		if (!this.parent) throw Error("[@destyler/xstate > send-parent] Cannot send event to parent machine, no parent is set. Use `machine.spawn()` to spawn a child machine.");
+		let s = toEvent(i);
+		this.parent?.send(s);
+	};
+	log = (...i) => {
+		this.options.debug && console.log(...i);
+	};
+	send = (i) => {
+		let s = toEvent(i);
+		this.transition(this.state.value, s);
+	};
+	transition = (i, s) => {
+		let c = isString(i) ? this.getStateNode(i) : i?.stateNode, l = toEvent(s);
+		if (!c && !this.config.on) {
+			let s = this.status === MachineStatus.Stopped ? "[@destyler/xstate > transition] Cannot transition a stopped machine" : `[destyler/xstate > transition] State does not have a definition for \`state\`: ${i}, \`event\`: ${l.type}`;
+			console.warn(s);
+			return;
+		}
+		let u = c?.on?.[l.type] ?? this.config.on?.[l.type], d = this.getNextStateInfo(u, l);
+		return this.performStateChangeEffects(this.state.value, d, l), d.stateNode;
+	};
+	subscribe = (i) => (this.stateListeners.add(i), this.status === MachineStatus.Running && i(this.stateSnapshot), () => {
+		this.stateListeners.delete(i);
+	});
+	onDone = (i) => (this.doneListeners.add(i), this);
+	onTransition = (i) => (this.stateListeners.add(i), this.status === MachineStatus.Running && i(this.stateSnapshot), this);
+	get [Symbol.toStringTag]() {
+		return "Machine";
+	}
+	getHydrationState() {
+		let i = this.getState();
+		return {
+			value: i.value,
+			tags: i.tags
+		};
+	}
+};
+function createMachine(i, s) {
+	return new Machine(i, s);
+}
+function createProps() {
+	return (i) => Array.from(new Set(i));
+}
+function createNormalizer(i) {
+	return new Proxy({}, { get() {
+		return i;
+	} });
+}
+var parts = createAnatomy("popover").parts("arrow", "arrowTip", "anchor", "trigger", "indicator", "positioner", "content", "title", "description", "closeTrigger").build(), dom = createScope({
+	getAnchorId: (i) => i.ids?.anchor ?? `popover:${i.id}:anchor`,
+	getTriggerId: (i) => i.ids?.trigger ?? `popover:${i.id}:trigger`,
+	getContentId: (i) => i.ids?.content ?? `popover:${i.id}:content`,
+	getPositionerId: (i) => i.ids?.positioner ?? `popover:${i.id}:popper`,
+	getArrowId: (i) => i.ids?.arrow ?? `popover:${i.id}:arrow`,
+	getTitleId: (i) => i.ids?.title ?? `popover:${i.id}:title`,
+	getDescriptionId: (i) => i.ids?.description ?? `popover:${i.id}:desc`,
+	getCloseTriggerId: (i) => i.ids?.closeTrigger ?? `popover:${i.id}:close`,
+	getAnchorEl: (i) => dom.getById(i, dom.getAnchorId(i)),
+	getTriggerEl: (i) => dom.getById(i, dom.getTriggerId(i)),
+	getContentEl: (i) => dom.getById(i, dom.getContentId(i)),
+	getPositionerEl: (i) => dom.getById(i, dom.getPositionerId(i)),
+	getTitleEl: (i) => dom.getById(i, dom.getTitleId(i)),
+	getDescriptionEl: (i) => dom.getById(i, dom.getDescriptionId(i)),
+	getFocusableEls: (i) => getFocusables(dom.getContentEl(i)),
+	getFirstFocusableEl: (i) => dom.getFocusableEls(i)[0]
+});
+function connect(i, s, c) {
+	let l = i.matches("open"), u = i.context.currentPlacement, d = i.context.currentPortalled, f = i.context.renderedElements, p = getPlacementStyles({
+		...i.context.positioning,
+		placement: u
+	});
+	return {
+		portalled: d,
+		open: l,
+		setOpen(i) {
+			i !== l && s(i ? "OPEN" : "CLOSE");
+		},
+		reposition(i = {}) {
+			s({
+				type: "POSITIONING.SET",
+				options: i
+			});
+		},
+		getArrowProps() {
+			return c.element({
+				id: dom.getArrowId(i.context),
+				...parts.arrow.attrs,
+				dir: i.context.dir,
+				style: p.arrow
+			});
+		},
+		getArrowTipProps() {
+			return c.element({
+				...parts.arrowTip.attrs,
+				dir: i.context.dir,
+				style: p.arrowTip
+			});
+		},
+		getAnchorProps() {
+			return c.element({
+				...parts.anchor.attrs,
+				dir: i.context.dir,
+				id: dom.getAnchorId(i.context)
+			});
+		},
+		getTriggerProps() {
+			return c.button({
+				...parts.trigger.attrs,
+				dir: i.context.dir,
+				type: "button",
+				"data-placement": u,
+				id: dom.getTriggerId(i.context),
+				"aria-haspopup": "dialog",
+				"aria-expanded": l,
+				"data-state": l ? "open" : "closed",
+				"aria-controls": dom.getContentId(i.context),
+				onPointerDown(i) {
+					isSafari() && i.currentTarget.focus();
+				},
+				onClick(i) {
+					i.defaultPrevented || s("TOGGLE");
+				},
+				onBlur(i) {
+					s({
+						type: "TRIGGER_BLUR",
+						target: i.relatedTarget
+					});
+				}
+			});
+		},
+		getIndicatorProps() {
+			return c.element({
+				...parts.indicator.attrs,
+				dir: i.context.dir,
+				"data-state": l ? "open" : "closed"
+			});
+		},
+		getPositionerProps() {
+			return c.element({
+				id: dom.getPositionerId(i.context),
+				...parts.positioner.attrs,
+				dir: i.context.dir,
+				style: p.floating
+			});
+		},
+		getContentProps() {
+			return c.element({
+				...parts.content.attrs,
+				dir: i.context.dir,
+				id: dom.getContentId(i.context),
+				tabIndex: -1,
+				role: "dialog",
+				hidden: !l,
+				"data-state": l ? "open" : "closed",
+				"data-expanded": dataAttr(l),
+				"aria-labelledby": f.title ? dom.getTitleId(i.context) : void 0,
+				"aria-describedby": f.description ? dom.getDescriptionId(i.context) : void 0,
+				"data-placement": u
+			});
+		},
+		getTitleProps() {
+			return c.element({
+				...parts.title.attrs,
+				id: dom.getTitleId(i.context),
+				dir: i.context.dir
+			});
+		},
+		getDescriptionProps() {
+			return c.element({
+				...parts.description.attrs,
+				id: dom.getDescriptionId(i.context),
+				dir: i.context.dir
+			});
+		},
+		getCloseTriggerProps() {
+			return c.button({
+				...parts.closeTrigger.attrs,
+				dir: i.context.dir,
+				id: dom.getCloseTriggerId(i.context),
+				type: "button",
+				"aria-label": "close",
+				onClick(i) {
+					i.defaultPrevented || s("CLOSE");
+				}
+			});
+		}
+	};
+}
+function machine(i) {
+	let s = compact(i);
+	return createMachine({
+		id: "popover",
+		initial: s.open ? "open" : "closed",
+		context: {
+			closeOnInteractOutside: !0,
+			closeOnEscape: !0,
+			autoFocus: !0,
+			modal: !1,
+			portalled: !0,
+			positioning: {
+				placement: "bottom",
+				...s.positioning
+			},
+			currentPlacement: void 0,
+			...s,
+			renderedElements: {
+				title: !0,
+				description: !0
+			}
+		},
+		computed: { currentPortalled: (i) => !!i.modal || !!i.portalled },
+		watch: { open: ["toggleVisibility"] },
+		entry: ["checkRenderedElements"],
+		states: {
+			closed: { on: {
+				"CONTROLLED.OPEN": {
+					target: "open",
+					actions: ["setInitialFocus"]
+				},
+				TOGGLE: [{
+					guard: "isOpenControlled",
+					actions: ["invokeOnOpen"]
+				}, {
+					target: "open",
+					actions: ["invokeOnOpen", "setInitialFocus"]
+				}],
+				OPEN: [{
+					guard: "isOpenControlled",
+					actions: ["invokeOnOpen"]
+				}, {
+					target: "open",
+					actions: ["invokeOnOpen", "setInitialFocus"]
+				}]
+			} },
+			open: {
+				activities: [
+					"trapFocus",
+					"preventScroll",
+					"hideContentBelow",
+					"trackPositioning",
+					"trackDismissableElement",
+					"proxyTabFocus"
+				],
+				on: {
+					"CONTROLLED.CLOSE": {
+						target: "closed",
+						actions: ["setFinalFocus"]
+					},
+					CLOSE: [{
+						guard: "isOpenControlled",
+						actions: ["invokeOnClose"]
+					}, {
+						target: "closed",
+						actions: ["invokeOnClose", "setFinalFocus"]
+					}],
+					TOGGLE: [{
+						guard: "isOpenControlled",
+						actions: ["invokeOnClose"]
+					}, {
+						target: "closed",
+						actions: ["invokeOnClose"]
+					}],
+					"POSITIONING.SET": { actions: "reposition" }
+				}
+			}
+		}
+	}, {
+		guards: { isOpenControlled: (i) => !!i["open.controlled"] },
+		activities: {
+			trackPositioning(i) {
+				return i.currentPlacement = i.positioning.placement, getPlacement(dom.getAnchorEl(i) ?? dom.getTriggerEl(i), () => dom.getPositionerEl(i), {
+					...i.positioning,
+					defer: !0,
+					onComplete(s) {
+						i.currentPlacement = s.placement;
+					}
+				});
+			},
+			trackDismissableElement(i, s, { send: c }) {
+				let l = () => dom.getContentEl(i), u = !0;
+				return trackDismissableElement(l, {
+					pointerBlocking: i.modal,
+					exclude: dom.getTriggerEl(i),
+					defer: !0,
+					onEscapeKeyDown(s) {
+						i.onEscapeKeyDown?.(s), !i.closeOnEscape && s.preventDefault();
+					},
+					onInteractOutside(s) {
+						i.onInteractOutside?.(s), !s.defaultPrevented && (u = !(s.detail.focusable || s.detail.contextmenu), i.closeOnInteractOutside || s.preventDefault());
+					},
+					onPointerDownOutside: i.onPointerDownOutside,
+					onFocusOutside: i.onFocusOutside,
+					persistentElements: i.persistentElements,
+					onDismiss() {
+						c({
+							type: "CLOSE",
+							src: "interact-outside",
+							restoreFocus: u
+						});
+					}
+				});
+			},
+			proxyTabFocus(i) {
+				return i.modal || !i.portalled ? void 0 : proxyTabFocus(() => dom.getContentEl(i), {
+					triggerElement: dom.getTriggerEl(i),
+					defer: !0,
+					onFocus(i) {
+						i.focus({ preventScroll: !0 });
+					}
+				});
+			},
+			hideContentBelow(i) {
+				return i.modal ? ariaHidden(() => [dom.getContentEl(i), dom.getTriggerEl(i)], { defer: !0 }) : void 0;
+			},
+			preventScroll(i) {
+				if (i.modal) return preventBodyScroll(dom.getDoc(i));
+			},
+			trapFocus(i) {
+				return i.modal ? trapFocus(() => dom.getContentEl(i), { initialFocus: () => getInitialFocus({
+					root: dom.getContentEl(i),
+					getInitialEl: i.initialFocusEl,
+					enabled: i.autoFocus
+				}) }) : void 0;
+			}
+		},
+		actions: {
+			reposition(i, s) {
+				getPlacement(dom.getAnchorEl(i) ?? dom.getTriggerEl(i), () => dom.getPositionerEl(i), {
+					...i.positioning,
+					...s.options,
+					defer: !0,
+					listeners: !1,
+					onComplete(s) {
+						i.currentPlacement = s.placement;
+					}
+				});
+			},
+			checkRenderedElements(i) {
+				raf$1(() => {
+					Object.assign(i.renderedElements, {
+						title: !!dom.getTitleEl(i),
+						description: !!dom.getDescriptionEl(i)
+					});
+				});
+			},
+			setInitialFocus(i) {
+				i.modal || raf$1(() => {
+					getInitialFocus({
+						root: dom.getContentEl(i),
+						getInitialEl: i.initialFocusEl,
+						enabled: i.autoFocus
+					})?.focus({ preventScroll: !0 });
+				});
+			},
+			setFinalFocus(i, s) {
+				let c = s.restoreFocus ?? s.previousEvent?.restoreFocus;
+				c != null && !c || raf$1(() => {
+					dom.getTriggerEl(i)?.focus({ preventScroll: !0 });
+				});
+			},
+			invokeOnOpen(i) {
+				i.onOpenChange?.({ open: !0 });
+			},
+			invokeOnClose(i) {
+				i.onOpenChange?.({ open: !1 });
+			},
+			toggleVisibility(i, s, { send: c }) {
+				c({
+					type: i.open ? "CONTROLLED.OPEN" : "CONTROLLED.CLOSE",
+					previousEvent: s
+				});
+			}
+		}
+	});
+}
+createProps()([
+	"autoFocus",
+	"closeOnEscape",
+	"closeOnInteractOutside",
+	"dir",
+	"getRootNode",
+	"id",
+	"ids",
+	"initialFocusEl",
+	"modal",
+	"onEscapeKeyDown",
+	"onFocusOutside",
+	"onInteractOutside",
+	"onOpenChange",
+	"onPointerDownOutside",
+	"open.controlled",
+	"open",
+	"persistentElements",
+	"portalled",
+	"positioning"
+]);
+function useSnapshot(i, s) {
+	let { actions: c, context: l } = s ?? {}, u = shallowRef(i.state), d = subscribe(i.state, () => {
+		u.value = snapshot(i.state);
+	});
+	return onUnmounted(() => {
+		d?.();
+	}), watchEffect(() => {
+		i.setOptions({ actions: c });
+	}), l && watch(l, (s) => {
+		i.setContext(unref(s));
+	}, { deep: !0 }), u;
+}
+function useService(i, s) {
+	let { state: c, context: l } = s ?? {}, u = typeof i == "function" ? i() : i;
+	return l && u.setContext(unref(l)), u._created(), onMounted(() => {
+		u.start(c), onBeforeUnmount(() => {
+			u.stop();
+		});
+	}), u;
+}
+function useMachine(i, s) {
+	let c = useService(i, s);
+	return [
+		useSnapshot(c, s),
+		c.send,
+		c
+	];
+}
+function toCase(i) {
+	return i.charAt(0).toUpperCase() + i.substr(1).toLowerCase();
+}
+var propMap = {
+	htmlFor: "for",
+	className: "class",
+	onDoubleClick: "onDblclick",
+	onChange: "onInput",
+	onFocus: "onFocusin",
+	onBlur: "onFocusout",
+	defaultValue: "value",
+	defaultChecked: "checked"
+};
+function toVueProp(i) {
+	return i in propMap ? propMap[i] : i.startsWith("on") ? `on${toCase(i.substr(2))}` : i.toLowerCase();
+}
+var normalizeProps$1 = createNormalizer((i) => {
+	let s = {};
+	for (let c in i) {
+		let l = i[c];
+		c === "children" ? typeof l == "string" && (s.innerHTML = l) : s[toVueProp(c)] = i[c];
+	}
+	return s;
+}), _hoisted_1$7 = {
+	key: 0,
+	xmlns: "http://www.w3.org/2000/svg",
+	width: "1em",
+	height: "1em",
+	viewBox: "0 0 16 16"
+}, _hoisted_2$6 = {
+	key: 1,
+	xmlns: "http://www.w3.org/2000/svg",
+	width: "1em",
+	height: "1em",
+	viewBox: "0 0 16 16"
+}, ComponentsIcones_default = /* @__PURE__ */ defineComponent({
+	name: "ComponentIcones",
+	__name: "ComponentsIcones",
+	props: { expanded: {
+		type: Boolean,
+		default: !1
+	} },
+	setup(i) {
+		let s = i;
+		return (i, c) => s.expanded ? (openBlock(), createElementBlock("svg", _hoisted_1$7, [...c[0] ||= [createElementVNode("g", {
+			fill: "none",
+			"stroke-linecap": "round",
+			"stroke-linejoin": "round"
+		}, [createElementVNode("path", {
+			class: "stroke-dark dark:stroke-light",
+			d: "m1.87 8l.7-2.74a1 1 0 0 1 .96-.76h10.94a1 1 0 0 1 .97 1.24l-.219.875M6 13.5H2A1.5 1.5 0 0 1 .5 12V3.5a1 1 0 0 1 1-1h5a1 1 0 0 1 1 1v1"
+		}), createElementVNode("path", {
+			stroke: "#67B686",
+			d: "m9.485 9.516l3.968 3.968m-3.968 0l3.968-3.968m-1.634-1.874l3.507 3.507a.496.496 0 0 1 0 .702l-3.507 3.507a.496.496 0 0 1-.701 0L7.61 11.85a.496.496 0 0 1 0-.702l3.507-3.507a.496.496 0 0 1 .701 0z"
+		})], -1)]])) : (openBlock(), createElementBlock("svg", _hoisted_2$6, [...c[1] ||= [createElementVNode("g", {
+			fill: "none",
+			"stroke-linecap": "round",
+			"stroke-linejoin": "round"
+		}, [createElementVNode("path", {
+			class: "stroke-dark dark:stroke-light",
+			d: "M4.5 4.5H12c.83 0 1.5.67 1.5 1.5v.5m-7.5 7H2A1.5 1.5 0 0 1 .5 12V3.5a1 1 0 0 1 1-1h5a1 1 0 0 1 1 1v1"
+		}), createElementVNode("path", {
+			stroke: "#67B686",
+			d: "m9.485 9.516l3.968 3.968m-3.968 0l3.968-3.968m-1.634-1.874l3.507 3.507a.496.496 0 0 1 0 .702l-3.507 3.507a.496.496 0 0 1-.701 0L7.61 11.85a.496.496 0 0 1 0-.702l3.507-3.507a.496.496 0 0 1 .701 0z"
+		})], -1)]]));
+	}
+}), _hoisted_1$6 = {
+	key: 0,
+	xmlns: "http://www.w3.org/2000/svg",
+	width: "1em",
+	height: "1em",
+	viewBox: "0 0 16 16"
+}, _hoisted_2$5 = {
+	key: 1,
+	xmlns: "http://www.w3.org/2000/svg",
+	width: "1em",
+	height: "1em",
+	viewBox: "0 0 16 16"
+}, FolderIcones_default = /* @__PURE__ */ defineComponent({
+	name: "FolderIcones",
+	__name: "FolderIcones",
+	props: { expanded: {
+		type: Boolean,
+		default: !1
+	} },
+	setup(i) {
+		let s = i;
+		return (i, c) => s.expanded ? (openBlock(), createElementBlock("svg", _hoisted_1$6, [...c[0] ||= [createElementVNode("path", {
+			fill: "none",
+			class: "stroke-dark dark:stroke-light",
+			"stroke-linecap": "round",
+			"stroke-linejoin": "round",
+			d: "m1.87 8l.7-2.74a1 1 0 0 1 .96-.76h10.94a1 1 0 0 1 .97 1.24l-1.75 7a1 1 0 0 1-.97.76H2A1.5 1.5 0 0 1 .5 12V3.5a1 1 0 0 1 1-1h5a1 1 0 0 1 1 1v1"
+		}, null, -1)]])) : (openBlock(), createElementBlock("svg", _hoisted_2$5, [...c[1] ||= [createElementVNode("path", {
+			fill: "none",
+			class: "stroke-dark dark:stroke-light",
+			"stroke-linecap": "round",
+			"stroke-linejoin": "round",
+			d: "M4.5 4.5H12c.83 0 1.5.67 1.5 1.5v6c0 .83-.67 1.5-1.5 1.5H2A1.5 1.5 0 0 1 .5 12V3.5a1 1 0 0 1 1-1h5a1 1 0 0 1 1 1v1"
+		}, null, -1)]]));
+	}
+}), _hoisted_1$5 = {
+	key: 0,
+	xmlns: "http://www.w3.org/2000/svg",
+	width: "1em",
+	height: "1em",
+	viewBox: "0 0 16 16"
+}, _hoisted_2$4 = {
+	key: 1,
+	xmlns: "http://www.w3.org/2000/svg",
+	width: "1em",
+	height: "1em",
+	viewBox: "0 0 16 16"
+}, ModuleIcones_default = /* @__PURE__ */ defineComponent({
+	name: "ModleIcones",
+	__name: "ModuleIcones",
+	props: { expanded: {
+		type: Boolean,
+		default: !1
+	} },
+	setup(i) {
+		let s = i;
+		return (i, c) => s.expanded ? (openBlock(), createElementBlock("svg", _hoisted_1$5, [...c[0] ||= [createElementVNode("g", {
+			fill: "none",
+			"stroke-linecap": "round",
+			"stroke-linejoin": "round"
+		}, [createElementVNode("path", {
+			class: "stroke-dark dark:stroke-light",
+			d: "m1.875 8l.686-2.743a1 1 0 0 1 .97-.757h10.938a1 1 0 0 1 .97 1.243l-.315 1.26M6 13.5H2.004A1.5 1.5 0 0 1 .5 12V3.5a1 1 0 0 1 1-1h5a1 1 0 0 1 1 1v1"
+		}), createElementVNode("path", {
+			stroke: "#65bb87",
+			d: "M15.5 13.5v1.2a.8.8 0 0 1-.8.8h-4.4a.8.8 0 0 1-.8-.8v-1.2H9a1 1 0 0 1 0-2h.5v-1.2a.8.8 0 0 1 .8-.8h1.2V9a1 1 0 0 1 2 0v.5h1.2a.8.8 0 0 1 .8.8v1.2H15a1 1 0 0 0 0 2z"
+		})], -1)]])) : (openBlock(), createElementBlock("svg", _hoisted_2$4, [...c[1] ||= [createElementVNode("g", {
+			fill: "none",
+			"stroke-linecap": "round",
+			"stroke-linejoin": "round"
+		}, [createElementVNode("path", {
+			class: "stroke-dark dark:stroke-light",
+			d: "M4.5 4.5H12A1.5 1.5 0 0 1 13.5 6v.5m-7.5 7H2A1.5 1.5 0 0 1 .5 12V3.5a1 1 0 0 1 1-1h5a1 1 0 0 1 1 1v1"
+		}), createElementVNode("path", {
+			stroke: "#65bb87",
+			d: "M15.5 13.5v1.2a.8.8 0 0 1-.8.8h-4.4a.8.8 0 0 1-.8-.8v-1.2H9a1 1 0 0 1 0-2h.5v-1.2a.8.8 0 0 1 .8-.8h1.2V9a1 1 0 0 1 2 0v.5h1.2a.8.8 0 0 1 .8.8v1.2H15a1 1 0 0 0 0 2z"
+		})], -1)]]));
+	}
+}), _hoisted_1$4 = {
+	key: 0,
+	xmlns: "http://www.w3.org/2000/svg",
+	width: "1em",
+	height: "1em",
+	viewBox: "0 0 16 16"
+}, _hoisted_2$3 = {
+	key: 1,
+	xmlns: "http://www.w3.org/2000/svg",
+	width: "1em",
+	height: "1em",
+	viewBox: "0 0 16 16"
+}, PackagesIcones_default = /* @__PURE__ */ defineComponent({
+	name: "PackagesIcones",
+	__name: "PackagesIcones",
+	props: { expanded: {
+		type: Boolean,
+		default: !1
+	} },
+	setup(i) {
+		let s = i;
+		return (i, c) => s.expanded ? (openBlock(), createElementBlock("svg", _hoisted_1$4, [...c[0] ||= [createElementVNode("g", {
+			fill: "none",
+			"stroke-linecap": "round",
+			"stroke-linejoin": "round"
+		}, [createElementVNode("path", {
+			class: "stroke-dark dark:stroke-light",
+			d: "m1.875 8l.686-2.743a1 1 0 0 1 .97-.757h10.938a1 1 0 0 1 .97 1.243l-.315 1.26M6 13.5H2.004A1.5 1.5 0 0 1 .5 12V3.5a1 1 0 0 1 1-1h5a1 1 0 0 1 1 1v1"
+		}), createElementVNode("path", {
+			stroke: "#E23730",
+			d: "M12 15.337v-3.919L8.5 9.214m3.5 2.204l3.5-2.204M12 7.5l3.5 1.714v4.408L12 15.5l-3.5-1.878V9.214Z"
+		})], -1)]])) : (openBlock(), createElementBlock("svg", _hoisted_2$3, [...c[1] ||= [createElementVNode("g", {
+			fill: "none",
+			"stroke-linecap": "round",
+			"stroke-linejoin": "round"
+		}, [createElementVNode("path", {
+			class: "stroke-dark dark:stroke-light",
+			d: "M4.5 4.5H12A1.5 1.5 0 0 1 13.5 6v.5m-7.5 7H2A1.5 1.5 0 0 1 .5 12V3.5a1 1 0 0 1 1-1h5a1 1 0 0 1 1 1v1"
+		}), createElementVNode("path", {
+			stroke: "#E23730",
+			d: "M12 15.337v-3.919L8.5 9.214m3.5 2.204l3.5-2.204M12 7.5l3.5 1.714v4.408L12 15.5l-3.5-1.878V9.214Z"
+		})], -1)]]));
+	}
+}), _hoisted_1$3 = {
+	key: 0,
+	xmlns: "http://www.w3.org/2000/svg",
+	width: "1em",
+	height: "1em",
+	viewBox: "0 0 16 16"
+}, _hoisted_2$2 = {
+	key: 1,
+	xmlns: "http://www.w3.org/2000/svg",
+	width: "1em",
+	height: "1em",
+	viewBox: "0 0 16 16"
+}, SrcIcones_default = /* @__PURE__ */ defineComponent({
+	name: "SrcIcones",
+	__name: "SrcIcones",
+	props: { expanded: {
+		type: Boolean,
+		default: !1
+	} },
+	setup(i) {
+		let s = i;
+		return (i, c) => s.expanded ? (openBlock(), createElementBlock("svg", _hoisted_1$3, [...c[0] ||= [createElementVNode("g", {
+			fill: "none",
+			"stroke-linecap": "round",
+			"stroke-linejoin": "round"
+		}, [createElementVNode("path", {
+			class: "stroke-dark dark:stroke-light",
+			d: "m1.875 8l.686-2.743a1 1 0 0 1 .97-.757h10.938a1 1 0 0 1 .97 1.243l-.315 1.26M6 13.5H2.004A1.5 1.5 0 0 1 .5 12V3.5a1 1 0 0 1 1-1h5a1 1 0 0 1 1 1v1"
+		}), createElementVNode("path", {
+			stroke: "#65bb87",
+			d: "m10.5 8.5l-3 3.5l3 3.5m2-7l3 3.5l-3 3.5"
+		})], -1)]])) : (openBlock(), createElementBlock("svg", _hoisted_2$2, [...c[1] ||= [createElementVNode("g", {
+			fill: "none",
+			"stroke-linecap": "round",
+			"stroke-linejoin": "round"
+		}, [createElementVNode("path", {
+			class: "stroke-dark dark:stroke-light",
+			d: "M4.5 4.5H12A1.5 1.5 0 0 1 13.5 6v.5m-7.5 7H2A1.5 1.5 0 0 1 .5 12V3.5a1 1 0 0 1 1-1h5a1 1 0 0 1 1 1v1"
+		}), createElementVNode("path", {
+			stroke: "#65bb87",
+			d: "m10.5 8.5l-3 3.5l3 3.5m2-7l3 3.5l-3 3.5"
+		})], -1)]]));
+	}
+}), _hoisted_1$2 = {
+	key: 0,
+	xmlns: "http://www.w3.org/2000/svg",
+	width: "1em",
+	height: "1em",
+	viewBox: "0 0 16 16"
+}, _hoisted_2$1 = {
+	key: 1,
+	xmlns: "http://www.w3.org/2000/svg",
+	width: "1em",
+	height: "1em",
+	viewBox: "0 0 16 16"
+}, ViewIcones_default = /* @__PURE__ */ defineComponent({
+	name: "ViewIcones",
+	__name: "ViewIcones",
+	props: { expanded: {
+		type: Boolean,
+		default: !1
+	} },
+	setup(i) {
+		let s = i;
+		return (i, c) => s.expanded ? (openBlock(), createElementBlock("svg", _hoisted_1$2, [...c[0] ||= [createElementVNode("g", {
+			fill: "none",
+			"stroke-linecap": "round",
+			"stroke-linejoin": "round"
+		}, [createElementVNode("path", {
+			class: "stroke-dark dark:stroke-light",
+			d: "m1.875 8l.686-2.743a1 1 0 0 1 .97-.757h10.938a1 1 0 0 1 .97 1.243l-.315 1.26M6 13.5H2.004A1.5 1.5 0 0 1 .5 12V3.5a1 1 0 0 1 1-1h5a1 1 0 0 1 1 1v1"
+		}), createElementVNode("path", {
+			stroke: "#E23730",
+			d: "M14.692 8.5H9.308a.31.31 0 0 0-.307.336l.47 5.241c.01.128.1.235.223.27l2.303 1.153l2.308-1.153a.31.31 0 0 0 .225-.27L15 8.836a.31.31 0 0 0-.307-.336"
+		})], -1)]])) : (openBlock(), createElementBlock("svg", _hoisted_2$1, [...c[1] ||= [createElementVNode("g", {
+			fill: "none",
+			"stroke-linecap": "round",
+			"stroke-linejoin": "round"
+		}, [createElementVNode("path", {
+			class: "stroke-dark dark:stroke-light",
+			d: "M4.5 4.5H12A1.5 1.5 0 0 1 13.5 6v.5m-7.5 7H2A1.5 1.5 0 0 1 .5 12V3.5a1 1 0 0 1 1-1h5a1 1 0 0 1 1 1v1"
+		}), createElementVNode("path", {
+			stroke: "#E23730",
+			d: "M14.692 8.5H9.308a.31.31 0 0 0-.307.336l.47 5.241c.01.128.1.235.223.27l2.303 1.153l2.308-1.153a.31.31 0 0 0 .225-.27L15 8.836a.31.31 0 0 0-.307-.336"
+		})], -1)]]));
+	}
+}), _hoisted_1$1 = {
+	xmlns: "http://www.w3.org/2000/svg",
+	width: "1em",
+	height: "1em",
+	viewBox: "0 0 16 16"
+}, VueIcones_default = /* @__PURE__ */ defineComponent({
+	name: "VueIcones",
+	__name: "VueIcones",
+	setup(i) {
+		return (i, s) => (openBlock(), createElementBlock("svg", _hoisted_1$1, [...s[0] ||= [createElementVNode("g", {
+			fill: "none",
+			stroke: "#65bb87",
+			"stroke-linecap": "round",
+			"stroke-linejoin": "round"
+		}, [createElementVNode("path", { d: "M1 1.5h5.44L8 4.56L9.56 1.5H15l-6.99 13z" }), createElementVNode("path", { d: "M12.05 1.73L8 9.28L3.95 1.73" })], -1)]]));
+	}
+}), _hoisted_1 = { class: "mt-0" }, _hoisted_2 = { class: "w-152 mb-2" }, _hoisted_3 = { class: "inline-flex items-center text-inherit not-italic leading-[0] text-center normal-case [vertical-align:-0.125em] [text-rendering:optimizeLegibility] svg:size-4" }, _hoisted_4 = {
+	key: 1,
+	class: "flex items-center justify-center h-[220px]"
+}, ComponentSelect_default = /* @__PURE__ */ defineComponent({
+	name: "ComponentSelect",
+	__name: "ComponentSelect",
+	props: {
+		modelValue: { default: "" },
+		modelModifiers: {},
+		scope: { default: "" },
+		scopeModifiers: {}
+	},
+	emits: ["update:modelValue", "update:scope"],
+	setup(m) {
+		let b = Empty.PRESENTED_IMAGE_SIMPLE, x = useViewStore(), S = useModel(m, "modelValue"), T = useModel(m, "scope"), E = useTemplateRef("searchInputRef"), [M, B] = useMachine(machine({
+			id: useId(),
+			initialFocusEl: () => E.value
+		})), V = computed(() => connect(M.value, B, normalizeProps$1)), H = ref(!1), U = ref(""), W = computed(() => S.value ? [`${T.value ? `module:${T.value}` : "local"}/${S.value}`] : []), G = ref([]);
+		function K(i) {
+			return !i.includes("/");
+		}
+		function q(i) {
+			let s = i.indexOf("/");
+			return s === -1 ? i : i.slice(0, s);
+		}
+		function J(i) {
+			let s = i.split("/"), c = [], l = "";
+			for (let i = 0; i < Math.max(0, s.length - 1); i++) {
+				let u = s[i];
+				l = i === 0 ? u : `${l}/${u}`, c.push(l);
+			}
+			return c;
+		}
+		function Y(i, s) {
+			let c = i || [], l = s?.node?.key, u = !!s?.expanded, d;
+			d = l && K(l) ? u ? l : void 0 : l ? q(l) : c.find(K), G.value = c.filter((i) => !K(String(i)) || String(i) === d);
+		}
+		function X() {
+			let i = W.value[0];
+			i && (G.value = J(i));
+		}
+		watch(W, () => {
+			X();
+		}, { immediate: !0 }), watch(H, (i) => {
+			i && X();
+		}), watch(H, (i) => {
+			i && X();
+		});
+		let Z = computed(() => {
+			let i = U.value.trim();
+			return i ? x.filterRouteTree(i) : x.getRouteTreeData();
+		});
+		function Q(i) {
+			let s = [], c = (i) => {
+				for (let l of i || []) Array.isArray(l?.children) && l.children.length > 0 && (s.push(String(l.key)), c(l.children));
+			};
+			return c(i), s;
+		}
+		watch(U, (i) => {
+			if (String(i || "").trim().length > 0) {
+				let i = Z.value;
+				G.value = Q(i);
+			} else X();
+		});
+		function $(i, s) {
+			let c = s?.node, l = c?.dataRef ?? c;
+			l?.isLeaf && (S.value = l.value || "", T.value = l.scope || "", U.value = "", H.value = !1);
+		}
+		return (i, c) => {
+			let m = Input$1, x = FormItemRest, w = DirectoryTree, E = Empty$1;
+			return openBlock(), createElementBlock("div", _hoisted_1, [createElementVNode("div", normalizeProps(guardReactiveProps(unref(V).getTriggerProps())), [createVNode(m, {
+				value: S.value,
+				"onUpdate:value": c[0] ||= (i) => S.value = i,
+				"addon-before": T.value || "本地",
+				placeholder: "请输入或选择组件路径（views下的路径）"
+			}, null, 8, ["value", "addon-before"])], 16), (openBlock(), createBlock(Teleport, { to: "body" }, [unref(V).open ? (openBlock(), createElementBlock("div", mergeProps({ key: 0 }, unref(V).getPositionerProps(), { class: "z-1050" }), [createElementVNode("div", mergeProps(unref(V).getContentProps(), { class: "z-1050 w-162 rounded-md border border-solid p-4 border-[--g-border-color] shadow-md outline-none bg-#ffffff dark:bg-#141414 text-dark dark:text-light data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95" }), [createElementVNode("div", _hoisted_2, [createVNode(x, null, {
+				default: withCtx(() => [createVNode(m, {
+					ref: "searchInputRef",
+					value: unref(U),
+					"onUpdate:value": c[1] ||= (i) => isRef(U) ? U.value = i : null,
+					"allow-clear": "",
+					size: "small",
+					placeholder: "搜索组件或路径"
+				}, null, 8, ["value"])]),
+				_: 1
+			})]), unref(Z) && unref(Z).length ? (openBlock(), createBlock(w, {
+				key: 0,
+				"expanded-keys": unref(G),
+				"onUpdate:expandedKeys": c[2] ||= (i) => isRef(G) ? G.value = i : null,
+				class: "w-152 h-100 overflow-y-auto directory-tree-root",
+				"selected-keys": unref(W),
+				"tree-data": unref(Z),
+				"show-icon": !0,
+				"show-line": !0,
+				virtual: !0,
+				"expand-action": "click",
+				onExpand: Y,
+				onSelect: $
+			}, {
+				switcherIcon: withCtx(({ switcherCls: i }) => [createVNode(unref(CaretDownOutlined), { class: normalizeClass(i) }, null, 8, ["class"])]),
+				icon: withCtx(({ expanded: i, dataRef: s }) => [createElementVNode("span", _hoisted_3, [s?.root && !s?.module ? (openBlock(), createBlock(PackagesIcones_default, {
+					key: 0,
+					expanded: i
+				}, null, 8, ["expanded"])) : s?.root && s?.module ? (openBlock(), createBlock(ModuleIcones_default, {
+					key: 1,
+					expanded: i
+				}, null, 8, ["expanded"])) : s?.isLeaf ? (openBlock(), createBlock(VueIcones_default, { key: 2 })) : ["components", "component"].includes(String(s?.title).toLowerCase()) ? (openBlock(), createBlock(ComponentsIcones_default, {
+					key: 3,
+					expanded: i
+				}, null, 8, ["expanded"])) : [
+					"views",
+					"view",
+					"pages",
+					"page"
+				].includes(String(s?.title).toLowerCase()) ? (openBlock(), createBlock(ViewIcones_default, {
+					key: 4,
+					expanded: i
+				}, null, 8, ["expanded"])) : ["src"].includes(String(s?.title).toLowerCase()) ? (openBlock(), createBlock(SrcIcones_default, {
+					key: 5,
+					expanded: i
+				}, null, 8, ["expanded"])) : (openBlock(), createBlock(FolderIcones_default, {
+					key: 6,
+					expanded: i
+				}, null, 8, ["expanded"]))])]),
+				_: 1
+			}, 8, [
+				"expanded-keys",
+				"selected-keys",
+				"tree-data"
+			])) : (openBlock(), createElementBlock("div", _hoisted_4, [createVNode(E, {
+				image: unref(b),
+				description: "没有找到匹配的组件"
+			}, null, 8, ["image"])]))], 16)], 16)) : createCommentVNode("", !0)]))]);
+		};
+	}
+});
+export { ComponentSelect_default as t };