@xtctwins/tctwins-bimx-engine 0.3.0 → 0.3.2

package/dist/StructureTree-DHaOzAP9.mjs

@@ -0,0 +1,1662 @@
+import { u as ae, w as Be, b as ze, c as et, a as tt, i as se, d as xe, e as nt, f as ye, h as De, g as ve, j as we, k as me, l as Fe, N as ot, m as st, n as Pe, r as Ee, o as at, E as rt, p as dt, q as it, _ as Re, s as lt, t as ct, v as Z, x as ut, y as ht, z as ft, A as pt, B as yt, C as ne, D as ge, T as je, F as vt, G as gt, H as kt, I as Nt } from "./index-BDupeKSG.mjs";
+import { _ as Ct } from "./TallPanel-DtXOSzmF.mjs";
+import { defineComponent as de, openBlock as I, createBlock as Y, Transition as mt, mergeProps as bt, unref as T, toHandlers as _t, withCtx as L, renderSlot as be, useAttrs as Et, ref as w, computed as Ke, onMounted as Ae, onUpdated as qe, resolveDynamicComponent as Ve, normalizeStyle as Ue, normalizeClass as F, nextTick as re, reactive as xt, inject as fe, onBeforeUnmount as Ye, provide as pe, h as $e, getCurrentInstance as We, watch as q, resolveComponent as oe, withDirectives as G, createElementBlock as $, withModifiers as ee, createElementVNode as D, createCommentVNode as le, createVNode as A, Fragment as ue, renderList as he, vShow as Q, toDisplayString as R } from "vue";
+import { Loading as Dt, CaretRight as wt } from "@element-plus/icons-vue";
+import { _ as Kt } from "./Panel.vue_vue_type_style_index_0_lang-C4tqfy-B.mjs";
+import { S as ke } from "./bimTools-D3TraX9d.mjs";
+var Tt = /* @__PURE__ */ de({
+  name: "ElCollapseTransition",
+  __name: "collapse-transition",
+  setup(e) {
+    const t = ae("collapse-transition"), o = (n) => {
+      n.style.maxHeight = "", n.style.overflow = n.dataset.oldOverflow, n.style.paddingTop = n.dataset.oldPaddingTop, n.style.paddingBottom = n.dataset.oldPaddingBottom;
+    }, s = {
+      beforeEnter(n) {
+        n.dataset || (n.dataset = {}), n.dataset.oldPaddingTop = n.style.paddingTop, n.dataset.oldPaddingBottom = n.style.paddingBottom, n.style.height && (n.dataset.elExistsHeight = n.style.height), n.style.maxHeight = 0, n.style.paddingTop = 0, n.style.paddingBottom = 0;
+      },
+      enter(n) {
+        requestAnimationFrame(() => {
+          n.dataset.oldOverflow = n.style.overflow, n.dataset.elExistsHeight ? n.style.maxHeight = n.dataset.elExistsHeight : n.scrollHeight !== 0 ? n.style.maxHeight = `${n.scrollHeight}px` : n.style.maxHeight = 0, n.style.paddingTop = n.dataset.oldPaddingTop, n.style.paddingBottom = n.dataset.oldPaddingBottom, n.style.overflow = "hidden";
+        });
+      },
+      afterEnter(n) {
+        n.style.maxHeight = "", n.style.overflow = n.dataset.oldOverflow;
+      },
+      enterCancelled(n) {
+        o(n);
+      },
+      beforeLeave(n) {
+        n.dataset || (n.dataset = {}), n.dataset.oldPaddingTop = n.style.paddingTop, n.dataset.oldPaddingBottom = n.style.paddingBottom, n.dataset.oldOverflow = n.style.overflow, n.style.maxHeight = `${n.scrollHeight}px`, n.style.overflow = "hidden";
+      },
+      leave(n) {
+        n.scrollHeight !== 0 && (n.style.maxHeight = 0, n.style.paddingTop = 0, n.style.paddingBottom = 0);
+      },
+      afterLeave(n) {
+        o(n);
+      },
+      leaveCancelled(n) {
+        o(n);
+      }
+    };
+    return (n, a) => (I(), Y(mt, bt({ name: T(t).b() }, _t(s)), {
+      default: L(() => [be(n.$slots, "default")]),
+      _: 3
+    }, 16, ["name"]));
+  }
+}), It = Tt;
+const St = Be(It), Bt = ze({
+  /**
+  * @description text type
+  */
+  type: {
+    type: String,
+    values: [
+      "primary",
+      "success",
+      "info",
+      "warning",
+      "danger",
+      ""
+    ],
+    default: ""
+  },
+  /**
+  * @description text size
+  */
+  size: {
+    type: String,
+    values: et,
+    default: ""
+  },
+  /**
+  * @description render ellipsis
+  */
+  truncated: Boolean,
+  /**
+  * @description maximum lines
+  */
+  lineClamp: { type: [String, Number] },
+  /**
+  * @description custom element tag
+  */
+  tag: {
+    type: String,
+    default: "span"
+  }
+});
+var At = /* @__PURE__ */ de({
+  name: "ElText",
+  __name: "text",
+  props: Bt,
+  setup(e) {
+    const t = e, o = Et(), s = w(), n = tt(), a = ae("text"), d = Ke(() => [
+      a.b(),
+      a.m(t.type),
+      a.m(n.value),
+      a.is("truncated", t.truncated),
+      a.is("line-clamp", !se(t.lineClamp))
+    ]), l = async () => {
+      var u, r, c, y, E, x, N;
+      if (await re(), o.title) return;
+      let p = !1;
+      const h = ((u = s.value) == null ? void 0 : u.textContent) || "";
+      if (t.truncated) {
+        const k = (r = s.value) == null ? void 0 : r.offsetWidth, S = (c = s.value) == null ? void 0 : c.scrollWidth;
+        k && S && S > k && (p = !0);
+      } else if (!se(t.lineClamp)) {
+        const k = (y = s.value) == null ? void 0 : y.offsetHeight, S = (E = s.value) == null ? void 0 : E.scrollHeight;
+        k && S && S > k && (p = !0);
+      }
+      p ? (x = s.value) == null || x.setAttribute("title", h) : (N = s.value) == null || N.removeAttribute("title");
+    };
+    return Ae(l), qe(l), (p, h) => (I(), Y(Ve(e.tag), {
+      ref_key: "textRef",
+      ref: s,
+      class: F(d.value),
+      style: Ue({ "-webkit-line-clamp": e.lineClamp })
+    }, {
+      default: L(() => [be(p.$slots, "default")]),
+      _: 3
+    }, 8, ["class", "style"]));
+  }
+}), Lt = At;
+const Ot = Be(Lt), Le = "RootTree", Je = "NodeInstance", He = "TreeNodeMap", Pt = ze({
+  data: {
+    type: ye(Array),
+    default: () => []
+  },
+  emptyText: { type: String },
+  renderAfterExpand: {
+    type: Boolean,
+    default: !0
+  },
+  nodeKey: String,
+  checkStrictly: Boolean,
+  defaultExpandAll: Boolean,
+  expandOnClickNode: {
+    type: Boolean,
+    default: !0
+  },
+  checkOnClickNode: Boolean,
+  checkOnClickLeaf: {
+    type: Boolean,
+    default: !0
+  },
+  checkDescendants: Boolean,
+  autoExpandParent: {
+    type: Boolean,
+    default: !0
+  },
+  defaultCheckedKeys: { type: Array },
+  defaultExpandedKeys: { type: Array },
+  currentNodeKey: { type: [String, Number] },
+  renderContent: { type: ye(Function) },
+  showCheckbox: Boolean,
+  draggable: Boolean,
+  allowDrag: { type: ye(Function) },
+  allowDrop: { type: ye(Function) },
+  props: {
+    type: Object,
+    default: () => ({
+      children: "children",
+      label: "label",
+      disabled: "disabled"
+    })
+  },
+  lazy: Boolean,
+  highlightCurrent: Boolean,
+  load: { type: Function },
+  filterNodeMethod: { type: Function },
+  accordion: Boolean,
+  indent: {
+    type: Number,
+    default: 18
+  },
+  icon: { type: nt }
+}), jt = {
+  "check-change": (e, t, o) => e && xe(t) && xe(o),
+  "current-change": (e, t) => !0,
+  "node-click": (e, t, o, s) => e && t && s instanceof Event,
+  "node-contextmenu": (e, t, o, s) => e instanceof Event && t && o,
+  "node-collapse": (e, t, o) => e && t,
+  "node-expand": (e, t, o) => e && t,
+  check: (e, t) => e && t,
+  "node-drag-start": (e, t) => e && t,
+  "node-drag-end": (e, t, o, s) => e && s,
+  "node-drop": (e, t, o, s) => e && t && s,
+  "node-drag-leave": (e, t, o) => e && t && o,
+  "node-drag-enter": (e, t, o) => e && t && o,
+  "node-drag-over": (e, t, o) => e && t && o
+}, Ge = "$treeNodeId", Me = function(e, t) {
+  !t || t.$treeNodeId || Object.defineProperty(t, Ge, {
+    value: e.id,
+    enumerable: !1,
+    configurable: !1,
+    writable: !1
+  });
+}, Oe = (e, t) => t == null ? void 0 : t[e || "$treeNodeId"], Te = (e, t, o) => {
+  const s = e.value.currentNode;
+  o();
+  const n = e.value.currentNode;
+  s !== n && t("current-change", n ? n.data : null, n);
+}, Qe = (e) => {
+  let t = !0, o = !0, s = !0, n = !0;
+  for (let a = 0, d = e.length; a < d; a++) {
+    const l = e[a];
+    (l.checked !== !0 || l.indeterminate) && (t = !1, l.disabled || (s = !1)), (l.checked !== !1 || l.indeterminate) && (o = !1), l.isEffectivelyChecked || (n = !1);
+  }
+  return {
+    all: t,
+    none: o,
+    allWithoutDisable: s,
+    half: !t && !o,
+    isEffectivelyChecked: n
+  };
+}, ce = function(e) {
+  if (e.childNodes.length === 0 || e.loading) {
+    e.isEffectivelyChecked = e.disabled || e.checked;
+    return;
+  }
+  const { all: t, none: o, half: s, isEffectivelyChecked: n } = Qe(e.childNodes);
+  e.isEffectivelyChecked = n, t ? (e.checked = !0, e.indeterminate = !1) : s ? (e.checked = !1, e.indeterminate = !0) : o && (e.checked = !1, e.indeterminate = !1);
+  const a = e.parent;
+  !a || a.level === 0 || e.store.checkStrictly || ce(a);
+}, Ne = function(e, t) {
+  const o = e.store.props, s = e.data || {}, n = o[t];
+  if (me(n)) return n(s, e);
+  if (Fe(n)) return s[n];
+  if (se(n)) {
+    const a = s[t];
+    return se(a) ? "" : a;
+  }
+}, Ie = function(e, t) {
+  e.forEach((o) => {
+    o.canFocus = t, Ie(o.childNodes, t);
+  });
+};
+let $t = 0;
+var Se = class Ce {
+  constructor(t) {
+    this.isLeafByUser = void 0, this.isLeaf = void 0, this.isEffectivelyChecked = !1, this.id = $t++, 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) De(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() {
+    var a;
+    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 d = Ne(this, "isLeaf");
+      xe(d) && (this.isLeafByUser = d);
+    }
+    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.isLeafByUser && this.expand(), ve(this.data) || Me(this, this.data), !this.data) return;
+    const s = t.defaultExpandedKeys, n = t.key;
+    n && !we(this.key) && s && s.includes(this.key) && this.expand(null, t.autoExpandParent), n && t.currentNodeKey !== void 0 && this.key === t.currentNodeKey && (t.currentNode && (t.currentNode.isCurrent = !1), t.currentNode = this, t.currentNode.isCurrent = !0), t.lazy && t._initDefaultCheckedNode(this), this.updateLeafState(), (this.level === 1 || ((a = this.parent) == null ? void 0 : a.expanded) === !0) && (this.canFocus = !0);
+  }
+  setData(t) {
+    ve(t) || Me(this, t), this.data = t, this.childNodes = [];
+    let o;
+    this.level === 0 && ve(this.data) ? o = this.data : o = Ne(this, "children") || [];
+    for (let s = 0, n = o.length; s < n; s++) this.insertChild({ data: o[s] });
+  }
+  get label() {
+    return Ne(this, "label");
+  }
+  get key() {
+    const t = this.store.key;
+    return this.data ? this.data[t] : null;
+  }
+  get disabled() {
+    return Ne(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((s) => s === t || o && s.contains(t));
+  }
+  remove() {
+    const t = this.parent;
+    t && t.removeChild(this);
+  }
+  insertChild(t, o, s) {
+    if (!t) throw new Error("InsertChild error: child is required.");
+    if (!(t instanceof Ce)) {
+      if (!s) {
+        const n = this.getChildren(!0);
+        n != null && n.includes(t.data) || (se(o) || o < 0 ? n == null || n.push(t.data) : n == null || n.splice(o, 0, t.data));
+      }
+      Object.assign(t, {
+        parent: this,
+        store: this.store
+      }), t = xt(new Ce(t)), t instanceof Ce && t.initialize();
+    }
+    t.level = this.level + 1, se(o) || o < 0 ? this.childNodes.push(t) : this.childNodes.splice(o, 0, t), this.updateLeafState();
+  }
+  insertBefore(t, o) {
+    let s;
+    o && (s = this.childNodes.indexOf(o)), this.insertChild(t, s);
+  }
+  insertAfter(t, o) {
+    let s;
+    o && (s = this.childNodes.indexOf(o), s !== -1 && (s += 1)), this.insertChild(t, s);
+  }
+  removeChild(t) {
+    const o = this.getChildren() || [], s = o.indexOf(t.data);
+    s > -1 && o.splice(s, 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) {
+    const o = this.childNodes.find((s) => s.data === t);
+    o && this.removeChild(o);
+  }
+  expand(t, o) {
+    const s = () => {
+      if (o) {
+        let n = this.parent;
+        for (; n && n.level > 0; )
+          n.expanded = !0, n = n.parent;
+      }
+      this.expanded = !0, t && t(), Ie(this.childNodes, !0);
+    };
+    this.shouldLoadData() ? this.loadData((n) => {
+      ve(n) && (this.store.checkStrictly || (this.checked ? this.setChecked(!0, !0) : ce(this)), s());
+    }) : s();
+  }
+  doCreateChildren(t, o = {}) {
+    t.forEach((s) => {
+      this.insertChild(Object.assign({ data: s }, o), void 0, !0);
+    });
+  }
+  collapse() {
+    this.expanded = !1, Ie(this.childNodes, !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, this.isEffectivelyChecked = this.isLeaf && this.disabled;
+      return;
+    }
+    const t = this.childNodes;
+    if (!this.store.lazy || this.store.lazy === !0 && this.loaded === !0) {
+      this.isLeaf = !t || t.length === 0, this.isEffectivelyChecked = this.isLeaf && this.disabled;
+      return;
+    }
+    this.isLeaf = !1;
+  }
+  setChecked(t, o, s, n) {
+    if (this.indeterminate = t === "half", this.checked = t === !0, this.isEffectivelyChecked = !this.childNodes.length && (this.disabled || this.checked), this.store.checkStrictly && !o) return;
+    if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
+      const d = () => {
+        if (o) {
+          const l = this.childNodes;
+          for (let r = 0, c = l.length; r < c; r++) {
+            const y = l[r];
+            n = n || t !== !1;
+            const E = y.disabled && y.isLeaf ? y.checked : n;
+            y.setChecked(E, o, !0, n);
+          }
+          const { half: p, all: h, isEffectivelyChecked: u } = Qe(l);
+          h || (this.checked = h, this.indeterminate = p), this.isEffectivelyChecked = this.childNodes.length ? u : this.disabled || this.checked;
+        }
+      };
+      if (this.shouldLoadData()) {
+        this.loadData(() => {
+          d(), ce(this);
+        }, { checked: t !== !1 });
+        return;
+      } else d();
+    }
+    const a = this.parent;
+    !a || a.level === 0 || !s && !this.store.checkStrictly && ce(a);
+  }
+  getChildren(t = !1) {
+    if (this.level === 0) return this.data;
+    const o = this.data;
+    if (!o) return null;
+    const s = this.store.props;
+    let n = "children";
+    return s && (n = s.children || "children"), se(o[n]) && (o[n] = null), t && !o[n] && (o[n] = []), o[n];
+  }
+  updateChildren() {
+    const t = this.getChildren() || [], o = this.childNodes.map((a) => a.data), s = {}, n = [];
+    t.forEach((a, d) => {
+      const l = a[Ge];
+      l && o.some((p) => (p == null ? void 0 : p.$treeNodeId) === l) ? s[l] = {
+        index: d,
+        data: a
+      } : n.push({
+        index: d,
+        data: a
+      });
+    }), this.store.lazy || o.forEach((a) => {
+      s[a == null ? void 0 : a.$treeNodeId] || this.removeChildByData(a);
+    }), n.forEach(({ index: a, data: d }) => {
+      this.insertChild({ data: d }, a);
+    }), 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 s = (a) => {
+        this.childNodes = [], this.doCreateChildren(a, o), this.loaded = !0, this.loading = !1, this.updateLeafState(), t && t.call(this, a);
+      }, n = () => {
+        this.loading = !1;
+      };
+      this.store.load(this, s, n);
+    } else t && t.call(this);
+  }
+  eachNode(t) {
+    const o = [this];
+    for (; o.length; ) {
+      const s = o.shift();
+      o.unshift(...s.childNodes), t(s);
+    }
+  }
+  reInitChecked() {
+    this.store.checkStrictly || ce(this);
+  }
+}, Ht = class {
+  constructor(e) {
+    this.lazy = !1, this.checkStrictly = !1, this.autoExpandParent = !1, this.defaultExpandAll = !1, this.checkDescendants = !1, this.currentNode = null, this.currentNodeKey = null;
+    for (const t in e) De(e, t) && (this[t] = e[t]);
+    this.nodesMap = {};
+  }
+  initialize() {
+    if (this.root = new Se({
+      data: this.data,
+      store: this
+    }), this.root.initialize(), this.lazy && this.load) {
+      const e = this.load;
+      e(this.root, (t) => {
+        this.root.doCreateChildren(t), this._initDefaultCheckedNodes();
+      }, ot);
+    } else this._initDefaultCheckedNodes();
+  }
+  filter(e) {
+    const t = this.filterNodeMethod, o = this.lazy, s = async function(n) {
+      const a = n.root ? n.root.childNodes : n.childNodes;
+      for (const [d, l] of a.entries())
+        l.visible = !!(t != null && t.call(l, e, l.data, l)), d % 80 === 0 && d > 0 && await re(), await s(l);
+      if (!n.visible && a.length) {
+        let d = !0;
+        d = !a.some((l) => l.visible), n.root ? n.root.visible = d === !1 : n.visible = d === !1;
+      }
+      e && n.visible && !n.isLeaf && (!o || n.loaded) && n.expand();
+    };
+    s(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 Se) return e;
+    const t = st(e) ? Oe(this.key, e) : e;
+    return this.nodesMap[t] || null;
+  }
+  insertBefore(e, t) {
+    var s;
+    const o = this.getNode(t);
+    (s = o.parent) == null || s.insertBefore({ data: e }, o);
+  }
+  insertAfter(e, t) {
+    var s;
+    const o = this.getNode(t);
+    (s = o.parent) == null || s.insertAfter({ data: e }, o);
+  }
+  remove(e) {
+    const t = this.getNode(e);
+    t && t.parent && (t === this.currentNode && (this.currentNode = null), t.parent.removeChild(t));
+  }
+  append(e, t) {
+    const o = Pe(t) ? this.root : this.getNode(t);
+    o && o.insertChild({ data: e });
+  }
+  _initDefaultCheckedNodes() {
+    const e = this.defaultCheckedKeys || [], t = this.nodesMap;
+    e.forEach((o) => {
+      const s = t[o];
+      s && s.setChecked(!0, !this.checkStrictly);
+    });
+  }
+  _initDefaultCheckedNode(e) {
+    const t = this.defaultCheckedKeys || [];
+    !we(e.key) && t.includes(e.key) && e.setChecked(!0, !this.checkStrictly);
+  }
+  setDefaultCheckedKey(e) {
+    e !== this.defaultCheckedKeys && (this.defaultCheckedKeys = e, this._initDefaultCheckedNodes());
+  }
+  registerNode(e) {
+    const t = this.key;
+    if (!(!e || !e.data))
+      if (!t) this.nodesMap[e.id] = e;
+      else {
+        const o = e.key;
+        we(o) || (this.nodesMap[o] = e);
+      }
+  }
+  deregisterNode(e) {
+    !this.key || !e || !e.data || (e.childNodes.forEach((t) => {
+      this.deregisterNode(t);
+    }), delete this.nodesMap[e.key]);
+  }
+  getCheckedNodes(e = !1, t = !1) {
+    const o = [], s = function(n) {
+      (n.root ? n.root.childNodes : n.childNodes).forEach((a) => {
+        (a.checked || t && a.indeterminate) && (!e || e && a.isLeaf) && o.push(a.data), s(a);
+      });
+    };
+    return s(this), o;
+  }
+  getCheckedKeys(e = !1) {
+    return this.getCheckedNodes(e).map((t) => (t || {})[this.key]);
+  }
+  getHalfCheckedNodes() {
+    const e = [], t = function(o) {
+      (o.root ? o.root.childNodes : o.childNodes).forEach((s) => {
+        s.indeterminate && e.push(s.data), t(s);
+      });
+    };
+    return t(this), e;
+  }
+  getHalfCheckedKeys() {
+    return this.getHalfCheckedNodes().map((e) => (e || {})[this.key]);
+  }
+  _getAllNodes() {
+    const e = [], t = this.nodesMap;
+    for (const o in t) De(t, o) && e.push(t[o]);
+    return e;
+  }
+  updateChildren(e, t) {
+    const o = this.nodesMap[e];
+    if (!o) return;
+    const s = o.childNodes;
+    for (let n = s.length - 1; n >= 0; n--) {
+      const a = s[n];
+      this.remove(a.data);
+    }
+    for (let n = 0, a = t.length; n < a; n++) {
+      const d = t[n];
+      this.append(d, o.data);
+    }
+  }
+  _setCheckedKeys(e, t = !1, o) {
+    const s = this._getAllNodes().sort((l, p) => l.level - p.level), n = /* @__PURE__ */ Object.create(null), a = Object.keys(o);
+    s.forEach((l) => l.setChecked(!1, !1));
+    const d = (l) => {
+      l.childNodes.forEach((p) => {
+        var h;
+        n[p.data[e]] = !0, (h = p.childNodes) != null && h.length && d(p);
+      });
+    };
+    for (let l = 0, p = s.length; l < p; l++) {
+      const h = s[l], u = h.data[e].toString();
+      if (!a.includes(u)) {
+        h.checked && !n[u] && h.setChecked(!1, !1);
+        continue;
+      }
+      if (h.childNodes.length && d(h), h.isLeaf || this.checkStrictly) {
+        h.setChecked(!0, !1);
+        continue;
+      }
+      if (h.setChecked(!0, !0), t) {
+        h.setChecked(!1, !1, !0);
+        const r = function(c) {
+          c.childNodes.forEach((y) => {
+            y.isLeaf || y.setChecked(!1, !1, !0), r(y);
+          }), c.reInitChecked();
+        };
+        r(h);
+      }
+    }
+  }
+  setCheckedNodes(e, t = !1) {
+    const o = this.key, s = {};
+    e.forEach((n) => {
+      s[(n || {})[o]] = !0;
+    }), this._setCheckedKeys(o, t, s);
+  }
+  setCheckedKeys(e, t = !1) {
+    this.defaultCheckedKeys = e;
+    const o = this.key, s = {};
+    e.forEach((n) => {
+      s[n] = !0;
+    }), this._setCheckedKeys(o, t, s);
+  }
+  setDefaultExpandedKeys(e) {
+    e = e || [], this.defaultExpandedKeys = e, e.forEach((t) => {
+      const o = this.getNode(t);
+      o && o.expand(null, this.autoExpandParent);
+    });
+  }
+  setChecked(e, t, o) {
+    const s = this.getNode(e);
+    s && s.setChecked(!!t, o);
+  }
+  getCurrentNode() {
+    return this.currentNode;
+  }
+  setCurrentNode(e) {
+    const t = this.currentNode;
+    t && (t.isCurrent = !1), this.currentNode = e, this.currentNode.isCurrent = !0;
+  }
+  setUserCurrentNode(e, t = !0) {
+    var n;
+    const o = e[this.key], s = this.nodesMap[o];
+    this.setCurrentNode(s), t && this.currentNode && this.currentNode.level > 1 && ((n = this.currentNode.parent) == null || n.expand(null, !0));
+  }
+  setCurrentNodeKey(e, t = !0) {
+    var s;
+    if (this.currentNodeKey = e, Pe(e)) {
+      this.currentNode && (this.currentNode.isCurrent = !1), this.currentNode = null;
+      return;
+    }
+    const o = this.getNode(e);
+    o && (this.setCurrentNode(o), t && this.currentNode && this.currentNode.level > 1 && ((s = this.currentNode.parent) == null || s.expand(null, !0)));
+  }
+};
+function Xe(e) {
+  const t = fe(He, null);
+  let o = {
+    treeNodeExpand: (s) => {
+      var n;
+      e.node !== s && ((n = e.node) == null || n.collapse());
+    },
+    children: /* @__PURE__ */ new Set()
+  };
+  return t && t.children.add(o), Ye(() => {
+    t && t.children.delete(o), o = null;
+  }), pe(He, o), { broadcastExpanded: (s) => {
+    if (e.accordion)
+      for (const n of o.children) n.treeNodeExpand(s);
+  } };
+}
+const Ze = Symbol("dragEvents");
+function Mt({ props: e, ctx: t, el$: o, dropIndicator$: s, store: n }) {
+  const a = ae("tree"), d = w({
+    showDropIndicator: !1,
+    draggingNode: null,
+    dropNode: null,
+    allowDrop: !0,
+    dropType: null
+  });
+  return pe(Ze, {
+    treeNodeDragStart: ({ event: u, treeNode: r }) => {
+      if (u.dataTransfer) {
+        if (me(e.allowDrag) && !e.allowDrag(r.node))
+          return u.preventDefault(), !1;
+        u.dataTransfer.effectAllowed = "move";
+        try {
+          u.dataTransfer.setData("text/plain", "");
+        } catch {
+        }
+        d.value.draggingNode = r, t.emit("node-drag-start", r.node, u);
+      }
+    },
+    treeNodeDragOver: ({ event: u, treeNode: r }) => {
+      if (!u.dataTransfer) return;
+      const c = r, y = d.value.dropNode;
+      y && y.node.id !== c.node.id && Ee(y.$el, a.is("drop-inner"));
+      const E = d.value.draggingNode;
+      if (!E || !c) return;
+      let x = !0, N = !0, k = !0, S = !0;
+      me(e.allowDrop) && (x = e.allowDrop(E.node, c.node, "prev"), S = N = e.allowDrop(E.node, c.node, "inner"), k = e.allowDrop(E.node, c.node, "next")), u.dataTransfer.dropEffect = N || x || k ? "move" : "none", (x || N || k) && (y == null ? void 0 : y.node.id) !== c.node.id && (y && t.emit("node-drag-leave", E.node, y.node, u), t.emit("node-drag-enter", E.node, c.node, u)), x || N || k ? d.value.dropNode = c : d.value.dropNode = null, c.node.nextSibling === E.node && (k = !1), c.node.previousSibling === E.node && (x = !1), c.node.contains(E.node, !1) && (N = !1), (E.node === c.node || E.node.contains(c.node)) && (x = !1, N = !1, k = !1);
+      const j = c.$el, V = j.querySelector(`.${a.be("node", "content")}`).getBoundingClientRect(), H = o.value.getBoundingClientRect(), M = o.value.scrollTop;
+      let P;
+      const U = x ? N ? 0.25 : k ? 0.45 : 1 : Number.NEGATIVE_INFINITY, v = k ? N ? 0.75 : x ? 0.55 : 0 : Number.POSITIVE_INFINITY;
+      let b = -9999;
+      const B = u.clientY - V.top;
+      B < V.height * U ? P = "before" : B > V.height * v ? P = "after" : N ? P = "inner" : P = "none";
+      const O = j.querySelector(`.${a.be("node", "expand-icon")}`).getBoundingClientRect(), te = s.value;
+      P === "before" ? b = O.top - H.top + M : P === "after" && (b = O.bottom - H.top + M), te.style.top = `${b}px`, te.style.left = `${O.right - H.left}px`, P === "inner" ? at(j, a.is("drop-inner")) : Ee(j, a.is("drop-inner")), d.value.showDropIndicator = P === "before" || P === "after", d.value.allowDrop = d.value.showDropIndicator || S, d.value.dropType = P, t.emit("node-drag-over", E.node, c.node, u);
+    },
+    treeNodeDragEnd: (u) => {
+      var E, x;
+      const { draggingNode: r, dropType: c, dropNode: y } = d.value;
+      if (u.preventDefault(), u.dataTransfer && (u.dataTransfer.dropEffect = "move"), r != null && r.node.data && y) {
+        const N = { data: r.node.data };
+        c !== "none" && r.node.remove(), c === "before" ? (E = y.node.parent) == null || E.insertBefore(N, y.node) : c === "after" ? (x = y.node.parent) == null || x.insertAfter(N, y.node) : c === "inner" && y.node.insertChild(N), c !== "none" && (n.value.registerNode(N), n.value.key && r.node.eachNode((k) => {
+          var S;
+          (S = n.value.nodesMap[k.data[n.value.key]]) == null || S.setChecked(k.checked, !n.value.checkStrictly);
+        })), Ee(y.$el, a.is("drop-inner")), t.emit("node-drag-end", r.node, y.node, c, u), c !== "none" && t.emit("node-drop", r.node, y.node, c, u);
+      }
+      r && !y && t.emit("node-drag-end", r.node, null, c, u), d.value.showDropIndicator = !1, d.value.draggingNode = null, d.value.dropNode = null, d.value.allowDrop = !0;
+    }
+  }), { dragState: d };
+}
+var zt = de({
+  name: "ElTreeNodeContent",
+  props: {
+    node: {
+      type: Object,
+      required: !0
+    },
+    renderContent: Function
+  },
+  setup(e) {
+    const t = ae("tree"), o = fe(Je), s = fe(Le);
+    return () => {
+      const n = e.node, { data: a, store: d } = n;
+      return e.renderContent ? e.renderContent($e, {
+        _self: o,
+        node: n,
+        data: a,
+        store: d
+      }) : be(s.ctx.slots, "default", {
+        node: n,
+        data: a
+      }, () => [$e(Ot, {
+        tag: "span",
+        truncated: !0,
+        class: t.be("node", "label")
+      }, () => [n.label])]);
+    };
+  }
+}), Ft = zt, Rt = de({
+  name: "ElTreeNode",
+  components: {
+    ElCollapseTransition: St,
+    ElCheckbox: dt,
+    NodeContent: Ft,
+    ElIcon: rt,
+    Loading: Dt
+  },
+  props: {
+    node: {
+      type: Se,
+      default: () => ({})
+    },
+    props: {
+      type: Object,
+      default: () => ({})
+    },
+    accordion: Boolean,
+    renderContent: Function,
+    renderAfterExpand: Boolean,
+    showCheckbox: Boolean
+  },
+  emits: ["node-expand"],
+  setup(e, t) {
+    const o = ae("tree"), { broadcastExpanded: s } = Xe(e), n = fe(Le), a = w(!1), d = w(!1), l = w(), p = w(), h = w(), u = fe(Ze), r = We();
+    pe(Je, r), n || it("Tree", "Can not find node's tree."), e.node.expanded && (a.value = !0, d.value = !0);
+    const c = n.props.props.children || "children";
+    q(() => {
+      var b;
+      const v = (b = e.node.data) == null ? void 0 : b[c];
+      return v && [...v];
+    }, () => {
+      e.node.updateChildren();
+    }), q(() => e.node.indeterminate, (v) => {
+      x(e.node.checked, v);
+    }), q(() => e.node.checked, (v) => {
+      x(v, e.node.indeterminate);
+    }), q(() => e.node.childNodes.length, () => e.node.reInitChecked()), q(() => e.node.expanded, (v) => {
+      re(() => a.value = v), v && (d.value = !0);
+    });
+    const y = (v) => n.props.nodeKey ? Oe(n.props.nodeKey, v.data) : v.id, E = (v) => {
+      const b = e.props.class;
+      if (!b) return {};
+      let B;
+      if (me(b)) {
+        const { data: O } = v;
+        B = b(O, v);
+      } else B = b;
+      return Fe(B) ? { [B]: !0 } : B;
+    }, x = (v, b) => {
+      (l.value !== v || p.value !== b) && n.ctx.emit("check-change", e.node.data, v, b), l.value = v, p.value = b;
+    }, N = (v) => {
+      Te(n.store, n.ctx.emit, () => {
+        var b;
+        if ((b = n == null ? void 0 : n.props) != null && b.nodeKey) {
+          const B = y(e.node);
+          n.store.value.setCurrentNodeKey(B);
+        } else n.store.value.setCurrentNode(e.node);
+      }), n.currentNode.value = e.node, n.props.expandOnClickNode && S(), (n.props.checkOnClickNode || e.node.isLeaf && n.props.checkOnClickLeaf && e.showCheckbox) && !e.node.disabled && j(!e.node.checked), n.ctx.emit("node-click", e.node.data, e.node, r, v);
+    }, k = (v) => {
+      var b;
+      (b = n.instance.vnode.props) != null && b.onNodeContextmenu && (v.stopPropagation(), v.preventDefault()), n.ctx.emit("node-contextmenu", v, e.node.data, e.node, r);
+    }, S = () => {
+      e.node.isLeaf || (a.value ? (n.ctx.emit("node-collapse", e.node.data, e.node, r), e.node.collapse()) : e.node.expand(() => {
+        t.emit("node-expand", e.node.data, e.node, r);
+      }));
+    }, j = (v) => {
+      const b = n == null ? void 0 : n.props.checkStrictly, B = e.node.childNodes;
+      !b && B.length && (v = B.some((O) => !O.isEffectivelyChecked)), e.node.setChecked(v, !b), re(() => {
+        const O = n.store.value;
+        n.ctx.emit("check", e.node.data, {
+          checkedNodes: O.getCheckedNodes(),
+          checkedKeys: O.getCheckedKeys(),
+          halfCheckedNodes: O.getHalfCheckedNodes(),
+          halfCheckedKeys: O.getHalfCheckedKeys()
+        });
+      });
+    };
+    return {
+      ns: o,
+      node$: h,
+      tree: n,
+      expanded: a,
+      childNodeRendered: d,
+      oldChecked: l,
+      oldIndeterminate: p,
+      getNodeKey: y,
+      getNodeClass: E,
+      handleSelectChange: x,
+      handleClick: N,
+      handleContextMenu: k,
+      handleExpandIconClick: S,
+      handleCheckChange: j,
+      handleChildNodeExpand: (v, b, B) => {
+        s(b), n.ctx.emit("node-expand", v, b, B);
+      },
+      handleDragStart: (v) => {
+        n.props.draggable && u.treeNodeDragStart({
+          event: v,
+          treeNode: e
+        });
+      },
+      handleDragOver: (v) => {
+        v.preventDefault(), n.props.draggable && u.treeNodeDragOver({
+          event: v,
+          treeNode: {
+            $el: h.value,
+            node: e.node
+          }
+        });
+      },
+      handleDrop: (v) => {
+        v.preventDefault();
+      },
+      handleDragEnd: (v) => {
+        n.props.draggable && u.treeNodeDragEnd(v);
+      },
+      CaretRight: wt
+    };
+  }
+});
+const qt = [
+  "aria-expanded",
+  "aria-disabled",
+  "aria-checked",
+  "draggable",
+  "data-key"
+], Vt = ["aria-expanded"];
+function Ut(e, t, o, s, n, a) {
+  const d = oe("el-icon"), l = oe("el-checkbox"), p = oe("loading"), h = oe("node-content"), u = oe("el-tree-node"), r = oe("el-collapse-transition");
+  return G((I(), $("div", {
+    ref: "node$",
+    class: F([
+      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[2] || (t[2] = ee((...c) => e.handleClick && e.handleClick(...c), ["stop"])),
+    onContextmenu: t[3] || (t[3] = (...c) => e.handleContextMenu && e.handleContextMenu(...c)),
+    onDragstart: t[4] || (t[4] = ee((...c) => e.handleDragStart && e.handleDragStart(...c), ["stop"])),
+    onDragover: t[5] || (t[5] = ee((...c) => e.handleDragOver && e.handleDragOver(...c), ["stop"])),
+    onDragend: t[6] || (t[6] = ee((...c) => e.handleDragEnd && e.handleDragEnd(...c), ["stop"])),
+    onDrop: t[7] || (t[7] = ee((...c) => e.handleDrop && e.handleDrop(...c), ["stop"]))
+  }, [D("div", {
+    class: F(e.ns.be("node", "content")),
+    style: Ue({ paddingLeft: (e.node.level - 1) * e.tree.props.indent + "px" })
+  }, [
+    e.tree.props.icon || e.CaretRight ? (I(), Y(d, {
+      key: 0,
+      class: F([
+        e.ns.be("node", "expand-icon"),
+        e.ns.is("leaf", e.node.isLeaf),
+        { expanded: !e.node.isLeaf && e.expanded }
+      ]),
+      onClick: ee(e.handleExpandIconClick, ["stop"])
+    }, {
+      default: L(() => [(I(), Y(Ve(e.tree.props.icon || e.CaretRight)))]),
+      _: 1
+    }, 8, ["class", "onClick"])) : le("v-if", !0),
+    e.showCheckbox ? (I(), Y(l, {
+      key: 1,
+      "model-value": e.node.checked,
+      indeterminate: e.node.indeterminate,
+      disabled: !!e.node.disabled,
+      onClick: t[0] || (t[0] = ee(() => {
+      }, ["stop"])),
+      onChange: e.handleCheckChange
+    }, null, 8, [
+      "model-value",
+      "indeterminate",
+      "disabled",
+      "onChange"
+    ])) : le("v-if", !0),
+    e.node.loading ? (I(), Y(d, {
+      key: 2,
+      class: F([e.ns.be("node", "loading-icon"), e.ns.is("loading")])
+    }, {
+      default: L(() => [A(p)]),
+      _: 1
+    }, 8, ["class"])) : le("v-if", !0),
+    A(h, {
+      node: e.node,
+      "render-content": e.renderContent
+    }, null, 8, ["node", "render-content"])
+  ], 6), A(r, null, {
+    default: L(() => [!e.renderAfterExpand || e.childNodeRendered ? G((I(), $("div", {
+      key: 0,
+      class: F(e.ns.be("node", "children")),
+      role: "group",
+      "aria-expanded": e.expanded,
+      onClick: t[1] || (t[1] = ee(() => {
+      }, ["stop"]))
+    }, [(I(!0), $(ue, null, he(e.node.childNodes, (c) => (I(), Y(u, {
+      key: e.getNodeKey(c),
+      "render-content": e.renderContent,
+      "render-after-expand": e.renderAfterExpand,
+      "show-checkbox": e.showCheckbox,
+      node: c,
+      accordion: e.accordion,
+      props: e.props,
+      onNodeExpand: e.handleChildNodeExpand
+    }, null, 8, [
+      "render-content",
+      "render-after-expand",
+      "show-checkbox",
+      "node",
+      "accordion",
+      "props",
+      "onNodeExpand"
+    ]))), 128))], 10, Vt)), [[Q, e.expanded]]) : le("v-if", !0)]),
+    _: 1
+  })], 42, qt)), [[Q, e.node.visible]]);
+}
+var Yt = /* @__PURE__ */ Re(Rt, [["render", Ut]]);
+function Wt({ el$: e }, t) {
+  const o = ae("tree");
+  Ae(() => {
+    a();
+  }), qe(() => {
+    var d;
+    (d = e.value) == null || d.querySelectorAll("input[type=checkbox]").forEach((l) => {
+      l.setAttribute("tabindex", "-1");
+    });
+  });
+  function s(d, l) {
+    var h, u;
+    const p = t.value.getNode(d[l].dataset.key);
+    return p.canFocus && p.visible && (((h = p.parent) == null ? void 0 : h.expanded) || ((u = p.parent) == null ? void 0 : u.level) === 0);
+  }
+  lt(e, "keydown", (d) => {
+    const l = d.target;
+    if (!l.className.includes(o.b("node"))) return;
+    const p = ct(d), h = Array.from(e.value.querySelectorAll(`.${o.is("focusable")}[role=treeitem]`)), u = h.indexOf(l);
+    let r;
+    if ([Z.up, Z.down].includes(p)) {
+      if (d.preventDefault(), p === Z.up) {
+        r = u === -1 ? 0 : u !== 0 ? u - 1 : h.length - 1;
+        const y = r;
+        for (; !s(h, r); ) {
+          if (r--, r === y) {
+            r = -1;
+            break;
+          }
+          r < 0 && (r = h.length - 1);
+        }
+      } else {
+        r = u === -1 ? 0 : u < h.length - 1 ? u + 1 : 0;
+        const y = r;
+        for (; !s(h, r); ) {
+          if (r++, r === y) {
+            r = -1;
+            break;
+          }
+          r >= h.length && (r = 0);
+        }
+      }
+      r !== -1 && h[r].focus();
+    }
+    [Z.left, Z.right].includes(p) && (d.preventDefault(), l.click());
+    const c = l.querySelector('[type="checkbox"]');
+    [
+      Z.enter,
+      Z.numpadEnter,
+      Z.space
+    ].includes(p) && c && (d.preventDefault(), c.click());
+  });
+  const a = () => {
+    var p;
+    if (!e.value) return;
+    const d = Array.from(e.value.querySelectorAll(`.${o.is("focusable")}[role=treeitem]`));
+    Array.from(e.value.querySelectorAll("input[type=checkbox]")).forEach((h) => {
+      h.setAttribute("tabindex", "-1");
+    });
+    const l = e.value.querySelectorAll(`.${o.is("checked")}[role=treeitem]`);
+    if (l.length) {
+      l[0].setAttribute("tabindex", "0");
+      return;
+    }
+    (p = d[0]) == null || p.setAttribute("tabindex", "0");
+  };
+}
+var Jt = de({
+  name: "ElTree",
+  components: { ElTreeNode: Yt },
+  props: Pt,
+  emits: jt,
+  setup(e, t) {
+    const { t: o } = ut(), s = ae("tree"), n = w(new Ht({
+      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 a = w(n.value.root), d = w(null), l = w(null), p = w(null), { broadcastExpanded: h } = Xe(e), { dragState: u } = Mt({
+      props: e,
+      ctx: t,
+      el$: l,
+      dropIndicator$: p,
+      store: n
+    });
+    Wt({ el$: l }, n);
+    const r = We(), c = Ke(() => {
+      let i = r == null ? void 0 : r.parent;
+      for (; i; ) {
+        if (i.type.name === "ElTreeSelect") return !0;
+        i = i.parent;
+      }
+      return !1;
+    }), y = Ke(() => {
+      const { childNodes: i } = a.value;
+      return (!i || i.length === 0 || i.every(({ visible: C }) => !C)) && !c.value;
+    });
+    q(() => e.currentNodeKey, (i) => {
+      n.value.setCurrentNodeKey(i ?? null);
+    }), q(() => e.defaultCheckedKeys, (i, C) => {
+      ht(i, C) || n.value.setDefaultCheckedKey(i ?? []);
+    }), q(() => e.defaultExpandedKeys, (i) => {
+      n.value.setDefaultExpandedKeys(i ?? []);
+    }), q(() => e.data, (i) => {
+      n.value.setData(i);
+    }, { deep: !0 }), q(() => e.checkStrictly, (i) => {
+      n.value.checkStrictly = i;
+    });
+    const E = (i) => {
+      if (!e.filterNodeMethod) throw new Error("[Tree] filterNodeMethod is required when filter");
+      n.value.filter(i);
+    }, x = (i) => e.nodeKey ? Oe(e.nodeKey, i.data) : i.id, N = (i) => {
+      if (!e.nodeKey) throw new Error(`[Tree] nodeKey is required in ${i}`);
+    }, k = (i) => {
+      N("getNodePath");
+      const C = n.value.getNode(i);
+      if (!C) return [];
+      const K = [C.data];
+      let z = C.parent;
+      for (; z && z !== a.value; )
+        K.push(z.data), z = z.parent;
+      return K.reverse();
+    }, S = (i, C) => n.value.getCheckedNodes(i, C), j = (i) => n.value.getCheckedKeys(i), V = () => {
+      const i = n.value.getCurrentNode();
+      return i ? i.data : null;
+    }, H = () => {
+      N("getCurrentKey");
+      const i = V();
+      return i ? i[e.nodeKey] : null;
+    }, M = (i, C) => {
+      N("setCheckedNodes"), n.value.setCheckedNodes(i, C);
+    }, P = (i, C) => {
+      N("setCheckedKeys"), n.value.setCheckedKeys(i, C);
+    }, U = (i, C, K = !1) => {
+      n.value.setChecked(i, C, K);
+    }, v = () => n.value.getHalfCheckedNodes(), b = () => n.value.getHalfCheckedKeys(), B = (i, C = !0) => {
+      N("setCurrentNode"), Te(n, t.emit, () => {
+        h(i), n.value.setUserCurrentNode(i, C);
+      });
+    }, O = (i = null, C = !0) => {
+      N("setCurrentKey"), Te(n, t.emit, () => {
+        h(), n.value.setCurrentNodeKey(i, C);
+      });
+    }, te = (i) => n.value.getNode(i), W = (i) => {
+      n.value.remove(i);
+    }, J = (i, C) => {
+      n.value.append(i, C);
+    }, ie = (i, C) => {
+      n.value.insertBefore(i, C);
+    }, f = (i, C) => {
+      n.value.insertAfter(i, C);
+    }, g = (i, C, K) => {
+      h(C), t.emit("node-expand", i, C, K);
+    }, _ = (i, C) => {
+      N("updateKeyChildren"), n.value.updateChildren(i, C);
+    };
+    return pe(Le, {
+      ctx: t,
+      props: e,
+      store: n,
+      root: a,
+      currentNode: d,
+      instance: r
+    }), pe(ft, void 0), {
+      ns: s,
+      store: n,
+      root: a,
+      currentNode: d,
+      dragState: u,
+      el$: l,
+      dropIndicator$: p,
+      isEmpty: y,
+      filter: E,
+      getNodeKey: x,
+      getNodePath: k,
+      getCheckedNodes: S,
+      getCheckedKeys: j,
+      getCurrentNode: V,
+      getCurrentKey: H,
+      setCheckedNodes: M,
+      setCheckedKeys: P,
+      setChecked: U,
+      getHalfCheckedNodes: v,
+      getHalfCheckedKeys: b,
+      setCurrentNode: B,
+      setCurrentKey: O,
+      t: o,
+      getNode: te,
+      remove: W,
+      append: J,
+      insertBefore: ie,
+      insertAfter: f,
+      handleNodeExpand: g,
+      updateKeyChildren: _
+    };
+  }
+});
+function Gt(e, t, o, s, n, a) {
+  const d = oe("el-tree-node");
+  return I(), $("div", {
+    ref: "el$",
+    class: F([
+      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"
+  }, [
+    (I(!0), $(ue, null, he(e.root.childNodes, (l) => (I(), Y(d, {
+      key: e.getNodeKey(l),
+      node: l,
+      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 ? (I(), $("div", {
+      key: 0,
+      class: F(e.ns.e("empty-block"))
+    }, [be(e.$slots, "empty", {}, () => [D("span", { class: F(e.ns.e("empty-text")) }, R(e.emptyText ?? e.t("el.tree.emptyText")), 3)])], 2)) : le("v-if", !0),
+    G(D("div", {
+      ref: "dropIndicator$",
+      class: F(e.ns.e("drop-indicator"))
+    }, null, 2), [[Q, e.dragState.showDropIndicator]])
+  ], 2);
+}
+var Qt = /* @__PURE__ */ Re(Jt, [["render", Gt]]);
+const Xt = Be(Qt), Zt = {
+  key: 0,
+  class: "panel_content"
+}, en = { class: "types" }, tn = ["onClick"], nn = { class: "tree" }, on = {
+  key: 1,
+  class: "panel_content_null"
+}, sn = { class: "pc_tree_type_button" }, an = ["onClick"], rn = { class: "pc_tree_content" }, dn = { class: "tree-search-box" }, ln = { class: "tree-wrapper" }, cn = ["id"], un = { class: "tree-wrapper" }, hn = ["id"], fn = { class: "tree-wrapper" }, pn = ["id"], yn = {
+  key: 2,
+  class: "operate-tree-box"
+}, vn = { class: "operate-tree" }, gn = { class: "tree-title-box" }, kn = { class: "tree-title" }, Nn = { class: "tree-title-icon" }, Cn = { class: "tree-category-box" }, mn = { class: "tree-category-list" }, bn = ["onClick"], _n = { class: "tree-search-box" }, En = { class: "tree-content" }, xn = { class: "tree-wrapper" }, Dn = ["id"], wn = { class: "tree-wrapper" }, Kn = ["id"], Tn = { class: "tree-wrapper" }, In = ["id"], Sn = /* @__PURE__ */ de({
+  __name: "StructureTree",
+  props: ["componentId"],
+  emits: ["closePanel", "emitHandler"],
+  setup(e, { emit: t }) {
+    const o = pt(), s = yt(), n = e, a = w(!1), d = w(!1), l = w(), p = w(), h = w(), u = w(), r = w(0), c = w(), y = w(), E = w(), x = w(), N = w();
+    let k;
+    const S = w(""), j = w(""), V = w("");
+    q(
+      () => s.isToolActive(n.componentId),
+      (f) => {
+        if (a.value && f) {
+          if (d.value || O(ke[0]), j.value == V.value || j.value == "")
+            return;
+          B(j.value);
+        }
+      }
+    ), q(S, (f) => {
+      var g, _, i;
+      r.value === 0 ? (g = l.value) == null || g.filter(f) : r.value === 1 ? (_ = p.value) == null || _.filter(f) : r.value === 2 && ((i = h.value) == null || i.filter(f));
+    });
+    const H = (f, g) => f ? g.title.includes(S.value) : !0, M = {
+      children: "children",
+      label: "title",
+      value: "nodeId"
+    }, P = t, U = (f) => {
+      P("emitHandler", f);
+    }, v = w(!1);
+    Ae(() => {
+      ne("userInfo").isInShare && ne("userInfo").isShareClient && (v.value = !0), s.setReadyById(n.componentId);
+    });
+    const b = () => {
+      d.value = !1, k = window.bimViewer;
+      const { eventTrigger: f } = k;
+      f.on("treeAllReady", (g) => {
+        a.value = !0, u.value = g, console.log("[Bimx Engine] 结构树数据已就绪"), k.SetShowSpaceModeActive(!1);
+      }), ne("isMobile") || f.on("pickedEntity", (g) => {
+        d.value && (j.value = g.id, s.isToolActive(n.componentId) && B(g.id));
+      }), ne("isMobile") && (f.on("touchEntity", (g) => {
+        d.value !== !1 && (j.value = g.id, s.isToolActive(n.componentId) && B(g.id));
+      }), f.on("touchNothing", () => {
+        re(() => {
+          N.value = "";
+        }), U({
+          isTool: !0,
+          event_target: "StructureTree",
+          event_name: "touchNothing",
+          content: {
+            msg: "pickedNothing"
+          }
+        });
+      }));
+    };
+    ge.on("BimViewer", b), Ye(() => {
+      ge.off("BimViewer", b);
+    });
+    const B = (f) => {
+      let g, _;
+      r.value === 0 ? g = k.objectsExplorer.objectList[f] ? k.objectsExplorer.objectList[f] : null : r.value === 1 ? g = k.classesExplorer.objectList[f] ? k.classesExplorer.objectList[f] : null : r.value === 2 && (g = k.storeysExplorer.objectList[f] ? k.storeysExplorer.objectList[f] : null), g && (N.value = g.nodeId, r.value === 0 ? (l.value.setCurrentKey(g.nodeId, !0), _ = document.getElementById(g.nodeId + "0")) : r.value === 1 ? (p.value.setCurrentKey(g.nodeId, !0), _ = document.getElementById(g.nodeId + "1")) : r.value === 2 && (h.value.setCurrentKey(g.nodeId, !0), _ = document.getElementById(g.nodeId + "2")), setTimeout(() => {
+        _ && re(() => {
+          _.scrollIntoView({ block: "center" });
+        });
+      }, 200), V.value = f, U({
+        isTool: !0,
+        event_target: "StructureTree",
+        event_name: "pickedEntity",
+        content: {
+          entityId: f,
+          viewer_nodeId: g.nodeId
+        }
+      }));
+    }, O = (f) => {
+      if (u.value) {
+        if (f.id == 0) {
+          if (!y.value) {
+            if (y.value = u.value.objectsData ? u.value.objectsData : [], y.value[0]) {
+              y.value[0].title = o("structure.all");
+              const g = y.value.map((_) => _.nodeId);
+              l.value.setCheckedKeys(g);
+            }
+            d.value = !0;
+          }
+        } else if (f.id == 1) {
+          if (!x.value && (E.value = u.value.classesData ? u.value.classesData : [], E.value[0])) {
+            E.value[0].title = o("structure.all");
+            const g = E.value.map((_) => _.nodeId);
+            p.value.setCheckedKeys(g);
+          }
+        } else if (f.id == 2 && !x.value && (x.value = u.value.storeysData ? u.value.storeysData : [], x.value[0])) {
+          x.value[0].title = o("structure.all");
+          const g = x.value.map((_) => _.nodeId);
+          h.value.setCheckedKeys(g);
+        }
+        U({
+          isTool: !0,
+          event_target: "StructureTree",
+          event_name: "changeTreeStructure",
+          content: {
+            item: f
+          }
+        }), r.value !== f.id && (r.value = f.id);
+      }
+    };
+    let te = [];
+    const W = (f, g) => {
+      te.includes(f.nodeId) ? f.checked = !0 : f.checked = !f.checked;
+      const _ = k.viewer.scene.objects[f.objectId];
+      _ ? k.setEntityVisible(_, f.checked) : i(f, f.checked), C(f, f.checked), U({
+        isTool: !0,
+        event_target: "StructureTree",
+        event_name: "clickTreeBox",
+        content: {
+          active_tree: r.value,
+          nodeId: f.nodeId,
+          status: f.checked
+        }
+      });
+      function i(K, z) {
+        if (K.checked = z, K.children.length == 0) {
+          const X = k.viewer.scene.objects[K.objectId];
+          X && k.setEntityVisible(X, K.checked);
+        } else
+          for (let X = 0; X < K.children.length; X++)
+            i(K.children[X], z);
+      }
+      function C(K, z) {
+        K.checked = z, K.parent && C(K.parent, z);
+      }
+      te = g.halfCheckedKeys;
+    }, J = (f, g) => {
+      const _ = k.viewer.scene.objects[f.objectId];
+      _ && (k.setAllObjectsSelected(!1), k.setEntitySelected(_), k.viewFitEntity(_)), ge.emit("tree_clickNode", _), U({
+        isTool: !0,
+        event_target: "StructureTree",
+        event_name: "clickTreeNode",
+        content: {
+          active_tree: r.value,
+          objectId: f.objectId
+        }
+      });
+    }, ie = () => {
+      ge.emit("hideToolbar", !1), P("closePanel");
+    };
+    return (f, g) => {
+      const _ = Xt, i = Kt, C = vt, K = gt, z = Ct, X = kt;
+      return !T(ne)("isMobile") && T(je).currentTheme == "blue" ? (I(), Y(i, {
+        key: 0,
+        class: "web_tree_container",
+        width: 268,
+        panelTitle: T(o)("structure.title"),
+        "click-handle": ie
+      }, {
+        default: L(() => [
+          d.value ? (I(), $("div", Zt, [
+            D("div", en, [
+              (I(!0), $(ue, null, he(T(ke), (m) => (I(), $("div", {
+                key: m.id,
+                class: F(["types-item", { "types-item-active": r.value === m.id }]),
+                onClick: (_e) => O(m)
+              }, R(T(o)(m.name)), 11, tn))), 128))
+            ]),
+            D("div", nn, [
+              A(_, {
+                ref: "tree",
+                height: 700,
+                "node-key": "nodeId",
+                data: c.value,
+                "current-node-key": N.value,
+                "highlight-current": !0,
+                props: M,
+                "show-checkbox": "",
+                onCheck: W,
+                onNodeClick: J,
+                "empty-text": T(o)("common.noData")
+              }, null, 8, ["data", "current-node-key", "empty-text"])
+            ])
+          ])) : (I(), $("div", on, [
+            D("span", null, R(T(o)("common.loading")), 1)
+          ]))
+        ]),
+        _: 1
+      }, 8, ["panelTitle"])) : !T(ne)("isMobile") && T(je).currentTheme == "light-gray" ? (I(), Y(z, {
+        key: 1,
+        class: "pc_structure_container",
+        width: 286,
+        panelTitle: T(o)("structure.title"),
+        "click-handle": ie,
+        pos: T(ne)("treePos"),
+        setWidth: ""
+      }, {
+        default: L(() => [
+          D("div", sn, [
+            (I(!0), $(ue, null, he(T(ke), (m) => (I(), $("div", {
+              key: m.id,
+              class: F(["type_button", { type_button_active: r.value === m.id }]),
+              onClick: (_e) => O(m)
+            }, R(T(o)(m.name)), 11, an))), 128))
+          ]),
+          D("div", rn, [
+            D("div", dn, [
+              A(C, {
+                modelValue: S.value,
+                "onUpdate:modelValue": g[0] || (g[0] = (m) => S.value = m),
+                placeholder: T(o)("structure.search"),
+                "prefix-icon": "Search",
+                clearable: ""
+              }, null, 8, ["modelValue", "placeholder"])
+            ]),
+            G(D("div", ln, [
+              A(K, null, {
+                default: L(() => [
+                  A(_, {
+                    ref_key: "tree0",
+                    ref: l,
+                    "node-key": "nodeId",
+                    data: y.value,
+                    "current-node-key": N.value,
+                    "highlight-current": !0,
+                    props: M,
+                    "filter-node-method": H,
+                    "show-checkbox": "",
+                    onCheck: W,
+                    onNodeClick: J,
+                    "empty-text": T(o)("common.noData")
+                  }, {
+                    default: L(({ node: m }) => [
+                      D("span", {
+                        id: m.key + "0",
+                        class: "tree_node_text"
+                      }, R(m.data.title), 9, cn)
+                    ]),
+                    _: 1
+                  }, 8, ["data", "current-node-key", "empty-text"])
+                ]),
+                _: 1
+              })
+            ], 512), [
+              [Q, r.value == 0]
+            ]),
+            G(D("div", un, [
+              A(K, null, {
+                default: L(() => [
+                  A(_, {
+                    ref_key: "tree1",
+                    ref: p,
+                    "node-key": "nodeId",
+                    data: E.value,
+                    "current-node-key": N.value,
+                    "highlight-current": !0,
+                    props: M,
+                    "filter-node-method": H,
+                    "show-checkbox": "",
+                    onCheck: W,
+                    onNodeClick: J,
+                    "empty-text": T(o)("common.noData")
+                  }, {
+                    default: L(({ node: m }) => [
+                      D("span", {
+                        id: m.key + "1",
+                        class: "tree_node_text"
+                      }, R(m.data.title), 9, hn)
+                    ]),
+                    _: 1
+                  }, 8, ["data", "current-node-key", "empty-text"])
+                ]),
+                _: 1
+              })
+            ], 512), [
+              [Q, r.value == 1]
+            ]),
+            G(D("div", fn, [
+              A(K, null, {
+                default: L(() => [
+                  A(_, {
+                    ref_key: "tree2",
+                    ref: h,
+                    "node-key": "nodeId",
+                    data: x.value,
+                    "current-node-key": N.value,
+                    "highlight-current": !0,
+                    props: M,
+                    "filter-node-method": H,
+                    "show-checkbox": "",
+                    onCheck: W,
+                    onNodeClick: J,
+                    "empty-text": T(o)("common.noData")
+                  }, {
+                    default: L(({ node: m }) => [
+                      D("span", {
+                        id: m.key + "2",
+                        class: "tree_node_text"
+                      }, R(m.data.title), 9, pn)
+                    ]),
+                    _: 1
+                  }, 8, ["data", "current-node-key", "empty-text"])
+                ]),
+                _: 1
+              })
+            ], 512), [
+              [Q, r.value == 2]
+            ])
+          ])
+        ]),
+        _: 1
+      }, 8, ["panelTitle", "pos"])) : (I(), $("div", yn, [
+        D("div", vn, [
+          D("div", gn, [
+            D("div", kn, R(T(o)("structure.title")), 1),
+            D("div", Nn, [
+              A(X, {
+                class: "close",
+                width: 0.4,
+                "size-type": "rem",
+                "click-handle": ie
+              })
+            ])
+          ]),
+          D("div", Cn, [
+            A(K, null, {
+              default: L(() => [
+                D("div", mn, [
+                  (I(!0), $(ue, null, he(T(ke), (m, _e) => (I(), $("div", {
+                    key: _e,
+                    class: F(["tree-category-item", {
+                      "tree-category-item-active": m.id === r.value
+                    }]),
+                    onClick: (Bn) => O(m)
+                  }, R(T(o)(m.name)), 11, bn))), 128))
+                ])
+              ]),
+              _: 1
+            })
+          ]),
+          D("div", _n, [
+            A(C, {
+              modelValue: S.value,
+              "onUpdate:modelValue": g[1] || (g[1] = (m) => S.value = m),
+              placeholder: T(o)("structure.search"),
+              "prefix-icon": "Search",
+              clearable: ""
+            }, null, 8, ["modelValue", "placeholder"])
+          ]),
+          D("div", En, [
+            G(D("div", xn, [
+              A(K, null, {
+                default: L(() => [
+                  A(_, {
+                    ref_key: "tree0",
+                    ref: l,
+                    "node-key": "nodeId",
+                    data: y.value,
+                    "current-node-key": N.value,
+                    "highlight-current": !0,
+                    props: M,
+                    "filter-node-method": H,
+                    "show-checkbox": "",
+                    onCheck: W,
+                    onNodeClick: J,
+                    "empty-text": T(o)("common.noData")
+                  }, {
+                    default: L(({ node: m }) => [
+                      D("span", {
+                        id: m.key + "0",
+                        class: "tree_node_text"
+                      }, R(m.data.title), 9, Dn)
+                    ]),
+                    _: 1
+                  }, 8, ["data", "current-node-key", "empty-text"])
+                ]),
+                _: 1
+              })
+            ], 512), [
+              [Q, r.value == 0]
+            ]),
+            G(D("div", wn, [
+              A(K, null, {
+                default: L(() => [
+                  A(_, {
+                    ref_key: "tree1",
+                    ref: p,
+                    "node-key": "nodeId",
+                    data: E.value,
+                    "current-node-key": N.value,
+                    "highlight-current": !0,
+                    props: M,
+                    "filter-node-method": H,
+                    "show-checkbox": "",
+                    onCheck: W,
+                    onNodeClick: J,
+                    "empty-text": T(o)("common.noData")
+                  }, {
+                    default: L(({ node: m }) => [
+                      D("span", {
+                        id: m.key + "1",
+                        class: "tree_node_text"
+                      }, R(m.data.title), 9, Kn)
+                    ]),
+                    _: 1
+                  }, 8, ["data", "current-node-key", "empty-text"])
+                ]),
+                _: 1
+              })
+            ], 512), [
+              [Q, r.value == 1]
+            ]),
+            G(D("div", Tn, [
+              A(K, null, {
+                default: L(() => [
+                  A(_, {
+                    ref_key: "tree2",
+                    ref: h,
+                    "node-key": "nodeId",
+                    data: x.value,
+                    "current-node-key": N.value,
+                    "highlight-current": !0,
+                    props: M,
+                    "filter-node-method": H,
+                    "show-checkbox": "",
+                    onCheck: W,
+                    onNodeClick: J,
+                    "empty-text": T(o)("common.noData")
+                  }, {
+                    default: L(({ node: m }) => [
+                      D("span", {
+                        id: m.key + "2",
+                        class: "tree_node_text"
+                      }, R(m.data.title), 9, In)
+                    ]),
+                    _: 1
+                  }, 8, ["data", "current-node-key", "empty-text"])
+                ]),
+                _: 1
+              })
+            ], 512), [
+              [Q, r.value == 2]
+            ])
+          ])
+        ])
+      ]));
+    };
+  }
+}), Hn = /* @__PURE__ */ Nt(Sn, [["__scopeId", "data-v-70f2d3c0"]]);
+export {
+  Hn as default
+};