pangu-vchart-config 1.0.16

package/dist/es/CRrwo5aH.js

@@ -0,0 +1,1095 @@
+import { reactive as Se, defineComponent as ie, inject as P, renderSlot as Ne, h as he, provide as W, ref as D, resolveComponent as L, withDirectives as te, createElementBlock as F, openBlock as E, withModifiers as B, normalizeClass as S, createElementVNode as ne, createVNode as Z, normalizeStyle as xe, createBlock as z, createCommentVNode as H, withCtx as _, resolveDynamicComponent as Te, Fragment as ge, renderList as ye, vShow as oe, getCurrentInstance as ke, watch as w, nextTick as ue, shallowRef as fe, onMounted as Ae, onUpdated as Ie, toDisplayString as Be, computed as Le } from "vue";
+import { s as Oe } from "./UNVJeAU8.js";
+import { aT as de, aj as $e, l as Q, a9 as re, r as X, G as Ce, a2 as Me, ak as ze, t as le, j as Y, aU as ee, aV as Fe, aK as qe, $ as Pe, aW as je, a4 as Re, ad as I, N as He, a7 as Ue, ap as We, w as Ye } from "./CZX0y1vH.js";
+import { E as Ge } from "./CCUPeOul.js";
+import { E as Je } from "./BNxNWAlX.js";
+const q = "$treeNodeId", pe = function(t, e) {
+  !e || e[q] || Object.defineProperty(e, q, {
+    value: t.id,
+    enumerable: !1,
+    configurable: !1,
+    writable: !1
+  });
+}, ce = function(t, e) {
+  return t ? e[t] : e[q];
+}, se = (t, e, n) => {
+  const d = t.value.currentNode;
+  n();
+  const o = t.value.currentNode;
+  d !== o && e("current-change", o ? o.data : null, o);
+}, ae = (t) => {
+  let e = !0, n = !0, d = !0;
+  for (let o = 0, r = t.length; o < r; o++) {
+    const s = t[o];
+    (s.checked !== !0 || s.indeterminate) && (e = !1, s.disabled || (d = !1)), (s.checked !== !1 || s.indeterminate) && (n = !1);
+  }
+  return { all: e, none: n, allWithoutDisable: d, half: !e && !n };
+}, U = function(t) {
+  if (t.childNodes.length === 0 || t.loading)
+    return;
+  const { all: e, none: n, half: d } = ae(t.childNodes);
+  e ? (t.checked = !0, t.indeterminate = !1) : d ? (t.checked = !1, t.indeterminate = !0) : n && (t.checked = !1, t.indeterminate = !1);
+  const o = t.parent;
+  !o || o.level === 0 || t.store.checkStrictly || U(o);
+}, V = function(t, e) {
+  const n = t.store.props, d = t.data || {}, o = n[e];
+  if (X(o))
+    return o(d, t);
+  if (Ce(o))
+    return d[o];
+  if (re(o)) {
+    const r = d[e];
+    return r === void 0 ? "" : r;
+  }
+};
+let Qe = 0;
+class O {
+  constructor(e) {
+    this.id = Qe++, this.text = null, this.checked = !1, this.indeterminate = !1, this.data = null, this.expanded = !1, this.parent = null, this.visible = !0, this.isCurrent = !1, this.canFocus = !1;
+    for (const n in e)
+      de(e, n) && (this[n] = e[n]);
+    this.level = 0, this.loaded = !1, this.childNodes = [], this.loading = !1, this.parent && (this.level = this.parent.level + 1);
+  }
+  initialize() {
+    const e = this.store;
+    if (!e)
+      throw new Error("[Node]store is required!");
+    e.registerNode(this);
+    const n = e.props;
+    if (n && typeof n.isLeaf < "u") {
+      const r = V(this, "isLeaf");
+      $e(r) && (this.isLeafByUser = r);
+    }
+    if (e.lazy !== !0 && this.data ? (this.setData(this.data), e.defaultExpandAll && (this.expanded = !0, this.canFocus = !0)) : this.level > 0 && e.lazy && e.defaultExpandAll && !this.isLeafByUser && this.expand(), Q(this.data) || pe(this, this.data), !this.data)
+      return;
+    const d = e.defaultExpandedKeys, o = e.key;
+    o && d && d.includes(this.key) && this.expand(null, e.autoExpandParent), o && e.currentNodeKey !== void 0 && this.key === e.currentNodeKey && (e.currentNode = this, e.currentNode.isCurrent = !0), e.lazy && e._initDefaultCheckedNode(this), this.updateLeafState(), this.parent && (this.level === 1 || this.parent.expanded === !0) && (this.canFocus = !0);
+  }
+  setData(e) {
+    Q(e) || pe(this, e), this.data = e, this.childNodes = [];
+    let n;
+    this.level === 0 && Q(this.data) ? n = this.data : n = V(this, "children") || [];
+    for (let d = 0, o = n.length; d < o; d++)
+      this.insertChild({ data: n[d] });
+  }
+  get label() {
+    return V(this, "label");
+  }
+  get key() {
+    const e = this.store.key;
+    return this.data ? this.data[e] : null;
+  }
+  get disabled() {
+    return V(this, "disabled");
+  }
+  get nextSibling() {
+    const e = this.parent;
+    if (e) {
+      const n = e.childNodes.indexOf(this);
+      if (n > -1)
+        return e.childNodes[n + 1];
+    }
+    return null;
+  }
+  get previousSibling() {
+    const e = this.parent;
+    if (e) {
+      const n = e.childNodes.indexOf(this);
+      if (n > -1)
+        return n > 0 ? e.childNodes[n - 1] : null;
+    }
+    return null;
+  }
+  contains(e, n = !0) {
+    return (this.childNodes || []).some((d) => d === e || n && d.contains(e));
+  }
+  remove() {
+    const e = this.parent;
+    e && e.removeChild(this);
+  }
+  insertChild(e, n, d) {
+    if (!e)
+      throw new Error("InsertChild error: child is required.");
+    if (!(e instanceof O)) {
+      if (!d) {
+        const o = this.getChildren(!0);
+        o.includes(e.data) || (re(n) || n < 0 ? o.push(e.data) : o.splice(n, 0, e.data));
+      }
+      Object.assign(e, {
+        parent: this,
+        store: this.store
+      }), e = Se(new O(e)), e instanceof O && e.initialize();
+    }
+    e.level = this.level + 1, re(n) || n < 0 ? this.childNodes.push(e) : this.childNodes.splice(n, 0, e), this.updateLeafState();
+  }
+  insertBefore(e, n) {
+    let d;
+    n && (d = this.childNodes.indexOf(n)), this.insertChild(e, d);
+  }
+  insertAfter(e, n) {
+    let d;
+    n && (d = this.childNodes.indexOf(n), d !== -1 && (d += 1)), this.insertChild(e, d);
+  }
+  removeChild(e) {
+    const n = this.getChildren() || [], d = n.indexOf(e.data);
+    d > -1 && n.splice(d, 1);
+    const o = this.childNodes.indexOf(e);
+    o > -1 && (this.store && this.store.deregisterNode(e), e.parent = null, this.childNodes.splice(o, 1)), this.updateLeafState();
+  }
+  removeChildByData(e) {
+    let n = null;
+    for (let d = 0; d < this.childNodes.length; d++)
+      if (this.childNodes[d].data === e) {
+        n = this.childNodes[d];
+        break;
+      }
+    n && this.removeChild(n);
+  }
+  expand(e, n) {
+    const d = () => {
+      if (n) {
+        let o = this.parent;
+        for (; o.level > 0; )
+          o.expanded = !0, o = o.parent;
+      }
+      this.expanded = !0, e && e(), this.childNodes.forEach((o) => {
+        o.canFocus = !0;
+      });
+    };
+    this.shouldLoadData() ? this.loadData((o) => {
+      Q(o) && (this.checked ? this.setChecked(!0, !0) : this.store.checkStrictly || U(this), d());
+    }) : d();
+  }
+  doCreateChildren(e, n = {}) {
+    e.forEach((d) => {
+      this.insertChild(Object.assign({ data: d }, n), void 0, !0);
+    });
+  }
+  collapse() {
+    this.expanded = !1, this.childNodes.forEach((e) => {
+      e.canFocus = !1;
+    });
+  }
+  shouldLoadData() {
+    return this.store.lazy === !0 && this.store.load && !this.loaded;
+  }
+  updateLeafState() {
+    if (this.store.lazy === !0 && this.loaded !== !0 && typeof this.isLeafByUser < "u") {
+      this.isLeaf = this.isLeafByUser;
+      return;
+    }
+    const e = this.childNodes;
+    if (!this.store.lazy || this.store.lazy === !0 && this.loaded === !0) {
+      this.isLeaf = !e || e.length === 0;
+      return;
+    }
+    this.isLeaf = !1;
+  }
+  setChecked(e, n, d, o) {
+    if (this.indeterminate = e === "half", this.checked = e === !0, this.store.checkStrictly)
+      return;
+    if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
+      const { all: s, allWithoutDisable: i } = ae(this.childNodes);
+      !this.isLeaf && !s && i && (this.checked = !1, e = !1);
+      const f = () => {
+        if (n) {
+          const g = this.childNodes;
+          for (let h = 0, p = g.length; h < p; h++) {
+            const y = g[h];
+            o = o || e !== !1;
+            const C = y.disabled ? y.checked : o;
+            y.setChecked(C, n, !0, o);
+          }
+          const { half: l, all: c } = ae(g);
+          c || (this.checked = c, this.indeterminate = l);
+        }
+      };
+      if (this.shouldLoadData()) {
+        this.loadData(() => {
+          f(), U(this);
+        }, {
+          checked: e !== !1
+        });
+        return;
+      } else
+        f();
+    }
+    const r = this.parent;
+    !r || r.level === 0 || d || U(r);
+  }
+  getChildren(e = !1) {
+    if (this.level === 0)
+      return this.data;
+    const n = this.data;
+    if (!n)
+      return null;
+    const d = this.store.props;
+    let o = "children";
+    return d && (o = d.children || "children"), n[o] === void 0 && (n[o] = null), e && !n[o] && (n[o] = []), n[o];
+  }
+  updateChildren() {
+    const e = this.getChildren() || [], n = this.childNodes.map((r) => r.data), d = {}, o = [];
+    e.forEach((r, s) => {
+      const i = r[q];
+      !!i && n.findIndex((g) => g[q] === i) >= 0 ? d[i] = { index: s, data: r } : o.push({ index: s, data: r });
+    }), this.store.lazy || n.forEach((r) => {
+      d[r[q]] || this.removeChildByData(r);
+    }), o.forEach(({ index: r, data: s }) => {
+      this.insertChild({ data: s }, r);
+    }), this.updateLeafState();
+  }
+  loadData(e, n = {}) {
+    if (this.store.lazy === !0 && this.store.load && !this.loaded && (!this.loading || Object.keys(n).length)) {
+      this.loading = !0;
+      const d = (r) => {
+        this.childNodes = [], this.doCreateChildren(r, n), this.loaded = !0, this.loading = !1, this.updateLeafState(), e && e.call(this, r);
+      }, o = () => {
+        this.loading = !1;
+      };
+      this.store.load(this, d, o);
+    } else
+      e && e.call(this);
+  }
+  eachNode(e) {
+    const n = [this];
+    for (; n.length; ) {
+      const d = n.shift();
+      n.unshift(...d.childNodes), e(d);
+    }
+  }
+  reInitChecked() {
+    this.store.checkStrictly || U(this);
+  }
+}
+class Ve {
+  constructor(e) {
+    this.currentNode = null, this.currentNodeKey = null;
+    for (const n in e)
+      de(e, n) && (this[n] = e[n]);
+    this.nodesMap = {};
+  }
+  initialize() {
+    if (this.root = new O({
+      data: this.data,
+      store: this
+    }), this.root.initialize(), this.lazy && this.load) {
+      const e = this.load;
+      e(this.root, (n) => {
+        this.root.doCreateChildren(n), this._initDefaultCheckedNodes();
+      });
+    } else
+      this._initDefaultCheckedNodes();
+  }
+  filter(e) {
+    const n = this.filterNodeMethod, d = this.lazy, o = function(r) {
+      const s = r.root ? r.root.childNodes : r.childNodes;
+      if (s.forEach((i) => {
+        i.visible = n.call(i, e, i.data, i), o(i);
+      }), !r.visible && s.length) {
+        let i = !0;
+        i = !s.some((f) => f.visible), r.root ? r.root.visible = i === !1 : r.visible = i === !1;
+      }
+      e && r.visible && !r.isLeaf && (!d || r.loaded) && r.expand();
+    };
+    o(this);
+  }
+  setData(e) {
+    e !== this.root.data ? (this.nodesMap = {}, this.root.setData(e), this._initDefaultCheckedNodes(), this.setCurrentNodeKey(this.currentNodeKey)) : this.root.updateChildren();
+  }
+  getNode(e) {
+    if (e instanceof O)
+      return e;
+    const n = Me(e) ? ce(this.key, e) : e;
+    return this.nodesMap[n] || null;
+  }
+  insertBefore(e, n) {
+    const d = this.getNode(n);
+    d.parent.insertBefore({ data: e }, d);
+  }
+  insertAfter(e, n) {
+    const d = this.getNode(n);
+    d.parent.insertAfter({ data: e }, d);
+  }
+  remove(e) {
+    const n = this.getNode(e);
+    n && n.parent && (n === this.currentNode && (this.currentNode = null), n.parent.removeChild(n));
+  }
+  append(e, n) {
+    const d = ze(n) ? this.root : this.getNode(n);
+    d && d.insertChild({ data: e });
+  }
+  _initDefaultCheckedNodes() {
+    const e = this.defaultCheckedKeys || [], n = this.nodesMap;
+    e.forEach((d) => {
+      const o = n[d];
+      o && o.setChecked(!0, !this.checkStrictly);
+    });
+  }
+  _initDefaultCheckedNode(e) {
+    (this.defaultCheckedKeys || []).includes(e.key) && e.setChecked(!0, !this.checkStrictly);
+  }
+  setDefaultCheckedKey(e) {
+    e !== this.defaultCheckedKeys && (this.defaultCheckedKeys = e, this._initDefaultCheckedNodes());
+  }
+  registerNode(e) {
+    const n = this.key;
+    !e || !e.data || (n ? e.key !== void 0 && (this.nodesMap[e.key] = e) : this.nodesMap[e.id] = e);
+  }
+  deregisterNode(e) {
+    !this.key || !e || !e.data || (e.childNodes.forEach((d) => {
+      this.deregisterNode(d);
+    }), delete this.nodesMap[e.key]);
+  }
+  getCheckedNodes(e = !1, n = !1) {
+    const d = [], o = function(r) {
+      (r.root ? r.root.childNodes : r.childNodes).forEach((i) => {
+        (i.checked || n && i.indeterminate) && (!e || e && i.isLeaf) && d.push(i.data), o(i);
+      });
+    };
+    return o(this), d;
+  }
+  getCheckedKeys(e = !1) {
+    return this.getCheckedNodes(e).map((n) => (n || {})[this.key]);
+  }
+  getHalfCheckedNodes() {
+    const e = [], n = function(d) {
+      (d.root ? d.root.childNodes : d.childNodes).forEach((r) => {
+        r.indeterminate && e.push(r.data), n(r);
+      });
+    };
+    return n(this), e;
+  }
+  getHalfCheckedKeys() {
+    return this.getHalfCheckedNodes().map((e) => (e || {})[this.key]);
+  }
+  _getAllNodes() {
+    const e = [], n = this.nodesMap;
+    for (const d in n)
+      de(n, d) && e.push(n[d]);
+    return e;
+  }
+  updateChildren(e, n) {
+    const d = this.nodesMap[e];
+    if (!d)
+      return;
+    const o = d.childNodes;
+    for (let r = o.length - 1; r >= 0; r--) {
+      const s = o[r];
+      this.remove(s.data);
+    }
+    for (let r = 0, s = n.length; r < s; r++) {
+      const i = n[r];
+      this.append(i, d.data);
+    }
+  }
+  _setCheckedKeys(e, n = !1, d) {
+    const o = this._getAllNodes().sort((f, g) => f.level - g.level), r = /* @__PURE__ */ Object.create(null), s = Object.keys(d);
+    o.forEach((f) => f.setChecked(!1, !1));
+    const i = (f) => {
+      f.childNodes.forEach((g) => {
+        var l;
+        r[g.data[e]] = !0, (l = g.childNodes) != null && l.length && i(g);
+      });
+    };
+    for (let f = 0, g = o.length; f < g; f++) {
+      const l = o[f], c = l.data[e].toString();
+      if (!s.includes(c)) {
+        l.checked && !r[c] && l.setChecked(!1, !1);
+        continue;
+      }
+      if (l.childNodes.length && i(l), l.isLeaf || this.checkStrictly) {
+        l.setChecked(!0, !1);
+        continue;
+      }
+      if (l.setChecked(!0, !0), n) {
+        l.setChecked(!1, !1);
+        const p = function(y) {
+          y.childNodes.forEach((v) => {
+            v.isLeaf || v.setChecked(!1, !1), p(v);
+          });
+        };
+        p(l);
+      }
+    }
+  }
+  setCheckedNodes(e, n = !1) {
+    const d = this.key, o = {};
+    e.forEach((r) => {
+      o[(r || {})[d]] = !0;
+    }), this._setCheckedKeys(d, n, o);
+  }
+  setCheckedKeys(e, n = !1) {
+    this.defaultCheckedKeys = e;
+    const d = this.key, o = {};
+    e.forEach((r) => {
+      o[r] = !0;
+    }), this._setCheckedKeys(d, n, o);
+  }
+  setDefaultExpandedKeys(e) {
+    e = e || [], this.defaultExpandedKeys = e, e.forEach((n) => {
+      const d = this.getNode(n);
+      d && d.expand(null, this.autoExpandParent);
+    });
+  }
+  setChecked(e, n, d) {
+    const o = this.getNode(e);
+    o && o.setChecked(!!n, d);
+  }
+  getCurrentNode() {
+    return this.currentNode;
+  }
+  setCurrentNode(e) {
+    const n = this.currentNode;
+    n && (n.isCurrent = !1), this.currentNode = e, this.currentNode.isCurrent = !0;
+  }
+  setUserCurrentNode(e, n = !0) {
+    const d = e[this.key], o = this.nodesMap[d];
+    this.setCurrentNode(o), n && this.currentNode.level > 1 && this.currentNode.parent.expand(null, !0);
+  }
+  setCurrentNodeKey(e, n = !0) {
+    if (this.currentNodeKey = e, e == null) {
+      this.currentNode && (this.currentNode.isCurrent = !1), this.currentNode = null;
+      return;
+    }
+    const d = this.getNode(e);
+    d && (this.setCurrentNode(d), n && this.currentNode.level > 1 && this.currentNode.parent.expand(null, !0));
+  }
+}
+const Xe = ie({
+  name: "ElTreeNodeContent",
+  props: {
+    node: {
+      type: Object,
+      required: !0
+    },
+    renderContent: Function
+  },
+  setup(t) {
+    const e = Y("tree"), n = P("NodeInstance"), d = P("RootTree");
+    return () => {
+      const o = t.node, { data: r, store: s } = o;
+      return t.renderContent ? t.renderContent(he, { _self: n, node: o, data: r, store: s }) : Ne(d.ctx.slots, "default", { node: o, data: r }, () => [
+        he("span", { class: e.be("node", "label") }, [o.label])
+      ]);
+    };
+  }
+});
+var Ze = /* @__PURE__ */ le(Xe, [["__file", "tree-node-content.vue"]]);
+function ve(t) {
+  const e = P("TreeNodeMap", null), n = {
+    treeNodeExpand: (d) => {
+      t.node !== d && t.node.collapse();
+    },
+    children: []
+  };
+  return e && e.children.push(n), W("TreeNodeMap", n), {
+    broadcastExpanded: (d) => {
+      if (t.accordion)
+        for (const o of n.children)
+          o.treeNodeExpand(d);
+    }
+  };
+}
+const me = Symbol("dragEvents");
+function _e({ props: t, ctx: e, el$: n, dropIndicator$: d, store: o }) {
+  const r = Y("tree"), s = D({
+    showDropIndicator: !1,
+    draggingNode: null,
+    dropNode: null,
+    allowDrop: !0,
+    dropType: null
+  });
+  return W(me, {
+    treeNodeDragStart: ({ event: l, treeNode: c }) => {
+      if (X(t.allowDrag) && !t.allowDrag(c.node))
+        return l.preventDefault(), !1;
+      l.dataTransfer.effectAllowed = "move";
+      try {
+        l.dataTransfer.setData("text/plain", "");
+      } catch {
+      }
+      s.value.draggingNode = c, e.emit("node-drag-start", c.node, l);
+    },
+    treeNodeDragOver: ({ event: l, treeNode: c }) => {
+      const h = c, p = s.value.dropNode;
+      p && p.node.id !== h.node.id && ee(p.$el, r.is("drop-inner"));
+      const y = s.value.draggingNode;
+      if (!y || !h)
+        return;
+      let C = !0, v = !0, K = !0, x = !0;
+      X(t.allowDrop) && (C = t.allowDrop(y.node, h.node, "prev"), x = v = t.allowDrop(y.node, h.node, "inner"), K = t.allowDrop(y.node, h.node, "next")), l.dataTransfer.dropEffect = v || C || K ? "move" : "none", (C || v || K) && p?.node.id !== h.node.id && (p && e.emit("node-drag-leave", y.node, p.node, l), e.emit("node-drag-enter", y.node, h.node, l)), C || v || K ? s.value.dropNode = h : s.value.dropNode = null, h.node.nextSibling === y.node && (K = !1), h.node.previousSibling === y.node && (C = !1), h.node.contains(y.node, !1) && (v = !1), (y.node === h.node || y.node.contains(h.node)) && (C = !1, v = !1, K = !1);
+      const T = h.$el.querySelector(`.${r.be("node", "content")}`).getBoundingClientRect(), $ = n.value.getBoundingClientRect();
+      let b;
+      const G = C ? v ? 0.25 : K ? 0.45 : 1 : -1, J = K ? v ? 0.75 : C ? 0.55 : 0 : 1;
+      let M = -9999;
+      const u = l.clientY - T.top;
+      u < T.height * G ? b = "before" : u > T.height * J ? b = "after" : v ? b = "inner" : b = "none";
+      const k = h.$el.querySelector(`.${r.be("node", "expand-icon")}`).getBoundingClientRect(), m = d.value;
+      b === "before" ? M = k.top - $.top : b === "after" && (M = k.bottom - $.top), m.style.top = `${M}px`, m.style.left = `${k.right - $.left}px`, b === "inner" ? Fe(h.$el, r.is("drop-inner")) : ee(h.$el, r.is("drop-inner")), s.value.showDropIndicator = b === "before" || b === "after", s.value.allowDrop = s.value.showDropIndicator || x, s.value.dropType = b, e.emit("node-drag-over", y.node, h.node, l);
+    },
+    treeNodeDragEnd: (l) => {
+      const { draggingNode: c, dropType: h, dropNode: p } = s.value;
+      if (l.preventDefault(), l.dataTransfer && (l.dataTransfer.dropEffect = "move"), c && p) {
+        const y = { data: c.node.data };
+        h !== "none" && c.node.remove(), h === "before" ? p.node.parent.insertBefore(y, p.node) : h === "after" ? p.node.parent.insertAfter(y, p.node) : h === "inner" && p.node.insertChild(y), h !== "none" && (o.value.registerNode(y), o.value.key && c.node.eachNode((C) => {
+          var v;
+          (v = o.value.nodesMap[C.data[o.value.key]]) == null || v.setChecked(C.checked, !o.value.checkStrictly);
+        })), ee(p.$el, r.is("drop-inner")), e.emit("node-drag-end", c.node, p.node, h, l), h !== "none" && e.emit("node-drop", c.node, p.node, h, l);
+      }
+      c && !p && e.emit("node-drag-end", c.node, null, h, l), s.value.showDropIndicator = !1, s.value.draggingNode = null, s.value.dropNode = null, s.value.allowDrop = !0;
+    }
+  }), {
+    dragState: s
+  };
+}
+const et = ie({
+  name: "ElTreeNode",
+  components: {
+    ElCollapseTransition: Ge,
+    ElCheckbox: Je,
+    NodeContent: Ze,
+    ElIcon: Pe,
+    Loading: qe
+  },
+  props: {
+    node: {
+      type: O,
+      default: () => ({})
+    },
+    props: {
+      type: Object,
+      default: () => ({})
+    },
+    accordion: Boolean,
+    renderContent: Function,
+    renderAfterExpand: Boolean,
+    showCheckbox: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: ["node-expand"],
+  setup(t, e) {
+    const n = Y("tree"), { broadcastExpanded: d } = ve(t), o = P("RootTree"), r = D(!1), s = D(!1), i = D(null), f = D(null), g = D(null), l = P(me), c = ke();
+    W("NodeInstance", c), t.node.expanded && (r.value = !0, s.value = !0);
+    const h = o.props.props.children || "children";
+    w(() => {
+      const u = t.node.data[h];
+      return u && [...u];
+    }, () => {
+      t.node.updateChildren();
+    }), w(() => t.node.indeterminate, (u) => {
+      C(t.node.checked, u);
+    }), w(() => t.node.checked, (u) => {
+      C(u, t.node.indeterminate);
+    }), w(() => t.node.childNodes.length, () => t.node.reInitChecked()), w(() => t.node.expanded, (u) => {
+      ue(() => r.value = u), u && (s.value = !0);
+    });
+    const p = (u) => ce(o.props.nodeKey, u.data), y = (u) => {
+      const k = t.props.class;
+      if (!k)
+        return {};
+      let m;
+      if (X(k)) {
+        const { data: j } = u;
+        m = k(j, u);
+      } else
+        m = k;
+      return Ce(m) ? { [m]: !0 } : m;
+    }, C = (u, k) => {
+      (i.value !== u || f.value !== k) && o.ctx.emit("check-change", t.node.data, u, k), i.value = u, f.value = k;
+    }, v = (u) => {
+      se(o.store, o.ctx.emit, () => {
+        var k;
+        if ((k = o?.props) == null ? void 0 : k.nodeKey) {
+          const j = p(t.node);
+          o.store.value.setCurrentNodeKey(j);
+        } else
+          o.store.value.setCurrentNode(t.node);
+      }), o.currentNode.value = t.node, o.props.expandOnClickNode && x(), o.props.checkOnClickNode && !t.node.disabled && T(null, {
+        target: { checked: !t.node.checked }
+      }), o.ctx.emit("node-click", t.node.data, t.node, c, u);
+    }, K = (u) => {
+      o.instance.vnode.props.onNodeContextmenu && (u.stopPropagation(), u.preventDefault()), o.ctx.emit("node-contextmenu", u, t.node.data, t.node, c);
+    }, x = () => {
+      t.node.isLeaf || (r.value ? (o.ctx.emit("node-collapse", t.node.data, t.node, c), t.node.collapse()) : t.node.expand(() => {
+        e.emit("node-expand", t.node.data, t.node, c);
+      }));
+    }, T = (u, k) => {
+      t.node.setChecked(k.target.checked, !o.props.checkStrictly), ue(() => {
+        const m = o.store.value;
+        o.ctx.emit("check", t.node.data, {
+          checkedNodes: m.getCheckedNodes(),
+          checkedKeys: m.getCheckedKeys(),
+          halfCheckedNodes: m.getHalfCheckedNodes(),
+          halfCheckedKeys: m.getHalfCheckedKeys()
+        });
+      });
+    };
+    return {
+      ns: n,
+      node$: g,
+      tree: o,
+      expanded: r,
+      childNodeRendered: s,
+      oldChecked: i,
+      oldIndeterminate: f,
+      getNodeKey: p,
+      getNodeClass: y,
+      handleSelectChange: C,
+      handleClick: v,
+      handleContextMenu: K,
+      handleExpandIconClick: x,
+      handleCheckChange: T,
+      handleChildNodeExpand: (u, k, m) => {
+        d(k), o.ctx.emit("node-expand", u, k, m);
+      },
+      handleDragStart: (u) => {
+        o.props.draggable && l.treeNodeDragStart({ event: u, treeNode: t });
+      },
+      handleDragOver: (u) => {
+        u.preventDefault(), o.props.draggable && l.treeNodeDragOver({
+          event: u,
+          treeNode: { $el: g.value, node: t.node }
+        });
+      },
+      handleDrop: (u) => {
+        u.preventDefault();
+      },
+      handleDragEnd: (u) => {
+        o.props.draggable && l.treeNodeDragEnd(u);
+      },
+      CaretRight: je
+    };
+  }
+});
+function tt(t, e, n, d, o, r) {
+  const s = L("el-icon"), i = L("el-checkbox"), f = L("loading"), g = L("node-content"), l = L("el-tree-node"), c = L("el-collapse-transition");
+  return te((E(), F("div", {
+    ref: "node$",
+    class: S([
+      t.ns.b("node"),
+      t.ns.is("expanded", t.expanded),
+      t.ns.is("current", t.node.isCurrent),
+      t.ns.is("hidden", !t.node.visible),
+      t.ns.is("focusable", !t.node.disabled),
+      t.ns.is("checked", !t.node.disabled && t.node.checked),
+      t.getNodeClass(t.node)
+    ]),
+    role: "treeitem",
+    tabindex: "-1",
+    "aria-expanded": t.expanded,
+    "aria-disabled": t.node.disabled,
+    "aria-checked": t.node.checked,
+    draggable: t.tree.props.draggable,
+    "data-key": t.getNodeKey(t.node),
+    onClick: B(t.handleClick, ["stop"]),
+    onContextmenu: t.handleContextMenu,
+    onDragstart: B(t.handleDragStart, ["stop"]),
+    onDragover: B(t.handleDragOver, ["stop"]),
+    onDragend: B(t.handleDragEnd, ["stop"]),
+    onDrop: B(t.handleDrop, ["stop"])
+  }, [
+    ne("div", {
+      class: S(t.ns.be("node", "content")),
+      style: xe({ paddingLeft: (t.node.level - 1) * t.tree.props.indent + "px" })
+    }, [
+      t.tree.props.icon || t.CaretRight ? (E(), z(s, {
+        key: 0,
+        class: S([
+          t.ns.be("node", "expand-icon"),
+          t.ns.is("leaf", t.node.isLeaf),
+          {
+            expanded: !t.node.isLeaf && t.expanded
+          }
+        ]),
+        onClick: B(t.handleExpandIconClick, ["stop"])
+      }, {
+        default: _(() => [
+          (E(), z(Te(t.tree.props.icon || t.CaretRight)))
+        ]),
+        _: 1
+      }, 8, ["class", "onClick"])) : H("v-if", !0),
+      t.showCheckbox ? (E(), z(i, {
+        key: 1,
+        "model-value": t.node.checked,
+        indeterminate: t.node.indeterminate,
+        disabled: !!t.node.disabled,
+        onClick: B(() => {
+        }, ["stop"]),
+        onChange: t.handleCheckChange
+      }, null, 8, ["model-value", "indeterminate", "disabled", "onClick", "onChange"])) : H("v-if", !0),
+      t.node.loading ? (E(), z(s, {
+        key: 2,
+        class: S([t.ns.be("node", "loading-icon"), t.ns.is("loading")])
+      }, {
+        default: _(() => [
+          Z(f)
+        ]),
+        _: 1
+      }, 8, ["class"])) : H("v-if", !0),
+      Z(g, {
+        node: t.node,
+        "render-content": t.renderContent
+      }, null, 8, ["node", "render-content"])
+    ], 6),
+    Z(c, null, {
+      default: _(() => [
+        !t.renderAfterExpand || t.childNodeRendered ? te((E(), F("div", {
+          key: 0,
+          class: S(t.ns.be("node", "children")),
+          role: "group",
+          "aria-expanded": t.expanded
+        }, [
+          (E(!0), F(ge, null, ye(t.node.childNodes, (h) => (E(), z(l, {
+            key: t.getNodeKey(h),
+            "render-content": t.renderContent,
+            "render-after-expand": t.renderAfterExpand,
+            "show-checkbox": t.showCheckbox,
+            node: h,
+            accordion: t.accordion,
+            props: t.props,
+            onNodeExpand: t.handleChildNodeExpand
+          }, null, 8, ["render-content", "render-after-expand", "show-checkbox", "node", "accordion", "props", "onNodeExpand"]))), 128))
+        ], 10, ["aria-expanded"])), [
+          [oe, t.expanded]
+        ]) : H("v-if", !0)
+      ]),
+      _: 1
+    })
+  ], 42, ["aria-expanded", "aria-disabled", "aria-checked", "draggable", "data-key", "onClick", "onContextmenu", "onDragstart", "onDragover", "onDragend", "onDrop"])), [
+    [oe, t.node.visible]
+  ]);
+}
+var nt = /* @__PURE__ */ le(et, [["render", tt], ["__file", "tree-node.vue"]]);
+function ot({ el$: t }, e) {
+  const n = Y("tree"), d = fe([]), o = fe([]);
+  Ae(() => {
+    s();
+  }), Ie(() => {
+    d.value = Array.from(t.value.querySelectorAll("[role=treeitem]")), o.value = Array.from(t.value.querySelectorAll("input[type=checkbox]"));
+  }), w(o, (i) => {
+    i.forEach((f) => {
+      f.setAttribute("tabindex", "-1");
+    });
+  }), Re(t, "keydown", (i) => {
+    const f = i.target;
+    if (!f.className.includes(n.b("node")))
+      return;
+    const g = i.code;
+    d.value = Array.from(t.value.querySelectorAll(`.${n.is("focusable")}[role=treeitem]`));
+    const l = d.value.indexOf(f);
+    let c;
+    if ([I.up, I.down].includes(g)) {
+      if (i.preventDefault(), g === I.up) {
+        c = l === -1 ? 0 : l !== 0 ? l - 1 : d.value.length - 1;
+        const p = c;
+        for (; !e.value.getNode(d.value[c].dataset.key).canFocus; ) {
+          if (c--, c === p) {
+            c = -1;
+            break;
+          }
+          c < 0 && (c = d.value.length - 1);
+        }
+      } else {
+        c = l === -1 ? 0 : l < d.value.length - 1 ? l + 1 : 0;
+        const p = c;
+        for (; !e.value.getNode(d.value[c].dataset.key).canFocus; ) {
+          if (c++, c === p) {
+            c = -1;
+            break;
+          }
+          c >= d.value.length && (c = 0);
+        }
+      }
+      c !== -1 && d.value[c].focus();
+    }
+    [I.left, I.right].includes(g) && (i.preventDefault(), f.click());
+    const h = f.querySelector('[type="checkbox"]');
+    [I.enter, I.numpadEnter, I.space].includes(g) && h && (i.preventDefault(), h.click());
+  });
+  const s = () => {
+    var i;
+    d.value = Array.from(t.value.querySelectorAll(`.${n.is("focusable")}[role=treeitem]`)), o.value = Array.from(t.value.querySelectorAll("input[type=checkbox]"));
+    const f = t.value.querySelectorAll(`.${n.is("checked")}[role=treeitem]`);
+    if (f.length) {
+      f[0].setAttribute("tabindex", "0");
+      return;
+    }
+    (i = d.value[0]) == null || i.setAttribute("tabindex", "0");
+  };
+}
+const dt = ie({
+  name: "ElTree",
+  components: { ElTreeNode: nt },
+  props: {
+    data: {
+      type: Array,
+      default: () => []
+    },
+    emptyText: {
+      type: String
+    },
+    renderAfterExpand: {
+      type: Boolean,
+      default: !0
+    },
+    nodeKey: String,
+    checkStrictly: Boolean,
+    defaultExpandAll: Boolean,
+    expandOnClickNode: {
+      type: Boolean,
+      default: !0
+    },
+    checkOnClickNode: Boolean,
+    checkDescendants: {
+      type: Boolean,
+      default: !1
+    },
+    autoExpandParent: {
+      type: Boolean,
+      default: !0
+    },
+    defaultCheckedKeys: Array,
+    defaultExpandedKeys: Array,
+    currentNodeKey: [String, Number],
+    renderContent: Function,
+    showCheckbox: {
+      type: Boolean,
+      default: !1
+    },
+    draggable: {
+      type: Boolean,
+      default: !1
+    },
+    allowDrag: Function,
+    allowDrop: Function,
+    props: {
+      type: Object,
+      default: () => ({
+        children: "children",
+        label: "label",
+        disabled: "disabled"
+      })
+    },
+    lazy: {
+      type: Boolean,
+      default: !1
+    },
+    highlightCurrent: Boolean,
+    load: Function,
+    filterNodeMethod: Function,
+    accordion: Boolean,
+    indent: {
+      type: Number,
+      default: 18
+    },
+    icon: {
+      type: He
+    }
+  },
+  emits: [
+    "check-change",
+    "current-change",
+    "node-click",
+    "node-contextmenu",
+    "node-collapse",
+    "node-expand",
+    "check",
+    "node-drag-start",
+    "node-drag-end",
+    "node-drop",
+    "node-drag-leave",
+    "node-drag-enter",
+    "node-drag-over"
+  ],
+  setup(t, e) {
+    const { t: n } = Ue(), d = Y("tree"), o = P(Oe, null), r = D(new Ve({
+      key: t.nodeKey,
+      data: t.data,
+      lazy: t.lazy,
+      props: t.props,
+      load: t.load,
+      currentNodeKey: t.currentNodeKey,
+      checkStrictly: t.checkStrictly,
+      checkDescendants: t.checkDescendants,
+      defaultCheckedKeys: t.defaultCheckedKeys,
+      defaultExpandedKeys: t.defaultExpandedKeys,
+      autoExpandParent: t.autoExpandParent,
+      defaultExpandAll: t.defaultExpandAll,
+      filterNodeMethod: t.filterNodeMethod
+    }));
+    r.value.initialize();
+    const s = D(r.value.root), i = D(null), f = D(null), g = D(null), { broadcastExpanded: l } = ve(t), { dragState: c } = _e({
+      props: t,
+      ctx: e,
+      el$: f,
+      dropIndicator$: g,
+      store: r
+    });
+    ot({ el$: f }, r);
+    const h = Le(() => {
+      const { childNodes: a } = s.value, N = o ? o.hasFilteredOptions !== 0 : !1;
+      return (!a || a.length === 0 || a.every(({ visible: A }) => !A)) && !N;
+    });
+    w(() => t.currentNodeKey, (a) => {
+      r.value.setCurrentNodeKey(a);
+    }), w(() => t.defaultCheckedKeys, (a) => {
+      r.value.setDefaultCheckedKey(a);
+    }), w(() => t.defaultExpandedKeys, (a) => {
+      r.value.setDefaultExpandedKeys(a);
+    }), w(() => t.data, (a) => {
+      r.value.setData(a);
+    }, { deep: !0 }), w(() => t.checkStrictly, (a) => {
+      r.value.checkStrictly = a;
+    });
+    const p = (a) => {
+      if (!t.filterNodeMethod)
+        throw new Error("[Tree] filterNodeMethod is required when filter");
+      r.value.filter(a);
+    }, y = (a) => ce(t.nodeKey, a.data), C = (a) => {
+      if (!t.nodeKey)
+        throw new Error("[Tree] nodeKey is required in getNodePath");
+      const N = r.value.getNode(a);
+      if (!N)
+        return [];
+      const A = [N.data];
+      let R = N.parent;
+      for (; R && R !== s.value; )
+        A.push(R.data), R = R.parent;
+      return A.reverse();
+    }, v = (a, N) => r.value.getCheckedNodes(a, N), K = (a) => r.value.getCheckedKeys(a), x = () => {
+      const a = r.value.getCurrentNode();
+      return a ? a.data : null;
+    }, T = () => {
+      if (!t.nodeKey)
+        throw new Error("[Tree] nodeKey is required in getCurrentKey");
+      const a = x();
+      return a ? a[t.nodeKey] : null;
+    }, $ = (a, N) => {
+      if (!t.nodeKey)
+        throw new Error("[Tree] nodeKey is required in setCheckedNodes");
+      r.value.setCheckedNodes(a, N);
+    }, b = (a, N) => {
+      if (!t.nodeKey)
+        throw new Error("[Tree] nodeKey is required in setCheckedKeys");
+      r.value.setCheckedKeys(a, N);
+    }, G = (a, N, A) => {
+      r.value.setChecked(a, N, A);
+    }, J = () => r.value.getHalfCheckedNodes(), M = () => r.value.getHalfCheckedKeys(), u = (a, N = !0) => {
+      if (!t.nodeKey)
+        throw new Error("[Tree] nodeKey is required in setCurrentNode");
+      se(r, e.emit, () => {
+        l(a), r.value.setUserCurrentNode(a, N);
+      });
+    }, k = (a, N = !0) => {
+      if (!t.nodeKey)
+        throw new Error("[Tree] nodeKey is required in setCurrentKey");
+      se(r, e.emit, () => {
+        l(), r.value.setCurrentNodeKey(a, N);
+      });
+    }, m = (a) => r.value.getNode(a), j = (a) => {
+      r.value.remove(a);
+    }, be = (a, N) => {
+      r.value.append(a, N);
+    }, Ke = (a, N) => {
+      r.value.insertBefore(a, N);
+    }, Ee = (a, N) => {
+      r.value.insertAfter(a, N);
+    }, De = (a, N, A) => {
+      l(N), e.emit("node-expand", a, N, A);
+    }, we = (a, N) => {
+      if (!t.nodeKey)
+        throw new Error("[Tree] nodeKey is required in updateKeyChild");
+      r.value.updateChildren(a, N);
+    };
+    return W("RootTree", {
+      ctx: e,
+      props: t,
+      store: r,
+      root: s,
+      currentNode: i,
+      instance: ke()
+    }), W(We, void 0), {
+      ns: d,
+      store: r,
+      root: s,
+      currentNode: i,
+      dragState: c,
+      el$: f,
+      dropIndicator$: g,
+      isEmpty: h,
+      filter: p,
+      getNodeKey: y,
+      getNodePath: C,
+      getCheckedNodes: v,
+      getCheckedKeys: K,
+      getCurrentNode: x,
+      getCurrentKey: T,
+      setCheckedNodes: $,
+      setCheckedKeys: b,
+      setChecked: G,
+      getHalfCheckedNodes: J,
+      getHalfCheckedKeys: M,
+      setCurrentNode: u,
+      setCurrentKey: k,
+      t: n,
+      getNode: m,
+      remove: j,
+      append: be,
+      insertBefore: Ke,
+      insertAfter: Ee,
+      handleNodeExpand: De,
+      updateKeyChildren: we
+    };
+  }
+});
+function rt(t, e, n, d, o, r) {
+  const s = L("el-tree-node");
+  return E(), F("div", {
+    ref: "el$",
+    class: S([
+      t.ns.b(),
+      t.ns.is("dragging", !!t.dragState.draggingNode),
+      t.ns.is("drop-not-allow", !t.dragState.allowDrop),
+      t.ns.is("drop-inner", t.dragState.dropType === "inner"),
+      { [t.ns.m("highlight-current")]: t.highlightCurrent }
+    ]),
+    role: "tree"
+  }, [
+    (E(!0), F(ge, null, ye(t.root.childNodes, (i) => (E(), z(s, {
+      key: t.getNodeKey(i),
+      node: i,
+      props: t.props,
+      accordion: t.accordion,
+      "render-after-expand": t.renderAfterExpand,
+      "show-checkbox": t.showCheckbox,
+      "render-content": t.renderContent,
+      onNodeExpand: t.handleNodeExpand
+    }, null, 8, ["node", "props", "accordion", "render-after-expand", "show-checkbox", "render-content", "onNodeExpand"]))), 128)),
+    t.isEmpty ? (E(), F("div", {
+      key: 0,
+      class: S(t.ns.e("empty-block"))
+    }, [
+      Ne(t.$slots, "empty", {}, () => {
+        var i;
+        return [
+          ne("span", {
+            class: S(t.ns.e("empty-text"))
+          }, Be((i = t.emptyText) != null ? i : t.t("el.tree.emptyText")), 3)
+        ];
+      })
+    ], 2)) : H("v-if", !0),
+    te(ne("div", {
+      ref: "dropIndicator$",
+      class: S(t.ns.e("drop-indicator"))
+    }, null, 2), [
+      [oe, t.dragState.showDropIndicator]
+    ])
+  ], 2);
+}
+var st = /* @__PURE__ */ le(dt, [["render", rt], ["__file", "tree.vue"]]);
+const ut = Ye(st);
+export {
+  ut as E
+};