pangu-vchart-config 1.0.16

package/dist/es/Dvyb3F-s.js

@@ -0,0 +1,753 @@
+import { ref as Y, getCurrentInstance as _e, watch as fe, nextTick as he, computed as P, shallowRef as Ge, defineComponent as te, inject as De, h as Ue, createElementBlock as pe, openBlock as F, withModifiers as U, normalizeClass as X, unref as a, createElementVNode as Se, normalizeStyle as Te, createBlock as q, createCommentVNode as Ke, createVNode as Xe, withCtx as we, resolveDynamicComponent as qe, useSlots as Je, provide as xe, renderSlot as We, toDisplayString as Qe, useAttrs as Ze, mergeProps as et } from "vue";
+import { b as tt } from "./NT4UeedI.js";
+import { aj as Le, H as ye, M as $, N as nt, L as Z, r as Ie, a2 as ot, j as ve, t as Me, aW as at, $ as lt, G as st, ap as dt, a7 as ct, w as rt, _ as it } from "./CZX0y1vH.js";
+import { E as ut } from "./BNxNWAlX.js";
+import { F as ft } from "./BRTQiTTh.js";
+const Ce = Symbol(), ht = {
+  key: -1,
+  level: -1,
+  data: {}
+};
+var ee = /* @__PURE__ */ ((t) => (t.KEY = "id", t.LABEL = "label", t.CHILDREN = "children", t.DISABLED = "disabled", t.CLASS = "", t))(ee || {}), ke = /* @__PURE__ */ ((t) => (t.ADD = "add", t.DELETE = "delete", t))(ke || {});
+const Be = {
+  type: Number,
+  default: 26
+}, pt = ye({
+  data: {
+    type: $(Array),
+    default: () => Z([])
+  },
+  emptyText: {
+    type: String
+  },
+  height: {
+    type: Number,
+    default: 200
+  },
+  props: {
+    type: $(Object),
+    default: () => Z({
+      children: "children",
+      label: "label",
+      disabled: "disabled",
+      value: "id",
+      class: ""
+      /* CLASS */
+    })
+  },
+  highlightCurrent: {
+    type: Boolean,
+    default: !1
+  },
+  showCheckbox: {
+    type: Boolean,
+    default: !1
+  },
+  defaultCheckedKeys: {
+    type: $(Array),
+    default: () => Z([])
+  },
+  checkStrictly: {
+    type: Boolean,
+    default: !1
+  },
+  defaultExpandedKeys: {
+    type: $(Array),
+    default: () => Z([])
+  },
+  indent: {
+    type: Number,
+    default: 16
+  },
+  itemSize: Be,
+  icon: {
+    type: nt
+  },
+  expandOnClickNode: {
+    type: Boolean,
+    default: !0
+  },
+  checkOnClickNode: {
+    type: Boolean,
+    default: !1
+  },
+  currentNodeKey: {
+    type: $([String, Number])
+  },
+  accordion: {
+    type: Boolean,
+    default: !1
+  },
+  filterMethod: {
+    type: $(Function)
+  },
+  perfMode: {
+    type: Boolean,
+    default: !0
+  }
+}), kt = ye({
+  node: {
+    type: $(Object),
+    default: () => Z(ht)
+  },
+  expanded: {
+    type: Boolean,
+    default: !1
+  },
+  checked: {
+    type: Boolean,
+    default: !1
+  },
+  indeterminate: {
+    type: Boolean,
+    default: !1
+  },
+  showCheckbox: {
+    type: Boolean,
+    default: !1
+  },
+  disabled: {
+    type: Boolean,
+    default: !1
+  },
+  current: {
+    type: Boolean,
+    default: !1
+  },
+  hiddenExpandIcon: {
+    type: Boolean,
+    default: !1
+  },
+  itemSize: Be
+}), yt = ye({
+  node: {
+    type: $(Object),
+    required: !0
+  }
+}), He = "node-click", Oe = "node-drop", Ae = "node-expand", Pe = "node-collapse", ze = "current-change", Fe = "check", Re = "check-change", $e = "node-contextmenu", vt = {
+  [He]: (t, n, d) => t && n && d,
+  [Oe]: (t, n, d) => t && n && d,
+  [Ae]: (t, n) => t && n,
+  [Pe]: (t, n) => t && n,
+  [ze]: (t, n) => t && n,
+  [Fe]: (t, n) => t && n,
+  [Re]: (t, n) => t && Le(n),
+  [$e]: (t, n, d) => t && n && d
+}, Ct = {
+  click: (t, n) => !!(t && n),
+  drop: (t, n) => !!(t && n),
+  toggle: (t) => !!t,
+  check: (t, n) => t && Le(n)
+};
+function Nt(t, n) {
+  const d = Y(/* @__PURE__ */ new Set()), l = Y(/* @__PURE__ */ new Set()), { emit: r } = _e();
+  fe([() => n.value, () => t.defaultCheckedKeys], () => he(() => {
+    I(t.defaultCheckedKeys);
+  }), {
+    immediate: !0
+  });
+  const b = () => {
+    if (!n.value || !t.showCheckbox || t.checkStrictly)
+      return;
+    const { levelTreeNodeMap: s, maxLevel: i } = n.value, p = d.value, u = /* @__PURE__ */ new Set();
+    for (let y = i - 1; y >= 1; --y) {
+      const g = s.get(y);
+      g && g.forEach((K) => {
+        const O = K.children;
+        if (O) {
+          let D = !0, V = !1;
+          for (const J of O) {
+            const j = J.key;
+            if (p.has(j))
+              V = !0;
+            else if (u.has(j)) {
+              D = !1, V = !0;
+              break;
+            } else
+              D = !1;
+          }
+          D ? p.add(K.key) : V ? (u.add(K.key), p.delete(K.key)) : (p.delete(K.key), u.delete(K.key));
+        }
+      });
+    }
+    l.value = u;
+  }, T = (s) => d.value.has(s.key), v = (s) => l.value.has(s.key), C = (s, i, p = !0) => {
+    const u = d.value, y = (g, K) => {
+      u[K ? ke.ADD : ke.DELETE](g.key);
+      const O = g.children;
+      !t.checkStrictly && O && O.forEach((D) => {
+        D.disabled || y(D, K);
+      });
+    };
+    y(s, i), b(), p && w(s, i);
+  }, w = (s, i) => {
+    const { checkedNodes: p, checkedKeys: u } = k(), { halfCheckedNodes: y, halfCheckedKeys: g } = f();
+    r(Fe, s.data, {
+      checkedKeys: u,
+      checkedNodes: p,
+      halfCheckedKeys: g,
+      halfCheckedNodes: y
+    }), r(Re, s.data, i);
+  };
+  function H(s = !1) {
+    return k(s).checkedKeys;
+  }
+  function _(s = !1) {
+    return k(s).checkedNodes;
+  }
+  function L() {
+    return f().halfCheckedKeys;
+  }
+  function o() {
+    return f().halfCheckedNodes;
+  }
+  function k(s = !1) {
+    const i = [], p = [];
+    if (n?.value && t.showCheckbox) {
+      const { treeNodeMap: u } = n.value;
+      d.value.forEach((y) => {
+        const g = u.get(y);
+        g && (!s || s && g.isLeaf) && (p.push(y), i.push(g.data));
+      });
+    }
+    return {
+      checkedKeys: p,
+      checkedNodes: i
+    };
+  }
+  function f() {
+    const s = [], i = [];
+    if (n?.value && t.showCheckbox) {
+      const { treeNodeMap: p } = n.value;
+      l.value.forEach((u) => {
+        const y = p.get(u);
+        y && (i.push(u), s.push(y.data));
+      });
+    }
+    return {
+      halfCheckedNodes: s,
+      halfCheckedKeys: i
+    };
+  }
+  function N(s) {
+    d.value.clear(), l.value.clear(), he(() => {
+      I(s);
+    });
+  }
+  function h(s, i) {
+    if (n?.value && t.showCheckbox) {
+      const p = n.value.treeNodeMap.get(s);
+      p && C(p, i, !1);
+    }
+  }
+  function I(s) {
+    if (n?.value) {
+      const { treeNodeMap: i } = n.value;
+      if (t.showCheckbox && i && s)
+        for (const p of s) {
+          const u = i.get(p);
+          u && !T(u) && C(u, !0, !1);
+        }
+    }
+  }
+  return {
+    updateCheckedKeys: b,
+    toggleCheckbox: C,
+    isChecked: T,
+    isIndeterminate: v,
+    getCheckedKeys: H,
+    getCheckedNodes: _,
+    getHalfCheckedKeys: L,
+    getHalfCheckedNodes: o,
+    setChecked: h,
+    setCheckedKeys: N
+  };
+}
+function gt(t, n) {
+  const d = Y(/* @__PURE__ */ new Set([])), l = Y(/* @__PURE__ */ new Set([])), r = P(() => Ie(t.filterMethod));
+  function b(v) {
+    var C;
+    if (!r.value)
+      return;
+    const w = /* @__PURE__ */ new Set(), H = l.value, _ = d.value, L = [], o = ((C = n.value) == null ? void 0 : C.treeNodes) || [], k = t.filterMethod;
+    _.clear();
+    function f(N) {
+      N.forEach((h) => {
+        L.push(h), k?.(v, h.data) ? L.forEach((s) => {
+          w.add(s.key);
+        }) : h.isLeaf && _.add(h.key);
+        const I = h.children;
+        if (I && f(I), !h.isLeaf) {
+          if (!w.has(h.key))
+            _.add(h.key);
+          else if (I) {
+            let s = !0;
+            for (const i of I)
+              if (!_.has(i.key)) {
+                s = !1;
+                break;
+              }
+            s ? H.add(h.key) : H.delete(h.key);
+          }
+        }
+        L.pop();
+      });
+    }
+    return f(o), w;
+  }
+  function T(v) {
+    return l.value.has(v.key);
+  }
+  return {
+    hiddenExpandIconKeySet: l,
+    hiddenNodeKeySet: d,
+    doFilter: b,
+    isForceHiddenExpandIcon: T
+  };
+}
+function mt(t, n) {
+  const d = Y(new Set(t.defaultExpandedKeys)), l = Y(), r = Ge(), b = Y();
+  fe(() => t.currentNodeKey, (e) => {
+    l.value = e;
+  }, {
+    immediate: !0
+  }), fe(() => t.data, (e) => {
+    Ne(e);
+  }, {
+    immediate: !0
+  });
+  const {
+    isIndeterminate: T,
+    isChecked: v,
+    toggleCheckbox: C,
+    getCheckedKeys: w,
+    getCheckedNodes: H,
+    getHalfCheckedKeys: _,
+    getHalfCheckedNodes: L,
+    setChecked: o,
+    setCheckedKeys: k
+  } = Nt(t, r), { doFilter: f, hiddenNodeKeySet: N, isForceHiddenExpandIcon: h } = gt(t, r), I = P(() => {
+    var e;
+    return ((e = t.props) == null ? void 0 : e.value) || ee.KEY;
+  }), s = P(() => {
+    var e;
+    return ((e = t.props) == null ? void 0 : e.children) || ee.CHILDREN;
+  }), i = P(() => {
+    var e;
+    return ((e = t.props) == null ? void 0 : e.disabled) || ee.DISABLED;
+  }), p = P(() => {
+    var e;
+    return ((e = t.props) == null ? void 0 : e.label) || ee.LABEL;
+  }), u = P(() => {
+    var e;
+    const c = d.value, m = N.value, M = [], E = ((e = r.value) == null ? void 0 : e.treeNodes) || [], G = [];
+    for (let S = E.length - 1; S >= 0; --S)
+      G.push(E[S]);
+    for (; G.length; ) {
+      const S = G.pop();
+      if (!m.has(S.key) && (M.push(S), S.children && c.has(S.key)))
+        for (let B = S.children.length - 1; B >= 0; --B)
+          G.push(S.children[B]);
+    }
+    return M;
+  }), y = P(() => u.value.length > 0);
+  function g(e) {
+    const c = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map();
+    let M = 1;
+    function E(S, B = 1, Ye = void 0) {
+      var me;
+      const be = [];
+      for (const W of S) {
+        const Ee = D(W), z = {
+          level: B,
+          key: Ee,
+          data: W
+        };
+        z.label = J(W), z.parent = Ye;
+        const Q = O(W);
+        z.disabled = V(W), z.isLeaf = !Q || Q.length === 0, Q && Q.length && (z.children = E(Q, B + 1, z)), be.push(z), c.set(Ee, z), m.has(B) || m.set(B, []), (me = m.get(B)) == null || me.push(z);
+      }
+      return B > M && (M = B), be;
+    }
+    const G = E(e);
+    return {
+      treeNodeMap: c,
+      levelTreeNodeMap: m,
+      maxLevel: M,
+      treeNodes: G
+    };
+  }
+  function K(e) {
+    const c = f(e);
+    c && (d.value = c);
+  }
+  function O(e) {
+    return e[s.value];
+  }
+  function D(e) {
+    return e ? e[I.value] : "";
+  }
+  function V(e) {
+    return e[i.value];
+  }
+  function J(e) {
+    return e[p.value];
+  }
+  function j(e) {
+    d.value.has(e.key) ? oe(e) : ne(e);
+  }
+  function ae(e) {
+    const c = /* @__PURE__ */ new Set(), m = r.value.treeNodeMap;
+    e.forEach((M) => {
+      let E = m.get(M);
+      for (; E && !c.has(E.key); )
+        c.add(E.key), E = E.parent;
+    }), d.value = c;
+  }
+  function le(e, c) {
+    n(He, e.data, e, c), de(e), t.expandOnClickNode && j(e), t.showCheckbox && t.checkOnClickNode && !e.disabled && C(e, !v(e), !0);
+  }
+  function se(e, c) {
+    n(Oe, e.data, e, c);
+  }
+  function de(e) {
+    ie(e) || (l.value = e.key, n(ze, e.data, e));
+  }
+  function ce(e, c) {
+    C(e, c);
+  }
+  function ne(e) {
+    const c = d.value;
+    if (r.value && t.accordion) {
+      const { treeNodeMap: m } = r.value;
+      c.forEach((M) => {
+        const E = m.get(M);
+        e && e.level === E?.level && c.delete(M);
+      });
+    }
+    c.add(e.key), n(Ae, e.data, e);
+  }
+  function oe(e) {
+    d.value.delete(e.key), n(Pe, e.data, e);
+  }
+  function re(e) {
+    return d.value.has(e.key);
+  }
+  function R(e) {
+    return !!e.disabled;
+  }
+  function ie(e) {
+    const c = l.value;
+    return c !== void 0 && c === e.key;
+  }
+  function x() {
+    var e, c;
+    if (l.value)
+      return (c = (e = r.value) == null ? void 0 : e.treeNodeMap.get(l.value)) == null ? void 0 : c.data;
+  }
+  function A() {
+    return l.value;
+  }
+  function ue(e) {
+    l.value = e;
+  }
+  function Ne(e) {
+    he(() => r.value = g(e));
+  }
+  function ge(e) {
+    var c;
+    const m = ot(e) ? D(e) : e;
+    return (c = r.value) == null ? void 0 : c.treeNodeMap.get(m);
+  }
+  function Ve(e, c = "auto") {
+    const m = ge(e);
+    m && b.value && b.value.scrollToItem(u.value.indexOf(m), c);
+  }
+  function je(e) {
+    var c;
+    (c = b.value) == null || c.scrollTo(e);
+  }
+  return {
+    tree: r,
+    flattenTree: u,
+    isNotEmpty: y,
+    listRef: b,
+    getKey: D,
+    getChildren: O,
+    toggleExpand: j,
+    toggleCheckbox: C,
+    isExpanded: re,
+    isChecked: v,
+    isIndeterminate: T,
+    isDisabled: R,
+    isCurrent: ie,
+    isForceHiddenExpandIcon: h,
+    handleNodeClick: le,
+    handleNodeDrop: se,
+    handleNodeCheck: ce,
+    getCurrentNode: x,
+    getCurrentKey: A,
+    setCurrentKey: ue,
+    getCheckedKeys: w,
+    getCheckedNodes: H,
+    getHalfCheckedKeys: _,
+    getHalfCheckedNodes: L,
+    setChecked: o,
+    setCheckedKeys: k,
+    filter: K,
+    setData: Ne,
+    getNode: ge,
+    expandNode: ne,
+    collapseNode: oe,
+    setExpandedKeys: ae,
+    scrollToNode: Ve,
+    scrollTo: je
+  };
+}
+var bt = te({
+  name: "ElTreeNodeContent",
+  props: yt,
+  setup(t) {
+    const n = De(Ce), d = ve("tree");
+    return () => {
+      const l = t.node, { data: r } = l;
+      return n?.ctx.slots.default ? n.ctx.slots.default({ node: l, data: r }) : Ue("span", { class: d.be("node", "label") }, [l?.label]);
+    };
+  }
+});
+const Et = te({
+  name: "ElTreeNode"
+}), Kt = /* @__PURE__ */ te({
+  ...Et,
+  props: kt,
+  emits: Ct,
+  setup(t, { emit: n }) {
+    const d = t, l = De(Ce), r = ve("tree"), b = P(() => {
+      var o;
+      return (o = l?.props.indent) != null ? o : 16;
+    }), T = P(() => {
+      var o;
+      return (o = l?.props.icon) != null ? o : at;
+    }), v = (o) => {
+      const k = l?.props.props.class;
+      if (!k)
+        return {};
+      let f;
+      if (Ie(k)) {
+        const { data: N } = o;
+        f = k(N, o);
+      } else
+        f = k;
+      return st(f) ? { [f]: !0 } : f;
+    }, C = (o) => {
+      n("click", d.node, o);
+    }, w = (o) => {
+      n("drop", d.node, o);
+    }, H = () => {
+      n("toggle", d.node);
+    }, _ = (o) => {
+      n("check", d.node, o);
+    }, L = (o) => {
+      var k, f, N, h;
+      (N = (f = (k = l?.instance) == null ? void 0 : k.vnode) == null ? void 0 : f.props) != null && N.onNodeContextmenu && (o.stopPropagation(), o.preventDefault()), l?.ctx.emit($e, o, (h = d.node) == null ? void 0 : h.data, d.node);
+    };
+    return (o, k) => {
+      var f, N, h;
+      return F(), pe("div", {
+        ref: "node$",
+        class: X([
+          a(r).b("node"),
+          a(r).is("expanded", o.expanded),
+          a(r).is("current", o.current),
+          a(r).is("focusable", !o.disabled),
+          a(r).is("checked", !o.disabled && o.checked),
+          v(o.node)
+        ]),
+        role: "treeitem",
+        tabindex: "-1",
+        "aria-expanded": o.expanded,
+        "aria-disabled": o.disabled,
+        "aria-checked": o.checked,
+        "data-key": (f = o.node) == null ? void 0 : f.key,
+        onClick: U(C, ["stop"]),
+        onContextmenu: L,
+        onDragover: U(() => {
+        }, ["prevent"]),
+        onDragenter: U(() => {
+        }, ["prevent"]),
+        onDrop: U(w, ["stop"])
+      }, [
+        Se("div", {
+          class: X(a(r).be("node", "content")),
+          style: Te({
+            paddingLeft: `${(o.node.level - 1) * a(b)}px`,
+            height: o.itemSize + "px"
+          })
+        }, [
+          a(T) ? (F(), q(a(lt), {
+            key: 0,
+            class: X([
+              a(r).is("leaf", !!((N = o.node) != null && N.isLeaf)),
+              a(r).is("hidden", o.hiddenExpandIcon),
+              {
+                expanded: !((h = o.node) != null && h.isLeaf) && o.expanded
+              },
+              a(r).be("node", "expand-icon")
+            ]),
+            onClick: U(H, ["stop"])
+          }, {
+            default: we(() => [
+              (F(), q(qe(a(T))))
+            ]),
+            _: 1
+          }, 8, ["class", "onClick"])) : Ke("v-if", !0),
+          o.showCheckbox ? (F(), q(a(ut), {
+            key: 1,
+            "model-value": o.checked,
+            indeterminate: o.indeterminate,
+            disabled: o.disabled,
+            onChange: _,
+            onClick: U(() => {
+            }, ["stop"])
+          }, null, 8, ["model-value", "indeterminate", "disabled", "onClick"])) : Ke("v-if", !0),
+          Xe(a(bt), { node: o.node }, null, 8, ["node"])
+        ], 6)
+      ], 42, ["aria-expanded", "aria-disabled", "aria-checked", "data-key", "onClick", "onDragover", "onDragenter", "onDrop"]);
+    };
+  }
+});
+var xt = /* @__PURE__ */ Me(Kt, [["__file", "tree-node.vue"]]);
+const _t = te({
+  name: "ElTreeV2"
+}), Dt = /* @__PURE__ */ te({
+  ..._t,
+  props: pt,
+  emits: vt,
+  setup(t, { expose: n, emit: d }) {
+    const l = t, r = Je(), b = P(() => l.itemSize);
+    xe(Ce, {
+      ctx: {
+        emit: d,
+        slots: r
+      },
+      props: l,
+      instance: _e()
+    }), xe(dt, void 0);
+    const { t: T } = ct(), v = ve("tree"), {
+      flattenTree: C,
+      isNotEmpty: w,
+      listRef: H,
+      toggleExpand: _,
+      isExpanded: L,
+      isIndeterminate: o,
+      isChecked: k,
+      isDisabled: f,
+      isCurrent: N,
+      isForceHiddenExpandIcon: h,
+      handleNodeClick: I,
+      handleNodeDrop: s,
+      handleNodeCheck: i,
+      toggleCheckbox: p,
+      getCurrentNode: u,
+      getCurrentKey: y,
+      setCurrentKey: g,
+      getCheckedKeys: K,
+      getCheckedNodes: O,
+      getHalfCheckedKeys: D,
+      getHalfCheckedNodes: V,
+      setChecked: J,
+      setCheckedKeys: j,
+      filter: ae,
+      setData: le,
+      getNode: se,
+      expandNode: de,
+      collapseNode: ce,
+      setExpandedKeys: ne,
+      scrollToNode: oe,
+      scrollTo: re
+    } = mt(l, d);
+    return n({
+      toggleCheckbox: p,
+      getCurrentNode: u,
+      getCurrentKey: y,
+      setCurrentKey: g,
+      getCheckedKeys: K,
+      getCheckedNodes: O,
+      getHalfCheckedKeys: D,
+      getHalfCheckedNodes: V,
+      setChecked: J,
+      setCheckedKeys: j,
+      filter: ae,
+      setData: le,
+      getNode: se,
+      expandNode: de,
+      collapseNode: ce,
+      setExpandedKeys: ne,
+      scrollToNode: oe,
+      scrollTo: re
+    }), (R, ie) => (F(), pe("div", {
+      class: X([a(v).b(), { [a(v).m("highlight-current")]: R.highlightCurrent }]),
+      role: "tree"
+    }, [
+      a(w) ? (F(), q(a(ft), {
+        key: 0,
+        ref_key: "listRef",
+        ref: H,
+        "class-name": a(v).b("virtual-list"),
+        data: a(C),
+        total: a(C).length,
+        height: R.height,
+        "item-size": a(b),
+        "perf-mode": R.perfMode
+      }, {
+        default: we(({ data: x, index: A, style: ue }) => [
+          (F(), q(xt, {
+            key: x[A].key,
+            style: Te(ue),
+            node: x[A],
+            expanded: a(L)(x[A]),
+            "show-checkbox": R.showCheckbox,
+            checked: a(k)(x[A]),
+            indeterminate: a(o)(x[A]),
+            "item-size": a(b),
+            disabled: a(f)(x[A]),
+            current: a(N)(x[A]),
+            "hidden-expand-icon": a(h)(x[A]),
+            onClick: a(I),
+            onToggle: a(_),
+            onCheck: a(i),
+            onDrop: a(s)
+          }, null, 8, ["style", "node", "expanded", "show-checkbox", "checked", "indeterminate", "item-size", "disabled", "current", "hidden-expand-icon", "onClick", "onToggle", "onCheck", "onDrop"]))
+        ]),
+        _: 1
+      }, 8, ["class-name", "data", "total", "height", "item-size", "perf-mode"])) : (F(), pe("div", {
+        key: 1,
+        class: X(a(v).e("empty-block"))
+      }, [
+        We(R.$slots, "empty", {}, () => {
+          var x;
+          return [
+            Se("span", {
+              class: X(a(v).e("empty-text"))
+            }, Qe((x = R.emptyText) != null ? x : a(T)("el.tree.emptyText")), 3)
+          ];
+        })
+      ], 2))
+    ], 2));
+  }
+});
+var St = /* @__PURE__ */ Me(Dt, [["__file", "tree.vue"]]);
+const Tt = rt(St), wt = {
+  __name: "index",
+  props: {
+    ...tt
+  },
+  setup(t) {
+    const n = Ze();
+    return (d, l) => (F(), q(a(Tt), et({ class: d.className }, a(n)), null, 16, ["class"]));
+  }
+}, Lt = /* @__PURE__ */ it(wt, [["__scopeId", "data-v-79344e49"]]), At = Lt;
+export {
+  At as VTreeV2,
+  Lt as default
+};