@pubinfo/module-rbac 2.0.8 → 2.0.10

package/dist/ComponentSelect.vue_vue_type_style_index_0_lang-CMEO08Uz.js

@@ -0,0 +1,3981 @@
+import { Input as Vn, FormItemRest as jn, DirectoryTree as Wn, Empty as $n } from "ant-design-vue/es";
+import { unref as M, onMounted as Hn, onBeforeUnmount as Gn, shallowRef as zn, onUnmounted as Kn, watchEffect as Un, watch as Lt, defineComponent as pt, createElementBlock as D, openBlock as F, createElementVNode as T, useModel as Le, useTemplateRef as Yn, useId as qn, computed as oe, ref as se, createBlock as J, normalizeProps as Xn, guardReactiveProps as Zn, createVNode as Pt, Teleport as Qn, createCommentVNode as Jn, mergeProps as Me, withCtx as ie, isRef as Re, normalizeClass as to } from "vue";
+import { CaretDownOutlined as eo } from "@ant-design/icons-vue";
+import { Empty as no } from "ant-design-vue";
+import { useViewStore as oo } from "./index.js";
+import './ComponentSelect.css';const so = ["top", "right", "bottom", "left"], ft = Math.min, _ = Math.max, Kt = Math.round, Wt = Math.floor, Y = (t) => ({
+  x: t,
+  y: t
+}), io = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, ro = {
+  start: "end",
+  end: "start"
+};
+function he(t, e, n) {
+  return _(t, ft(e, n));
+}
+function st(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function it(t) {
+  return t.split("-")[0];
+}
+function kt(t) {
+  return t.split("-")[1];
+}
+function Ee(t) {
+  return t === "x" ? "y" : "x";
+}
+function Oe(t) {
+  return t === "y" ? "height" : "width";
+}
+const ao = /* @__PURE__ */ new Set(["top", "bottom"]);
+function U(t) {
+  return ao.has(it(t)) ? "y" : "x";
+}
+function Ae(t) {
+  return Ee(U(t));
+}
+function co(t, e, n) {
+  n === void 0 && (n = !1);
+  const o = kt(t), s = Ae(t), i = Oe(s);
+  let r = s === "x" ? o === (n ? "end" : "start") ? "right" : "left" : o === "start" ? "bottom" : "top";
+  return e.reference[i] > e.floating[i] && (r = Ut(r)), [r, Ut(r)];
+}
+function lo(t) {
+  const e = Ut(t);
+  return [pe(t), e, pe(e)];
+}
+function pe(t) {
+  return t.replace(/start|end/g, (e) => ro[e]);
+}
+const _e = ["left", "right"], Be = ["right", "left"], uo = ["top", "bottom"], fo = ["bottom", "top"];
+function ho(t, e, n) {
+  switch (t) {
+    case "top":
+    case "bottom":
+      return n ? e ? Be : _e : e ? _e : Be;
+    case "left":
+    case "right":
+      return e ? uo : fo;
+    default:
+      return [];
+  }
+}
+function po(t, e, n, o) {
+  const s = kt(t);
+  let i = ho(it(t), n === "start", o);
+  return s && (i = i.map((r) => r + "-" + s), e && (i = i.concat(i.map(pe)))), i;
+}
+function Ut(t) {
+  return t.replace(/left|right|bottom|top/g, (e) => io[e]);
+}
+function go(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+function hn(t) {
+  return typeof t != "number" ? go(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function Yt(t) {
+  const {
+    x: e,
+    y: n,
+    width: o,
+    height: s
+  } = t;
+  return {
+    width: o,
+    height: s,
+    top: n,
+    left: e,
+    right: e + o,
+    bottom: n + s,
+    x: e,
+    y: n
+  };
+}
+function Ve(t, e, n) {
+  let {
+    reference: o,
+    floating: s
+  } = t;
+  const i = U(e), r = Ae(e), a = Oe(r), c = it(e), l = i === "y", f = o.x + o.width / 2 - s.width / 2, h = o.y + o.height / 2 - s.height / 2, u = o[a] / 2 - s[a] / 2;
+  let d;
+  switch (c) {
+    case "top":
+      d = {
+        x: f,
+        y: o.y - s.height
+      };
+      break;
+    case "bottom":
+      d = {
+        x: f,
+        y: o.y + o.height
+      };
+      break;
+    case "right":
+      d = {
+        x: o.x + o.width,
+        y: h
+      };
+      break;
+    case "left":
+      d = {
+        x: o.x - s.width,
+        y: h
+      };
+      break;
+    default:
+      d = {
+        x: o.x,
+        y: o.y
+      };
+  }
+  switch (kt(e)) {
+    case "start":
+      d[r] -= u * (n && l ? -1 : 1);
+      break;
+    case "end":
+      d[r] += u * (n && l ? -1 : 1);
+      break;
+  }
+  return d;
+}
+const mo = async (t, e, n) => {
+  const {
+    placement: o = "bottom",
+    strategy: s = "absolute",
+    middleware: i = [],
+    platform: r
+  } = n, a = i.filter(Boolean), c = await (r.isRTL == null ? void 0 : r.isRTL(e));
+  let l = await r.getElementRects({
+    reference: t,
+    floating: e,
+    strategy: s
+  }), {
+    x: f,
+    y: h
+  } = Ve(l, o, c), u = o, d = {}, p = 0;
+  for (let m = 0; m < a.length; m++) {
+    const {
+      name: w,
+      fn: g
+    } = a[m], {
+      x,
+      y: O,
+      data: P,
+      reset: y
+    } = await g({
+      x: f,
+      y: h,
+      initialPlacement: o,
+      placement: u,
+      strategy: s,
+      middlewareData: d,
+      rects: l,
+      platform: r,
+      elements: {
+        reference: t,
+        floating: e
+      }
+    });
+    f = x ?? f, h = O ?? h, d = {
+      ...d,
+      [w]: {
+        ...d[w],
+        ...P
+      }
+    }, y && p <= 50 && (p++, typeof y == "object" && (y.placement && (u = y.placement), y.rects && (l = y.rects === !0 ? await r.getElementRects({
+      reference: t,
+      floating: e,
+      strategy: s
+    }) : y.rects), {
+      x: f,
+      y: h
+    } = Ve(l, u, c)), m = -1);
+  }
+  return {
+    x: f,
+    y: h,
+    placement: u,
+    strategy: s,
+    middlewareData: d
+  };
+};
+async function Rt(t, e) {
+  var n;
+  e === void 0 && (e = {});
+  const {
+    x: o,
+    y: s,
+    platform: i,
+    rects: r,
+    elements: a,
+    strategy: c
+  } = t, {
+    boundary: l = "clippingAncestors",
+    rootBoundary: f = "viewport",
+    elementContext: h = "floating",
+    altBoundary: u = !1,
+    padding: d = 0
+  } = st(e, t), p = hn(d), w = a[u ? h === "floating" ? "reference" : "floating" : h], g = Yt(await i.getClippingRect({
+    element: (n = await (i.isElement == null ? void 0 : i.isElement(w))) == null || n ? w : w.contextElement || await (i.getDocumentElement == null ? void 0 : i.getDocumentElement(a.floating)),
+    boundary: l,
+    rootBoundary: f,
+    strategy: c
+  })), x = h === "floating" ? {
+    x: o,
+    y: s,
+    width: r.floating.width,
+    height: r.floating.height
+  } : r.reference, O = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(a.floating)), P = await (i.isElement == null ? void 0 : i.isElement(O)) ? await (i.getScale == null ? void 0 : i.getScale(O)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, y = Yt(i.convertOffsetParentRelativeRectToViewportRelativeRect ? await i.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: a,
+    rect: x,
+    offsetParent: O,
+    strategy: c
+  }) : x);
+  return {
+    top: (g.top - y.top + p.top) / P.y,
+    bottom: (y.bottom - g.bottom + p.bottom) / P.y,
+    left: (g.left - y.left + p.left) / P.x,
+    right: (y.right - g.right + p.right) / P.x
+  };
+}
+const yo = (t) => ({
+  name: "arrow",
+  options: t,
+  async fn(e) {
+    const {
+      x: n,
+      y: o,
+      placement: s,
+      rects: i,
+      platform: r,
+      elements: a,
+      middlewareData: c
+    } = e, {
+      element: l,
+      padding: f = 0
+    } = st(t, e) || {};
+    if (l == null)
+      return {};
+    const h = hn(f), u = {
+      x: n,
+      y: o
+    }, d = Ae(s), p = Oe(d), m = await r.getDimensions(l), w = d === "y", g = w ? "top" : "left", x = w ? "bottom" : "right", O = w ? "clientHeight" : "clientWidth", P = i.reference[p] + i.reference[d] - u[d] - i.floating[p], y = u[d] - i.reference[d], k = await (r.getOffsetParent == null ? void 0 : r.getOffsetParent(l));
+    let b = k ? k[O] : 0;
+    (!b || !await (r.isElement == null ? void 0 : r.isElement(k))) && (b = a.floating[O] || i.floating[p]);
+    const v = P / 2 - y / 2, E = b / 2 - m[p] / 2 - 1, S = ft(h[g], E), C = ft(h[x], E), N = S, R = b - m[p] - C, I = b / 2 - m[p] / 2 + v, mt = he(N, I, R), Q = !c.arrow && kt(s) != null && I !== mt && i.reference[p] / 2 - (I < N ? S : C) - m[p] / 2 < 0, V = Q ? I < N ? I - N : I - R : 0;
+    return {
+      [d]: u[d] + V,
+      data: {
+        [d]: mt,
+        centerOffset: I - mt - V,
+        ...Q && {
+          alignmentOffset: V
+        }
+      },
+      reset: Q
+    };
+  }
+}), bo = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "flip",
+    options: t,
+    async fn(e) {
+      var n, o;
+      const {
+        placement: s,
+        middlewareData: i,
+        rects: r,
+        initialPlacement: a,
+        platform: c,
+        elements: l
+      } = e, {
+        mainAxis: f = !0,
+        crossAxis: h = !0,
+        fallbackPlacements: u,
+        fallbackStrategy: d = "bestFit",
+        fallbackAxisSideDirection: p = "none",
+        flipAlignment: m = !0,
+        ...w
+      } = st(t, e);
+      if ((n = i.arrow) != null && n.alignmentOffset)
+        return {};
+      const g = it(s), x = U(a), O = it(a) === a, P = await (c.isRTL == null ? void 0 : c.isRTL(l.floating)), y = u || (O || !m ? [Ut(a)] : lo(a)), k = p !== "none";
+      !u && k && y.push(...po(a, m, p, P));
+      const b = [a, ...y], v = await Rt(e, w), E = [];
+      let S = ((o = i.flip) == null ? void 0 : o.overflows) || [];
+      if (f && E.push(v[g]), h) {
+        const I = co(s, r, P);
+        E.push(v[I[0]], v[I[1]]);
+      }
+      if (S = [...S, {
+        placement: s,
+        overflows: E
+      }], !E.every((I) => I <= 0)) {
+        var C, N;
+        const I = (((C = i.flip) == null ? void 0 : C.index) || 0) + 1, mt = b[I];
+        if (mt && (!(h === "alignment" ? x !== U(mt) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        S.every((j) => j.overflows[0] > 0 && U(j.placement) === x)))
+          return {
+            data: {
+              index: I,
+              overflows: S
+            },
+            reset: {
+              placement: mt
+            }
+          };
+        let Q = (N = S.filter((V) => V.overflows[0] <= 0).sort((V, j) => V.overflows[1] - j.overflows[1])[0]) == null ? void 0 : N.placement;
+        if (!Q)
+          switch (d) {
+            case "bestFit": {
+              var R;
+              const V = (R = S.filter((j) => {
+                if (k) {
+                  const rt = U(j.placement);
+                  return rt === x || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  rt === "y";
+                }
+                return !0;
+              }).map((j) => [j.placement, j.overflows.filter((rt) => rt > 0).reduce((rt, Bn) => rt + Bn, 0)]).sort((j, rt) => j[1] - rt[1])[0]) == null ? void 0 : R[0];
+              V && (Q = V);
+              break;
+            }
+            case "initialPlacement":
+              Q = a;
+              break;
+          }
+        if (s !== Q)
+          return {
+            reset: {
+              placement: Q
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function je(t, e) {
+  return {
+    top: t.top - e.height,
+    right: t.right - e.width,
+    bottom: t.bottom - e.height,
+    left: t.left - e.width
+  };
+}
+function We(t) {
+  return so.some((e) => t[e] >= 0);
+}
+const vo = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "hide",
+    options: t,
+    async fn(e) {
+      const {
+        rects: n
+      } = e, {
+        strategy: o = "referenceHidden",
+        ...s
+      } = st(t, e);
+      switch (o) {
+        case "referenceHidden": {
+          const i = await Rt(e, {
+            ...s,
+            elementContext: "reference"
+          }), r = je(i, n.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: r,
+              referenceHidden: We(r)
+            }
+          };
+        }
+        case "escaped": {
+          const i = await Rt(e, {
+            ...s,
+            altBoundary: !0
+          }), r = je(i, n.floating);
+          return {
+            data: {
+              escapedOffsets: r,
+              escaped: We(r)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+}, pn = /* @__PURE__ */ new Set(["left", "top"]);
+async function wo(t, e) {
+  const {
+    placement: n,
+    platform: o,
+    elements: s
+  } = t, i = await (o.isRTL == null ? void 0 : o.isRTL(s.floating)), r = it(n), a = kt(n), c = U(n) === "y", l = pn.has(r) ? -1 : 1, f = i && c ? -1 : 1, h = st(e, t);
+  let {
+    mainAxis: u,
+    crossAxis: d,
+    alignmentAxis: p
+  } = typeof h == "number" ? {
+    mainAxis: h,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: h.mainAxis || 0,
+    crossAxis: h.crossAxis || 0,
+    alignmentAxis: h.alignmentAxis
+  };
+  return a && typeof p == "number" && (d = a === "end" ? p * -1 : p), c ? {
+    x: d * f,
+    y: u * l
+  } : {
+    x: u * l,
+    y: d * f
+  };
+}
+const xo = function(t) {
+  return t === void 0 && (t = 0), {
+    name: "offset",
+    options: t,
+    async fn(e) {
+      var n, o;
+      const {
+        x: s,
+        y: i,
+        placement: r,
+        middlewareData: a
+      } = e, c = await wo(e, t);
+      return r === ((n = a.offset) == null ? void 0 : n.placement) && (o = a.arrow) != null && o.alignmentOffset ? {} : {
+        x: s + c.x,
+        y: i + c.y,
+        data: {
+          ...c,
+          placement: r
+        }
+      };
+    }
+  };
+}, Eo = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(e) {
+      const {
+        x: n,
+        y: o,
+        placement: s
+      } = e, {
+        mainAxis: i = !0,
+        crossAxis: r = !1,
+        limiter: a = {
+          fn: (w) => {
+            let {
+              x: g,
+              y: x
+            } = w;
+            return {
+              x: g,
+              y: x
+            };
+          }
+        },
+        ...c
+      } = st(t, e), l = {
+        x: n,
+        y: o
+      }, f = await Rt(e, c), h = U(it(s)), u = Ee(h);
+      let d = l[u], p = l[h];
+      if (i) {
+        const w = u === "y" ? "top" : "left", g = u === "y" ? "bottom" : "right", x = d + f[w], O = d - f[g];
+        d = he(x, d, O);
+      }
+      if (r) {
+        const w = h === "y" ? "top" : "left", g = h === "y" ? "bottom" : "right", x = p + f[w], O = p - f[g];
+        p = he(x, p, O);
+      }
+      const m = a.fn({
+        ...e,
+        [u]: d,
+        [h]: p
+      });
+      return {
+        ...m,
+        data: {
+          x: m.x - n,
+          y: m.y - o,
+          enabled: {
+            [u]: i,
+            [h]: r
+          }
+        }
+      };
+    }
+  };
+}, Oo = function(t) {
+  return t === void 0 && (t = {}), {
+    options: t,
+    fn(e) {
+      const {
+        x: n,
+        y: o,
+        placement: s,
+        rects: i,
+        middlewareData: r
+      } = e, {
+        offset: a = 0,
+        mainAxis: c = !0,
+        crossAxis: l = !0
+      } = st(t, e), f = {
+        x: n,
+        y: o
+      }, h = U(s), u = Ee(h);
+      let d = f[u], p = f[h];
+      const m = st(a, e), w = typeof m == "number" ? {
+        mainAxis: m,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...m
+      };
+      if (c) {
+        const O = u === "y" ? "height" : "width", P = i.reference[u] - i.floating[O] + w.mainAxis, y = i.reference[u] + i.reference[O] - w.mainAxis;
+        d < P ? d = P : d > y && (d = y);
+      }
+      if (l) {
+        var g, x;
+        const O = u === "y" ? "width" : "height", P = pn.has(it(s)), y = i.reference[h] - i.floating[O] + (P && ((g = r.offset) == null ? void 0 : g[h]) || 0) + (P ? 0 : w.crossAxis), k = i.reference[h] + i.reference[O] + (P ? 0 : ((x = r.offset) == null ? void 0 : x[h]) || 0) - (P ? w.crossAxis : 0);
+        p < y ? p = y : p > k && (p = k);
+      }
+      return {
+        [u]: d,
+        [h]: p
+      };
+    }
+  };
+}, Ao = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "size",
+    options: t,
+    async fn(e) {
+      var n, o;
+      const {
+        placement: s,
+        rects: i,
+        platform: r,
+        elements: a
+      } = e, {
+        apply: c = () => {
+        },
+        ...l
+      } = st(t, e), f = await Rt(e, l), h = it(s), u = kt(s), d = U(s) === "y", {
+        width: p,
+        height: m
+      } = i.floating;
+      let w, g;
+      h === "top" || h === "bottom" ? (w = h, g = u === (await (r.isRTL == null ? void 0 : r.isRTL(a.floating)) ? "start" : "end") ? "left" : "right") : (g = h, w = u === "end" ? "top" : "bottom");
+      const x = m - f.top - f.bottom, O = p - f.left - f.right, P = ft(m - f[w], x), y = ft(p - f[g], O), k = !e.middlewareData.shift;
+      let b = P, v = y;
+      if ((n = e.middlewareData.shift) != null && n.enabled.x && (v = O), (o = e.middlewareData.shift) != null && o.enabled.y && (b = x), k && !u) {
+        const S = _(f.left, 0), C = _(f.right, 0), N = _(f.top, 0), R = _(f.bottom, 0);
+        d ? v = p - 2 * (S !== 0 || C !== 0 ? S + C : _(f.left, f.right)) : b = m - 2 * (N !== 0 || R !== 0 ? N + R : _(f.top, f.bottom));
+      }
+      await c({
+        ...e,
+        availableWidth: v,
+        availableHeight: b
+      });
+      const E = await r.getDimensions(a.floating);
+      return p !== E.width || m !== E.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function Jt() {
+  return typeof window < "u";
+}
+function St(t) {
+  return gn(t) ? (t.nodeName || "").toLowerCase() : "#document";
+}
+function B(t) {
+  var e;
+  return (t == null || (e = t.ownerDocument) == null ? void 0 : e.defaultView) || window;
+}
+function Z(t) {
+  var e;
+  return (e = (gn(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : e.documentElement;
+}
+function gn(t) {
+  return Jt() ? t instanceof Node || t instanceof B(t).Node : !1;
+}
+function G(t) {
+  return Jt() ? t instanceof Element || t instanceof B(t).Element : !1;
+}
+function X(t) {
+  return Jt() ? t instanceof HTMLElement || t instanceof B(t).HTMLElement : !1;
+}
+function $e(t) {
+  return !Jt() || typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof B(t).ShadowRoot;
+}
+const ko = /* @__PURE__ */ new Set(["inline", "contents"]);
+function Bt(t) {
+  const {
+    overflow: e,
+    overflowX: n,
+    overflowY: o,
+    display: s
+  } = z(t);
+  return /auto|scroll|overlay|hidden|clip/.test(e + o + n) && !ko.has(s);
+}
+const So = /* @__PURE__ */ new Set(["table", "td", "th"]);
+function To(t) {
+  return So.has(St(t));
+}
+const Po = [":popover-open", ":modal"];
+function te(t) {
+  return Po.some((e) => {
+    try {
+      return t.matches(e);
+    } catch {
+      return !1;
+    }
+  });
+}
+const Co = ["transform", "translate", "scale", "rotate", "perspective"], No = ["transform", "translate", "scale", "rotate", "perspective", "filter"], Fo = ["paint", "layout", "strict", "content"];
+function ke(t) {
+  const e = Se(), n = G(t) ? z(t) : t;
+  return Co.some((o) => n[o] ? n[o] !== "none" : !1) || (n.containerType ? n.containerType !== "normal" : !1) || !e && (n.backdropFilter ? n.backdropFilter !== "none" : !1) || !e && (n.filter ? n.filter !== "none" : !1) || No.some((o) => (n.willChange || "").includes(o)) || Fo.some((o) => (n.contain || "").includes(o));
+}
+function Io(t) {
+  let e = ht(t);
+  for (; X(e) && !At(e); ) {
+    if (ke(e))
+      return e;
+    if (te(e))
+      return null;
+    e = ht(e);
+  }
+  return null;
+}
+function Se() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+const Do = /* @__PURE__ */ new Set(["html", "body", "#document"]);
+function At(t) {
+  return Do.has(St(t));
+}
+function z(t) {
+  return B(t).getComputedStyle(t);
+}
+function ee(t) {
+  return G(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.scrollX,
+    scrollTop: t.scrollY
+  };
+}
+function ht(t) {
+  if (St(t) === "html")
+    return t;
+  const e = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    t.assignedSlot || // DOM Element detected.
+    t.parentNode || // ShadowRoot detected.
+    $e(t) && t.host || // Fallback.
+    Z(t)
+  );
+  return $e(e) ? e.host : e;
+}
+function mn(t) {
+  const e = ht(t);
+  return At(e) ? t.ownerDocument ? t.ownerDocument.body : t.body : X(e) && Bt(e) ? e : mn(e);
+}
+function _t(t, e, n) {
+  var o;
+  e === void 0 && (e = []), n === void 0 && (n = !0);
+  const s = mn(t), i = s === ((o = t.ownerDocument) == null ? void 0 : o.body), r = B(s);
+  if (i) {
+    const a = ge(r);
+    return e.concat(r, r.visualViewport || [], Bt(s) ? s : [], a && n ? _t(a) : []);
+  }
+  return e.concat(s, _t(s, [], n));
+}
+function ge(t) {
+  return t.parent && Object.getPrototypeOf(t.parent) ? t.frameElement : null;
+}
+const Lo = (t) => t.length === 0;
+function xt(t) {
+  return t.replace(/([a-z\d])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function Gt(t, e = []) {
+  return {
+    parts: (...n) => {
+      if (Lo(e)) return Gt(t, n);
+      throw new Error("createAnatomy().parts(...) should only be called once. Did you mean to use .extendWith(...) ?");
+    },
+    extendWith: (...n) => Gt(t, [...e, ...n]),
+    rename: (n) => Gt(n, e),
+    keys: () => e,
+    build: () => [...new Set(e)].reduce((n, o) => Object.assign(n, { [o]: {
+      selector: [`&[data-scope="${xt(t)}"][data-part="${xt(o)}"]`, `& [data-scope="${xt(t)}"][data-part="${xt(o)}"]`].join(", "),
+      attrs: {
+        "data-scope": xt(t),
+        "data-part": xt(o)
+      }
+    } }), {})
+  };
+}
+const ne = (t) => typeof t == "object" && t !== null, Mo = (t) => t ? "" : void 0, Ro = 1, _o = 9, Bo = 11;
+function L(t) {
+  return ne(t) && t.nodeType === Ro && typeof t.nodeName == "string";
+}
+const Te = (t) => ne(t) && t.nodeType === _o, Vo = (t) => ne(t) && t === t.window;
+function yn(t) {
+  return L(t) ? t.localName || "" : "#document";
+}
+function jo(t) {
+  return [
+    "html",
+    "body",
+    "#document"
+  ].includes(yn(t));
+}
+const Wo = (t) => ne(t) && t.nodeType !== void 0;
+function qt(t) {
+  return Wo(t) && t.nodeType === Bo && "host" in t;
+}
+const $o = (t) => L(t) && t.localName === "input";
+function Ho(t) {
+  return L(t) ? t.offsetWidth > 0 || t.offsetHeight > 0 || t.getClientRects().length > 0 : !1;
+}
+const Go = /(textarea|select)/;
+function zo(t) {
+  if (t == null || !L(t)) return !1;
+  try {
+    return $o(t) && t.selectionStart != null || Go.test(t.localName) || t.isContentEditable || t.getAttribute("contenteditable") === "true" || t.getAttribute("contenteditable") === "";
+  } catch {
+    return !1;
+  }
+}
+function Xt(t, e) {
+  if (!t || !e || !L(t) || !L(e)) return !1;
+  const n = e.getRootNode?.();
+  if (t === e || t.contains(e)) return !0;
+  if (n && qt(n)) {
+    let o = e;
+    for (; o; ) {
+      if (t === o) return !0;
+      o = o.parentNode || o.host;
+    }
+  }
+  return !1;
+}
+function gt(t) {
+  return Te(t) ? t : Vo(t) ? t.document : t?.ownerDocument ?? document;
+}
+function Ko(t) {
+  return gt(t).documentElement;
+}
+function Tt(t) {
+  return qt(t) ? Tt(t.host) : Te(t) ? t.defaultView ?? window : L(t) ? t.ownerDocument?.defaultView ?? window : window;
+}
+function bn(t) {
+  let e = t.activeElement;
+  for (; e?.shadowRoot; ) {
+    const n = e.shadowRoot.activeElement;
+    if (n === e) break;
+    e = n;
+  }
+  return e;
+}
+function Uo(t) {
+  if (yn(t) === "html") return t;
+  const e = t.assignedSlot || t.parentNode || qt(t) && t.host || Ko(t);
+  return qt(e) ? e.host : e;
+}
+const re = /* @__PURE__ */ new WeakMap();
+function Yo(t) {
+  return re.has(t) || re.set(t, Tt(t).getComputedStyle(t)), re.get(t);
+}
+const vn = () => typeof document < "u";
+function qo() {
+  return navigator.userAgentData?.platform ?? navigator.platform;
+}
+const Pe = (t) => vn() && t.test(qo()), Xo = (t) => vn() && t.test(navigator.vendor), Zo = () => Pe(/^Mac/), Qo = () => Pe(/mac|iphone|ipad|ipod/i), Jo = () => Qo() && Xo(/apple/i), ts = () => Pe(/iP(hone|ad|od)|iOS/);
+function es(t) {
+  return t.composedPath?.() ?? t.nativeEvent?.composedPath?.();
+}
+function ut(t) {
+  return es(t)?.[0] ?? t.target;
+}
+function ns(t) {
+  return t.button === 2 || Zo() && t.ctrlKey && t.button === 0;
+}
+function H(t, e, n, o) {
+  const s = typeof t == "function" ? t() : t;
+  return s?.addEventListener(e, n, o), () => {
+    s?.removeEventListener(e, n, o);
+  };
+}
+function os(t, e) {
+  const { type: n = "HTMLInputElement", property: o = "value" } = e, s = Tt(t)[n].prototype;
+  return Object.getOwnPropertyDescriptor(s, o) ?? {};
+}
+function ss(t) {
+  if (t.localName === "input") return "HTMLInputElement";
+  if (t.localName === "textarea") return "HTMLTextAreaElement";
+  if (t.localName === "select") return "HTMLSelectElement";
+}
+function is(t, e, n = "value") {
+  const o = ss(t);
+  o && os(t, {
+    type: o,
+    property: n
+  }).set?.call(t, e), t.setAttribute(n, e);
+}
+const wn = (t) => L(t) && t.tagName === "IFRAME", rs = (t) => !Number.isNaN(Number.parseInt(t.getAttribute("tabindex") || "0", 10)), as = (t) => Number.parseInt(t.getAttribute("tabindex") || "0", 10) < 0, Ce = "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 Ne(t, e = !1) {
+  if (!t) return [];
+  const n = Array.from(t.querySelectorAll(Ce));
+  (e === !0 || e === "if-empty" && n.length === 0) && L(t) && dt(t) && n.unshift(t);
+  const s = n.filter(dt);
+  return s.forEach((i, r) => {
+    if (wn(i) && i.contentDocument) {
+      const a = i.contentDocument.body;
+      s.splice(r, 1, ...Ne(a));
+    }
+  }), s;
+}
+function dt(t) {
+  return !t || t.closest("[inert]") ? !1 : t.matches(Ce) && Ho(t);
+}
+function Vt(t, e) {
+  if (!t) return [];
+  const n = Array.from(t.querySelectorAll(Ce)), o = n.filter(lt);
+  return e && lt(t) && o.unshift(t), o.forEach((s, i) => {
+    if (wn(s) && s.contentDocument) {
+      const r = s.contentDocument.body, a = Vt(r);
+      o.splice(i, 1, ...a);
+    }
+  }), !o.length && e ? n : o;
+}
+function lt(t) {
+  return t != null && t.tabIndex > 0 ? !0 : dt(t) && !as(t);
+}
+function cs(t, e) {
+  const n = Vt(t, e), o = n[0] || null, s = n[n.length - 1] || null;
+  return [o, s];
+}
+function ls(t, e) {
+  const n = Vt(t), o = t?.ownerDocument || document, s = e ?? o.activeElement;
+  if (!s) return null;
+  const i = n.indexOf(s);
+  return n[i + 1] || null;
+}
+function Ct(t) {
+  return t.tabIndex < 0 && (/^(audio|video|details)$/.test(t.localName) || zo(t)) && !rs(t) ? 0 : t.tabIndex;
+}
+function He(t) {
+  const { root: e, getInitialEl: n, filter: o, enabled: s = !0 } = t;
+  if (!s) return;
+  let i = null;
+  if (i ||= typeof n == "function" ? n() : n, i ||= e?.querySelector("[data-autofocus],[autofocus]"), !i) {
+    const r = Vt(e);
+    i = o ? r.filter(o)[0] : r[0];
+  }
+  return i || e || void 0;
+}
+function q(t) {
+  const e = globalThis.requestAnimationFrame(t);
+  return () => {
+    globalThis.cancelAnimationFrame(e);
+  };
+}
+function me(t) {
+  const e = Uo(t);
+  return jo(e) ? gt(e).body : L(e) && ds(e) ? e : me(e);
+}
+const us = /auto|scroll|overlay|hidden|clip/;
+function ds(t) {
+  const e = Tt(t), { overflow: n, overflowX: o, overflowY: s, display: i } = e.getComputedStyle(t);
+  return us.test(n + s + o) && !["inline", "contents"].includes(i);
+}
+function fs(t, e = {}) {
+  const { triggerElement: n, onFocus: o } = e, s = t?.ownerDocument || document, i = s.body;
+  function r(a) {
+    if (a.key !== "Tab") return;
+    let c = null;
+    const [l, f] = cs(t, !0), h = !l && !f;
+    a.shiftKey && (s.activeElement === l || h) ? c = n : !a.shiftKey && s.activeElement === n ? c = l : !a.shiftKey && (s.activeElement === f || h) && (c = ls(i, n)), c && (a.preventDefault(), typeof o == "function" ? o(c) : c.focus());
+  }
+  return H(s, "keydown", r, !0);
+}
+function hs(t, e) {
+  const { defer: n, triggerElement: o, ...s } = e, i = n ? q : (a) => a(), r = [];
+  return r.push(i(() => {
+    const a = typeof t == "function" ? t() : t, c = typeof o == "function" ? o() : o;
+    r.push(fs(a, {
+      triggerElement: c,
+      ...s
+    }));
+  })), () => {
+    r.forEach((a) => a?.());
+  };
+}
+function ps(t) {
+  const e = {
+    getRootNode: (n) => n.getRootNode?.() ?? document,
+    getDoc: (n) => gt(e.getRootNode(n)),
+    getWin: (n) => e.getDoc(n).defaultView ?? window,
+    getActiveElement: (n) => bn(e.getRootNode(n)),
+    isActiveElement: (n, o) => o === e.getActiveElement(n),
+    getById: (n, o) => e.getRootNode(n).getElementById(o),
+    setValue: (n, o) => {
+      n == null || o == null || is(n, o.toString());
+    }
+  };
+  return {
+    ...e,
+    ...t
+  };
+}
+const ae = /* @__PURE__ */ new WeakMap();
+function gs(t, e, n) {
+  ae.has(t) || ae.set(t, /* @__PURE__ */ new Map());
+  const o = ae.get(t), s = o.get(e);
+  if (!s)
+    return o.set(e, n()), () => {
+      o.get(e)?.(), o.delete(e);
+    };
+  const i = n(), r = () => {
+    i(), s(), o.delete(e);
+  };
+  return o.set(e, r), () => {
+    o.get(e) === r && (i(), o.set(e, s));
+  };
+}
+function ms(t, e) {
+  return t ? gs(t, "style", () => {
+    const o = t.style.cssText;
+    return Object.assign(t.style, e), () => {
+      t.style.cssText = o;
+    };
+  }) : () => {
+  };
+}
+const ys = 1e3 / 60;
+function bs(t, e) {
+  const n = t();
+  if (L(n) && n.isConnected)
+    return e(n), () => {
+    };
+  {
+    const o = setInterval(() => {
+      const s = t();
+      L(s) && s.isConnected && (e(s), clearInterval(o));
+    }, ys);
+    return () => clearInterval(o);
+  }
+}
+function vs(t, e) {
+  const n = [];
+  return t?.forEach((o) => {
+    const s = bs(o, e);
+    n.push(s);
+  }), () => {
+    n.forEach((o) => o());
+  };
+}
+function ws(t) {
+  for (; t.length > 0; ) t.pop();
+  return t;
+}
+function ye(t, ...e) {
+  return (typeof t == "function" ? t(...e) : t) ?? void 0;
+}
+const nt = (t) => t;
+function xn() {
+}
+function Ge(...t) {
+  return (...e) => {
+    t.forEach((n) => {
+      n?.(...e);
+    });
+  };
+}
+const ze = /* @__PURE__ */ (() => {
+  let t = 0;
+  return () => (t++, t.toString(36));
+})(), Zt = (t) => Array.isArray(t), En = (t) => t != null && typeof t == "object", zt = (t) => En(t) && !Zt(t), xs = (t) => typeof t == "number" && !Number.isNaN(t), ot = (t) => typeof t == "string", Qt = (t) => typeof t == "function", Es = (t) => t == null;
+function On(t, e) {
+  return Object.prototype.hasOwnProperty.call(t, e);
+}
+const Os = (t) => Object.prototype.toString.call(t), An = Function.prototype.toString, As = An.call(Object);
+function $t(t) {
+  if (!En(t) || Os(t) !== "[object Object]") return !1;
+  const e = Object.getPrototypeOf(t);
+  if (e === null) return !0;
+  const n = On(e, "constructor") && e.constructor;
+  return typeof n == "function" && n instanceof n && An.call(n) === As;
+}
+function jt(t) {
+  if (!ks(t) || t === void 0) return t;
+  const e = Reflect.ownKeys(t).filter((o) => typeof o == "string"), n = {};
+  for (const o of e) {
+    const s = t[o];
+    s !== void 0 && (n[o] = jt(s));
+  }
+  return n;
+}
+function ks(t) {
+  return t && typeof t == "object" && t.constructor === Object;
+}
+function kn(t) {
+  const e = z(t);
+  let n = parseFloat(e.width) || 0, o = parseFloat(e.height) || 0;
+  const s = X(t), i = s ? t.offsetWidth : n, r = s ? t.offsetHeight : o, a = Kt(n) !== i || Kt(o) !== r;
+  return a && (n = i, o = r), {
+    width: n,
+    height: o,
+    $: a
+  };
+}
+function Fe(t) {
+  return G(t) ? t : t.contextElement;
+}
+function Ot(t) {
+  const e = Fe(t);
+  if (!X(e))
+    return Y(1);
+  const n = e.getBoundingClientRect(), {
+    width: o,
+    height: s,
+    $: i
+  } = kn(e);
+  let r = (i ? Kt(n.width) : n.width) / o, a = (i ? Kt(n.height) : n.height) / s;
+  return (!r || !Number.isFinite(r)) && (r = 1), (!a || !Number.isFinite(a)) && (a = 1), {
+    x: r,
+    y: a
+  };
+}
+const Ss = /* @__PURE__ */ Y(0);
+function Sn(t) {
+  const e = B(t);
+  return !Se() || !e.visualViewport ? Ss : {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+function Ts(t, e, n) {
+  return e === void 0 && (e = !1), !n || e && n !== B(t) ? !1 : e;
+}
+function wt(t, e, n, o) {
+  e === void 0 && (e = !1), n === void 0 && (n = !1);
+  const s = t.getBoundingClientRect(), i = Fe(t);
+  let r = Y(1);
+  e && (o ? G(o) && (r = Ot(o)) : r = Ot(t));
+  const a = Ts(i, n, o) ? Sn(i) : Y(0);
+  let c = (s.left + a.x) / r.x, l = (s.top + a.y) / r.y, f = s.width / r.x, h = s.height / r.y;
+  if (i) {
+    const u = B(i), d = o && G(o) ? B(o) : o;
+    let p = u, m = ge(p);
+    for (; m && o && d !== p; ) {
+      const w = Ot(m), g = m.getBoundingClientRect(), x = z(m), O = g.left + (m.clientLeft + parseFloat(x.paddingLeft)) * w.x, P = g.top + (m.clientTop + parseFloat(x.paddingTop)) * w.y;
+      c *= w.x, l *= w.y, f *= w.x, h *= w.y, c += O, l += P, p = B(m), m = ge(p);
+    }
+  }
+  return Yt({
+    width: f,
+    height: h,
+    x: c,
+    y: l
+  });
+}
+function Ie(t, e) {
+  const n = ee(t).scrollLeft;
+  return e ? e.left + n : wt(Z(t)).left + n;
+}
+function Tn(t, e, n) {
+  n === void 0 && (n = !1);
+  const o = t.getBoundingClientRect(), s = o.left + e.scrollLeft - (n ? 0 : (
+    // RTL <body> scrollbar.
+    Ie(t, o)
+  )), i = o.top + e.scrollTop;
+  return {
+    x: s,
+    y: i
+  };
+}
+function Ps(t) {
+  let {
+    elements: e,
+    rect: n,
+    offsetParent: o,
+    strategy: s
+  } = t;
+  const i = s === "fixed", r = Z(o), a = e ? te(e.floating) : !1;
+  if (o === r || a && i)
+    return n;
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, l = Y(1);
+  const f = Y(0), h = X(o);
+  if ((h || !h && !i) && ((St(o) !== "body" || Bt(r)) && (c = ee(o)), X(o))) {
+    const d = wt(o);
+    l = Ot(o), f.x = d.x + o.clientLeft, f.y = d.y + o.clientTop;
+  }
+  const u = r && !h && !i ? Tn(r, c, !0) : Y(0);
+  return {
+    width: n.width * l.x,
+    height: n.height * l.y,
+    x: n.x * l.x - c.scrollLeft * l.x + f.x + u.x,
+    y: n.y * l.y - c.scrollTop * l.y + f.y + u.y
+  };
+}
+function Cs(t) {
+  return Array.from(t.getClientRects());
+}
+function Ns(t) {
+  const e = Z(t), n = ee(t), o = t.ownerDocument.body, s = _(e.scrollWidth, e.clientWidth, o.scrollWidth, o.clientWidth), i = _(e.scrollHeight, e.clientHeight, o.scrollHeight, o.clientHeight);
+  let r = -n.scrollLeft + Ie(t);
+  const a = -n.scrollTop;
+  return z(o).direction === "rtl" && (r += _(e.clientWidth, o.clientWidth) - s), {
+    width: s,
+    height: i,
+    x: r,
+    y: a
+  };
+}
+function Fs(t, e) {
+  const n = B(t), o = Z(t), s = n.visualViewport;
+  let i = o.clientWidth, r = o.clientHeight, a = 0, c = 0;
+  if (s) {
+    i = s.width, r = s.height;
+    const l = Se();
+    (!l || l && e === "fixed") && (a = s.offsetLeft, c = s.offsetTop);
+  }
+  return {
+    width: i,
+    height: r,
+    x: a,
+    y: c
+  };
+}
+function Is(t, e) {
+  const n = wt(t, !0, e === "fixed"), o = n.top + t.clientTop, s = n.left + t.clientLeft, i = X(t) ? Ot(t) : Y(1), r = t.clientWidth * i.x, a = t.clientHeight * i.y, c = s * i.x, l = o * i.y;
+  return {
+    width: r,
+    height: a,
+    x: c,
+    y: l
+  };
+}
+function Ke(t, e, n) {
+  let o;
+  if (e === "viewport")
+    o = Fs(t, n);
+  else if (e === "document")
+    o = Ns(Z(t));
+  else if (G(e))
+    o = Is(e, n);
+  else {
+    const s = Sn(t);
+    o = {
+      x: e.x - s.x,
+      y: e.y - s.y,
+      width: e.width,
+      height: e.height
+    };
+  }
+  return Yt(o);
+}
+function Pn(t, e) {
+  const n = ht(t);
+  return n === e || !G(n) || At(n) ? !1 : z(n).position === "fixed" || Pn(n, e);
+}
+function Ds(t, e) {
+  const n = e.get(t);
+  if (n)
+    return n;
+  let o = _t(t, [], !1).filter((a) => G(a) && St(a) !== "body"), s = null;
+  const i = z(t).position === "fixed";
+  let r = i ? ht(t) : t;
+  for (; G(r) && !At(r); ) {
+    const a = z(r), c = ke(r);
+    !c && a.position === "fixed" && (s = null), (i ? !c && !s : !c && a.position === "static" && !!s && ["absolute", "fixed"].includes(s.position) || Bt(r) && !c && Pn(t, r)) ? o = o.filter((f) => f !== r) : s = a, r = ht(r);
+  }
+  return e.set(t, o), o;
+}
+function Ls(t) {
+  let {
+    element: e,
+    boundary: n,
+    rootBoundary: o,
+    strategy: s
+  } = t;
+  const r = [...n === "clippingAncestors" ? te(e) ? [] : Ds(e, this._c) : [].concat(n), o], a = r[0], c = r.reduce((l, f) => {
+    const h = Ke(e, f, s);
+    return l.top = _(h.top, l.top), l.right = ft(h.right, l.right), l.bottom = ft(h.bottom, l.bottom), l.left = _(h.left, l.left), l;
+  }, Ke(e, a, s));
+  return {
+    width: c.right - c.left,
+    height: c.bottom - c.top,
+    x: c.left,
+    y: c.top
+  };
+}
+function Ms(t) {
+  const {
+    width: e,
+    height: n
+  } = kn(t);
+  return {
+    width: e,
+    height: n
+  };
+}
+function Rs(t, e, n) {
+  const o = X(e), s = Z(e), i = n === "fixed", r = wt(t, !0, i, e);
+  let a = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const c = Y(0);
+  function l() {
+    c.x = Ie(s);
+  }
+  if (o || !o && !i)
+    if ((St(e) !== "body" || Bt(s)) && (a = ee(e)), o) {
+      const d = wt(e, !0, i, e);
+      c.x = d.x + e.clientLeft, c.y = d.y + e.clientTop;
+    } else s && l();
+  i && !o && s && l();
+  const f = s && !o && !i ? Tn(s, a) : Y(0), h = r.left + a.scrollLeft - c.x - f.x, u = r.top + a.scrollTop - c.y - f.y;
+  return {
+    x: h,
+    y: u,
+    width: r.width,
+    height: r.height
+  };
+}
+function ce(t) {
+  return z(t).position === "static";
+}
+function Ue(t, e) {
+  if (!X(t) || z(t).position === "fixed")
+    return null;
+  if (e)
+    return e(t);
+  let n = t.offsetParent;
+  return Z(t) === n && (n = n.ownerDocument.body), n;
+}
+function Cn(t, e) {
+  const n = B(t);
+  if (te(t))
+    return n;
+  if (!X(t)) {
+    let s = ht(t);
+    for (; s && !At(s); ) {
+      if (G(s) && !ce(s))
+        return s;
+      s = ht(s);
+    }
+    return n;
+  }
+  let o = Ue(t, e);
+  for (; o && To(o) && ce(o); )
+    o = Ue(o, e);
+  return o && At(o) && ce(o) && !ke(o) ? n : o || Io(t) || n;
+}
+const _s = async function(t) {
+  const e = this.getOffsetParent || Cn, n = this.getDimensions, o = await n(t.floating);
+  return {
+    reference: Rs(t.reference, await e(t.floating), t.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: o.width,
+      height: o.height
+    }
+  };
+};
+function Bs(t) {
+  return z(t).direction === "rtl";
+}
+const Vs = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Ps,
+  getDocumentElement: Z,
+  getClippingRect: Ls,
+  getOffsetParent: Cn,
+  getElementRects: _s,
+  getClientRects: Cs,
+  getDimensions: Ms,
+  getScale: Ot,
+  isElement: G,
+  isRTL: Bs
+};
+function Nn(t, e) {
+  return t.x === e.x && t.y === e.y && t.width === e.width && t.height === e.height;
+}
+function js(t, e) {
+  let n = null, o;
+  const s = Z(t);
+  function i() {
+    var a;
+    clearTimeout(o), (a = n) == null || a.disconnect(), n = null;
+  }
+  function r(a, c) {
+    a === void 0 && (a = !1), c === void 0 && (c = 1), i();
+    const l = t.getBoundingClientRect(), {
+      left: f,
+      top: h,
+      width: u,
+      height: d
+    } = l;
+    if (a || e(), !u || !d)
+      return;
+    const p = Wt(h), m = Wt(s.clientWidth - (f + u)), w = Wt(s.clientHeight - (h + d)), g = Wt(f), O = {
+      rootMargin: -p + "px " + -m + "px " + -w + "px " + -g + "px",
+      threshold: _(0, ft(1, c)) || 1
+    };
+    let P = !0;
+    function y(k) {
+      const b = k[0].intersectionRatio;
+      if (b !== c) {
+        if (!P)
+          return r();
+        b ? r(!1, b) : o = setTimeout(() => {
+          r(!1, 1e-7);
+        }, 1e3);
+      }
+      b === 1 && !Nn(l, t.getBoundingClientRect()) && r(), P = !1;
+    }
+    try {
+      n = new IntersectionObserver(y, {
+        ...O,
+        // Handle <iframe>s
+        root: s.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(y, O);
+    }
+    n.observe(t);
+  }
+  return r(!0), i;
+}
+function Ws(t, e, n, o) {
+  o === void 0 && (o = {});
+  const {
+    ancestorScroll: s = !0,
+    ancestorResize: i = !0,
+    elementResize: r = typeof ResizeObserver == "function",
+    layoutShift: a = typeof IntersectionObserver == "function",
+    animationFrame: c = !1
+  } = o, l = Fe(t), f = s || i ? [...l ? _t(l) : [], ..._t(e)] : [];
+  f.forEach((g) => {
+    s && g.addEventListener("scroll", n, {
+      passive: !0
+    }), i && g.addEventListener("resize", n);
+  });
+  const h = l && a ? js(l, n) : null;
+  let u = -1, d = null;
+  r && (d = new ResizeObserver((g) => {
+    let [x] = g;
+    x && x.target === l && d && (d.unobserve(e), cancelAnimationFrame(u), u = requestAnimationFrame(() => {
+      var O;
+      (O = d) == null || O.observe(e);
+    })), n();
+  }), l && !c && d.observe(l), d.observe(e));
+  let p, m = c ? wt(t) : null;
+  c && w();
+  function w() {
+    const g = wt(t);
+    m && !Nn(m, g) && n(), m = g, p = requestAnimationFrame(w);
+  }
+  return n(), () => {
+    var g;
+    f.forEach((x) => {
+      s && x.removeEventListener("scroll", n), i && x.removeEventListener("resize", n);
+    }), h?.(), (g = d) == null || g.disconnect(), d = null, c && cancelAnimationFrame(p);
+  };
+}
+const $s = xo, Hs = Eo, Gs = bo, zs = Ao, Ks = vo, Us = yo, Ys = Oo, qs = (t, e, n) => {
+  const o = /* @__PURE__ */ new Map(), s = {
+    platform: Vs,
+    ...n
+  }, i = {
+    ...s.platform,
+    _c: o
+  };
+  return mo(t, e, {
+    ...s,
+    platform: i
+  });
+};
+function Ye(t = 0, e = 0, n = 0, o = 0) {
+  if (typeof DOMRect == "function") return new DOMRect(t, e, n, o);
+  const s = {
+    x: t,
+    y: e,
+    width: n,
+    height: o,
+    top: e,
+    right: t + n,
+    bottom: e + o,
+    left: t
+  };
+  return {
+    ...s,
+    toJSON: () => s
+  };
+}
+function Xs(t) {
+  if (!t) return Ye();
+  const { x: e, y: n, width: o, height: s } = t;
+  return Ye(e, n, o, s);
+}
+function Zs(t, e) {
+  return {
+    contextElement: L(t) ? t : void 0,
+    getBoundingClientRect: () => {
+      const n = t, o = e?.(n);
+      return o || !n ? Xs(o) : n.getBoundingClientRect();
+    }
+  };
+}
+const Nt = (t) => ({
+  variable: t,
+  reference: `var(${t})`
+}), et = {
+  arrowSize: Nt("--arrow-size"),
+  arrowSizeHalf: Nt("--arrow-size-half"),
+  arrowBg: Nt("--arrow-background"),
+  transformOrigin: Nt("--transform-origin"),
+  arrowOffset: Nt("--arrow-offset")
+};
+function Qs(t) {
+  return {
+    top: "bottom center",
+    "top-start": t ? `${t.x}px bottom` : "left bottom",
+    "top-end": t ? `${t.x}px bottom` : "right bottom",
+    bottom: "top center",
+    "bottom-start": t ? `${t.x}px top` : "top left",
+    "bottom-end": t ? `${t.x}px top` : "top right",
+    left: "right center",
+    "left-start": t ? `right ${t.y}px` : "right top",
+    "left-end": t ? `right ${t.y}px` : "right bottom",
+    right: "left center",
+    "right-start": t ? `left ${t.y}px` : "left top",
+    "right-end": t ? `left ${t.y}px` : "left bottom"
+  };
+}
+const Js = {
+  name: "transformOrigin",
+  fn({ placement: t, elements: e, middlewareData: n }) {
+    const { arrow: o } = n, s = Qs(o)[t], { floating: i } = e;
+    return i.style.setProperty(et.transformOrigin.variable, s), { data: { transformOrigin: s } };
+  }
+}, ti = {
+  name: "rects",
+  fn({ rects: t }) {
+    return { data: t };
+  }
+};
+function ei(t) {
+  if (t)
+    return {
+      name: "shiftArrow",
+      fn({ placement: e, middlewareData: n }) {
+        if (!n.arrow) return {};
+        const { x: o, y: s } = n.arrow, i = e.split("-")[0];
+        return Object.assign(t.style, {
+          left: o != null ? `${o}px` : "",
+          top: s != null ? `${s}px` : "",
+          [i]: `calc(100% + ${et.arrowOffset.reference})`
+        }), {};
+      }
+    };
+}
+function ni(t) {
+  const [e, n] = t.split("-");
+  return {
+    side: e,
+    align: n,
+    hasAlign: n != null
+  };
+}
+const oi = {
+  strategy: "absolute",
+  placement: "bottom",
+  listeners: !0,
+  gutter: 8,
+  flip: !0,
+  slide: !0,
+  overlap: !1,
+  sameWidth: !1,
+  fitViewport: !1,
+  overflowPadding: 8,
+  arrowPadding: 4
+};
+function qe(t, e) {
+  const n = t.devicePixelRatio || 1;
+  return Math.round(e * n) / n;
+}
+function Fn(t) {
+  return ye(t.boundary);
+}
+function si(t, e) {
+  if (t)
+    return Us({
+      element: t,
+      padding: e.arrowPadding
+    });
+}
+function ii(t, e) {
+  if (!Es(e.offset ?? e.gutter))
+    return $s(({ placement: n }) => {
+      const o = (t?.clientHeight || 0) / 2, s = e.offset?.mainAxis ?? e.gutter, i = typeof s == "number" ? s + o : s ?? o, { hasAlign: r } = ni(n), a = r ? void 0 : e.shift, c = e.offset?.crossAxis ?? a;
+      return jt({
+        crossAxis: c,
+        mainAxis: i,
+        alignmentAxis: e.shift
+      });
+    });
+}
+function ri(t) {
+  if (t.flip)
+    return Gs({
+      boundary: Fn(t),
+      padding: t.overflowPadding,
+      fallbackPlacements: t.flip === !0 ? void 0 : t.flip
+    });
+}
+function ai(t) {
+  if (!(!t.slide && !t.overlap))
+    return Hs({
+      boundary: Fn(t),
+      mainAxis: t.slide,
+      crossAxis: t.overlap,
+      padding: t.overflowPadding,
+      limiter: Ys()
+    });
+}
+function ci(t) {
+  return zs({
+    padding: t.overflowPadding,
+    apply({ elements: e, rects: n, availableHeight: o, availableWidth: s }) {
+      const i = e.floating, r = Math.round(n.reference.width);
+      s = Math.floor(s), o = Math.floor(o), i.style.setProperty("--reference-width", `${r}px`), i.style.setProperty("--available-width", `${s}px`), i.style.setProperty("--available-height", `${o}px`);
+    }
+  });
+}
+function li(t) {
+  if (t.hideWhenDetached)
+    return Ks({
+      strategy: "referenceHidden",
+      boundary: t.boundary?.() ?? "clippingAncestors"
+    });
+}
+function ui(t) {
+  return t ? t === !0 ? {
+    ancestorResize: !0,
+    ancestorScroll: !0,
+    elementResize: !0,
+    layoutShift: !0
+  } : t : {};
+}
+function di(t, e, n = {}) {
+  const o = Zs(t, n.getAnchorRect);
+  if (!e || !o) return;
+  const s = Object.assign({}, oi, n), i = e.querySelector("[data-part=arrow]"), r = [
+    ii(i, s),
+    ri(s),
+    ai(s),
+    si(i, s),
+    ei(i),
+    Js,
+    ci(s),
+    li(s),
+    ti
+  ], { placement: a, strategy: c, onComplete: l, onPositioned: f } = s, h = async () => {
+    if (!o || !e) return;
+    const m = await qs(o, e, {
+      placement: a,
+      middleware: r,
+      strategy: c
+    });
+    l?.(m), f?.({ placed: !0 });
+    const w = Tt(e), g = qe(w, m.x), x = qe(w, m.y);
+    e.style.setProperty("--x", `${g}px`), e.style.setProperty("--y", `${x}px`), s.hideWhenDetached && (m.middlewareData.hide?.referenceHidden ? (e.style.setProperty("visibility", "hidden"), e.style.setProperty("pointer-events", "none")) : (e.style.removeProperty("visibility"), e.style.removeProperty("pointer-events")));
+    const O = e.firstElementChild;
+    if (O) {
+      const P = Yo(O);
+      e.style.setProperty("--z-index", P.zIndex);
+    }
+  }, u = async () => {
+    n.updatePosition ? (await n.updatePosition({ updatePosition: h }), f?.({ placed: !0 })) : await h();
+  }, d = ui(s.listeners), p = s.listeners ? Ws(o, e, u, d) : xn;
+  return u(), () => {
+    p?.(), f?.({ placed: !1 });
+  };
+}
+function Xe(t, e, n = {}) {
+  const { defer: o, ...s } = n, i = o ? q : (a) => a(), r = [];
+  return r.push(i(() => {
+    const a = typeof t == "function" ? t() : t, c = typeof e == "function" ? e() : e;
+    r.push(di(a, c, s));
+  })), () => {
+    r.forEach((a) => a?.());
+  };
+}
+const fi = {
+  bottom: "rotate(45deg)",
+  left: "rotate(135deg)",
+  top: "rotate(225deg)",
+  right: "rotate(315deg)"
+};
+function hi(t = {}) {
+  const { placement: e, sameWidth: n, fitViewport: o, strategy: s = "absolute" } = t;
+  return {
+    arrow: {
+      position: "absolute",
+      width: et.arrowSize.reference,
+      height: et.arrowSize.reference,
+      [et.arrowSizeHalf.variable]: `calc(${et.arrowSize.reference} / 2)`,
+      [et.arrowOffset.variable]: `calc(${et.arrowSizeHalf.reference} * -1)`
+    },
+    arrowTip: {
+      transform: e ? fi[e.split("-")[0]] : void 0,
+      background: et.arrowBg.reference,
+      top: "0",
+      left: "0",
+      width: "100%",
+      height: "100%",
+      position: "absolute",
+      zIndex: "inherit"
+    },
+    floating: {
+      position: s,
+      isolation: "isolate",
+      minWidth: n ? void 0 : "max-content",
+      width: n ? "var(--reference-width)" : void 0,
+      maxWidth: o ? "var(--available-width)" : void 0,
+      maxHeight: o ? "var(--available-height)" : void 0,
+      top: "0px",
+      left: "0px",
+      transform: e ? "translate3d(var(--x), var(--y), 0)" : "translate3d(0, -100vh, 0)",
+      zIndex: "var(--z-index)"
+    }
+  };
+}
+let Et = /* @__PURE__ */ new WeakMap(), Ht = /* @__PURE__ */ new WeakMap(), le = {}, ue = 0;
+function In(t) {
+  return t && (t.host || In(t.parentNode));
+}
+function pi(t, e) {
+  return e.map((n) => {
+    if (t.contains(n)) return n;
+    const o = In(n);
+    return o && t.contains(o) ? o : (console.error("[@destyler/aria-hidden] target", n, "in not contained inside", t, ". Doing nothing"), null);
+  }).filter((n) => !!n);
+}
+function gi(t) {
+  return t.localName === "next-route-announcer" || t.localName === "script" || t.hasAttribute("aria-live") ? !0 : t.matches("[data-live-announcer]");
+}
+function mi(t, e) {
+  const { parentNode: n, markerName: o, controlAttribute: s, explicitBooleanValue: i } = e, r = pi(n, Array.isArray(t) ? t : [t]);
+  le[o] ||= /* @__PURE__ */ new WeakMap();
+  const a = le[o], c = [], l = /* @__PURE__ */ new Set(), f = new Set(r), h = (d) => {
+    !d || l.has(d) || (l.add(d), h(d.parentNode));
+  };
+  r.forEach(h);
+  const u = (d) => {
+    !d || f.has(d) || Array.prototype.forEach.call(d.children, (p) => {
+      if (l.has(p)) u(p);
+      else try {
+        if (gi(p)) return;
+        const m = p.getAttribute(s), w = i ? m === "true" : m !== null && m !== "false", g = (Et.get(p) || 0) + 1, x = (a.get(p) || 0) + 1;
+        Et.set(p, g), a.set(p, x), c.push(p), g === 1 && w && Ht.set(p, !0), x === 1 && p.setAttribute(o, ""), w || p.setAttribute(s, i ? "true" : "");
+      } catch (m) {
+        console.error("[@destyler/aria-hidden] cannot operate on ", p, m);
+      }
+    });
+  };
+  return u(n), l.clear(), ue++, () => {
+    c.forEach((d) => {
+      const p = Et.get(d) - 1, m = a.get(d) - 1;
+      Et.set(d, p), a.set(d, m), p || (Ht.has(d) || d.removeAttribute(s), Ht.delete(d)), m || d.removeAttribute(o);
+    }), ue--, ue || (Et = /* @__PURE__ */ new WeakMap(), Et = /* @__PURE__ */ new WeakMap(), Ht = /* @__PURE__ */ new WeakMap(), le = {});
+  };
+}
+function yi(t) {
+  return (Array.isArray(t) ? t[0] : t).ownerDocument.body;
+}
+function bi(t, e = yi(t), n = "data-aria-hidden") {
+  if (e)
+    return mi(t, {
+      parentNode: e,
+      markerName: n,
+      controlAttribute: "aria-hidden",
+      explicitBooleanValue: !0
+    });
+}
+function vi(t) {
+  const e = requestAnimationFrame(() => t());
+  return () => cancelAnimationFrame(e);
+}
+function wi(t, e = {}) {
+  const { defer: n = !0 } = e, o = n ? vi : (i) => i(), s = [];
+  return s.push(o(() => {
+    const r = (typeof t == "function" ? t() : t).filter(Boolean);
+    r.length !== 0 && s.push(bi(r));
+  })), () => {
+    s.forEach((i) => i?.());
+  };
+}
+function xi(t) {
+  const e = {
+    each(n) {
+      for (let o = 0; o < t.frames?.length; o += 1) {
+        const s = t.frames[o];
+        s && n(s);
+      }
+    },
+    addEventListener(n, o, s) {
+      return e.each((i) => {
+        try {
+          i.document.addEventListener(n, o, s);
+        } catch {
+        }
+      }), () => {
+        try {
+          e.removeEventListener(n, o, s);
+        } catch {
+        }
+      };
+    },
+    removeEventListener(n, o, s) {
+      e.each((i) => {
+        try {
+          i.document.removeEventListener(n, o, s);
+        } catch {
+        }
+      });
+    }
+  };
+  return e;
+}
+function Ei(t) {
+  const e = t.frameElement != null ? t.parent : null;
+  return {
+    addEventListener: (n, o, s) => {
+      try {
+        e?.addEventListener(n, o, s);
+      } catch {
+      }
+      return () => {
+        try {
+          e?.removeEventListener(n, o, s);
+        } catch {
+        }
+      };
+    },
+    removeEventListener: (n, o, s) => {
+      try {
+        e?.removeEventListener(n, o, s);
+      } catch {
+      }
+    }
+  };
+}
+const Ze = "pointerdown.outside", Qe = "focus.outside";
+function Oi(t) {
+  for (const e of t) if (L(e) && dt(e)) return !0;
+  return !1;
+}
+const Dn = (t) => "clientY" in t;
+function Ai(t, e) {
+  if (!Dn(e) || !t) return !1;
+  const n = t.getBoundingClientRect();
+  return n.width === 0 || n.height === 0 ? !1 : n.top <= e.clientY && e.clientY <= n.top + n.height && n.left <= e.clientX && e.clientX <= n.left + n.width;
+}
+function ki(t, e) {
+  return t.y <= e.y && e.y <= t.y + t.height && t.x <= e.x && e.x <= t.x + t.width;
+}
+function Je(t, e) {
+  if (!e || !Dn(t)) return !1;
+  const n = e.scrollHeight > e.clientHeight, o = n && t.clientX > e.offsetLeft + e.clientWidth, s = e.scrollWidth > e.clientWidth, i = s && t.clientY > e.offsetTop + e.clientHeight, r = {
+    x: e.offsetLeft,
+    y: e.offsetTop,
+    width: e.clientWidth + (n ? 16 : 0),
+    height: e.clientHeight + (s ? 16 : 0)
+  }, a = {
+    x: t.clientX,
+    y: t.clientY
+  };
+  return ki(r, a) ? o || i : !1;
+}
+function Si(t, e) {
+  const { exclude: n, onFocusOutside: o, onPointerDownOutside: s, onInteractOutside: i, defer: r } = e;
+  if (!t) return;
+  const a = gt(t), c = Tt(t), l = xi(c), f = Ei(c);
+  function h(g) {
+    const x = ut(g);
+    if (!L(x) || !x.isConnected || Xt(t, x) || Ai(t, g)) return !1;
+    const O = a.querySelector(`[aria-controls="${t.id}"]`);
+    if (O) {
+      const y = me(O);
+      if (Je(g, y)) return !1;
+    }
+    const P = me(t);
+    return Je(g, P) ? !1 : !n?.(x);
+  }
+  const u = /* @__PURE__ */ new Set();
+  function d(g) {
+    function x() {
+      const O = r ? q : (y) => y(), P = g.composedPath?.() ?? [g.target];
+      O(() => {
+        if (!(!t || !h(g))) {
+          if (s || i) {
+            const y = Ge(s, i);
+            t.addEventListener(Ze, y, { once: !0 });
+          }
+          tn(t, Ze, {
+            bubbles: !1,
+            cancelable: !0,
+            detail: {
+              originalEvent: g,
+              contextmenu: ns(g),
+              focusable: Oi(P)
+            }
+          });
+        }
+      });
+    }
+    g.pointerType === "touch" ? (u.forEach((O) => O()), u.add(H(a, "click", x, { once: !0 })), u.add(f.addEventListener("click", x, { once: !0 })), u.add(l.addEventListener("click", x, { once: !0 }))) : x();
+  }
+  const p = /* @__PURE__ */ new Set(), m = setTimeout(() => {
+    p.add(H(a, "pointerdown", d, !0)), p.add(f.addEventListener("pointerdown", d, !0)), p.add(l.addEventListener("pointerdown", d, !0));
+  }, 0);
+  function w(g) {
+    (r ? q : (O) => O())(() => {
+      if (!(!t || !h(g))) {
+        if (o || i) {
+          const O = Ge(o, i);
+          t.addEventListener(Qe, O, { once: !0 });
+        }
+        tn(t, Qe, {
+          bubbles: !1,
+          cancelable: !0,
+          detail: {
+            originalEvent: g,
+            contextmenu: !1,
+            focusable: dt(ut(g))
+          }
+        });
+      }
+    });
+  }
+  return p.add(H(a, "focusin", w, !0)), p.add(f.addEventListener("focusin", w, !0)), p.add(l.addEventListener("focusin", w, !0)), () => {
+    clearTimeout(m), u.forEach((g) => g()), p.forEach((g) => g());
+  };
+}
+function Ti(t, e) {
+  const { defer: n } = e, o = n ? q : (i) => i(), s = [];
+  return s.push(o(() => {
+    const i = typeof t == "function" ? t() : t;
+    s.push(Si(i, e));
+  })), () => {
+    s.forEach((i) => i?.());
+  };
+}
+function tn(t, e, n) {
+  const o = t.ownerDocument.defaultView || window, s = new o.CustomEvent(e, n);
+  return t.dispatchEvent(s);
+}
+function Pi(t, e) {
+  const n = (o) => {
+    o.key === "Escape" && (o.isComposing || e?.(o));
+  };
+  return H(gt(t), "keydown", n, { capture: !0 });
+}
+const $ = {
+  layers: [],
+  branches: [],
+  count() {
+    return this.layers.length;
+  },
+  pointerBlockingLayers() {
+    return this.layers.filter((t) => t.pointerBlocking);
+  },
+  topMostPointerBlockingLayer() {
+    return [...this.pointerBlockingLayers()].slice(-1)[0];
+  },
+  hasPointerBlockingLayer() {
+    return this.pointerBlockingLayers().length > 0;
+  },
+  isBelowPointerBlockingLayer(t) {
+    const e = this.indexOf(t), n = this.topMostPointerBlockingLayer() ? this.indexOf(this.topMostPointerBlockingLayer()?.node) : -1;
+    return e < n;
+  },
+  isTopMost(t) {
+    return this.layers[this.count() - 1]?.node === t;
+  },
+  getNestedLayers(t) {
+    return Array.from(this.layers).slice(this.indexOf(t) + 1);
+  },
+  isInNestedLayer(t, e) {
+    return this.getNestedLayers(t).some((n) => Xt(n.node, e));
+  },
+  isInBranch(t) {
+    return Array.from(this.branches).some((e) => Xt(e, t));
+  },
+  add(t) {
+    const e = this.layers.push(t);
+    t.node.style.setProperty("--layer-index", `${e}`);
+  },
+  addBranch(t) {
+    this.branches.push(t);
+  },
+  remove(t) {
+    const e = this.indexOf(t);
+    e < 0 || (e < this.count() - 1 && this.getNestedLayers(t).forEach((o) => o.dismiss()), this.layers.splice(e, 1), t.style.removeProperty("--layer-index"));
+  },
+  removeBranch(t) {
+    const e = this.branches.indexOf(t);
+    e >= 0 && this.branches.splice(e, 1);
+  },
+  indexOf(t) {
+    return this.layers.findIndex((e) => e.node === t);
+  },
+  dismiss(t) {
+    this.layers[this.indexOf(t)]?.dismiss();
+  },
+  clear() {
+    this.remove(this.layers[0].node);
+  }
+};
+let en;
+function nn() {
+  $.layers.forEach(({ node: t }) => {
+    t.style.pointerEvents = $.isBelowPointerBlockingLayer(t) ? "none" : "auto";
+  });
+}
+function Ci(t) {
+  t.style.pointerEvents = "";
+}
+function Ni(t, e) {
+  const n = gt(t), o = [];
+  if ($.hasPointerBlockingLayer() && !n.body.hasAttribute("data-inert") && (en = document.body.style.pointerEvents, queueMicrotask(() => {
+    n.body.style.pointerEvents = "none", n.body.setAttribute("data-inert", "");
+  })), e) {
+    const s = vs(e, (i) => {
+      o.push(ms(i, { pointerEvents: "auto" }));
+    });
+    o.push(s);
+  }
+  return () => {
+    $.hasPointerBlockingLayer() || (queueMicrotask(() => {
+      n.body.style.pointerEvents = en, n.body.removeAttribute("data-inert"), n.body.style.length === 0 && n.body.removeAttribute("style");
+    }), o.forEach((s) => s()));
+  };
+}
+function Fi(t, e) {
+  if (!t) throw new Error("[@destyler/dismissable] node is `null` or `undefined`");
+  const { onDismiss: n, pointerBlocking: o, exclude: s, debug: i } = e, r = {
+    dismiss: n,
+    node: t,
+    pointerBlocking: o
+  };
+  $.add(r), nn();
+  function a(u) {
+    const d = ut(u.detail.originalEvent);
+    $.isBelowPointerBlockingLayer(t) || $.isInBranch(d) || (e.onPointerDownOutside?.(u), e.onInteractOutside?.(u), !u.defaultPrevented && (i && console.log("onPointerDownOutside:", u.detail.originalEvent), n?.()));
+  }
+  function c(u) {
+    const d = ut(u.detail.originalEvent);
+    $.isInBranch(d) || (e.onFocusOutside?.(u), e.onInteractOutside?.(u), !u.defaultPrevented && (i && console.log("onFocusOutside:", u.detail.originalEvent), n?.()));
+  }
+  function l(u) {
+    $.isTopMost(t) && (e.onEscapeKeyDown?.(u), !u.defaultPrevented && n && (u.preventDefault(), n()));
+  }
+  function f(u) {
+    if (!t) return !1;
+    const d = typeof s == "function" ? s() : s, p = Array.isArray(d) ? d : [d], m = e.persistentElements?.map((w) => w()).filter(L);
+    return m && p.push(...m), p.some((w) => Xt(w, u)) || $.isInNestedLayer(t, u);
+  }
+  const h = [
+    o ? Ni(t, e.persistentElements) : void 0,
+    Pi(t, l),
+    Ti(t, {
+      exclude: f,
+      onFocusOutside: c,
+      onPointerDownOutside: a,
+      defer: e.defer
+    })
+  ];
+  return () => {
+    $.remove(t), nn(), Ci(t), h.forEach((u) => u?.());
+  };
+}
+function Ii(t, e) {
+  const { defer: n } = e, o = n ? q : (i) => i(), s = [];
+  return s.push(o(() => {
+    const i = Qt(t) ? t() : t;
+    s.push(Fi(i, e));
+  })), () => {
+    s.forEach((i) => i?.());
+  };
+}
+const Ft = (t) => t.key === "Tab", It = (t, ...e) => typeof t == "function" ? t(...e) : t, Di = (t) => !t.isComposing && t.key === "Escape", on = (t) => setTimeout(t, 0);
+function Li(t) {
+  return t.localName === "input" && "select" in t && typeof t.select == "function";
+}
+const sn = {
+  activateTrap(t, e) {
+    if (t.length > 0) {
+      const o = t[t.length - 1];
+      o !== e && o.pause();
+    }
+    const n = t.indexOf(e);
+    n === -1 || t.splice(n, 1), t.push(e);
+  },
+  deactivateTrap(t, e) {
+    const n = t.indexOf(e);
+    n !== -1 && t.splice(n, 1), t.length > 0 && t[t.length - 1].unpause();
+  }
+}, Mi = [];
+var Ri = 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(t, e) {
+    this.trapStack = e.trapStack || Mi;
+    const n = {
+      returnFocusOnDeactivate: !0,
+      escapeDeactivates: !0,
+      delayInitialFocus: !0,
+      isKeyForward(o) {
+        return Ft(o) && !o.shiftKey;
+      },
+      isKeyBackward(o) {
+        return Ft(o) && o.shiftKey;
+      },
+      ...e
+    };
+    this.doc = n.document || gt(Array.isArray(t) ? t[0] : t), this.config = n, this.updateContainerElements(t), this.setupMutationObserver();
+  }
+  findContainerIndex(t, e) {
+    const n = typeof e?.composedPath == "function" ? e.composedPath() : void 0;
+    return this.state.containerGroups.findIndex(({ container: o, tabbableNodes: s }) => o.contains(t) || n?.includes(o) || s.find((i) => i === t));
+  }
+  updateTabbableNodes() {
+    if (this.state.containerGroups = this.state.containers.map((t) => {
+      const e = Vt(t), n = Ne(t), o = e.length > 0 ? e[0] : void 0, s = e.length > 0 ? e[e.length - 1] : void 0, i = n.find((l) => lt(l)), r = n.slice().reverse().find((l) => lt(l)), a = !!e.find((l) => Ct(l) > 0);
+      function c(l, f = !0) {
+        const h = e.indexOf(l);
+        return h < 0 ? f ? n.slice(n.indexOf(l) + 1).find((u) => lt(u)) : n.slice(0, n.indexOf(l)).reverse().find((u) => lt(u)) : e[h + (f ? 1 : -1)];
+      }
+      return {
+        container: t,
+        tabbableNodes: e,
+        focusableNodes: n,
+        posTabIndexesFound: a,
+        firstTabbableNode: o,
+        lastTabbableNode: s,
+        firstDomTabbableNode: i,
+        lastDomTabbableNode: r,
+        nextTabbableNode: c
+      };
+    }), this.state.tabbableGroups = this.state.containerGroups.filter((t) => t.tabbableNodes.length > 0), this.state.tabbableGroups.length <= 0 && !this.getNodeForOption("fallbackFocus")) throw new 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((t) => t.posTabIndexesFound) && this.state.containerGroups.length > 1) throw new 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 sn.activateTrap(this.trapStack, this), this.state.delayInitialFocusTimer = this.config.delayInitialFocus ? on(() => {
+        this.tryFocus(this.getInitialFocusNode());
+      }) : this.tryFocus(this.getInitialFocusNode()), this.listenerCleanups.push(H(this.doc, "focusin", this.handleFocus, !0), H(this.doc, "mousedown", this.handlePointerDown, {
+        capture: !0,
+        passive: !1
+      }), H(this.doc, "touchstart", this.handlePointerDown, {
+        capture: !0,
+        passive: !1
+      }), H(this.doc, "click", this.handleClick, {
+        capture: !0,
+        passive: !1
+      }), H(this.doc, "keydown", this.handleTabKey, {
+        capture: !0,
+        passive: !1
+      }), H(this.doc, "keydown", this.handleEscapeKey)), this;
+  }
+  removeListeners() {
+    if (this.state.active)
+      return this.listenerCleanups.forEach((t) => t()), this.listenerCleanups = [], this;
+  }
+  handleFocus = (t) => {
+    const e = ut(t), n = this.findContainerIndex(e, t) >= 0;
+    if (n || Te(e))
+      n && (this.state.mostRecentlyFocusedNode = e);
+    else {
+      t.stopImmediatePropagation();
+      let o, s = !0;
+      if (this.state.mostRecentlyFocusedNode)
+        if (Ct(this.state.mostRecentlyFocusedNode) > 0) {
+          const i = this.findContainerIndex(this.state.mostRecentlyFocusedNode), { tabbableNodes: r } = this.state.containerGroups[i];
+          if (r.length > 0) {
+            const a = r.findIndex((c) => c === this.state.mostRecentlyFocusedNode);
+            a >= 0 && (this.config.isKeyForward(this.state.recentNavEvent) ? a + 1 < r.length && (o = r[a + 1], s = !1) : a - 1 >= 0 && (o = r[a - 1], s = !1));
+          }
+        } else this.state.containerGroups.some((i) => i.tabbableNodes.some((r) => Ct(r) > 0)) || (s = !1);
+      else s = !1;
+      s && (o = this.findNextNavNode({
+        target: this.state.mostRecentlyFocusedNode,
+        isBackward: this.config.isKeyBackward(this.state.recentNavEvent)
+      })), o ? this.tryFocus(o) : this.tryFocus(this.state.mostRecentlyFocusedNode || this.getInitialFocusNode());
+    }
+    this.state.recentNavEvent = void 0;
+  };
+  handlePointerDown = (t) => {
+    const e = ut(t);
+    if (!(this.findContainerIndex(e, t) >= 0)) {
+      if (It(this.config.clickOutsideDeactivates, t)) {
+        this.deactivate({ returnFocus: this.config.returnFocusOnDeactivate });
+        return;
+      }
+      It(this.config.allowOutsideClick, t) || t.preventDefault();
+    }
+  };
+  handleClick = (t) => {
+    const e = ut(t);
+    this.findContainerIndex(e, t) >= 0 || It(this.config.clickOutsideDeactivates, t) || It(this.config.allowOutsideClick, t) || (t.preventDefault(), t.stopImmediatePropagation());
+  };
+  handleTabKey = (t) => {
+    if (this.config.isKeyForward(t) || this.config.isKeyBackward(t)) {
+      this.state.recentNavEvent = t;
+      const e = this.config.isKeyBackward(t), n = this.findNextNavNode({
+        event: t,
+        isBackward: e
+      });
+      if (!n) return;
+      Ft(t) && t.preventDefault(), this.tryFocus(n);
+    }
+  };
+  handleEscapeKey = (t) => {
+    Di(t) && It(this.config.escapeDeactivates, t) !== !1 && (t.preventDefault(), this.deactivate());
+  };
+  _mutationObserver;
+  setupMutationObserver = () => {
+    const t = this.doc.defaultView || window;
+    this._mutationObserver = new t.MutationObserver((e) => {
+      e.some((o) => Array.from(o.removedNodes).includes(this.state.mostRecentlyFocusedNode)) && this.tryFocus(this.getInitialFocusNode());
+    });
+  };
+  updateObservedNodes = () => {
+    this._mutationObserver?.disconnect(), this.state.active && !this.state.paused && this.state.containers.forEach((t) => {
+      this._mutationObserver?.observe(t, {
+        subtree: !0,
+        childList: !0
+      });
+    });
+  };
+  getInitialFocusNode = () => {
+    let t = this.getNodeForOption("initialFocus", { hasFallback: !0 });
+    if (t === !1) return !1;
+    if (t === void 0 || t && !dt(t)) if (this.findContainerIndex(this.doc.activeElement) >= 0) t = this.doc.activeElement;
+    else {
+      const e = this.state.tabbableGroups[0];
+      t = e && e.firstTabbableNode || this.getNodeForOption("fallbackFocus");
+    }
+    else t === null && (t = this.getNodeForOption("fallbackFocus"));
+    if (!t) throw new Error("Your focus-trap needs to have at least one focusable element");
+    return t.isConnected || (t = this.getNodeForOption("fallbackFocus")), t;
+  };
+  tryFocus = (t) => {
+    if (t !== !1 && t !== bn(this.doc)) {
+      if (!t || !t.focus) {
+        this.tryFocus(this.getInitialFocusNode());
+        return;
+      }
+      t.focus({ preventScroll: !!this.config.preventScroll }), this.state.mostRecentlyFocusedNode = t, Li(t) && t.select();
+    }
+  };
+  activate(t) {
+    if (this.state.active) return this;
+    const e = this.getOption(t, "onActivate"), n = this.getOption(t, "onPostActivate"), o = this.getOption(t, "checkCanFocusTrap");
+    o || this.updateTabbableNodes(), this.state.active = !0, this.state.paused = !1, this.state.nodeFocusedBeforeActivation = this.doc.activeElement || null, e?.();
+    const s = () => {
+      o && this.updateTabbableNodes(), this.addListeners(), this.updateObservedNodes(), n?.();
+    };
+    return o ? (o(this.state.containers.concat()).then(s, s), this) : (s(), this);
+  }
+  deactivate = (t) => {
+    if (!this.state.active) return this;
+    const e = {
+      onDeactivate: this.config.onDeactivate,
+      onPostDeactivate: this.config.onPostDeactivate,
+      checkCanReturnFocus: this.config.checkCanReturnFocus,
+      ...t
+    };
+    clearTimeout(this.state.delayInitialFocusTimer), this.state.delayInitialFocusTimer = void 0, this.removeListeners(), this.state.active = !1, this.state.paused = !1, this.updateObservedNodes(), sn.deactivateTrap(this.trapStack, this);
+    const n = this.getOption(e, "onDeactivate"), o = this.getOption(e, "onPostDeactivate"), s = this.getOption(e, "checkCanReturnFocus"), i = this.getOption(e, "returnFocus", "returnFocusOnDeactivate");
+    n?.();
+    const r = () => {
+      on(() => {
+        if (i) {
+          const a = this.getReturnFocusNode(this.state.nodeFocusedBeforeActivation);
+          this.tryFocus(a);
+        }
+        o?.();
+      });
+    };
+    if (i && s) {
+      const a = this.getReturnFocusNode(this.state.nodeFocusedBeforeActivation);
+      return s(a).then(r, r), this;
+    }
+    return r(), this;
+  };
+  pause = (t) => {
+    if (this.state.paused || !this.state.active) return this;
+    const e = this.getOption(t, "onPause"), n = this.getOption(t, "onPostPause");
+    return this.state.paused = !0, e?.(), this.removeListeners(), this.updateObservedNodes(), n?.(), this;
+  };
+  unpause = (t) => {
+    if (!this.state.paused || !this.state.active) return this;
+    const e = this.getOption(t, "onUnpause"), n = this.getOption(t, "onPostUnpause");
+    return this.state.paused = !1, e?.(), this.updateTabbableNodes(), this.addListeners(), this.updateObservedNodes(), n?.(), this;
+  };
+  updateContainerElements = (t) => (this.state.containers = Array.isArray(t) ? t.filter(Boolean) : [t].filter(Boolean), this.state.active && this.updateTabbableNodes(), this.updateObservedNodes(), this);
+  getReturnFocusNode = (t) => {
+    const e = this.getNodeForOption("setReturnFocus", { params: [t] });
+    return e || (e === !1 ? !1 : t);
+  };
+  getOption = (t, e, n) => t && t[e] !== void 0 ? t[e] : this.config[n || e];
+  getNodeForOption = (t, { hasFallback: e = !1, params: n = [] } = {}) => {
+    let o = this.config[t];
+    if (typeof o == "function" && (o = o(...n)), o === !0 && (o = void 0), !o) {
+      if (o === void 0 || o === !1) return o;
+      throw new Error(`\`${t}\` was specified but was not a node, or did not return a node`);
+    }
+    let s = o;
+    if (typeof o == "string") {
+      try {
+        s = this.doc.querySelector(o);
+      } catch (i) {
+        throw new Error(`\`${t}\` appears to be an invalid selector; error="${i.message}"`);
+      }
+      if (!s && !e)
+        throw new Error(`\`${t}\` as selector refers to no known node`);
+    }
+    return s;
+  };
+  findNextNavNode = (t) => {
+    const { event: e, isBackward: n = !1 } = t, o = t.target || ut(e);
+    this.updateTabbableNodes();
+    let s = null;
+    if (this.state.tabbableGroups.length > 0) {
+      const i = this.findContainerIndex(o, e), r = i >= 0 ? this.state.containerGroups[i] : void 0;
+      if (i < 0) n ? s = this.state.tabbableGroups[this.state.tabbableGroups.length - 1].lastTabbableNode : s = this.state.tabbableGroups[0].firstTabbableNode;
+      else if (n) {
+        let a = this.state.tabbableGroups.findIndex(({ firstTabbableNode: c }) => o === c);
+        if (a < 0 && (r?.container === o || dt(o) && !lt(o) && !r?.nextTabbableNode(o, !1)) && (a = i), a >= 0) {
+          const c = a === 0 ? this.state.tabbableGroups.length - 1 : a - 1, l = this.state.tabbableGroups[c];
+          s = Ct(o) >= 0 ? l.lastTabbableNode : l.lastDomTabbableNode;
+        } else Ft(e) || (s = r?.nextTabbableNode(o, !1));
+      } else {
+        let a = this.state.tabbableGroups.findIndex(({ lastTabbableNode: c }) => o === c);
+        if (a < 0 && (r?.container === o || dt(o) && !lt(o) && !r?.nextTabbableNode(o)) && (a = i), a >= 0) {
+          const c = a === this.state.tabbableGroups.length - 1 ? 0 : a + 1, l = this.state.tabbableGroups[c];
+          s = Ct(o) >= 0 ? l.firstTabbableNode : l.firstDomTabbableNode;
+        } else Ft(e) || (s = r?.nextTabbableNode(o));
+      }
+    } else s = this.getNodeForOption("fallbackFocus");
+    return s;
+  };
+};
+function _i(t, e = {}) {
+  let n;
+  const o = q(() => {
+    const s = typeof t == "function" ? t() : t;
+    if (s) {
+      n = new Ri(s, {
+        escapeDeactivates: !1,
+        allowOutsideClick: !0,
+        preventScroll: !0,
+        returnFocusOnDeactivate: !0,
+        delayInitialFocus: !1,
+        fallbackFocus: s,
+        ...e,
+        document: gt(s)
+      });
+      try {
+        n.activate();
+      } catch {
+      }
+    }
+  });
+  return function() {
+    n?.deactivate(), o();
+  };
+}
+const de = "data-scroll-lock";
+function rn(t, e) {
+  if (!t) return;
+  const n = Object.keys(e).reduce((o, s) => (o[s] = t.style.getPropertyValue(s), o), {});
+  return Object.assign(t.style, e), () => {
+    Object.assign(t.style, n);
+  };
+}
+function Bi(t, e, n) {
+  if (!t) return;
+  const o = t.style.getPropertyValue(e);
+  return t.style.setProperty(e, n), () => {
+    o ? t.style.setProperty(e, o) : t.style.removeProperty(e);
+  };
+}
+function Vi(t) {
+  const e = t.getBoundingClientRect().left;
+  return Math.round(e) + t.scrollLeft ? "paddingLeft" : "paddingRight";
+}
+function ji(t) {
+  const e = t ?? document, n = e.defaultView ?? window, { documentElement: o, body: s } = e;
+  if (s.hasAttribute(de)) return;
+  s.setAttribute(de, "");
+  const r = n.innerWidth - o.clientWidth, a = () => Bi(o, "--scrollbar-width", `${r}px`), c = Vi(o), l = () => rn(s, {
+    overflow: "hidden",
+    [c]: `${r}px`
+  }), f = () => {
+    const { scrollX: u, scrollY: d, visualViewport: p } = n, m = p?.offsetLeft ?? 0, w = p?.offsetTop ?? 0, g = rn(s, {
+      position: "fixed",
+      overflow: "hidden",
+      top: `${-(d - Math.floor(w))}px`,
+      left: `${-(u - Math.floor(m))}px`,
+      right: "0",
+      [c]: `${r}px`
+    });
+    return () => {
+      g?.(), n.scrollTo({
+        left: u,
+        top: d,
+        behavior: "instant"
+      });
+    };
+  }, h = [a(), ts() ? f() : l()];
+  return () => {
+    h.forEach((u) => u?.()), s.removeAttribute(de);
+  };
+}
+const Wi = Symbol(), an = Object.getPrototypeOf, be = /* @__PURE__ */ new WeakMap(), $i = (t) => t && (be.has(t) ? be.get(t) : an(t) === Object.prototype || an(t) === Array.prototype), Hi = (t) => $i(t) && t[Wi] || null, cn = (t, e = !0) => {
+  be.set(t, e);
+};
+function Gi() {
+  if (typeof globalThis < "u" || typeof globalThis < "u") return globalThis;
+  if (typeof window < "u") return window;
+}
+function Ln(t, e) {
+  const n = Gi();
+  return n ? (n[t] ||= e(), n[t]) : e();
+}
+const Mt = Ln("__destyler__refSet", () => /* @__PURE__ */ new WeakSet()), zi = (t) => typeof t == "object" && t !== null && "$$typeof" in t && "props" in t, Ki = (t) => typeof t == "object" && t !== null && "__v_isVNode" in t;
+function Ui(t) {
+  return typeof t == "object" && t !== null && "nodeType" in t && typeof t.nodeName == "string";
+}
+const Yi = (t) => zi(t) || Ki(t) || Ui(t), ve = (t) => t !== null && typeof t == "object";
+function we(t) {
+  return ve(t) && !Mt.has(t) && (Array.isArray(t) || !(Symbol.iterator in t)) && !Yi(t) && !(t instanceof WeakMap) && !(t instanceof WeakSet) && !(t instanceof Error) && typeof t != "number" && !(t instanceof Date) && typeof t != "string" && !(t instanceof RegExp) && !(t instanceof ArrayBuffer) && !(t instanceof Promise);
+}
+function ln(t, e, n) {
+  typeof n.value == "object" && !we(n.value) && (n.value = bt(n.value)), !n.enumerable || n.get || n.set || !n.configurable || !n.writable || e === "__proto__" ? Object.defineProperty(t, e, n) : t[e] = n.value;
+}
+function bt(t) {
+  if (typeof t != "object") return t;
+  let e = 0, n, o, s;
+  const i = Object.prototype.toString.call(t);
+  if (i === "[object Object]" ? s = Object.create(Object.getPrototypeOf(t) || null) : i === "[object Array]" ? s = Array.from({ length: t.length }) : i === "[object Set]" ? (s = /* @__PURE__ */ new Set(), t.forEach((r) => {
+    s.add(bt(r));
+  })) : i === "[object Map]" ? (s = /* @__PURE__ */ new Map(), t.forEach((r, a) => {
+    s.set(bt(a), bt(r));
+  })) : i === "[object Date]" ? s = /* @__PURE__ */ new Date(+t) : i === "[object RegExp]" ? s = new RegExp(t.source, t.flags) : i === "[object DataView]" ? s = new t.constructor(bt(t.buffer)) : i === "[object ArrayBuffer]" ? s = t.slice(0) : i === "[object Blob]" ? s = t.slice() : i.slice(-6) === "Array]" && (s = new t.constructor(t)), s) {
+    for (o = Object.getOwnPropertySymbols(t); e < o.length; e++) ln(s, o[e], Object.getOwnPropertyDescriptor(t, o[e]));
+    for (e = 0, o = Object.getOwnPropertyNames(t); e < o.length; e++)
+      Object.hasOwnProperty.call(s, n = o[e]) && s[n] === t[n] || ln(s, n, Object.getOwnPropertyDescriptor(t, n));
+  }
+  return s || t;
+}
+const yt = Ln("__destyler__proxyStateMap", () => /* @__PURE__ */ new WeakMap());
+function qi(t = Object.is, e = (a, c) => new Proxy(a, c), n = /* @__PURE__ */ new WeakMap(), o = (a, c) => {
+  const l = n.get(a);
+  if (l?.[0] === c) return l[1];
+  const f = Array.isArray(a) ? [] : Object.create(Object.getPrototypeOf(a));
+  return cn(f, !0), n.set(a, [c, f]), Reflect.ownKeys(a).forEach((h) => {
+    const u = Reflect.get(a, h);
+    Mt.has(u) ? (cn(u, !1), f[h] = u) : yt.has(u) ? f[h] = vt(u) : f[h] = u;
+  }), Object.freeze(f);
+}, s = /* @__PURE__ */ new WeakMap(), i = [1, 1], r = (a) => {
+  if (!ve(a)) throw new Error("object required");
+  const c = s.get(a);
+  if (c) return c;
+  let l = i[0];
+  const f = /* @__PURE__ */ new Set(), h = /* @__PURE__ */ new Map(), u = (b, v = ++i[0]) => {
+    l !== v && (l = v, f.forEach((E) => E(b, v)));
+  };
+  let d = i[1];
+  const p = (b = ++i[1]) => (d !== b && !f.size && (d = b, h.forEach(([v]) => {
+    const E = v[1](b);
+    E > l && (l = E);
+  })), l), m = (b) => (v, E) => {
+    const S = [...v];
+    S[1] = [b, ...S[1]], u(S, E);
+  }, w = (b, v) => {
+    if (f.size) {
+      const E = v[3](m(b));
+      h.set(b, [v, E]);
+    } else h.set(b, [v]);
+  }, g = (b) => {
+    const v = h.get(b);
+    v && (h.delete(b), v[1]?.());
+  }, x = (b) => (f.add(b), f.size === 1 && h.forEach(([E], S) => {
+    const C = E[3](m(S));
+    h.set(S, [E, C]);
+  }), () => {
+    f.delete(b), f.size === 0 && h.forEach(([E, S], C) => {
+      S && (S(), h.set(C, [E]));
+    });
+  }), O = Array.isArray(a) ? [] : Object.create(Object.getPrototypeOf(a)), y = e(O, {
+    deleteProperty(b, v) {
+      const E = Reflect.get(b, v);
+      g(v);
+      const S = Reflect.deleteProperty(b, v);
+      return S && u([
+        "delete",
+        [v],
+        E
+      ]), S;
+    },
+    set(b, v, E, S) {
+      const C = Reflect.has(b, v), N = Reflect.get(b, v, S);
+      if (C && (t(N, E) || s.has(E) && t(N, s.get(E)))) return !0;
+      g(v), ve(E) && (E = Hi(E) || E);
+      let R = E;
+      if (!Object.getOwnPropertyDescriptor(b, v)?.set) {
+        !yt.has(E) && we(E) && (R = De(E));
+        const I = !Mt.has(R) && yt.get(R);
+        I && w(v, I);
+      }
+      return Reflect.set(b, v, R, S), u([
+        "set",
+        [v],
+        E,
+        N
+      ]), !0;
+    }
+  });
+  s.set(a, y);
+  const k = [
+    O,
+    p,
+    o,
+    x
+  ];
+  return yt.set(y, k), Reflect.ownKeys(a).forEach((b) => {
+    const v = Object.getOwnPropertyDescriptor(a, b);
+    v.get || v.set ? Object.defineProperty(O, b, v) : y[b] = a[b];
+  }), y;
+}) {
+  return [
+    r,
+    yt,
+    Mt,
+    t,
+    e,
+    we,
+    n,
+    o,
+    s,
+    i
+  ];
+}
+const [Xi] = qi();
+function De(t = {}) {
+  return Xi(t);
+}
+function xe(t, e, n) {
+  const o = yt.get(t);
+  let s;
+  const i = [], r = o[3];
+  let a = !1;
+  const l = r((f) => {
+    if (i.push(f), n) {
+      e(i.splice(0));
+      return;
+    }
+    s || (s = Promise.resolve().then(() => {
+      s = void 0, a && e(i.splice(0));
+    }));
+  });
+  return a = !0, () => {
+    a = !1, l();
+  };
+}
+function vt(t) {
+  const e = yt.get(t), [n, o, s] = e;
+  return s(n, o());
+}
+function un(t) {
+  return Mt.add(t), t;
+}
+function Zi(t, e) {
+  const n = Object.keys(e);
+  n.forEach((s) => {
+    if (Object.getOwnPropertyDescriptor(t, s)) throw new Error("object property already defined");
+  });
+  const o = De(t);
+  return n.forEach((s) => {
+    const i = e[s], { get: r, set: a } = typeof i == "function" ? { get: i } : i, c = {};
+    c.get = () => r(vt(o)), a && (c.set = (l) => a(o, l)), Object.defineProperty(o, s, c);
+  }), o;
+}
+function Mn(t, ...e) {
+  if (!$t(t)) throw new TypeError("Source argument must be a plain object");
+  const n = t;
+  for (const o of e) {
+    if (!$t(o)) continue;
+    const s = jt(o);
+    for (const i in s) {
+      if (!Object.prototype.hasOwnProperty.call(s, i) || i === "__proto__" || i === "constructor" || i === "prototype") continue;
+      const r = n[i], a = o[i];
+      $t(a) ? n[i] = $t(r) ? Mn(r, a) : { ...a } : n[i] = a;
+    }
+  }
+  return n;
+}
+function W(t) {
+  return ot(t) ? { type: t } : t;
+}
+function ct(t) {
+  return t ? Zt(t) ? t.slice() : [t] : [];
+}
+function Rn(t) {
+  return zt(t) && t.predicate != null;
+}
+const Qi = () => !0;
+function _n(t, e) {
+  return t = t ?? Qi, (n, o, s) => {
+    if (ot(t)) {
+      const i = e[t];
+      return Qt(i) ? i(n, o, s) : i;
+    }
+    return Rn(t) ? t.predicate(e)(n, o, s) : t?.(n, o, s);
+  };
+}
+function fe(t, e) {
+  return (n, o, s) => Rn(t) ? t.predicate(e)(n, o, s) : t;
+}
+let at = /* @__PURE__ */ function(t) {
+  return t.NotStarted = "Not Started", t.Running = "Running", t.Stopped = "Stopped", t;
+}({}), tt = /* @__PURE__ */ function(t) {
+  return t.Start = "machine.start", t.Stop = "machine.stop", t.Created = "machine.created", t.Init = "machine.init", t;
+}({}), dn = /* @__PURE__ */ function(t) {
+  return t.Machine = "machine", t.Actor = "machine.actor", t;
+}({});
+function Ji(t) {
+  const e = t.computed ?? nt({}), n = t.context ?? nt({}), o = t.initial ? t.states?.[t.initial]?.tags : [], s = De({
+    value: t.initial ?? "",
+    previousValue: "",
+    event: nt({}),
+    previousEvent: nt({}),
+    context: Zi(n, e),
+    done: !1,
+    tags: o ?? [],
+    hasTag(i) {
+      return this.tags.includes(i);
+    },
+    matches(...i) {
+      return i.includes(this.value);
+    },
+    can(i) {
+      return nt(this).nextEvents.includes(i);
+    },
+    get nextEvents() {
+      const i = t.states?.[this.value]?.on ?? {}, r = t?.on ?? {};
+      return Object.keys({
+        ...i,
+        ...r
+      });
+    },
+    get changed() {
+      return this.event.value === tt.Init || !this.previousValue ? !1 : this.value !== this.previousValue;
+    }
+  });
+  return nt(s);
+}
+function Dt(t, e) {
+  return (n, o) => {
+    if (xs(t)) return t;
+    if (Qt(t)) return t(n, o);
+    if (ot(t)) {
+      const s = Number.parseFloat(t);
+      if (!Number.isNaN(s)) return s;
+      if (e) {
+        const i = e?.[t];
+        if (i === null) throw new Error(`[@destyler/xstate > determine-delay] Cannot determine delay for \`${t}\`. It is set to null in \`options.delays\``);
+        return Qt(i) ? i(n, o) : i;
+      }
+    }
+  };
+}
+function tr(t) {
+  return ot(t) ? { target: t } : t;
+}
+function er(t, e) {
+  return (n, o, s) => ct(t).map(tr).find((i) => _n(i.guard, e)(n, o, s) ?? i.target ?? i.actions);
+}
+var nr = class {
+  status = at.NotStarted;
+  state;
+  initialState;
+  initialContext;
+  id;
+  type = dn.Machine;
+  activityEvents = /* @__PURE__ */ new Map();
+  delayedEvents = /* @__PURE__ */ new Map();
+  stateListeners = /* @__PURE__ */ new Set();
+  doneListeners = /* @__PURE__ */ new Set();
+  contextWatchers = /* @__PURE__ */ new Set();
+  removeStateListener = xn;
+  parent;
+  children = /* @__PURE__ */ new Map();
+  guardMap;
+  actionMap;
+  delayMap;
+  activityMap;
+  sync;
+  options;
+  config;
+  constructor(t, e) {
+    this.config = bt(t), this.options = bt(e ?? {}), this.id = this.config.id ?? `machine-${ze()}`, 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 = Ji(this.config), this.initialContext = vt(this.state.context);
+  }
+  get stateSnapshot() {
+    return nt(vt(this.state));
+  }
+  getState() {
+    return this.stateSnapshot;
+  }
+  get contextSnapshot() {
+    return this.stateSnapshot.context;
+  }
+  _created = () => {
+    if (!this.config.created) return;
+    const t = W(tt.Created);
+    this.executeActions(this.config.created, t);
+  };
+  start = (t) => {
+    if (this.state.value = "", this.state.tags = [], this.status === at.Running) return this;
+    this.status = at.Running, this.removeStateListener = xe(this.state, () => {
+      this.stateListeners.forEach((r) => {
+        r(this.stateSnapshot);
+      });
+    }, this.sync), this.setupContextWatchers(), this.executeActivities(W(tt.Start), ct(this.config.activities), tt.Start), this.executeActions(this.config.entry, W(tt.Start));
+    const e = W(tt.Init), n = zt(t) ? t.value : t, o = zt(t) ? t.context : void 0;
+    o && this.setContext(o);
+    const s = { target: n ?? this.config.initial }, i = this.getNextStateInfo(s, e);
+    return this.initialState = i, this.performStateChangeEffects(this.state.value, i, e), this;
+  };
+  setupContextWatchers = () => {
+    const { watch: t } = this.config;
+    if (!t) return;
+    let e = vt(this.state.context);
+    const n = xe(this.state.context, () => {
+      const o = vt(this.state.context);
+      for (const [s, i] of Object.entries(t))
+        (this.options.compareFns?.[s] ?? Object.is)(e[s], o[s]) || this.executeActions(i, this.state.event);
+      e = o;
+    });
+    this.contextWatchers.add(n);
+  };
+  stop = () => {
+    if (this.status !== at.Stopped)
+      return this.performExitEffects(this.state.value, W(tt.Stop)), this.executeActions(this.config.exit, W(tt.Stop)), this.setState(""), this.setEvent(tt.Stop), this.stopStateListeners(), this.stopChildren(), this.stopActivities(), this.stopDelayedEvents(), this.stopContextWatchers(), this.status = at.Stopped, this;
+  };
+  stopStateListeners = () => {
+    this.removeStateListener(), this.stateListeners.clear();
+  };
+  stopContextWatchers = () => {
+    this.contextWatchers.forEach((t) => t()), this.contextWatchers.clear();
+  };
+  stopDelayedEvents = () => {
+    this.delayedEvents.forEach((t) => {
+      t.forEach((e) => e());
+    }), this.delayedEvents.clear();
+  };
+  stopActivities = (t) => {
+    t ? (this.activityEvents.get(t)?.forEach((e) => e()), this.activityEvents.get(t)?.clear(), this.activityEvents.delete(t)) : (this.activityEvents.forEach((e) => {
+      e.forEach((n) => n()), e.clear();
+    }), this.activityEvents.clear());
+  };
+  /**
+  * Function to send event to spawned child machine or actor
+  */
+  sendChild = (t, e) => {
+    const n = W(t), o = ye(e, this.contextSnapshot), s = this.children.get(o);
+    if (!s) throw new Error(`[@destyler/xstate] Cannot send '${n.type}' event to unknown child`);
+    s.send(n);
+  };
+  /**
+  * Function to stop a running child machine or actor
+  */
+  stopChild = (t) => {
+    if (!this.children.has(t)) throw new Error(`[@destyler.xstate > stop-child] Cannot stop unknown child ${t}`);
+    this.children.get(t).stop(), this.children.delete(t);
+  };
+  removeChild = (t) => {
+    this.children.delete(t);
+  };
+  stopChildren = () => {
+    this.children.forEach((t) => t.stop()), this.children.clear();
+  };
+  setParent = (t) => {
+    this.parent = t;
+  };
+  spawn = (t, e) => {
+    const n = ye(t);
+    return e && (n.id = e), n.type = dn.Actor, n.setParent(this), this.children.set(n.id, nt(n)), n.onDone(() => {
+      this.removeChild(n.id);
+    }).start(), nt(un(n));
+  };
+  stopActivity = (t) => {
+    if (!this.state.value) return;
+    const e = this.activityEvents.get(this.state.value);
+    e?.get(t)?.(), e?.delete(t);
+  };
+  addActivityCleanup = (t, e, n) => {
+    t && (this.activityEvents.has(t) ? this.activityEvents.get(t)?.set(e, n) : this.activityEvents.set(t, /* @__PURE__ */ new Map([[e, n]])));
+  };
+  setState = (t) => {
+    this.state.previousValue = this.state.value, this.state.value = t;
+    const e = this.getStateNode(t);
+    t == null ? ws(this.state.tags) : this.state.tags = ct(e?.tags);
+  };
+  /**
+  * To used within side effects for React or Vue to update context
+  */
+  setContext = (t) => {
+    t && Mn(this.state.context, t);
+  };
+  setOptions = (t) => {
+    const e = jt(t);
+    this.actionMap = {
+      ...this.actionMap,
+      ...e.actions
+    }, this.delayMap = {
+      ...this.delayMap,
+      ...e.delays
+    }, this.activityMap = {
+      ...this.activityMap,
+      ...e.activities
+    }, this.guardMap = {
+      ...this.guardMap,
+      ...e.guards
+    };
+  };
+  getStateNode = (t) => {
+    if (t)
+      return this.config.states?.[t];
+  };
+  getNextStateInfo = (t, e) => {
+    const n = this.determineTransition(t, e), o = !n?.target, s = n?.target ?? this.state.value, i = this.state.value !== s, r = this.getStateNode(s), c = {
+      reenter: !o && !i && !n?.internal,
+      transition: n,
+      stateNode: r,
+      target: s,
+      changed: i
+    };
+    return this.log("NextState:", `[${e.type}]`, this.state.value, "---->", c.target), c;
+  };
+  getAfterActions = (t, e) => {
+    let n;
+    const o = this.state.value;
+    return {
+      entry: () => {
+        n = globalThis.setTimeout(() => {
+          const s = this.getNextStateInfo(t, this.state.event);
+          this.performStateChangeEffects(o, s, this.state.event);
+        }, e);
+      },
+      exit: () => {
+        globalThis.clearTimeout(n);
+      }
+    };
+  };
+  /**
+  * All `after` events leverage `setTimeout` and `clearTimeout`,
+  * we invoke the `clearTimeout` on exit and `setTimeout` on entry.
+  *
+  * To achieve this, we split the `after` definition into `entry` and `exit`
+  *  functions and append them to the state's `entry` and `exit` actions
+  */
+  getDelayedEventActions = (t) => {
+    const e = this.getStateNode(t), n = this.state.event;
+    if (!e || !e.after) return;
+    const o = [], s = [];
+    if (Zt(e.after)) {
+      const i = this.determineTransition(e.after, n);
+      if (!i) return;
+      if (!On(i, "delay")) throw new Error(`[@destyler/xstate > after] Delay is required for after transition: ${JSON.stringify(i)}`);
+      const a = Dt(i.delay, this.delayMap)(this.contextSnapshot, n), c = this.getAfterActions(i, a);
+      return o.push(c.entry), s.push(c.exit), {
+        entries: o,
+        exits: s
+      };
+    }
+    if (zt(e.after)) for (const i in e.after) {
+      const r = e.after[i], c = Dt(i, this.delayMap)(this.contextSnapshot, n), l = this.getAfterActions(r, c);
+      o.push(l.entry), s.push(l.exit);
+    }
+    return {
+      entries: o,
+      exits: s
+    };
+  };
+  /**
+  * A reference to the instance methods of the machine.
+  * Useful when spawning child machines and managing the communication between them.
+  */
+  get self() {
+    const t = 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 t.stateSnapshot;
+      },
+      get initialContext() {
+        return t.initialContext;
+      },
+      get initialState() {
+        return t.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: (t) => this.actionMap[t],
+      getGuard: (t) => this.guardMap[t]
+    };
+  }
+  get guardMeta() {
+    return { state: this.stateSnapshot };
+  }
+  /**
+  * Function to executes defined actions. It can accept actions as string
+  * (referencing `options.actions`) or actual functions.
+  */
+  executeActions = (t, e) => {
+    const n = fe(t, this.guardMap)(this.contextSnapshot, e, this.guardMeta);
+    for (const o of ct(n)) {
+      const s = ot(o) ? this.actionMap?.[o] : o;
+      ot(o) && !s && console.warn(`[@destyler/xstate > execute-actions] No implementation found for action: \`${o}\``), s?.(this.state.context, e, this.meta);
+    }
+  };
+  /**
+  * Function to execute running activities and registers
+  * their cleanup function internally (to be called later on when we exit the state)
+  */
+  executeActivities = (t, e, n) => {
+    for (const o of e) {
+      const s = ot(o) ? this.activityMap?.[o] : o;
+      if (!s) {
+        console.warn(`[@destyler/xstate > execute-activity] No implementation found for activity: \`${o}\``);
+        continue;
+      }
+      const i = s(this.state.context, t, this.meta);
+      if (i) {
+        const r = ot(o) ? o : o.name || ze();
+        this.addActivityCleanup(n ?? this.state.value, r, i);
+      }
+    }
+  };
+  /**
+  * Normalizes the `every` definition to transition. `every` can be:
+  * - An array of possible actions to run (we need to pick the first match based on guard)
+  * - An object of intervals and actions
+  */
+  createEveryActivities = (t, e) => {
+    if (t)
+      if (Zt(t)) {
+        const n = ct(t).find((r) => {
+          const a = r.delay, l = Dt(a, this.delayMap)(this.contextSnapshot, this.state.event);
+          return _n(r.guard, this.guardMap)(this.contextSnapshot, this.state.event, this.guardMeta) ?? l != null;
+        });
+        if (!n) return;
+        const s = Dt(n.delay, this.delayMap)(this.contextSnapshot, this.state.event);
+        e(() => {
+          const r = globalThis.setInterval(() => {
+            this.executeActions(n.actions, this.state.event);
+          }, s);
+          return () => {
+            globalThis.clearInterval(r);
+          };
+        });
+      } else for (const n in t) {
+        const o = t?.[n], i = Dt(n, this.delayMap)(this.contextSnapshot, this.state.event);
+        e(() => {
+          const a = globalThis.setInterval(() => {
+            this.executeActions(o, this.state.event);
+          }, i);
+          return () => {
+            globalThis.clearInterval(a);
+          };
+        });
+      }
+  };
+  setEvent = (t) => {
+    this.state.previousEvent = this.state.event, this.state.event = un(W(t));
+  };
+  performExitEffects = (t, e) => {
+    const n = this.state.value;
+    if (n === "") return;
+    const o = t ? this.getStateNode(t) : void 0;
+    this.stopActivities(n);
+    const s = fe(o?.exit, this.guardMap)(this.contextSnapshot, e, this.guardMeta), i = ct(s), r = this.delayedEvents.get(n);
+    r && i.push(...r), this.executeActions(i, e), this.delayedEvents.delete(n);
+  };
+  performEntryEffects = (t, e) => {
+    const n = this.getStateNode(t), o = ct(n?.activities);
+    this.createEveryActivities(n?.every, (a) => {
+      o.unshift(a);
+    }), o.length > 0 && this.executeActivities(e, o);
+    const s = fe(n?.entry, this.guardMap)(this.contextSnapshot, e, this.guardMeta), i = ct(s), r = this.getDelayedEventActions(t);
+    n?.after && r && (this.delayedEvents.set(t, r?.exits), i.push(...r.entries)), this.executeActions(i, e), n?.type === "final" && (this.state.done = !0, this.doneListeners.forEach((a) => {
+      a(this.stateSnapshot);
+    }), this.stop());
+  };
+  performTransitionEffects = (t, e) => {
+    const n = this.determineTransition(t, e);
+    this.executeActions(n?.actions, e);
+  };
+  /**
+  * Performs all the requires side-effects or reactions when
+  * we move from state A => state B.
+  *
+  * The Effect order:
+  * Exit actions (current state) => Transition actions  => Go to state => Entry actions (next state)
+  */
+  performStateChangeEffects = (t, e, n) => {
+    this.setEvent(n);
+    const o = e.changed || e.reenter;
+    o && this.performExitEffects(t, n), this.performTransitionEffects(e.transition, n), this.setState(e.target), o && this.performEntryEffects(e.target, n);
+  };
+  determineTransition = (t, e) => er(t, this.guardMap)?.(this.contextSnapshot, e, this.guardMeta);
+  /**
+  * Function to send event to parent machine from spawned child
+  */
+  sendParent = (t) => {
+    if (!this.parent) throw new Error("[@destyler/xstate > send-parent] Cannot send event to parent machine, no parent is set. Use `machine.spawn()` to spawn a child machine.");
+    const e = W(t);
+    this.parent?.send(e);
+  };
+  log = (...t) => {
+    this.options.debug && console.log(...t);
+  };
+  /**
+  * Function to send an event to current machine
+  */
+  send = (t) => {
+    const e = W(t);
+    this.transition(this.state.value, e);
+  };
+  transition = (t, e) => {
+    const n = ot(t) ? this.getStateNode(t) : t?.stateNode, o = W(e);
+    if (!n && !this.config.on) {
+      const r = this.status === at.Stopped ? "[@destyler/xstate > transition] Cannot transition a stopped machine" : `[destyler/xstate > transition] State does not have a definition for \`state\`: ${t}, \`event\`: ${o.type}`;
+      console.warn(r);
+      return;
+    }
+    const s = n?.on?.[o.type] ?? this.config.on?.[o.type], i = this.getNextStateInfo(s, o);
+    return this.performStateChangeEffects(this.state.value, i, o), i.stateNode;
+  };
+  subscribe = (t) => (this.stateListeners.add(t), this.status === at.Running && t(this.stateSnapshot), () => {
+    this.stateListeners.delete(t);
+  });
+  onDone = (t) => (this.doneListeners.add(t), this);
+  onTransition = (t) => (this.stateListeners.add(t), this.status === at.Running && t(this.stateSnapshot), this);
+  get [Symbol.toStringTag]() {
+    return "Machine";
+  }
+  getHydrationState() {
+    const t = this.getState();
+    return {
+      value: t.value,
+      tags: t.tags
+    };
+  }
+};
+function or(t, e) {
+  return new nr(t, e);
+}
+function sr() {
+  return (t) => Array.from(new Set(t));
+}
+function ir(t) {
+  return new Proxy({}, { get() {
+    return t;
+  } });
+}
+const rr = Gt("popover").parts("arrow", "arrowTip", "anchor", "trigger", "indicator", "positioner", "content", "title", "description", "closeTrigger"), K = rr.build(), A = ps({
+  getAnchorId: (t) => t.ids?.anchor ?? `popover:${t.id}:anchor`,
+  getTriggerId: (t) => t.ids?.trigger ?? `popover:${t.id}:trigger`,
+  getContentId: (t) => t.ids?.content ?? `popover:${t.id}:content`,
+  getPositionerId: (t) => t.ids?.positioner ?? `popover:${t.id}:popper`,
+  getArrowId: (t) => t.ids?.arrow ?? `popover:${t.id}:arrow`,
+  getTitleId: (t) => t.ids?.title ?? `popover:${t.id}:title`,
+  getDescriptionId: (t) => t.ids?.description ?? `popover:${t.id}:desc`,
+  getCloseTriggerId: (t) => t.ids?.closeTrigger ?? `popover:${t.id}:close`,
+  getAnchorEl: (t) => A.getById(t, A.getAnchorId(t)),
+  getTriggerEl: (t) => A.getById(t, A.getTriggerId(t)),
+  getContentEl: (t) => A.getById(t, A.getContentId(t)),
+  getPositionerEl: (t) => A.getById(t, A.getPositionerId(t)),
+  getTitleEl: (t) => A.getById(t, A.getTitleId(t)),
+  getDescriptionEl: (t) => A.getById(t, A.getDescriptionId(t)),
+  getFocusableEls: (t) => Ne(A.getContentEl(t)),
+  getFirstFocusableEl: (t) => A.getFocusableEls(t)[0]
+});
+function ar(t, e, n) {
+  const o = t.matches("open"), s = t.context.currentPlacement, i = t.context.currentPortalled, r = t.context.renderedElements, a = hi({
+    ...t.context.positioning,
+    placement: s
+  });
+  return {
+    portalled: i,
+    open: o,
+    setOpen(c) {
+      c !== o && e(c ? "OPEN" : "CLOSE");
+    },
+    reposition(c = {}) {
+      e({
+        type: "POSITIONING.SET",
+        options: c
+      });
+    },
+    getArrowProps() {
+      return n.element({
+        id: A.getArrowId(t.context),
+        ...K.arrow.attrs,
+        dir: t.context.dir,
+        style: a.arrow
+      });
+    },
+    getArrowTipProps() {
+      return n.element({
+        ...K.arrowTip.attrs,
+        dir: t.context.dir,
+        style: a.arrowTip
+      });
+    },
+    getAnchorProps() {
+      return n.element({
+        ...K.anchor.attrs,
+        dir: t.context.dir,
+        id: A.getAnchorId(t.context)
+      });
+    },
+    getTriggerProps() {
+      return n.button({
+        ...K.trigger.attrs,
+        dir: t.context.dir,
+        type: "button",
+        "data-placement": s,
+        id: A.getTriggerId(t.context),
+        "aria-haspopup": "dialog",
+        "aria-expanded": o,
+        "data-state": o ? "open" : "closed",
+        "aria-controls": A.getContentId(t.context),
+        onPointerDown(c) {
+          Jo() && c.currentTarget.focus();
+        },
+        onClick(c) {
+          c.defaultPrevented || e("TOGGLE");
+        },
+        onBlur(c) {
+          e({
+            type: "TRIGGER_BLUR",
+            target: c.relatedTarget
+          });
+        }
+      });
+    },
+    getIndicatorProps() {
+      return n.element({
+        ...K.indicator.attrs,
+        dir: t.context.dir,
+        "data-state": o ? "open" : "closed"
+      });
+    },
+    getPositionerProps() {
+      return n.element({
+        id: A.getPositionerId(t.context),
+        ...K.positioner.attrs,
+        dir: t.context.dir,
+        style: a.floating
+      });
+    },
+    getContentProps() {
+      return n.element({
+        ...K.content.attrs,
+        dir: t.context.dir,
+        id: A.getContentId(t.context),
+        tabIndex: -1,
+        role: "dialog",
+        hidden: !o,
+        "data-state": o ? "open" : "closed",
+        "data-expanded": Mo(o),
+        "aria-labelledby": r.title ? A.getTitleId(t.context) : void 0,
+        "aria-describedby": r.description ? A.getDescriptionId(t.context) : void 0,
+        "data-placement": s
+      });
+    },
+    getTitleProps() {
+      return n.element({
+        ...K.title.attrs,
+        id: A.getTitleId(t.context),
+        dir: t.context.dir
+      });
+    },
+    getDescriptionProps() {
+      return n.element({
+        ...K.description.attrs,
+        id: A.getDescriptionId(t.context),
+        dir: t.context.dir
+      });
+    },
+    getCloseTriggerProps() {
+      return n.button({
+        ...K.closeTrigger.attrs,
+        dir: t.context.dir,
+        id: A.getCloseTriggerId(t.context),
+        type: "button",
+        "aria-label": "close",
+        onClick(c) {
+          c.defaultPrevented || e("CLOSE");
+        }
+      });
+    }
+  };
+}
+function cr(t) {
+  const e = jt(t);
+  return or({
+    id: "popover",
+    initial: e.open ? "open" : "closed",
+    context: {
+      closeOnInteractOutside: !0,
+      closeOnEscape: !0,
+      autoFocus: !0,
+      modal: !1,
+      portalled: !0,
+      positioning: {
+        placement: "bottom",
+        ...e.positioning
+      },
+      currentPlacement: void 0,
+      ...e,
+      renderedElements: {
+        title: !0,
+        description: !0
+      }
+    },
+    computed: { currentPortalled: (n) => !!n.modal || !!n.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: (n) => !!n["open.controlled"] },
+    activities: {
+      trackPositioning(n) {
+        n.currentPlacement = n.positioning.placement;
+        const o = A.getAnchorEl(n) ?? A.getTriggerEl(n);
+        return Xe(o, () => A.getPositionerEl(n), {
+          ...n.positioning,
+          defer: !0,
+          onComplete(i) {
+            n.currentPlacement = i.placement;
+          }
+        });
+      },
+      trackDismissableElement(n, o, { send: s }) {
+        const i = () => A.getContentEl(n);
+        let r = !0;
+        return Ii(i, {
+          pointerBlocking: n.modal,
+          exclude: A.getTriggerEl(n),
+          defer: !0,
+          onEscapeKeyDown(a) {
+            n.onEscapeKeyDown?.(a), !n.closeOnEscape && a.preventDefault();
+          },
+          onInteractOutside(a) {
+            n.onInteractOutside?.(a), !a.defaultPrevented && (r = !(a.detail.focusable || a.detail.contextmenu), n.closeOnInteractOutside || a.preventDefault());
+          },
+          onPointerDownOutside: n.onPointerDownOutside,
+          onFocusOutside: n.onFocusOutside,
+          persistentElements: n.persistentElements,
+          onDismiss() {
+            s({
+              type: "CLOSE",
+              src: "interact-outside",
+              restoreFocus: r
+            });
+          }
+        });
+      },
+      proxyTabFocus(n) {
+        return n.modal || !n.portalled ? void 0 : hs(() => A.getContentEl(n), {
+          triggerElement: A.getTriggerEl(n),
+          defer: !0,
+          onFocus(s) {
+            s.focus({ preventScroll: !0 });
+          }
+        });
+      },
+      hideContentBelow(n) {
+        return n.modal ? wi(() => [A.getContentEl(n), A.getTriggerEl(n)], { defer: !0 }) : void 0;
+      },
+      preventScroll(n) {
+        if (n.modal)
+          return ji(A.getDoc(n));
+      },
+      trapFocus(n) {
+        return n.modal ? _i(() => A.getContentEl(n), { initialFocus: () => He({
+          root: A.getContentEl(n),
+          getInitialEl: n.initialFocusEl,
+          enabled: n.autoFocus
+        }) }) : void 0;
+      }
+    },
+    actions: {
+      reposition(n, o) {
+        const s = A.getAnchorEl(n) ?? A.getTriggerEl(n);
+        Xe(s, () => A.getPositionerEl(n), {
+          ...n.positioning,
+          ...o.options,
+          defer: !0,
+          listeners: !1,
+          onComplete(r) {
+            n.currentPlacement = r.placement;
+          }
+        });
+      },
+      checkRenderedElements(n) {
+        q(() => {
+          Object.assign(n.renderedElements, {
+            title: !!A.getTitleEl(n),
+            description: !!A.getDescriptionEl(n)
+          });
+        });
+      },
+      setInitialFocus(n) {
+        n.modal || q(() => {
+          He({
+            root: A.getContentEl(n),
+            getInitialEl: n.initialFocusEl,
+            enabled: n.autoFocus
+          })?.focus({ preventScroll: !0 });
+        });
+      },
+      setFinalFocus(n, o) {
+        const s = o.restoreFocus ?? o.previousEvent?.restoreFocus;
+        s != null && !s || q(() => {
+          A.getTriggerEl(n)?.focus({ preventScroll: !0 });
+        });
+      },
+      invokeOnOpen(n) {
+        n.onOpenChange?.({ open: !0 });
+      },
+      invokeOnClose(n) {
+        n.onOpenChange?.({ open: !1 });
+      },
+      toggleVisibility(n, o, { send: s }) {
+        s({
+          type: n.open ? "CONTROLLED.OPEN" : "CONTROLLED.CLOSE",
+          previousEvent: o
+        });
+      }
+    }
+  });
+}
+sr()([
+  "autoFocus",
+  "closeOnEscape",
+  "closeOnInteractOutside",
+  "dir",
+  "getRootNode",
+  "id",
+  "ids",
+  "initialFocusEl",
+  "modal",
+  "onEscapeKeyDown",
+  "onFocusOutside",
+  "onInteractOutside",
+  "onOpenChange",
+  "onPointerDownOutside",
+  "open.controlled",
+  "open",
+  "persistentElements",
+  "portalled",
+  "positioning"
+]);
+function lr(t, e) {
+  const { actions: n, context: o } = {}, s = zn(t.state), i = xe(t.state, () => {
+    s.value = vt(t.state);
+  });
+  return Kn(() => {
+    i?.();
+  }), Un(() => {
+    t.setOptions({ actions: n });
+  }), o && Lt(o, (r) => {
+    t.setContext(M(r));
+  }, { deep: !0 }), s;
+}
+function ur(t, e) {
+  const { state: n, context: o } = {}, s = typeof t == "function" ? t() : t;
+  return o && s.setContext(M(o)), s._created(), Hn(() => {
+    s.start(n), Gn(() => {
+      s.stop();
+    });
+  }), s;
+}
+function dr(t, e) {
+  const n = ur(t);
+  return [
+    lr(n),
+    n.send,
+    n
+  ];
+}
+function fr(t) {
+  return t.charAt(0).toUpperCase() + t.substr(1).toLowerCase();
+}
+const fn = {
+  htmlFor: "for",
+  className: "class",
+  onDoubleClick: "onDblclick",
+  onChange: "onInput",
+  onFocus: "onFocusin",
+  onBlur: "onFocusout",
+  defaultValue: "value",
+  defaultChecked: "checked"
+};
+function hr(t) {
+  return t in fn ? fn[t] : t.startsWith("on") ? `on${fr(t.substr(2))}` : t.toLowerCase();
+}
+const pr = ir((t) => {
+  const e = {};
+  for (const n in t) {
+    const o = t[n];
+    n === "children" ? typeof o == "string" && (e.innerHTML = o) : e[hr(n)] = t[n];
+  }
+  return e;
+}), gr = {
+  key: 0,
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "1em",
+  height: "1em",
+  viewBox: "0 0 16 16"
+}, mr = {
+  key: 1,
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "1em",
+  height: "1em",
+  viewBox: "0 0 16 16"
+}, yr = /* @__PURE__ */ pt({
+  name: "ComponentIcones",
+  __name: "ComponentsIcones",
+  props: {
+    expanded: { type: Boolean, default: !1 }
+  },
+  setup(t) {
+    const e = t;
+    return (n, o) => e.expanded ? (F(), D("svg", gr, o[0] || (o[0] = [
+      T("g", {
+        fill: "none",
+        "stroke-linecap": "round",
+        "stroke-linejoin": "round"
+      }, [
+        T("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"
+        }),
+        T("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)
+    ]))) : (F(), D("svg", mr, o[1] || (o[1] = [
+      T("g", {
+        fill: "none",
+        "stroke-linecap": "round",
+        "stroke-linejoin": "round"
+      }, [
+        T("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"
+        }),
+        T("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)
+    ])));
+  }
+}), br = {
+  key: 0,
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "1em",
+  height: "1em",
+  viewBox: "0 0 16 16"
+}, vr = {
+  key: 1,
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "1em",
+  height: "1em",
+  viewBox: "0 0 16 16"
+}, wr = /* @__PURE__ */ pt({
+  name: "FolderIcones",
+  __name: "FolderIcones",
+  props: {
+    expanded: { type: Boolean, default: !1 }
+  },
+  setup(t) {
+    const e = t;
+    return (n, o) => e.expanded ? (F(), D("svg", br, o[0] || (o[0] = [
+      T("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)
+    ]))) : (F(), D("svg", vr, o[1] || (o[1] = [
+      T("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)
+    ])));
+  }
+}), xr = {
+  key: 0,
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "1em",
+  height: "1em",
+  viewBox: "0 0 16 16"
+}, Er = {
+  key: 1,
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "1em",
+  height: "1em",
+  viewBox: "0 0 16 16"
+}, Or = /* @__PURE__ */ pt({
+  name: "ModleIcones",
+  __name: "ModuleIcones",
+  props: {
+    expanded: { type: Boolean, default: !1 }
+  },
+  setup(t) {
+    const e = t;
+    return (n, o) => e.expanded ? (F(), D("svg", xr, o[0] || (o[0] = [
+      T("g", {
+        fill: "none",
+        "stroke-linecap": "round",
+        "stroke-linejoin": "round"
+      }, [
+        T("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"
+        }),
+        T("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)
+    ]))) : (F(), D("svg", Er, o[1] || (o[1] = [
+      T("g", {
+        fill: "none",
+        "stroke-linecap": "round",
+        "stroke-linejoin": "round"
+      }, [
+        T("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"
+        }),
+        T("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)
+    ])));
+  }
+}), Ar = {
+  key: 0,
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "1em",
+  height: "1em",
+  viewBox: "0 0 16 16"
+}, kr = {
+  key: 1,
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "1em",
+  height: "1em",
+  viewBox: "0 0 16 16"
+}, Sr = /* @__PURE__ */ pt({
+  name: "PackagesIcones",
+  __name: "PackagesIcones",
+  props: {
+    expanded: { type: Boolean, default: !1 }
+  },
+  setup(t) {
+    const e = t;
+    return (n, o) => e.expanded ? (F(), D("svg", Ar, o[0] || (o[0] = [
+      T("g", {
+        fill: "none",
+        "stroke-linecap": "round",
+        "stroke-linejoin": "round"
+      }, [
+        T("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"
+        }),
+        T("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)
+    ]))) : (F(), D("svg", kr, o[1] || (o[1] = [
+      T("g", {
+        fill: "none",
+        "stroke-linecap": "round",
+        "stroke-linejoin": "round"
+      }, [
+        T("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"
+        }),
+        T("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)
+    ])));
+  }
+}), Tr = {
+  key: 0,
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "1em",
+  height: "1em",
+  viewBox: "0 0 16 16"
+}, Pr = {
+  key: 1,
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "1em",
+  height: "1em",
+  viewBox: "0 0 16 16"
+}, Cr = /* @__PURE__ */ pt({
+  name: "SrcIcones",
+  __name: "SrcIcones",
+  props: {
+    expanded: { type: Boolean, default: !1 }
+  },
+  setup(t) {
+    const e = t;
+    return (n, o) => e.expanded ? (F(), D("svg", Tr, o[0] || (o[0] = [
+      T("g", {
+        fill: "none",
+        "stroke-linecap": "round",
+        "stroke-linejoin": "round"
+      }, [
+        T("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"
+        }),
+        T("path", {
+          stroke: "#65bb87",
+          d: "m10.5 8.5l-3 3.5l3 3.5m2-7l3 3.5l-3 3.5"
+        })
+      ], -1)
+    ]))) : (F(), D("svg", Pr, o[1] || (o[1] = [
+      T("g", {
+        fill: "none",
+        "stroke-linecap": "round",
+        "stroke-linejoin": "round"
+      }, [
+        T("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"
+        }),
+        T("path", {
+          stroke: "#65bb87",
+          d: "m10.5 8.5l-3 3.5l3 3.5m2-7l3 3.5l-3 3.5"
+        })
+      ], -1)
+    ])));
+  }
+}), Nr = {
+  key: 0,
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "1em",
+  height: "1em",
+  viewBox: "0 0 16 16"
+}, Fr = {
+  key: 1,
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "1em",
+  height: "1em",
+  viewBox: "0 0 16 16"
+}, Ir = /* @__PURE__ */ pt({
+  name: "ViewIcones",
+  __name: "ViewIcones",
+  props: {
+    expanded: { type: Boolean, default: !1 }
+  },
+  setup(t) {
+    const e = t;
+    return (n, o) => e.expanded ? (F(), D("svg", Nr, o[0] || (o[0] = [
+      T("g", {
+        fill: "none",
+        "stroke-linecap": "round",
+        "stroke-linejoin": "round"
+      }, [
+        T("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"
+        }),
+        T("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)
+    ]))) : (F(), D("svg", Fr, o[1] || (o[1] = [
+      T("g", {
+        fill: "none",
+        "stroke-linecap": "round",
+        "stroke-linejoin": "round"
+      }, [
+        T("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"
+        }),
+        T("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)
+    ])));
+  }
+}), Dr = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "1em",
+  height: "1em",
+  viewBox: "0 0 16 16"
+}, Lr = /* @__PURE__ */ pt({
+  name: "VueIcones",
+  __name: "VueIcones",
+  setup(t) {
+    return (e, n) => (F(), D("svg", Dr, n[0] || (n[0] = [
+      T("g", {
+        fill: "none",
+        stroke: "#65bb87",
+        "stroke-linecap": "round",
+        "stroke-linejoin": "round"
+      }, [
+        T("path", { d: "M1 1.5h5.44L8 4.56L9.56 1.5H15l-6.99 13z" }),
+        T("path", { d: "M12.05 1.73L8 9.28L3.95 1.73" })
+      ], -1)
+    ])));
+  }
+}), Mr = { class: "mt-0" }, Rr = { class: "w-152 mb-2" }, _r = { 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" }, Br = {
+  key: 1,
+  class: "flex items-center justify-center h-[220px]"
+}, Gr = /* @__PURE__ */ pt({
+  name: "ComponentSelect",
+  __name: "ComponentSelect",
+  props: {
+    modelValue: {
+      default: ""
+    },
+    modelModifiers: {},
+    scope: {
+      default: ""
+    },
+    scopeModifiers: {}
+  },
+  emits: ["update:modelValue", "update:scope"],
+  setup(t) {
+    const e = no.PRESENTED_IMAGE_SIMPLE, n = oo(), o = Le(t, "modelValue"), s = Le(t, "scope"), i = Yn("searchInputRef"), [r, a] = dr(cr({
+      id: qn(),
+      initialFocusEl: () => i.value
+    })), c = oe(() => ar(r.value, a, pr)), l = se(!1), f = se(""), h = oe(() => o.value ? [`${s.value ? `module:${s.value}` : "local"}/${o.value}`] : []), u = se([]);
+    function d(y) {
+      return !y.includes("/");
+    }
+    function p(y) {
+      const k = y.indexOf("/");
+      return k === -1 ? y : y.slice(0, k);
+    }
+    function m(y) {
+      const k = y.split("/"), b = [];
+      let v = "";
+      for (let E = 0; E < Math.max(0, k.length - 1); E++) {
+        const S = k[E];
+        v = E === 0 ? S : `${v}/${S}`, b.push(v);
+      }
+      return b;
+    }
+    function w(y, k) {
+      const b = y || [], v = k?.node?.key, E = !!k?.expanded;
+      let S;
+      v && d(v) ? S = E ? v : void 0 : v ? S = p(v) : S = b.find(d);
+      const C = b.filter((N) => !d(String(N)) || String(N) === S);
+      u.value = C;
+    }
+    function g() {
+      const y = h.value[0];
+      if (!y)
+        return;
+      const k = m(y);
+      u.value = k;
+    }
+    Lt(h, () => {
+      g();
+    }, { immediate: !0 }), Lt(l, (y) => {
+      y && g();
+    }), Lt(l, (y) => {
+      y && g();
+    });
+    const x = oe(() => {
+      const y = f.value.trim();
+      return y ? n.filterRouteTree(y) : n.getRouteTreeData();
+    });
+    function O(y) {
+      const k = [], b = (v) => {
+        for (const E of v || [])
+          Array.isArray(E?.children) && E.children.length > 0 && (k.push(String(E.key)), b(E.children));
+      };
+      return b(y), k;
+    }
+    Lt(f, (y) => {
+      if (String(y || "").trim().length > 0) {
+        const b = x.value;
+        u.value = O(b);
+      } else
+        g();
+    });
+    function P(y, k) {
+      const b = k?.node, v = b?.dataRef ?? b;
+      v?.isLeaf && (o.value = v.value || "", s.value = v.scope || "", f.value = "", l.value = !1);
+    }
+    return (y, k) => {
+      const b = Vn, v = jn, E = Wn, S = $n;
+      return F(), D("div", Mr, [
+        T("div", Xn(Zn(M(c).getTriggerProps())), [
+          Pt(b, {
+            value: o.value,
+            "onUpdate:value": k[0] || (k[0] = (C) => o.value = C),
+            "addon-before": s.value || "本地",
+            placeholder: "请输入或选择组件路径（views下的路径）"
+          }, null, 8, ["value", "addon-before"])
+        ], 16),
+        (F(), J(Qn, { to: "body" }, [
+          M(c).open ? (F(), D("div", Me({ key: 0 }, M(c).getPositionerProps(), { class: "z-1050" }), [
+            T("div", Me(M(c).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" }), [
+              T("div", Rr, [
+                Pt(v, null, {
+                  default: ie(() => [
+                    Pt(b, {
+                      ref: "searchInputRef",
+                      value: M(f),
+                      "onUpdate:value": k[1] || (k[1] = (C) => Re(f) ? f.value = C : null),
+                      "allow-clear": "",
+                      size: "small",
+                      placeholder: "搜索组件或路径"
+                    }, null, 8, ["value"])
+                  ]),
+                  _: 1
+                })
+              ]),
+              M(x) && M(x).length ? (F(), J(E, {
+                key: 0,
+                "expanded-keys": M(u),
+                "onUpdate:expandedKeys": k[2] || (k[2] = (C) => Re(u) ? u.value = C : null),
+                class: "w-152 h-100 overflow-y-auto directory-tree-root",
+                "selected-keys": M(h),
+                "tree-data": M(x),
+                "show-icon": !0,
+                "show-line": !0,
+                virtual: !0,
+                "expand-action": "click",
+                onExpand: w,
+                onSelect: P
+              }, {
+                switcherIcon: ie(({ switcherCls: C }) => [
+                  Pt(M(eo), {
+                    class: to(C)
+                  }, null, 8, ["class"])
+                ]),
+                icon: ie(({ expanded: C, dataRef: N }) => [
+                  T("span", _r, [
+                    N?.root && !N?.module ? (F(), J(Sr, {
+                      key: 0,
+                      expanded: C
+                    }, null, 8, ["expanded"])) : N?.root && N?.module ? (F(), J(Or, {
+                      key: 1,
+                      expanded: C
+                    }, null, 8, ["expanded"])) : N?.isLeaf ? (F(), J(Lr, { key: 2 })) : ["components", "component"].includes(String(N?.title).toLowerCase()) ? (F(), J(yr, {
+                      key: 3,
+                      expanded: C
+                    }, null, 8, ["expanded"])) : ["views", "view", "pages", "page"].includes(String(N?.title).toLowerCase()) ? (F(), J(Ir, {
+                      key: 4,
+                      expanded: C
+                    }, null, 8, ["expanded"])) : ["src"].includes(String(N?.title).toLowerCase()) ? (F(), J(Cr, {
+                      key: 5,
+                      expanded: C
+                    }, null, 8, ["expanded"])) : (F(), J(wr, {
+                      key: 6,
+                      expanded: C
+                    }, null, 8, ["expanded"]))
+                  ])
+                ]),
+                _: 1
+              }, 8, ["expanded-keys", "selected-keys", "tree-data"])) : (F(), D("div", Br, [
+                Pt(S, {
+                  image: M(e),
+                  description: "没有找到匹配的组件"
+                }, null, 8, ["image"])
+              ]))
+            ], 16)
+          ], 16)) : Jn("", !0)
+        ]))
+      ]);
+    };
+  }
+});
+export {
+  Gr as _
+};