jmash-core 0.0.2 → 0.0.4

package/dist/el-tree-select-CyDKS6nF.mjs

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