@xtctwins/tctwins-bimx-engine 0.1.0

package/dist/StructureTree-CmsIBbBk.mjs

@@ -0,0 +1,1415 @@
+import { i as Pe, m as xt, b as de, d as U, a as ue, u as me, c as Se, e as Me, h as wt, t as Tt, f as It, g as Mt, _ as nt, j as Kt, w as Ot, k as V, l as Lt } from "./index-3StVDuUH.mjs";
+import { E as Rt } from "./el-checkbox-id3wFY0e.mjs";
+import { B as Dt } from "./el-scrollbar-La242VUu.mjs";
+import { _ as zt } from "./closeButton.vue_vue_type_style_index_0_scope_true_lang-CBPVV86B.mjs";
+import { getCurrentInstance as we, computed as M, defineComponent as ce, ref as z, reactive as At, unref as i, watch as _e, onBeforeUnmount as Bt, h as re, withModifiers as Ee, onMounted as Ht, onUpdated as Ft, resolveDynamicComponent as Ke, nextTick as Q, shallowRef as $t, inject as ot, openBlock as ee, createElementBlock as ye, normalizeClass as ie, createElementVNode as se, normalizeStyle as lt, createBlock as Ce, withCtx as st, createCommentVNode as We, createVNode as Oe, useSlots as Pt, provide as Ue, toDisplayString as at, withDirectives as Ye, Fragment as jt, renderList as Vt, vShow as Xe, pushScopeId as Gt, popScopeId as qt } from "vue";
+import { S as Wt } from "./const-DeAig7Pj.mjs";
+import { i as Ut, m as ve, E as Yt } from "./use-form-item-DkYURTpK.mjs";
+import { i as Xt, c as Zt } from "./icon-DZm1Csdm.mjs";
+import { u as Jt } from "./index-BgjjA9sB.mjs";
+const ct = (e) => Pe ? window.requestAnimationFrame(e) : setTimeout(e, 16), rt = (e) => Pe ? window.cancelAnimationFrame(e) : clearTimeout(e);
+var Ze = Number.isNaN || function(t) {
+  return typeof t == "number" && t !== t;
+};
+function Qt(e, t) {
+  return !!(e === t || Ze(e) && Ze(t));
+}
+function en(e, t) {
+  if (e.length !== t.length)
+    return !1;
+  for (var o = 0; o < e.length; o++)
+    if (!Qt(e[o], t[o]))
+      return !1;
+  return !0;
+}
+function tn(e, t) {
+  t === void 0 && (t = en);
+  var o = null;
+  function a() {
+    for (var s = [], y = 0; y < arguments.length; y++)
+      s[y] = arguments[y];
+    if (o && o.lastThis === this && t(s, o.lastArgs))
+      return o.lastResult;
+    var p = e.apply(this, s);
+    return o = {
+      lastResult: p,
+      lastArgs: s,
+      lastThis: this
+    }, p;
+  }
+  return a.clear = function() {
+    o = null;
+  }, a;
+}
+const nn = () => {
+  const t = we().proxy.$props;
+  return M(() => {
+    const o = (a, s, y) => ({});
+    return t.perfMode ? xt(o) : tn(o);
+  });
+}, Je = "itemRendered", Qe = "scroll", it = "forward", dt = "backward", Le = "auto", on = "smart", ln = "start", et = "center", sn = "end", ge = "horizontal", je = "vertical", an = "ltr", Ne = "rtl", Re = "negative", ut = "positive-ascending", ft = "positive-descending", cn = {
+  [ge]: "left",
+  [je]: "top"
+}, rn = 20, dn = {
+  [ge]: "deltaX",
+  [je]: "deltaY"
+}, un = ({ atEndEdge: e, atStartEdge: t, layout: o }, a) => {
+  let s, y = 0;
+  const p = (v) => v < 0 && t.value || v > 0 && e.value;
+  return {
+    hasReachedEdge: p,
+    onWheel: (v) => {
+      rt(s);
+      const g = v[dn[o.value]];
+      p(y) && p(y + g) || (y += g, Ut() || v.preventDefault(), s = ct(() => {
+        a(y), y = 0;
+      }));
+    }
+  };
+}, De = de({
+  type: U([Number, Function]),
+  required: !0
+}), ze = de({
+  type: Number
+}), Ae = de({
+  type: Number,
+  default: 2
+}), fn = de({
+  type: String,
+  values: ["ltr", "rtl"],
+  default: "ltr"
+}), Be = de({
+  type: Number,
+  default: 0
+}), xe = de({
+  type: Number,
+  required: !0
+}), ht = de({
+  type: String,
+  values: ["horizontal", "vertical"],
+  default: je
+}), vt = ue({
+  className: {
+    type: String,
+    default: ""
+  },
+  containerElement: {
+    type: U([String, Object]),
+    default: "div"
+  },
+  data: {
+    type: U(Array),
+    default: () => ve([])
+  },
+  direction: fn,
+  height: {
+    type: [String, Number],
+    required: !0
+  },
+  innerElement: {
+    type: [String, Object],
+    default: "div"
+  },
+  style: {
+    type: U([Object, String, Array])
+  },
+  useIsScrolling: {
+    type: Boolean,
+    default: !1
+  },
+  width: {
+    type: [Number, String],
+    required: !1
+  },
+  perfMode: {
+    type: Boolean,
+    default: !0
+  },
+  scrollbarAlwaysOn: {
+    type: Boolean,
+    default: !1
+  }
+}), hn = ue({
+  cache: Ae,
+  estimatedItemSize: ze,
+  layout: ht,
+  initScrollOffset: Be,
+  total: xe,
+  itemSize: De,
+  ...vt
+}), He = {
+  type: Number,
+  default: 6
+}, yt = { type: Number, default: 0 }, mt = { type: Number, default: 2 };
+ue({
+  columnCache: Ae,
+  columnWidth: De,
+  estimatedColumnWidth: ze,
+  estimatedRowHeight: ze,
+  initScrollLeft: Be,
+  initScrollTop: Be,
+  itemKey: {
+    type: U(Function),
+    default: ({
+      columnIndex: e,
+      rowIndex: t
+    }) => `${t}:${e}`
+  },
+  rowCache: Ae,
+  rowHeight: De,
+  totalColumn: xe,
+  totalRow: xe,
+  hScrollbarSize: He,
+  vScrollbarSize: He,
+  scrollbarStartGap: yt,
+  scrollbarEndGap: mt,
+  role: String,
+  ...vt
+});
+const vn = ue({
+  alwaysOn: Boolean,
+  class: String,
+  layout: ht,
+  total: xe,
+  ratio: {
+    type: Number,
+    required: !0
+  },
+  clientSize: {
+    type: Number,
+    required: !0
+  },
+  scrollFrom: {
+    type: Number,
+    required: !0
+  },
+  scrollbarSize: He,
+  startGap: yt,
+  endGap: mt,
+  visible: Boolean
+}), Ie = (e, t) => e < t ? it : dt, Fe = (e) => e === an || e === Ne || e === ge;
+let he = null;
+function tt(e = !1) {
+  if (he === null || e) {
+    const t = document.createElement("div"), o = t.style;
+    o.width = "50px", o.height = "50px", o.overflow = "scroll", o.direction = "rtl";
+    const a = document.createElement("div"), s = a.style;
+    return s.width = "100px", s.height = "100px", t.appendChild(a), document.body.appendChild(t), t.scrollLeft > 0 ? he = ft : (t.scrollLeft = 1, t.scrollLeft === 0 ? he = Re : he = ut), document.body.removeChild(t), he;
+  }
+  return he;
+}
+function yn({ move: e, size: t, bar: o }, a) {
+  const s = {}, y = `translate${o.axis}(${e}px)`;
+  return s[o.size] = t, s.transform = y, s.msTransform = y, s.webkitTransform = y, a === "horizontal" ? s.height = "100%" : s.width = "100%", s;
+}
+const mn = ce({
+  name: "ElVirtualScrollBar",
+  props: vn,
+  emits: ["scroll", "start-move", "stop-move"],
+  setup(e, { emit: t }) {
+    const o = M(() => e.startGap + e.endGap), a = me("virtual-scrollbar"), s = me("scrollbar"), y = z(), p = z();
+    let b = null, v = null;
+    const g = At({
+      isDragging: !1,
+      traveled: 0
+    }), l = M(() => Dt[e.layout]), r = M(() => e.clientSize - i(o)), _ = M(() => ({
+      position: "absolute",
+      width: `${ge === e.layout ? r.value : e.scrollbarSize}px`,
+      height: `${ge === e.layout ? e.scrollbarSize : r.value}px`,
+      [cn[e.layout]]: "2px",
+      right: "2px",
+      bottom: "2px",
+      borderRadius: "4px"
+    })), O = M(() => {
+      const d = e.ratio, k = e.clientSize;
+      if (d >= 100)
+        return Number.POSITIVE_INFINITY;
+      if (d >= 50)
+        return d * k / 100;
+      const T = k / 3;
+      return Math.floor(Math.min(Math.max(d * k, rn), T));
+    }), w = M(() => {
+      if (!Number.isFinite(O.value))
+        return {
+          display: "none"
+        };
+      const d = `${O.value}px`;
+      return yn({
+        bar: l.value,
+        size: d,
+        move: g.traveled
+      }, e.layout);
+    }), S = M(() => Math.floor(e.clientSize - O.value - i(o))), $ = () => {
+      window.addEventListener("mousemove", f), window.addEventListener("mouseup", h);
+      const d = i(p);
+      d && (v = document.onselectstart, document.onselectstart = () => !1, d.addEventListener("touchmove", f), d.addEventListener("touchend", h));
+    }, x = () => {
+      window.removeEventListener("mousemove", f), window.removeEventListener("mouseup", h), document.onselectstart = v, v = null;
+      const d = i(p);
+      d && (d.removeEventListener("touchmove", f), d.removeEventListener("touchend", h));
+    }, A = (d) => {
+      d.stopImmediatePropagation(), !(d.ctrlKey || [1, 2].includes(d.button)) && (g.isDragging = !0, g[l.value.axis] = d.currentTarget[l.value.offset] - (d[l.value.client] - d.currentTarget.getBoundingClientRect()[l.value.direction]), t("start-move"), $());
+    }, h = () => {
+      g.isDragging = !1, g[l.value.axis] = 0, t("stop-move"), x();
+    }, f = (d) => {
+      const { isDragging: k } = g;
+      if (!k || !p.value || !y.value)
+        return;
+      const T = g[l.value.axis];
+      if (!T)
+        return;
+      rt(b);
+      const L = (y.value.getBoundingClientRect()[l.value.direction] - d[l.value.client]) * -1, R = p.value[l.value.offset] - T, B = L - R;
+      b = ct(() => {
+        g.traveled = Math.max(e.startGap, Math.min(B, S.value)), t("scroll", B, S.value);
+      });
+    }, E = (d) => {
+      const k = Math.abs(d.target.getBoundingClientRect()[l.value.direction] - d[l.value.client]), T = p.value[l.value.offset] / 2, L = k - T;
+      g.traveled = Math.max(0, Math.min(L, S.value)), t("scroll", L, S.value);
+    };
+    return _e(() => e.scrollFrom, (d) => {
+      g.isDragging || (g.traveled = Math.ceil(d * S.value));
+    }), Bt(() => {
+      x();
+    }), () => re("div", {
+      role: "presentation",
+      ref: y,
+      class: [
+        a.b(),
+        e.class,
+        (e.alwaysOn || g.isDragging) && "always-on"
+      ],
+      style: _.value,
+      onMousedown: Ee(E, ["stop", "prevent"]),
+      onTouchstartPrevent: A
+    }, re("div", {
+      ref: p,
+      class: s.e("thumb"),
+      style: w.value,
+      onMousedown: A
+    }, []));
+  }
+}), gn = ({
+  name: e,
+  getOffset: t,
+  getItemSize: o,
+  getItemOffset: a,
+  getEstimatedTotalSize: s,
+  getStartIndexForOffset: y,
+  getStopIndexForStartIndex: p,
+  initCache: b,
+  clearCache: v,
+  validateProps: g
+}) => ce({
+  name: e ?? "ElVirtualList",
+  props: hn,
+  emits: [Je, Qe],
+  setup(l, { emit: r, expose: _ }) {
+    g(l);
+    const O = we(), w = me("vl"), S = z(b(l, O)), $ = nn(), x = z(), A = z(), h = z(), f = z({
+      isScrolling: !1,
+      scrollDir: "forward",
+      scrollOffset: Se(l.initScrollOffset) ? l.initScrollOffset : 0,
+      updateRequested: !1,
+      isScrollbarDragging: !1,
+      scrollbarAlwaysOn: l.scrollbarAlwaysOn
+    }), E = M(() => {
+      const { total: u, cache: N } = l, { isScrolling: I, scrollDir: P, scrollOffset: K } = i(f);
+      if (u === 0)
+        return [0, 0, 0, 0];
+      const n = y(l, K, i(S)), m = p(l, n, K, i(S)), F = !I || P === dt ? Math.max(1, N) : 1, j = !I || P === it ? Math.max(1, N) : 1;
+      return [
+        Math.max(0, n - F),
+        Math.max(0, Math.min(u - 1, m + j)),
+        n,
+        m
+      ];
+    }), d = M(() => s(l, i(S))), k = M(() => Fe(l.layout)), T = M(() => [
+      {
+        position: "relative",
+        [`overflow-${k.value ? "x" : "y"}`]: "scroll",
+        WebkitOverflowScrolling: "touch",
+        willChange: "transform"
+      },
+      {
+        direction: l.direction,
+        height: Se(l.height) ? `${l.height}px` : l.height,
+        width: Se(l.width) ? `${l.width}px` : l.width
+      },
+      l.style
+    ]), L = M(() => {
+      const u = i(d), N = i(k);
+      return {
+        height: N ? "100%" : `${u}px`,
+        pointerEvents: i(f).isScrolling ? "none" : void 0,
+        width: N ? `${u}px` : "100%"
+      };
+    }), R = M(() => k.value ? l.width : l.height), { onWheel: B } = un({
+      atStartEdge: M(() => f.value.scrollOffset <= 0),
+      atEndEdge: M(() => f.value.scrollOffset >= d.value),
+      layout: M(() => l.layout)
+    }, (u) => {
+      var N, I;
+      (I = (N = h.value).onMouseUp) == null || I.call(N), q(Math.min(f.value.scrollOffset + u, d.value - R.value));
+    }), c = () => {
+      const { total: u } = l;
+      if (u > 0) {
+        const [K, n, m, F] = i(E);
+        r(Je, K, n, m, F);
+      }
+      const { scrollDir: N, scrollOffset: I, updateRequested: P } = i(f);
+      r(Qe, N, I, P);
+    }, C = (u) => {
+      const { clientHeight: N, scrollHeight: I, scrollTop: P } = u.currentTarget, K = i(f);
+      if (K.scrollOffset === P)
+        return;
+      const n = Math.max(0, Math.min(P, I - N));
+      f.value = {
+        ...K,
+        isScrolling: !0,
+        scrollDir: Ie(K.scrollOffset, n),
+        scrollOffset: n,
+        updateRequested: !1
+      }, Q(ae);
+    }, D = (u) => {
+      const { clientWidth: N, scrollLeft: I, scrollWidth: P } = u.currentTarget, K = i(f);
+      if (K.scrollOffset === I)
+        return;
+      const { direction: n } = l;
+      let m = I;
+      if (n === Ne)
+        switch (tt()) {
+          case Re: {
+            m = -I;
+            break;
+          }
+          case ft: {
+            m = P - N - I;
+            break;
+          }
+        }
+      m = Math.max(0, Math.min(m, P - N)), f.value = {
+        ...K,
+        isScrolling: !0,
+        scrollDir: Ie(K.scrollOffset, m),
+        scrollOffset: m,
+        updateRequested: !1
+      }, Q(ae);
+    }, Y = (u) => {
+      i(k) ? D(u) : C(u), c();
+    }, G = (u, N) => {
+      const I = (d.value - R.value) / N * u;
+      q(Math.min(d.value - R.value, I));
+    }, q = (u) => {
+      u = Math.max(u, 0), u !== i(f).scrollOffset && (f.value = {
+        ...i(f),
+        scrollOffset: u,
+        scrollDir: Ie(i(f).scrollOffset, u),
+        updateRequested: !0
+      }, Q(ae));
+    }, X = (u, N = Le) => {
+      const { scrollOffset: I } = i(f);
+      u = Math.max(0, Math.min(u, l.total - 1)), q(t(l, u, N, I, i(S)));
+    }, W = (u) => {
+      const { direction: N, itemSize: I, layout: P } = l, K = $.value(v && I, v && P, v && N);
+      let n;
+      if (wt(K, String(u)))
+        n = K[u];
+      else {
+        const m = a(l, u, i(S)), F = o(l, u, i(S)), j = i(k), te = N === Ne, oe = j ? m : 0;
+        K[u] = n = {
+          position: "absolute",
+          left: te ? void 0 : `${oe}px`,
+          right: te ? `${oe}px` : void 0,
+          top: j ? 0 : `${m}px`,
+          height: j ? "100%" : `${F}px`,
+          width: j ? `${F}px` : "100%"
+        };
+      }
+      return n;
+    }, ae = () => {
+      f.value.isScrolling = !1, Q(() => {
+        $.value(-1, null, null);
+      });
+    }, ne = () => {
+      const u = x.value;
+      u && (u.scrollTop = 0);
+    };
+    Ht(() => {
+      if (!Pe)
+        return;
+      const { initScrollOffset: u } = l, N = i(x);
+      Se(u) && N && (i(k) ? N.scrollLeft = u : N.scrollTop = u), c();
+    }), Ft(() => {
+      const { direction: u, layout: N } = l, { scrollOffset: I, updateRequested: P } = i(f), K = i(x);
+      if (P && K)
+        if (N === ge)
+          if (u === Ne)
+            switch (tt()) {
+              case Re: {
+                K.scrollLeft = -I;
+                break;
+              }
+              case ut: {
+                K.scrollLeft = I;
+                break;
+              }
+              default: {
+                const { clientWidth: n, scrollWidth: m } = K;
+                K.scrollLeft = m - n - I;
+                break;
+              }
+            }
+          else
+            K.scrollLeft = I;
+        else
+          K.scrollTop = I;
+    });
+    const H = {
+      ns: w,
+      clientSize: R,
+      estimatedTotalSize: d,
+      windowStyle: T,
+      windowRef: x,
+      innerRef: A,
+      innerStyle: L,
+      itemsToRender: E,
+      scrollbarRef: h,
+      states: f,
+      getItemStyle: W,
+      onScroll: Y,
+      onScrollbarScroll: G,
+      onWheel: B,
+      scrollTo: q,
+      scrollToItem: X,
+      resetScrollTop: ne
+    };
+    return _({
+      windowRef: x,
+      innerRef: A,
+      getItemStyleCache: $,
+      scrollTo: q,
+      scrollToItem: X,
+      resetScrollTop: ne,
+      states: f
+    }), H;
+  },
+  render(l) {
+    var r;
+    const {
+      $slots: _,
+      className: O,
+      clientSize: w,
+      containerElement: S,
+      data: $,
+      getItemStyle: x,
+      innerElement: A,
+      itemsToRender: h,
+      innerStyle: f,
+      layout: E,
+      total: d,
+      onScroll: k,
+      onScrollbarScroll: T,
+      onWheel: L,
+      states: R,
+      useIsScrolling: B,
+      windowStyle: c,
+      ns: C
+    } = l, [D, Y] = h, G = Ke(S), q = Ke(A), X = [];
+    if (d > 0)
+      for (let H = D; H <= Y; H++)
+        X.push((r = _.default) == null ? void 0 : r.call(_, {
+          data: $,
+          key: H,
+          index: H,
+          isScrolling: B ? R.isScrolling : void 0,
+          style: x(H)
+        }));
+    const W = [
+      re(q, {
+        style: f,
+        ref: "innerRef"
+      }, Me(q) ? X : {
+        default: () => X
+      })
+    ], ae = re(mn, {
+      ref: "scrollbarRef",
+      clientSize: w,
+      layout: E,
+      onScroll: T,
+      ratio: w * 100 / this.estimatedTotalSize,
+      scrollFrom: R.scrollOffset / (this.estimatedTotalSize - w),
+      total: d
+    }), ne = re(G, {
+      class: [C.e("window"), O],
+      style: c,
+      onScroll: k,
+      onWheel: L,
+      ref: "windowRef",
+      key: 0
+    }, Me(G) ? [W] : { default: () => [W] });
+    return re("div", {
+      key: 0,
+      class: [C.e("wrapper"), R.scrollbarAlwaysOn ? "always-on" : ""]
+    }, [ne, ae]);
+  }
+}), pn = gn({
+  name: "ElFixedSizeList",
+  getItemOffset: ({ itemSize: e }, t) => t * e,
+  getItemSize: ({ itemSize: e }) => e,
+  getEstimatedTotalSize: ({ total: e, itemSize: t }) => t * e,
+  getOffset: ({ height: e, total: t, itemSize: o, layout: a, width: s }, y, p, b) => {
+    const v = Fe(a) ? s : e;
+    process.env.NODE_ENV !== "production" && Me(v) && Tt("[ElVirtualList]", `
+        You should set
+          width/height
+        to number when your layout is
+          horizontal/vertical
+      `);
+    const g = Math.max(0, t * o - v), l = Math.min(g, y * o), r = Math.max(0, (y + 1) * o - v);
+    switch (p === on && (b >= r - v && b <= l + v ? p = Le : p = et), p) {
+      case ln:
+        return l;
+      case sn:
+        return r;
+      case et: {
+        const _ = Math.round(r + (l - r) / 2);
+        return _ < Math.ceil(v / 2) ? 0 : _ > g + Math.floor(v / 2) ? g : _;
+      }
+      case Le:
+      default:
+        return b >= r && b <= l ? b : b < r ? r : l;
+    }
+  },
+  getStartIndexForOffset: ({ total: e, itemSize: t }, o) => Math.max(0, Math.min(e - 1, Math.floor(o / t))),
+  getStopIndexForStartIndex: ({ height: e, total: t, itemSize: o, layout: a, width: s }, y, p) => {
+    const b = y * o, v = Fe(a) ? s : e, g = Math.ceil((v + p - b) / o);
+    return Math.max(0, Math.min(t - 1, y + g - 1));
+  },
+  initCache() {
+  },
+  clearCache: !0,
+  validateProps() {
+  }
+}), Ve = Symbol(), kn = {
+  key: -1,
+  level: -1,
+  data: {}
+};
+var be = /* @__PURE__ */ ((e) => (e.KEY = "id", e.LABEL = "label", e.CHILDREN = "children", e.DISABLED = "disabled", e))(be || {}), $e = /* @__PURE__ */ ((e) => (e.ADD = "add", e.DELETE = "delete", e))($e || {});
+const gt = {
+  type: Number,
+  default: 26
+}, bn = ue({
+  data: {
+    type: U(Array),
+    default: () => ve([])
+  },
+  emptyText: {
+    type: String
+  },
+  height: {
+    type: Number,
+    default: 200
+  },
+  props: {
+    type: U(Object),
+    default: () => ve({
+      children: "children",
+      label: "label",
+      disabled: "disabled",
+      value: "id"
+      /* KEY */
+    })
+  },
+  highlightCurrent: {
+    type: Boolean,
+    default: !1
+  },
+  showCheckbox: {
+    type: Boolean,
+    default: !1
+  },
+  defaultCheckedKeys: {
+    type: U(Array),
+    default: () => ve([])
+  },
+  checkStrictly: {
+    type: Boolean,
+    default: !1
+  },
+  defaultExpandedKeys: {
+    type: U(Array),
+    default: () => ve([])
+  },
+  indent: {
+    type: Number,
+    default: 16
+  },
+  itemSize: gt,
+  icon: {
+    type: Xt
+  },
+  expandOnClickNode: {
+    type: Boolean,
+    default: !0
+  },
+  checkOnClickNode: {
+    type: Boolean,
+    default: !1
+  },
+  currentNodeKey: {
+    type: U([String, Number])
+  },
+  accordion: {
+    type: Boolean,
+    default: !1
+  },
+  filterMethod: {
+    type: U(Function)
+  },
+  perfMode: {
+    type: Boolean,
+    default: !0
+  }
+}), Cn = ue({
+  node: {
+    type: U(Object),
+    default: () => ve(kn)
+  },
+  expanded: {
+    type: Boolean,
+    default: !1
+  },
+  checked: {
+    type: Boolean,
+    default: !1
+  },
+  indeterminate: {
+    type: Boolean,
+    default: !1
+  },
+  showCheckbox: {
+    type: Boolean,
+    default: !1
+  },
+  disabled: {
+    type: Boolean,
+    default: !1
+  },
+  current: {
+    type: Boolean,
+    default: !1
+  },
+  hiddenExpandIcon: {
+    type: Boolean,
+    default: !1
+  },
+  itemSize: gt
+}), Sn = ue({
+  node: {
+    type: U(Object),
+    required: !0
+  }
+}), pt = "node-click", kt = "node-expand", bt = "node-collapse", Ct = "current-change", St = "check", Et = "check-change", Nt = "node-contextmenu", En = {
+  [pt]: (e, t, o) => e && t && o,
+  [kt]: (e, t) => e && t,
+  [bt]: (e, t) => e && t,
+  [Ct]: (e, t) => e && t,
+  [St]: (e, t) => e && t,
+  [Et]: (e, t) => e && typeof t == "boolean",
+  [Nt]: (e, t, o) => e && t && o
+}, Nn = {
+  click: (e, t) => !!(e && t),
+  toggle: (e) => !!e,
+  check: (e, t) => e && typeof t == "boolean"
+};
+function _n(e, t) {
+  const o = z(/* @__PURE__ */ new Set()), a = z(/* @__PURE__ */ new Set()), { emit: s } = we();
+  _e([() => t.value, () => e.defaultCheckedKeys], () => Q(() => {
+    A(e.defaultCheckedKeys);
+  }), {
+    immediate: !0
+  });
+  const y = () => {
+    if (!t.value || !e.showCheckbox || e.checkStrictly)
+      return;
+    const { levelTreeNodeMap: h, maxLevel: f } = t.value, E = o.value, d = /* @__PURE__ */ new Set();
+    for (let k = f - 1; k >= 1; --k) {
+      const T = h.get(k);
+      T && T.forEach((L) => {
+        const R = L.children;
+        if (R) {
+          let B = !0, c = !1;
+          for (const C of R) {
+            const D = C.key;
+            if (E.has(D))
+              c = !0;
+            else if (d.has(D)) {
+              B = !1, c = !0;
+              break;
+            } else
+              B = !1;
+          }
+          B ? E.add(L.key) : c ? (d.add(L.key), E.delete(L.key)) : (E.delete(L.key), d.delete(L.key));
+        }
+      });
+    }
+    a.value = d;
+  }, p = (h) => o.value.has(h.key), b = (h) => a.value.has(h.key), v = (h, f, E = !0) => {
+    const d = o.value, k = (T, L) => {
+      d[L ? $e.ADD : $e.DELETE](T.key);
+      const R = T.children;
+      !e.checkStrictly && R && R.forEach((B) => {
+        B.disabled || k(B, L);
+      });
+    };
+    k(h, f), y(), E && g(h, f);
+  }, g = (h, f) => {
+    const { checkedNodes: E, checkedKeys: d } = w(), { halfCheckedNodes: k, halfCheckedKeys: T } = S();
+    s(St, h.data, {
+      checkedKeys: d,
+      checkedNodes: E,
+      halfCheckedKeys: T,
+      halfCheckedNodes: k
+    }), s(Et, h.data, f);
+  };
+  function l(h = !1) {
+    return w(h).checkedKeys;
+  }
+  function r(h = !1) {
+    return w(h).checkedNodes;
+  }
+  function _() {
+    return S().halfCheckedKeys;
+  }
+  function O() {
+    return S().halfCheckedNodes;
+  }
+  function w(h = !1) {
+    const f = [], E = [];
+    if (t != null && t.value && e.showCheckbox) {
+      const { treeNodeMap: d } = t.value;
+      o.value.forEach((k) => {
+        const T = d.get(k);
+        T && (!h || h && T.isLeaf) && (E.push(k), f.push(T.data));
+      });
+    }
+    return {
+      checkedKeys: E,
+      checkedNodes: f
+    };
+  }
+  function S() {
+    const h = [], f = [];
+    if (t != null && t.value && e.showCheckbox) {
+      const { treeNodeMap: E } = t.value;
+      a.value.forEach((d) => {
+        const k = E.get(d);
+        k && (f.push(d), h.push(k.data));
+      });
+    }
+    return {
+      halfCheckedNodes: h,
+      halfCheckedKeys: f
+    };
+  }
+  function $(h) {
+    o.value.clear(), a.value.clear(), Q(() => {
+      A(h);
+    });
+  }
+  function x(h, f) {
+    if (t != null && t.value && e.showCheckbox) {
+      const E = t.value.treeNodeMap.get(h);
+      E && v(E, f, !1);
+    }
+  }
+  function A(h) {
+    if (t != null && t.value) {
+      const { treeNodeMap: f } = t.value;
+      if (e.showCheckbox && f && h)
+        for (const E of h) {
+          const d = f.get(E);
+          d && !p(d) && v(d, !0, !1);
+        }
+    }
+  }
+  return {
+    updateCheckedKeys: y,
+    toggleCheckbox: v,
+    isChecked: p,
+    isIndeterminate: b,
+    getCheckedKeys: l,
+    getCheckedNodes: r,
+    getHalfCheckedKeys: _,
+    getHalfCheckedNodes: O,
+    setChecked: x,
+    setCheckedKeys: $
+  };
+}
+function xn(e, t) {
+  const o = z(/* @__PURE__ */ new Set([])), a = z(/* @__PURE__ */ new Set([])), s = M(() => It(e.filterMethod));
+  function y(b) {
+    var v;
+    if (!s.value)
+      return;
+    const g = /* @__PURE__ */ new Set(), l = a.value, r = o.value, _ = [], O = ((v = t.value) == null ? void 0 : v.treeNodes) || [], w = e.filterMethod;
+    r.clear();
+    function S($) {
+      $.forEach((x) => {
+        _.push(x), w != null && w(b, x.data) ? _.forEach((h) => {
+          g.add(h.key);
+        }) : x.isLeaf && r.add(x.key);
+        const A = x.children;
+        if (A && S(A), !x.isLeaf) {
+          if (!g.has(x.key))
+            r.add(x.key);
+          else if (A) {
+            let h = !0;
+            for (const f of A)
+              if (!r.has(f.key)) {
+                h = !1;
+                break;
+              }
+            h ? l.add(x.key) : l.delete(x.key);
+          }
+        }
+        _.pop();
+      });
+    }
+    return S(O), g;
+  }
+  function p(b) {
+    return a.value.has(b.key);
+  }
+  return {
+    hiddenExpandIconKeySet: a,
+    hiddenNodeKeySet: o,
+    doFilter: y,
+    isForceHiddenExpandIcon: p
+  };
+}
+function wn(e, t) {
+  const o = z(new Set(e.defaultExpandedKeys)), a = z(), s = $t();
+  _e(() => e.currentNodeKey, (n) => {
+    a.value = n;
+  }, {
+    immediate: !0
+  }), _e(() => e.data, (n) => {
+    P(n);
+  }, {
+    immediate: !0
+  });
+  const {
+    isIndeterminate: y,
+    isChecked: p,
+    toggleCheckbox: b,
+    getCheckedKeys: v,
+    getCheckedNodes: g,
+    getHalfCheckedKeys: l,
+    getHalfCheckedNodes: r,
+    setChecked: _,
+    setCheckedKeys: O
+  } = _n(e, s), { doFilter: w, hiddenNodeKeySet: S, isForceHiddenExpandIcon: $ } = xn(e, s), x = M(() => {
+    var n;
+    return ((n = e.props) == null ? void 0 : n.value) || be.KEY;
+  }), A = M(() => {
+    var n;
+    return ((n = e.props) == null ? void 0 : n.children) || be.CHILDREN;
+  }), h = M(() => {
+    var n;
+    return ((n = e.props) == null ? void 0 : n.disabled) || be.DISABLED;
+  }), f = M(() => {
+    var n;
+    return ((n = e.props) == null ? void 0 : n.label) || be.LABEL;
+  }), E = M(() => {
+    const n = o.value, m = S.value, F = [], j = s.value && s.value.treeNodes || [];
+    function te() {
+      const oe = [];
+      for (let Z = j.length - 1; Z >= 0; --Z)
+        oe.push(j[Z]);
+      for (; oe.length; ) {
+        const Z = oe.pop();
+        if (Z && (m.has(Z.key) || F.push(Z), n.has(Z.key))) {
+          const J = Z.children;
+          if (J) {
+            const Te = J.length;
+            for (let fe = Te - 1; fe >= 0; --fe)
+              oe.push(J[fe]);
+          }
+        }
+      }
+    }
+    return te(), F;
+  }), d = M(() => E.value.length > 0);
+  function k(n) {
+    const m = /* @__PURE__ */ new Map(), F = /* @__PURE__ */ new Map();
+    let j = 1;
+    function te(Z, J = 1, Te = void 0) {
+      var fe;
+      const Ge = [];
+      for (const pe of Z) {
+        const qe = R(pe), le = {
+          level: J,
+          key: qe,
+          data: pe
+        };
+        le.label = c(pe), le.parent = Te;
+        const ke = L(pe);
+        le.disabled = B(pe), le.isLeaf = !ke || ke.length === 0, ke && ke.length && (le.children = te(ke, J + 1, le)), Ge.push(le), m.set(qe, le), F.has(J) || F.set(J, []), (fe = F.get(J)) == null || fe.push(le);
+      }
+      return J > j && (j = J), Ge;
+    }
+    const oe = te(n);
+    return {
+      treeNodeMap: m,
+      levelTreeNodeMap: F,
+      maxLevel: j,
+      treeNodes: oe
+    };
+  }
+  function T(n) {
+    const m = w(n);
+    m && (o.value = m);
+  }
+  function L(n) {
+    return n[A.value];
+  }
+  function R(n) {
+    return n ? n[x.value] : "";
+  }
+  function B(n) {
+    return n[h.value];
+  }
+  function c(n) {
+    return n[f.value];
+  }
+  function C(n) {
+    o.value.has(n.key) ? W(n) : X(n);
+  }
+  function D(n) {
+    o.value = new Set(n);
+  }
+  function Y(n, m) {
+    t(pt, n.data, n, m), G(n), e.expandOnClickNode && C(n), e.showCheckbox && e.checkOnClickNode && !n.disabled && b(n, !p(n), !0);
+  }
+  function G(n) {
+    H(n) || (a.value = n.key, t(Ct, n.data, n));
+  }
+  function q(n, m) {
+    b(n, m);
+  }
+  function X(n) {
+    const m = o.value;
+    if (s.value && e.accordion) {
+      const { treeNodeMap: F } = s.value;
+      m.forEach((j) => {
+        const te = F.get(j);
+        n && n.level === (te == null ? void 0 : te.level) && m.delete(j);
+      });
+    }
+    m.add(n.key), t(kt, n.data, n);
+  }
+  function W(n) {
+    o.value.delete(n.key), t(bt, n.data, n);
+  }
+  function ae(n) {
+    return o.value.has(n.key);
+  }
+  function ne(n) {
+    return !!n.disabled;
+  }
+  function H(n) {
+    const m = a.value;
+    return m !== void 0 && m === n.key;
+  }
+  function u() {
+    var n, m;
+    if (a.value)
+      return (m = (n = s.value) == null ? void 0 : n.treeNodeMap.get(a.value)) == null ? void 0 : m.data;
+  }
+  function N() {
+    return a.value;
+  }
+  function I(n) {
+    a.value = n;
+  }
+  function P(n) {
+    Q(() => s.value = k(n));
+  }
+  function K(n) {
+    var m;
+    const F = Mt(n) ? R(n) : n;
+    return (m = s.value) == null ? void 0 : m.treeNodeMap.get(F);
+  }
+  return {
+    tree: s,
+    flattenTree: E,
+    isNotEmpty: d,
+    getKey: R,
+    getChildren: L,
+    toggleExpand: C,
+    toggleCheckbox: b,
+    isExpanded: ae,
+    isChecked: p,
+    isIndeterminate: y,
+    isDisabled: ne,
+    isCurrent: H,
+    isForceHiddenExpandIcon: $,
+    handleNodeClick: Y,
+    handleNodeCheck: q,
+    getCurrentNode: u,
+    getCurrentKey: N,
+    setCurrentKey: I,
+    getCheckedKeys: v,
+    getCheckedNodes: g,
+    getHalfCheckedKeys: l,
+    getHalfCheckedNodes: r,
+    setChecked: _,
+    setCheckedKeys: O,
+    filter: T,
+    setData: P,
+    getNode: K,
+    expandNode: X,
+    collapseNode: W,
+    setExpandedKeys: D
+  };
+}
+var Tn = ce({
+  name: "ElTreeNodeContent",
+  props: Sn,
+  setup(e) {
+    const t = ot(Ve), o = me("tree");
+    return () => {
+      const a = e.node, { data: s } = a;
+      return t != null && t.ctx.slots.default ? t.ctx.slots.default({ node: a, data: s }) : re("span", { class: o.be("node", "label") }, [a == null ? void 0 : a.label]);
+    };
+  }
+});
+const In = ["aria-expanded", "aria-disabled", "aria-checked", "data-key", "onClick"], Mn = ce({
+  name: "ElTreeNode"
+}), Kn = /* @__PURE__ */ ce({
+  ...Mn,
+  props: Cn,
+  emits: Nn,
+  setup(e, { emit: t }) {
+    const o = e, a = ot(Ve), s = me("tree"), y = M(() => {
+      var r;
+      return (r = a == null ? void 0 : a.props.indent) != null ? r : 16;
+    }), p = M(() => {
+      var r;
+      return (r = a == null ? void 0 : a.props.icon) != null ? r : Zt;
+    }), b = (r) => {
+      t("click", o.node, r);
+    }, v = () => {
+      t("toggle", o.node);
+    }, g = (r) => {
+      t("check", o.node, r);
+    }, l = (r) => {
+      var _, O, w, S;
+      (w = (O = (_ = a == null ? void 0 : a.instance) == null ? void 0 : _.vnode) == null ? void 0 : O.props) != null && w.onNodeContextmenu && (r.stopPropagation(), r.preventDefault()), a == null || a.ctx.emit(Nt, r, (S = o.node) == null ? void 0 : S.data, o.node);
+    };
+    return (r, _) => {
+      var O, w, S;
+      return ee(), ye("div", {
+        ref: "node$",
+        class: ie([
+          i(s).b("node"),
+          i(s).is("expanded", r.expanded),
+          i(s).is("current", r.current),
+          i(s).is("focusable", !r.disabled),
+          i(s).is("checked", !r.disabled && r.checked)
+        ]),
+        role: "treeitem",
+        tabindex: "-1",
+        "aria-expanded": r.expanded,
+        "aria-disabled": r.disabled,
+        "aria-checked": r.checked,
+        "data-key": (O = r.node) == null ? void 0 : O.key,
+        onClick: Ee(b, ["stop"]),
+        onContextmenu: l
+      }, [
+        se("div", {
+          class: ie(i(s).be("node", "content")),
+          style: lt({
+            paddingLeft: `${(r.node.level - 1) * i(y)}px`,
+            height: r.itemSize + "px"
+          })
+        }, [
+          i(p) ? (ee(), Ce(i(Yt), {
+            key: 0,
+            class: ie([
+              i(s).is("leaf", !!((w = r.node) != null && w.isLeaf)),
+              i(s).is("hidden", r.hiddenExpandIcon),
+              {
+                expanded: !((S = r.node) != null && S.isLeaf) && r.expanded
+              },
+              i(s).be("node", "expand-icon")
+            ]),
+            onClick: Ee(v, ["stop"])
+          }, {
+            default: st(() => [
+              (ee(), Ce(Ke(i(p))))
+            ]),
+            _: 1
+          }, 8, ["class", "onClick"])) : We("v-if", !0),
+          r.showCheckbox ? (ee(), Ce(i(Rt), {
+            key: 1,
+            "model-value": r.checked,
+            indeterminate: r.indeterminate,
+            disabled: r.disabled,
+            onChange: g,
+            onClick: _[0] || (_[0] = Ee(() => {
+            }, ["stop"]))
+          }, null, 8, ["model-value", "indeterminate", "disabled"])) : We("v-if", !0),
+          Oe(i(Tn), { node: r.node }, null, 8, ["node"])
+        ], 6)
+      ], 42, In);
+    };
+  }
+});
+var On = /* @__PURE__ */ nt(Kn, [["__file", "tree-node.vue"]]);
+const Ln = ce({
+  name: "ElTreeV2"
+}), Rn = /* @__PURE__ */ ce({
+  ...Ln,
+  props: bn,
+  emits: En,
+  setup(e, { expose: t, emit: o }) {
+    const a = e, s = Pt(), y = M(() => a.itemSize);
+    Ue(Ve, {
+      ctx: {
+        emit: o,
+        slots: s
+      },
+      props: a,
+      instance: we()
+    }), Ue(Kt, void 0);
+    const { t: p } = Jt(), b = me("tree"), {
+      flattenTree: v,
+      isNotEmpty: g,
+      toggleExpand: l,
+      isExpanded: r,
+      isIndeterminate: _,
+      isChecked: O,
+      isDisabled: w,
+      isCurrent: S,
+      isForceHiddenExpandIcon: $,
+      handleNodeClick: x,
+      handleNodeCheck: A,
+      toggleCheckbox: h,
+      getCurrentNode: f,
+      getCurrentKey: E,
+      setCurrentKey: d,
+      getCheckedKeys: k,
+      getCheckedNodes: T,
+      getHalfCheckedKeys: L,
+      getHalfCheckedNodes: R,
+      setChecked: B,
+      setCheckedKeys: c,
+      filter: C,
+      setData: D,
+      getNode: Y,
+      expandNode: G,
+      collapseNode: q,
+      setExpandedKeys: X
+    } = wn(a, o);
+    return t({
+      toggleCheckbox: h,
+      getCurrentNode: f,
+      getCurrentKey: E,
+      setCurrentKey: d,
+      getCheckedKeys: k,
+      getCheckedNodes: T,
+      getHalfCheckedKeys: L,
+      getHalfCheckedNodes: R,
+      setChecked: B,
+      setCheckedKeys: c,
+      filter: C,
+      setData: D,
+      getNode: Y,
+      expandNode: G,
+      collapseNode: q,
+      setExpandedKeys: X
+    }), (W, ae) => {
+      var ne;
+      return ee(), ye("div", {
+        class: ie([i(b).b(), { [i(b).m("highlight-current")]: W.highlightCurrent }]),
+        role: "tree"
+      }, [
+        i(g) ? (ee(), Ce(i(pn), {
+          key: 0,
+          "class-name": i(b).b("virtual-list"),
+          data: i(v),
+          total: i(v).length,
+          height: W.height,
+          "item-size": i(y),
+          "perf-mode": W.perfMode
+        }, {
+          default: st(({ data: H, index: u, style: N }) => [
+            (ee(), Ce(On, {
+              key: H[u].key,
+              style: lt(N),
+              node: H[u],
+              expanded: i(r)(H[u]),
+              "show-checkbox": W.showCheckbox,
+              checked: i(O)(H[u]),
+              indeterminate: i(_)(H[u]),
+              "item-size": i(y),
+              disabled: i(w)(H[u]),
+              current: i(S)(H[u]),
+              "hidden-expand-icon": i($)(H[u]),
+              onClick: i(x),
+              onToggle: i(l),
+              onCheck: i(A)
+            }, null, 8, ["style", "node", "expanded", "show-checkbox", "checked", "indeterminate", "item-size", "disabled", "current", "hidden-expand-icon", "onClick", "onToggle", "onCheck"]))
+          ]),
+          _: 1
+        }, 8, ["class-name", "data", "total", "height", "item-size", "perf-mode"])) : (ee(), ye("div", {
+          key: 1,
+          class: ie(i(b).e("empty-block"))
+        }, [
+          se("span", {
+            class: ie(i(b).e("empty-text"))
+          }, at((ne = W.emptyText) != null ? ne : i(p)("el.tree.emptyText")), 3)
+        ], 2))
+      ], 2);
+    };
+  }
+});
+var Dn = /* @__PURE__ */ nt(Rn, [["__file", "tree.vue"]]);
+const zn = Ot(Dn), _t = (e) => (Gt("data-v-1aaf48fb"), e = e(), qt(), e), An = { class: "structure_container" }, Bn = { class: "top" }, Hn = /* @__PURE__ */ _t(() => /* @__PURE__ */ se("span", null, "结构树", -1)), Fn = { class: "panel_content" }, $n = { class: "types" }, Pn = ["onClick"], jn = { class: "tree" }, Vn = { class: "panel_content_null" }, Gn = /* @__PURE__ */ _t(() => /* @__PURE__ */ se("span", null, "加载中...", -1)), qn = [
+  Gn
+], Wn = /* @__PURE__ */ ce({
+  __name: "StructureTree",
+  emits: ["closePanel"],
+  setup(e, { emit: t }) {
+    const o = z(), a = z(0), s = z(), y = z(), p = z(), b = z(), v = z([]), g = z();
+    let l, r, _, O;
+    const w = z(!1), S = t, $ = {
+      children: "children",
+      label: "title",
+      value: "nodeId"
+    };
+    V.on("BimViewer", () => {
+      l = window.BimViewer;
+      const { eventTrigger: c } = l;
+      r = l.objectsExplorer, _ = l.classesExplorer, O = l.storeysExplorer, c.on("treeAllReady", (C) => {
+        console.log("treeAllReady", C), y.value = C.objectsData, p.value = C.classesData, b.value = C.storeysData, s.value = y.value, console.log("初始化结构树数据", s.value), Q(() => {
+          if (s.value) {
+            if (s.value[0] == null) return;
+            s.value[0].title = "全部", g.value = s.value[0].nodeId, o.value.setCurrentKey(s.value[0].nodeId), h(), w.value = !0;
+          }
+        });
+      }), c.on("pickedEntity", (C) => {
+        if (w.value === !1) return;
+        let D, Y;
+        a.value === 0 ? D = l.objectsExplorer.getNodeIdByObjectId(C.id) : a.value === 1 ? D = l.classesExplorer.getNodeIdByObjectId(C.id) : a.value === 2 && (D = l.storeysExplorer.getNodeIdByObjectId(C.id)), D && (Y = o.value.getNode(D), Q(() => {
+          g.value = D, o.value.setCurrentKey(D, !0), v.value = [], x(Y), o.value.setExpandedKeys(v.value);
+        }));
+      }), c.on("pickedNothing", () => {
+      });
+    });
+    const x = (c) => {
+      c.parent && x(c.parent), v.value = [...v.value, c.key];
+    }, A = () => {
+      S("closePanel");
+    }, h = () => {
+      Q(() => {
+        const c = s.value.map((C) => C.nodeId);
+        o.value.setCheckedKeys(c);
+      });
+    };
+    V.on("getTreeNodeId1", (c) => {
+      r.checkboxChangeHandler(c.nodeId, c.status), o.value.setChecked(c.nodeId, c.status);
+    }), V.on("getTreeNodeId2", (c) => {
+      _.checkboxChangeHandler(c.nodeId, !c.checked), o.value.setChecked(c.nodeId, c.status);
+    }), V.on("getTreeNodeId3", (c) => {
+      O.checkboxChangeHandler(c.nodeId, !c.checked), o.value.setChecked(c.nodeId, c.status);
+    }), V.on("receiveTreeType", (c) => {
+      a.value = c, E();
+    });
+    const f = (c) => {
+      console.log("选择结构树类型data", c), a.value !== c.id && (a.value = c.id, E());
+    }, E = () => {
+      a.value === 0 ? s.value = y.value : a.value === 1 ? s.value = p.value : a.value === 2 && (s.value = b.value), s.value[0].title = "全部", Q(() => {
+        g.value = s.value[0].nodeId, o.value.setCurrentKey(s.value[0].nodeId);
+      }), h(), V.emit("treeTypeActiveId", a.value);
+    }, d = (c) => {
+      const C = {
+        nodeId: c.nodeId,
+        status: !c.checked
+      };
+      a.value === 0 ? (r.checkboxChangeHandler(c.nodeId, !c.checked), V.emit("checkedObjects", C)) : a.value === 1 ? (_.checkboxChangeHandler(c.nodeId, !c.checked), V.emit("checkedClasses", C)) : a.value === 2 && (O.checkboxChangeHandler(c.nodeId, !c.checked), V.emit("checkedStoreys", C));
+    }, k = (c, C) => {
+      const D = l.viewer.scene.objects[c.objectId];
+      D && (l.setAllObjectsSelected(!1), l.setEntitySelected(D), l.viewFitEntity(D));
+    }, T = (c, C) => {
+      R(C);
+    }, L = (c, C) => {
+      R(C);
+    }, R = (c) => {
+      a.value === 0 ? V.emit("nodeObjects", c) : a.value === 1 ? V.emit("nodeClasses", c) : a.value === 2 && V.emit("nodeStoreys", c);
+    };
+    V.on("structure_tree_title_objects", (c) => {
+      B(c);
+    }), V.on("structure_tree_title_categorys", (c) => {
+      B(c);
+    }), V.on("structure_tree_title_floors", (c) => {
+      B(c);
+    });
+    const B = (c) => {
+      v.value.includes(c.nodeId) ? v.value = v.value.filter((C) => C !== c.nodeId) : v.value = [...v.value, c.nodeId], o.value.setExpandedKeys(v.value);
+    };
+    return (c, C) => {
+      const D = zt, Y = zn;
+      return ee(), ye("div", An, [
+        se("div", Bn, [
+          Hn,
+          Oe(D, {
+            class: "close",
+            width: 18,
+            "click-handle": A,
+            light: ""
+          })
+        ]),
+        Ye(se("div", Fn, [
+          se("div", $n, [
+            (ee(!0), ye(jt, null, Vt(i(Wt), (G) => (ee(), ye("div", {
+              class: ie(["types-item", { "types-item-active": a.value === G.id }]),
+              key: G.id,
+              onClick: (q) => f(G)
+            }, at(G.name), 11, Pn))), 128))
+          ]),
+          se("div", jn, [
+            Oe(Y, {
+              ref_key: "tree",
+              ref: o,
+              height: 800,
+              "node-key": "nodeId",
+              data: s.value,
+              "default-expanded-keys": v.value,
+              "current-node-key": g.value,
+              "highlight-current": !0,
+              props: $,
+              onCheck: d,
+              onNodeClick: k,
+              onNodeExpand: T,
+              onNodeCollapse: L,
+              "show-checkbox": ""
+            }, null, 8, ["data", "default-expanded-keys", "current-node-key"])
+          ])
+        ], 512), [
+          [Xe, w.value]
+        ]),
+        Ye(se("div", Vn, qn, 512), [
+          [Xe, !w.value]
+        ])
+      ]);
+    };
+  }
+}), oo = /* @__PURE__ */ Lt(Wn, [["__scopeId", "data-v-1aaf48fb"]]);
+export {
+  oo as default
+};